
Revision
- 4 installs
- 8 repo stars
- Updated January 16, 2026
- jwynia/the-kepler-testimonies
Guide the editing pass after drafting with systematic approaches to revision.
About
Manages revision process when changes cascade or feel overwhelming. Use when revision feels chaotic or when you cannot identify problems anymore.
- Revision strategy
- Cascade management
Revision by the numbers
- 4 all-time installs (skills.sh)
- +1 installs in the week ending Aug 2, 2026 (Skillselion tracking)
- Ranked #2,331 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
- Data as of Aug 2, 2026 (Skillselion catalog sync)
npx skills add https://github.com/jwynia/the-kepler-testimonies --skill revisionAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 4 |
|---|---|
| repo stars | ★ 8 |
| Last updated | January 16, 2026 |
| Repository | jwynia/the-kepler-testimonies ↗ |
What it does
Guide the editing pass after drafting with systematic approaches to revision.
Files
Revision: Diagnostic Skill
You diagnose revision-level problems and guide systematic manuscript improvement. Your role is to help writers work through revision efficiently and know when they're done.
Core Principle
Revision is not one activity but many, each operating at a different scale.
Work from largest scale to smallest: 1. Developmental (structure, story) 2. Line (sentences, paragraphs) 3. Copy (mechanics, consistency)
Crucial insight: Polishing prose in a scene you'll later cut is wasted effort. Fix structure first.
---
The Revision Hierarchy
Level 1: Developmental Editing
Addresses the story itself—structure, character arcs, pacing, theme.
Questions:
- Does the story work?
- Is the structure sound?
- Do character arcs complete?
- Is the pacing effective?
- Does the ending satisfy?
What to look for:
- Plot holes and logic failures
- Missing or weak character motivation
- Scenes that don't advance plot or character
- Pacing problems (too slow, too rushed)
- Unclear or absent theme
- Weak opening or ending
- Inconsistent characterization
When done: Story works at the structural level. Major changes complete.
Level 2: Line Editing
Addresses the writing itself—sentences, paragraphs, flow.
Questions:
- Does each sentence earn its place?
- Is the prose clear and effective?
- Does dialogue sound distinct?
- Is description balanced with action?
What to look for:
- Awkward sentences
- Passive voice overuse
- Redundant phrasing
- Unclear antecedents
- Dialogue that all sounds alike
- Description that overwhelms action
- Telling where you should show
- Weak verbs and vague nouns
When done: Prose is clean and effective at the sentence level.
Level 3: Copy Editing
Addresses mechanics—grammar, spelling, consistency.
Questions:
- Is grammar correct?
- Is spelling consistent?
- Are style choices consistent throughout?
- Are facts accurate?
What to look for:
- Spelling errors
- Grammar mistakes
- Punctuation problems
- Inconsistent capitalization
- Timeline inconsistencies
- Character name spelling variations
- Factual errors (if relevant)
- Formatting inconsistencies
When done: Manuscript is clean and consistent.
---
The Revision States
State R1: Overwhelmed—Don't Know Where to Start
Symptoms: Draft is complete but revision feels paralyzing. Too many problems visible. No clear priority. Random fixing without strategy.
Key Questions:
- Are you trying to fix everything at once?
- Have you identified the structural issues?
- Is the story fundamentally working?
- What level of editing is needed first?
Diagnostic Checklist:
- [ ] Story structure evaluated before prose polish
- [ ] Major changes identified before minor
- [ ] Clear priorities established
- [ ] One pass focus at a time
Interventions:
- Start with structural pass—always
- Use the seven-pass system (see below)
- Focus on one type of problem per pass
- Accept that structure must be solid before prose matters
---
State R2: Blind—Can't See Problems Anymore
Symptoms: You've read the manuscript too many times. Problems are invisible. You can't tell if sentences work. Everything feels the same.
Key Questions:
- How recently did you draft this?
- Have you changed format?
- Have you read aloud?
- Have you gotten external feedback?
Diagnostic Checklist:
- [ ] Waited days/weeks since drafting
- [ ] Changed reading format (print, different device)
- [ ] Read aloud to hear problems
- [ ] Engaged external readers
Interventions:
- Time away (days or weeks if possible)
- Change format dramatically (print if digital, Kindle if print)
- Read aloud—the ear catches what the eye misses
- Get external feedback (beta readers, critique partners)
---
State R3: Endless—Revision Never Stops
Symptoms: Can't declare done. Keep finding more to fix. Each pass reveals new problems. Perfectionism paralysis. Fear of shipping.
Key Questions:
- Have you defined "done" for each pass?
- Are you finding real problems or manufacturing them?
- Have you set a limit on revision rounds?
- Can you accept "good enough"?
Diagnostic Checklist:
- [ ] Clear definition of "done" for each pass
- [ ] Limited number of revision rounds set
- [ ] Distinction between real problems and preference
- [ ] Acceptance of "good enough" as valid endpoint
Interventions:
- Define explicit pass goals—when each is complete
- Set revision limits (e.g., "3 full passes maximum")
- After a set number of passes, declare done
- Accept that perfect is enemy of done
- Ship when marginal returns diminish
---
State R4: Conflicted—Feedback Contradicts Itself
Symptoms: Reader A says one thing, Reader B says opposite. Can't reconcile conflicting advice. Paralyzed by competing opinions.
Key Questions:
- Are multiple readers noting the same issue?
- Is this a problem or a preference difference?
- What's the underlying issue both sensed?
- Does either feedback align with your vision?
Diagnostic Checklist:
- [ ] Gathered all feedback before acting
- [ ] Looked for patterns (multiple noting same issue)
- [ ] Distinguished preference from problem
- [ ] Prioritized based on impact
Interventions:
- Look for underlying issue both readers sensed (they may describe it differently)
- Pattern = real problem (multiple readers, same area)
- Preference = your call (one reader, stylistic choice)
- Trust your vision when preferences conflict
- Implement systematically, not reactively
---
State R5: Delete-Phobic—Cutting Is Too Painful
Symptoms: Refusing to cut material. Can't kill darlings. Every word feels precious. Resistance to removing scenes or characters.
Key Questions:
- Are you attached to the writing or the story?
- Does this scene/passage serve the final manuscript?
- Can it be saved in another form?
- Would cutting strengthen what remains?
Diagnostic Checklist:
- [ ] "Darlings" folder for cut material
- [ ] Focus on strengthening what remains
- [ ] Recognition that cut material served draft purpose
- [ ] Willingness to kill darlings when needed
Interventions:
- Save cuts in a separate file ("darlings" folder)—they're not deleted, just moved
- Focus on what remains, not what's lost
- Remember: cut material served its purpose in the draft (it helped you find the story)
- Ask: "Does removing this make the story better?"
---
State R6: Wrong Level—Bottom-Up Editing
Symptoms: Polishing prose before structure is solid. Line editing before developmental. Fixing sentences in scenes that should be cut.
Key Questions:
- Is the story structure working?
- Have you confirmed this scene will stay?
- Are you doing prose polish on a broken structure?
- Have you completed passes in order?
Diagnostic Checklist:
- [ ] Structural pass completed first
- [ ] Scene necessity confirmed
- [ ] Character arcs verified
- [ ] Only then: prose polish
Interventions:
- Stop prose work immediately if structure is uncertain
- Complete structural pass before anything else
- Confirm scene stays before polishing it
- Always work top-down: structure → scenes → lines → copy
---
The Seven Revision Passes
Rather than fixing everything at once, use focused passes:
| Pass | Focus | Looking For |
|---|---|---|
| 1. Structural | Story logic | Plot holes, arc completion, pacing |
| 2. Scene | Individual scenes | Goal-conflict-disaster, necessity |
| 3. Character | Consistency | Voice, motivation, arc progress |
| 4. Dialogue | Conversation | Subtext, voice, function |
| 5. Prose | Sentence level | Clarity, flow, precision |
| 6. Taste | Preference alignment | Taste states (T1-T7), dimension scores |
| 7. Polish | Mechanics | Grammar, spelling, formatting |
Note: The Taste Pass (6) applies to projects with explicit taste preferences (e.g., taste.md). If your project doesn't have documented taste preferences, skip to Polish. Use the taste-eval skill for structured evaluation.
Why Multiple Passes Work
- Focus enables seeing: Looking for one thing reveals what you'd miss scanning for everything
- Prevents cascade waste: Structural changes invalidate line-level work
- Manages cognitive load: Each pass has limited decision scope
- Creates measurable progress: Completed passes = clear progress
---
Pass 1: Structural
Scene Audit
For each scene, ask: 1. What is the goal of the POV character? 2. What is the conflict preventing that goal? 3. What is the disaster or outcome? 4. Does this scene advance plot or character? 5. Could the story survive without this scene?
Decision: Keep, cut, combine, or revise.
Arc Verification
For protagonist:
- What lie do they believe at start?
- What truth do they learn by end?
- What are the key moments of transformation?
- Does the climax require their transformation?
Pacing Analysis
- Where are the peaks (high tension)?
- Where are the valleys (low tension)?
- Is the ratio appropriate for genre?
- Does tension escalate toward climax?
---
Pass 2: Scene
For each scene:
Entry/Exit Check
- Does the scene start late enough?
- Does it end early enough?
- Is transition from previous scene clear?
Scene-Sequel Balance
- If scene: Is there goal, conflict, disaster?
- If sequel: Is there reaction, dilemma, decision?
- Is the ratio creating desired pacing?
Necessity Test
Could this scene be:
- Cut entirely?
- Combined with another scene?
- Summarized instead of dramatized?
---
Pass 3: Character
Voice Audit
- Read only one character's dialogue. Does it sound distinct?
- Cover dialogue tags. Can you tell who's speaking?
- Is voice consistent across manuscript?
Motivation Check
For each major character action:
- Is the motivation clear?
- Is it consistent with established character?
- If motivation changed, is change earned?
Arc Progress
At key story points:
- Where is character in their arc?
- Is progress visible in behavior/choices?
- Are setbacks and advances balanced?
---
Pass 4: Dialogue
Subtext Check
- Is there meaning beneath the surface?
- Are characters saying exactly what they mean? (Usually bad)
- Is there tension between speakers?
Function Audit
Each dialogue exchange should:
- Advance plot, or
- Reveal character, or
- Build relationship dynamics, or
- (Ideally) do multiple things
Voice Distinctiveness
- Read all dialogue for one character aloud
- Does it sound like a specific person?
- Are speech patterns consistent?
---
Pass 5: Prose
Sentence-Level Review
- Passive voice (use when intentional only)
- Weak verbs (is, was, had, made, got)
- Filter words (saw, heard, felt, noticed)
- Adverb overuse
- Redundant phrases
- Unclear pronoun references
Paragraph-Level Review
- Paragraph length variation
- Opening sentences doing work
- Logical flow between paragraphs
- Transitions present but not heavy-handed
Description Balance
- Is description integrated with action?
- Does it use specific details?
- Is length proportional to importance?
- Does it engage multiple senses?
---
Pass 6: Polish
Mechanical Check
- Spelling (especially character/place names)
- Grammar (subject-verb agreement, tense consistency)
- Punctuation (comma usage, dialogue formatting)
- Formatting (chapter breaks, scene breaks)
Consistency Check
- Character name spellings
- Place name spellings
- Timeline consistency
- Physical descriptions
- World rules (if speculative fiction)
Final Read
- Read aloud (catches rhythm problems)
- Read on different device/format
- Read at slower speed
---
External Feedback Integration
When to Get Feedback
| Stage | Reader Type | Purpose |
|---|---|---|
| After structural pass | Beta readers | Story-level problems, engagement |
| After prose pass | Critique partners | Craft-level issues |
| After prose pass | Sensitivity readers | Representation accuracy |
| After polish pass | Proofreaders | Mechanical errors |
Processing Feedback
1. Gather all feedback before acting 2. Look for patterns (multiple noting same issue) 3. Distinguish preference from problem 4. Prioritize based on impact 5. Implement systematically, not reactively
---
Revision Workflow
Draft Complete
↓
[Rest Period - days/weeks]
↓
Structural Pass
↓
[Beta Readers - optional]
↓
Scene Pass
↓
Character Pass
↓
Dialogue Pass
↓
Prose Pass
↓
[Critique Partners - optional]
↓
Taste Pass (if taste.md exists)
↓
Polish Pass
↓
[Proofreader - optional]
↓
Done---
Anti-Patterns
The Endless Polisher
Pattern: Revising forever without declaring done. Problem: Perfect is enemy of shipped. Fix: Define pass goals, set limits, accept "good enough."
The Bottom-Up Editor
Pattern: Starting with prose when structure is broken. Problem: Wasted effort on scenes that get cut. Fix: Always work top-down. Structure first.
The Immediate Revisor
Pattern: Revising immediately after drafting. Problem: Too close to see clearly. Fix: Time away creates necessary distance.
The Feedback Slave
Pattern: Implementing every piece of feedback. Problem: Loses authorial vision, creates Frankenstein. Fix: Look for patterns, distinguish preference from problem.
The Solo Perfectionist
Pattern: Trying to catch everything alone. Problem: Author blindness is real. Fix: External readers see what you can't.
The Delete-Phobic
Pattern: Refusing to cut material. Problem: Story drowns in unnecessary weight. Fix: Save cuts, focus on strengthening what remains.
---
Diagnostic Process
When a writer presents revision problems:
1. Identify the Problem Type
- Overwhelmed? → R1 (Start with structural pass)
- Can't see issues? → R2 (Distance and format change)
- Never done? → R3 (Define done, set limits)
- Conflicting feedback? → R4 (Find patterns, distinguish preference)
- Can't cut? → R5 (Darlings folder, focus on remainder)
- Polishing too early? → R6 (Stop, fix structure first)
2. Determine Current Level
- Is structure sound? If not → developmental focus
- Are scenes working? If not → scene-level focus
- Is prose clean? If not → line-level focus
- Are mechanics clean? If not → copy edit focus
3. Recommend Next Pass
Based on where they are in the seven-pass sequence.
4. Address Psychological Blocks
- Fear of cutting → darlings folder
- Perfectionism → define done
- Overwhelm → one pass at a time
- Blindness → external readers
---
Available Tools
revision-audit.ts
Helps track revision pass progress and scene decisions.
deno run --allow-read scripts/revision-audit.ts --scenes manuscript.txt
deno run --allow-read scripts/revision-audit.ts --pass structuralOutputs:
- Scene count and word count per scene
- Scene decision tracking (keep/cut/combine)
- Pass completion checklist
- Progress tracking
---
Integration with story-sense
| story-sense State | Maps to Revision |
|---|---|
| State 6: Draft Complete, Needs Revision | R1-R6 (diagnose which) |
When to Hand Off
- To scene-sequencing: For scene-level structural work
- To character-arc: For character consistency issues
- To dialogue: For dialogue-specific problems
- To prose-style: For sentence-level work (after structure solid)
- To endings: For resolution problems found in structural pass
---
Example Interactions
Example 1: Overwhelmed by Revision
Writer: "I finished my draft but I don't know where to start revising."
Your approach: 1. Identify state: R1 (Overwhelmed) 2. Ask: "Has anyone else read it yet? What do you know about structural issues?" 3. Recommend: Start with structural pass, not prose polish 4. Provide: Seven-pass framework as systematic approach
Example 2: Revision Never Ends
Writer: "I've revised this novel fifteen times and I still see problems."
Your approach: 1. Identify state: R3 (Endless) 2. Ask: "What are you finding on pass fifteen that you weren't finding on pass three?" 3. Check: Real problems or manufactured problems? 4. Recommend: Define done, set pass limit, accept good enough
Example 3: Conflicting Beta Feedback
Writer: "One reader says the pacing is too fast, another says it's too slow."
Your approach: 1. Identify state: R4 (Conflicted) 2. Ask: "Where specifically does each comment apply? Are they talking about the same sections?" 3. Look for: Underlying issue both sensed (maybe pacing is uneven, not uniformly fast or slow) 4. Recommend: Trust patterns, be wary of single-reader preferences
---
Output Persistence
This skill writes primary output to files so work persists across sessions.
Output Discovery
Before doing any other work:
1. Check for context/output-config.md in the project 2. If found, look for this skill's entry 3. If not found or no entry for this skill, ask the user first:
- "Where should I save output from this revision session?"
- Suggest:
explorations/revision/or a sensible location for this project
4. Store the user's preference:
- In
context/output-config.mdif context network exists - In
.revision-output.mdat project root otherwise
Primary Output
For this skill, persist:
- Revision state diagnosis - where they are in the process
- Pass plan - ordered list of revision passes with scope
- Feedback synthesis - patterns from reader feedback
- Definition of done - criteria for completion
Conversation vs. File
| Goes to File | Stays in Conversation |
|---|---|
| Revision state diagnosis | Clarifying questions |
| Pass plan and priorities | Discussion of specific feedback |
| Feedback pattern synthesis | Writer's revision decisions |
| Progress tracking | Real-time support |
File Naming
Pattern: {story}-revision-{date}.md Example: novel-revision-2025-01-15.md
What You Do NOT Do
- You do not revise manuscripts for writers
- You do not make structural decisions for them
- You do not resolve all feedback contradictions (some are preference)
- You do not encourage endless revision
Your role is diagnostic: identify where they are in the revision process, what's blocking them, and what the next step should be. They do the revising.
---
Key Insight
Revision is not "fixing the draft." It's building the final manuscript. The draft was exploration; revision is construction.
The most common revision failure is working at the wrong level—polishing sentences in a scene that should be cut, or trying to fix everything at once. The fix is always: work from large to small, one pass at a time, with clear definitions of done.
Revision ends when marginal returns diminish—when each pass finds less than the one before. At some point, the manuscript is done. Ship it.
#!/usr/bin/env -S deno run --allow-read
/**
* revision-audit.ts - Track revision pass progress and scene decisions
*
* Helps with:
* - Scene count and word count per scene
* - Scene decision tracking (keep/cut/combine)
* - Pass completion checklist
* - Progress summary
*
* Usage:
* deno run --allow-read revision-audit.ts --scenes manuscript.txt
* deno run --allow-read revision-audit.ts --pass structural
* deno run --allow-read revision-audit.ts --checklist
*/
interface SceneInfo {
number: number;
wordCount: number;
preview: string;
decision?: 'keep' | 'cut' | 'combine' | 'revise' | 'pending';
}
interface PassChecklist {
name: string;
items: { question: string; checked: boolean }[];
}
const PASS_CHECKLISTS: Record<string, PassChecklist> = {
structural: {
name: 'Structural Pass',
items: [
{ question: 'Does the story have a clear dramatic question?', checked: false },
{ question: 'Is the protagonist\'s goal clear from the start?', checked: false },
{ question: 'Does the protagonist drive the resolution?', checked: false },
{ question: 'Does each scene advance plot or character?', checked: false },
{ question: 'Are there plot holes or logic failures?', checked: false },
{ question: 'Is pacing appropriate (not too slow, not too rushed)?', checked: false },
{ question: 'Does tension escalate toward climax?', checked: false },
{ question: 'Is the climax the highest tension point?', checked: false },
{ question: 'Does the ending satisfy and emerge from the story?', checked: false },
{ question: 'Do all major character arcs complete?', checked: false },
],
},
scene: {
name: 'Scene Pass',
items: [
{ question: 'Does each scene have a clear POV character goal?', checked: false },
{ question: 'Does each scene have conflict preventing the goal?', checked: false },
{ question: 'Does each scene end with disaster or outcome?', checked: false },
{ question: 'Do scenes start late enough (no excessive setup)?', checked: false },
{ question: 'Do scenes end early enough (no wrap-up drag)?', checked: false },
{ question: 'Are scene-sequel rhythms creating good pacing?', checked: false },
{ question: 'Could any scenes be cut without loss?', checked: false },
{ question: 'Could any scenes be combined for efficiency?', checked: false },
{ question: 'Are transitions between scenes clear?', checked: false },
],
},
character: {
name: 'Character Pass',
items: [
{ question: 'Does protagonist have clear lie/false belief at start?', checked: false },
{ question: 'Does protagonist learn truth by end?', checked: false },
{ question: 'Are key transformation moments visible?', checked: false },
{ question: 'Does each major character have consistent voice?', checked: false },
{ question: 'Are character motivations clear for major actions?', checked: false },
{ question: 'Is motivation consistent with established character?', checked: false },
{ question: 'Can you identify who\'s speaking without tags?', checked: false },
{ question: 'Is character arc progress visible in choices/behavior?', checked: false },
],
},
dialogue: {
name: 'Dialogue Pass',
items: [
{ question: 'Does dialogue have subtext (meaning beneath surface)?', checked: false },
{ question: 'Do characters avoid saying exactly what they mean?', checked: false },
{ question: 'Is there tension between speakers?', checked: false },
{ question: 'Does each exchange advance plot, reveal character, or build dynamics?', checked: false },
{ question: 'Does each character sound distinct?', checked: false },
{ question: 'Are speech patterns consistent per character?', checked: false },
{ question: 'Is dialogue free of exposition dumps?', checked: false },
{ question: 'Are dialogue tags unobtrusive?', checked: false },
],
},
prose: {
name: 'Prose Pass',
items: [
{ question: 'Is passive voice used intentionally, not by default?', checked: false },
{ question: 'Are weak verbs (is, was, had, got) minimized?', checked: false },
{ question: 'Are filter words (saw, felt, noticed) minimized?', checked: false },
{ question: 'Are adverbs used sparingly?', checked: false },
{ question: 'Are pronoun references clear?', checked: false },
{ question: 'Do paragraphs vary in length?', checked: false },
{ question: 'Do sentences vary in length and structure?', checked: false },
{ question: 'Is description integrated with action?', checked: false },
{ question: 'Are specific details used rather than generic?', checked: false },
{ question: 'Does prose read well aloud?', checked: false },
],
},
polish: {
name: 'Polish Pass',
items: [
{ question: 'Is spelling correct (especially names)?', checked: false },
{ question: 'Is grammar correct throughout?', checked: false },
{ question: 'Is punctuation consistent and correct?', checked: false },
{ question: 'Is formatting consistent (chapters, breaks)?', checked: false },
{ question: 'Are character name spellings consistent?', checked: false },
{ question: 'Are place name spellings consistent?', checked: false },
{ question: 'Is timeline internally consistent?', checked: false },
{ question: 'Are physical descriptions consistent?', checked: false },
{ question: 'Have you done a final read-aloud?', checked: false },
],
},
};
// Scene break patterns (common markers)
const SCENE_BREAK_PATTERNS = [
/^#{1,3}\s+/m, // Markdown headers
/^\*{3,}$/m, // *** scene breaks
/^-{3,}$/m, // --- scene breaks
/^~{3,}$/m, // ~~~ scene breaks
/^\s*\*\s*\*\s*\*\s*$/m, // * * * scene breaks
/^Chapter\s+\d+/im, // Chapter markers
/^CHAPTER\s+/m, // CHAPTER markers
/^\[Scene\s+\d+\]/im, // [Scene n] markers
];
function splitIntoScenes(text: string): string[] {
// Try each pattern
for (const pattern of SCENE_BREAK_PATTERNS) {
if (pattern.test(text)) {
const scenes = text.split(pattern).filter(s => s.trim().length > 0);
if (scenes.length > 1) {
return scenes;
}
}
}
// Fallback: split by double newlines if very long
const paragraphs = text.split(/\n\s*\n/).filter(p => p.trim().length > 0);
if (paragraphs.length > 20) {
// Group into approximate scenes of 5-10 paragraphs
const scenes: string[] = [];
const groupSize = 7;
for (let i = 0; i < paragraphs.length; i += groupSize) {
scenes.push(paragraphs.slice(i, i + groupSize).join('\n\n'));
}
return scenes;
}
// Otherwise treat whole text as one scene
return [text];
}
function countWords(text: string): number {
return text.split(/\s+/).filter(w => w.length > 0).length;
}
function analyzeScenes(text: string): SceneInfo[] {
const scenes = splitIntoScenes(text);
return scenes.map((scene, i) => {
const words = countWords(scene);
const preview = scene.trim().slice(0, 100).replace(/\n/g, ' ') + (scene.length > 100 ? '...' : '');
return {
number: i + 1,
wordCount: words,
preview,
decision: 'pending' as const,
};
});
}
function formatSceneReport(scenes: SceneInfo[]): string {
const totalWords = scenes.reduce((sum, s) => sum + s.wordCount, 0);
const avgWords = scenes.length > 0 ? totalWords / scenes.length : 0;
let report = `
SCENE AUDIT
===========
Summary:
Total scenes: ${scenes.length}
Total words: ${totalWords.toLocaleString()}
Average scene length: ${Math.round(avgWords).toLocaleString()} words
Scenes:
`;
for (const scene of scenes) {
report += `
Scene ${scene.number}: ${scene.wordCount.toLocaleString()} words
"${scene.preview}"
Decision: ${scene.decision}
`;
}
report += `
SCENE DECISION GUIDE
--------------------
For each scene, ask:
1. What is the POV character's goal?
2. What conflict prevents it?
3. What is the disaster/outcome?
4. Does this advance plot or character?
5. Could the story survive without it?
Decisions:
KEEP - Scene is essential, working well
CUT - Scene adds nothing essential
COMBINE - Merge with another scene
REVISE - Scene needed but not working
Mark your decisions and re-run to track progress.
`;
return report;
}
function formatPassChecklist(pass: string): string {
const checklist = PASS_CHECKLISTS[pass.toLowerCase()];
if (!checklist) {
return `Unknown pass: ${pass}\n\nAvailable passes: ${Object.keys(PASS_CHECKLISTS).join(', ')}`;
}
let report = `
${checklist.name.toUpperCase()} CHECKLIST
${'='.repeat(checklist.name.length + 10)}
`;
for (let i = 0; i < checklist.items.length; i++) {
const item = checklist.items[i];
report += ` ${i + 1}. [ ] ${item.question}\n`;
}
report += `
Instructions:
- Print this checklist
- Work through your manuscript with these questions
- Check off each item when addressed
- Don't proceed to next pass until all items checked
`;
return report;
}
function formatFullChecklist(): string {
let report = `
FULL REVISION CHECKLIST
=======================
Work through these passes in order. Complete each before moving to the next.
`;
const passOrder = ['structural', 'scene', 'character', 'dialogue', 'prose', 'polish'];
for (const pass of passOrder) {
const checklist = PASS_CHECKLISTS[pass];
report += `
## ${checklist.name}
`;
for (let i = 0; i < checklist.items.length; i++) {
report += ` [ ] ${checklist.items[i].question}\n`;
}
}
report += `
REVISION PRINCIPLES
-------------------
- Work from large to small (structure before prose)
- Complete one pass before starting the next
- Don't polish prose in scenes you might cut
- Take time away between passes when possible
- Get external feedback after structural and prose passes
`;
return report;
}
function showUsage(): void {
console.log(`
Usage:
deno run --allow-read revision-audit.ts --scenes <file>
Analyze scenes in manuscript file
deno run --allow-read revision-audit.ts --pass <passname>
Show checklist for a specific pass
Passes: structural, scene, character, dialogue, prose, polish
deno run --allow-read revision-audit.ts --checklist
Show full revision checklist (all passes)
Examples:
deno run --allow-read revision-audit.ts --scenes manuscript.txt
deno run --allow-read revision-audit.ts --pass structural
deno run --allow-read revision-audit.ts --checklist
`);
}
async function main() {
const args = Deno.args;
if (args.includes('--scenes')) {
const fileIndex = args.indexOf('--scenes') + 1;
if (fileIndex >= args.length) {
console.error('Error: --scenes requires a filename');
Deno.exit(1);
}
const filename = args[fileIndex];
try {
const text = await Deno.readTextFile(filename);
const scenes = analyzeScenes(text);
console.log(formatSceneReport(scenes));
} catch (e) {
console.error(`Error reading file: ${filename}`);
console.error(e);
Deno.exit(1);
}
} else if (args.includes('--pass')) {
const passIndex = args.indexOf('--pass') + 1;
if (passIndex >= args.length) {
console.error('Error: --pass requires a pass name');
console.error('Available: structural, scene, character, dialogue, prose, polish');
Deno.exit(1);
}
const pass = args[passIndex];
console.log(formatPassChecklist(pass));
} else if (args.includes('--checklist')) {
console.log(formatFullChecklist());
} else {
showUsage();
}
}
main();