@ai-dev-methodologies/rlp-desk 0.9.0 → 0.9.1

package/docs/superpowers/specs/2026-04-12-flywheel-redesign.md

@@ -0,0 +1,161 @@
+# Flywheel Redesign Spec
+
+## Problem
+
+rlp-desk's current loop is: Worker → Verify → FAIL → fix contract → Worker (same approach).
+When the approach itself is wrong, retrying with fixes wastes iterations.
+The loop needs a direction review step that challenges premises and forces alternatives before the next Worker runs.
+
+## Design
+
+### Loop Structure
+
+```
+First iteration (no flywheel):
+  Worker → Verify → PASS → next US
+
+On FAIL (--flywheel on-fail):
+  Verify FAIL
+    → Flywheel Agent (fresh context, opus)
+      Step 0A: Premise Challenge
+      Step 0B: Existing Code Leverage
+      Step 0C: Ideal State Mapping
+      Step 0D: Implementation Alternatives (min 2)
+      Step 0E: Scope Decision (HOLD/PIVOT/REDUCE/EXPAND)
+      Step 0F: Contract Rewrite + Rejected Directions
+    → Worker (reads updated contract) → Verify
+```
+
+Flywheel runs BEFORE Worker. It decides direction, Worker executes.
+
+### Execution Modes
+
+tmux mode (3 panes):
+```
+┌──────────────┬──────────────┬──────────────┐
+│ Flywheel     │ Worker       │ Verifier     │
+│ claude opus  │ claude/codex │ claude/codex │
+│ direction    │ implements   │ verifies     │
+└──────────────┴──────────────┴──────────────┘
+```
+- Leader dispatches to flywheel pane, polls flywheel-signal.json
+- After signal received, dispatches Worker with updated contract
+
+agent mode:
+- Leader calls Agent() with flywheel prompt → fresh context automatic
+- Agent() returns decision directly (no file signal needed)
+- Leader updates memory, then dispatches Worker agent
+
+### CLI Flags
+
+```
+--flywheel off|on-fail       (default: off)
+--flywheel-model MODEL       (default: opus)
+```
+
+### 4 Scope Decisions
+
+| Decision | When | Action |
+|----------|------|--------|
+| HOLD | Premises valid, approach correct | Refine contract with specific fixes |
+| PIVOT | Premise broken, approach wrong | Switch to alternative, record rejected direction |
+| REDUCE | US too complex for current scope | Split AC or simplify, defer remainder |
+| EXPAND | Missing prerequisite discovered | Add AC or expand contract |
+
+### Flywheel Prompt Template (plan-ceo-review core internalized)
+
+6-step review process:
+
+**0A. Premise Challenge**
+List every assumption in the current approach. For each, state whether this iteration's evidence supports or contradicts it. Broken premise → PIVOT or REDUCE.
+
+**0B. Existing Code Leverage**
+Check if Worker missed reusable code. Check if a different approach fits existing patterns better.
+
+**0C. Ideal State Mapping**
+Describe the ideal completion of this US in 2-3 sentences. How far is the current approach from ideal?
+
+**0D. Implementation Alternatives (MANDATORY)**
+Minimum 2 alternatives. Each: summary, effort (S/M/L), risk, tradeoff vs current approach.
+
+**0E. Scope Decision**
+Choose HOLD/PIVOT/REDUCE/EXPAND. Justify with evidence from this iteration only.
+
+**0F. Contract Rewrite**
+Rewrite Next Iteration Contract in campaign memory.
+Record decision in Key Decisions.
+Record failed approaches in Rejected Directions (prevents future Workers from repeating).
+
+**CEO Cognitive Patterns (embedded in prompt):**
+1. First-principles — ignore convention, start from the problem
+2. 10x check — can 2x effort yield 10x better result?
+3. Inversion — what must be true for this approach to fail?
+4. Simplicity bias — prefer simple over complex solutions
+5. User-back — reason backwards from end-user experience
+6. Time-value — does this pivot save 3+ iterations?
+7. Sunk cost immunity — ignore prior investment
+8. Blast radius — assess impact scope of direction change
+9. Reversibility — prefer easily reversible decisions
+10. Evidence > opinion — judge only by this iteration's actual results
+
+### Signal Protocol
+
+flywheel-signal.json:
+```json
+{
+  "iteration": N,
+  "decision": "hold|pivot|reduce|expand",
+  "summary": "one line explanation",
+  "rejected_directions": ["approach X because Y"],
+  "contract_updated": true,
+  "timestamp": "ISO"
+}
+```
+
+### Campaign Memory Updates
+
+Flywheel agent writes directly to campaign memory:
+- **Next Iteration Contract**: rewritten based on decision
+- **Key Decisions**: flywheel decision + reasoning appended
+- **Rejected Directions**: new section, append-only (Worker reads to avoid repeating)
+
+### Files Changed
+
+| File | Change |
+|------|--------|
+| src/scripts/init_ralph_desk.zsh | Flywheel prompt template, 3rd pane setup, --flywheel flags in presets |
+| src/node/runner/campaign-main-loop.mjs | Flywheel dispatch (tmux + agent), shouldRunFlywheel(), pane management |
+| src/node/run.mjs | --flywheel, --flywheel-model flag parsing |
+| src/commands/rlp-desk.md | Flywheel documentation, options reference |
+| src/governance.md | Flywheel step in Leader loop protocol |
+| src/scripts/run_ralph_desk.zsh | 3rd pane creation for tmux mode |
+
+### What Stays (from current branch)
+
+- SV Report generation (generateSVReport in campaign-reporting.mjs)
+- Brainstorm step 0 SV feedback (rlp-desk.md)
+- analyticsDir in buildPaths
+
+### What Gets Removed (from current branch)
+
+- Current pivot implementation (shouldRunPivot, dispatchPivot, buildPivotTriggerCmd)
+- Current pivot prompt template in init_ralph_desk.zsh
+- Current --pivot-mode, --pivot-model flags
+- test-pivot-step.mjs
+
+## Verification
+
+### TDD Tests
+- shouldRunFlywheel logic (off/on-fail conditions)
+- Flywheel prompt contains all 6 steps + 10 cognitive patterns
+- Signal protocol parsing
+- Rejected directions persistence across iterations
+- 3-pane creation in tmux mode
+
+### Self-Verification (3 scenarios)
+- LOW: --flywheel off → normal loop unchanged
+- MEDIUM: --flywheel on-fail + FAIL → flywheel fires → memory updated → Worker reflects
+- CRITICAL: PIVOT decision → rejected direction recorded → next Worker avoids it
+
+### E2E
+- Test project with intentional FAIL → flywheel activates → direction change → success

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-dev-methodologies/rlp-desk",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Fresh-context iterative loops for Claude Code — autonomous task completion with independent verification",
   "scripts": {
     "postinstall": "node scripts/postinstall.js",

package/src/commands/rlp-desk.md

@@ -112,7 +112,17 @@ Ask about these items one by one (or in small groups):
 
 After all items are confirmed:
 
-0. **SV Report Feedback** — If a prior campaign's self-verification report exists for this project (`~/.claude/ralph-desk/analytics/*/self-verification-report-*.md`), reference it to inform this brainstorm: which US types failed most, which model tiers underperformed, which AC patterns caused issues. Present relevant findings to the user. (governance §8½)
+0. **SV Report Feedback** — If a prior campaign's self-verification report exists:
+   a. Scan `~/.claude/ralph-desk/analytics/` for directories matching this project (by slug or project root)
+   b. Read the latest `self-verification-report.md` from each matching directory
+   c. Extract from §7 (Patterns) and §8 (Recommendations):
+      - Which US types/sizes failed most frequently
+      - Which AC quality dimensions scored lowest
+      - Which model tiers underperformed for this project's complexity
+      - Specific brainstorm/PRD/test-spec recommendations from prior campaigns
+   d. Present findings to user: "Prior campaign analysis found: [patterns]. Recommendations: [suggestions]."
+   e. If no prior reports exist, skip and note "No prior campaign data available."
+   (governance §8½)
 1. **Ambiguity Gate (IL-2)** — score each AC per governance §1a IL-2 (6 dimensions, 0-12 points).
    If ANY AC scores below 6: **REJECT** — refine that AC before proceeding.
    If all ACs score 6-9: **WARN** — proceed with logged warning, show low-scoring dimensions.
@@ -180,6 +190,8 @@ Tell the user:
    #   --iter-timeout N                       tmux only (default: 600)
    #   --debug                                debug logging
    #   --with-self-verification               post-campaign SV report
+   #   --flywheel off|on-fail                 direction review on fail (default: off)
+   #   --flywheel-model MODEL                 flywheel reviewer model (default: opus)
    ```
 
    **If codex is NOT installed** — show claude-only presets + install recommendation:
@@ -208,6 +220,8 @@ Tell the user:
    #   --iter-timeout N                       tmux only (default: 600)
    #   --debug                                debug logging
    #   --with-self-verification               post-campaign SV report
+   #   --flywheel off|on-fail                 direction review on fail (default: off)
+   #   --flywheel-model MODEL                 flywheel reviewer model (default: opus)
    ```
 
    Replace `<actual-slug>` with the real slug from this init (e.g. `auth-refactor`).

package/src/node/reporting/campaign-reporting.mjs

@@ -226,6 +226,370 @@ export async function generateCampaignReport({
   await fs.writeFile(reportFile, `${lines.join('\n')}\n`, 'utf8');
 }
 
+function svReportVersionPath(targetPath, version) {
+  return targetPath.replace(/\.md$/u, `-v${version}.md`);
+}
+
+async function collectIterFiles(logsDir, pattern) {
+  const entries = await fs.readdir(logsDir, { withFileTypes: true }).catch(() => []);
+  return entries
+    .filter((entry) => entry.isFile() && pattern.test(entry.name))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function computeWorkerQuality(doneClaims) {
+  if (doneClaims.length === 0) {
+    return { planPercent: 0, tddPercent: 0, redConfirmPercent: 0, total: 0 };
+  }
+
+  let withPlan = 0;
+  let withTdd = 0;
+  let withRedConfirm = 0;
+
+  for (const claim of doneClaims) {
+    const steps = claim.execution_steps ?? [];
+    const stepNames = steps.map((s) => s.step);
+
+    if (stepNames.includes('plan')) {
+      withPlan += 1;
+    }
+
+    const writeIdx = stepNames.indexOf('write_test');
+    const implIdx = stepNames.indexOf('implement');
+    if (writeIdx !== -1 && implIdx !== -1 && writeIdx < implIdx) {
+      withTdd += 1;
+    }
+
+    const redStep = steps.find((s) => s.step === 'verify_red');
+    if (redStep && redStep.exit_code === 1) {
+      withRedConfirm += 1;
+    }
+  }
+
+  const pct = (n) => Math.round((n / doneClaims.length) * 100);
+
+  return {
+    planPercent: pct(withPlan),
+    tddPercent: pct(withTdd),
+    redConfirmPercent: pct(withRedConfirm),
+    total: doneClaims.length,
+  };
+}
+
+function computeVerifierQuality(verdicts) {
+  if (verdicts.length === 0) {
+    return { reasoningPercent: 0, independentPercent: 0, total: 0 };
+  }
+
+  const REQUIRED_CATEGORIES = ['il1_compliance', 'layer_enforcement', 'test_sufficiency', 'anti_gaming', 'worker_process_audit'];
+  let withComplete = 0;
+  let withIndependent = 0;
+
+  for (const v of verdicts) {
+    const reasoning = v.reasoning ?? {};
+    const present = REQUIRED_CATEGORIES.filter((cat) => reasoning[cat]);
+    if (present.length === REQUIRED_CATEGORIES.length) {
+      withComplete += 1;
+    }
+    if (present.length > 0) {
+      withIndependent += 1;
+    }
+  }
+
+  const pct = (n) => Math.round((n / verdicts.length) * 100);
+
+  return {
+    reasoningPercent: pct(withComplete),
+    independentPercent: pct(withIndependent),
+    total: verdicts.length,
+  };
+}
+
+function buildAcLifecycle(doneClaims, verdicts) {
+  const lifecycle = {};
+
+  for (const claim of doneClaims) {
+    const usId = claim.us_id ?? 'unknown';
+    const iter = claim.iteration ?? 0;
+    if (!lifecycle[usId]) {
+      lifecycle[usId] = { firstClaimed: iter, firstVerified: null, reopenCount: 0, finalStatus: 'pending' };
+    }
+    if (iter < lifecycle[usId].firstClaimed) {
+      lifecycle[usId].firstClaimed = iter;
+    }
+  }
+
+  for (const v of verdicts) {
+    const usId = v.us_id ?? 'unknown';
+    const iter = v.iteration ?? 0;
+    if (!lifecycle[usId]) {
+      lifecycle[usId] = { firstClaimed: iter, firstVerified: null, reopenCount: 0, finalStatus: 'pending' };
+    }
+    if (v.verdict === 'pass' && lifecycle[usId].firstVerified === null) {
+      lifecycle[usId].firstVerified = iter;
+      lifecycle[usId].finalStatus = 'verified';
+    } else if (v.verdict === 'fail' && lifecycle[usId].firstVerified !== null) {
+      lifecycle[usId].reopenCount += 1;
+      lifecycle[usId].finalStatus = 'pending';
+    }
+  }
+
+  return lifecycle;
+}
+
+function extractPatterns(doneClaims, verdicts) {
+  const strengths = [];
+  const weaknesses = [];
+  const passCount = verdicts.filter((v) => v.verdict === 'pass').length;
+  const failCount = verdicts.filter((v) => v.verdict === 'fail').length;
+
+  if (passCount > 0 && failCount === 0) {
+    strengths.push('All iterations passed on first attempt.');
+  } else if (passCount > failCount) {
+    strengths.push(`${passCount} of ${verdicts.length} iterations passed.`);
+  }
+
+  if (failCount > 0) {
+    weaknesses.push(`${failCount} of ${verdicts.length} iterations failed verification.`);
+  }
+
+  const wq = computeWorkerQuality(doneClaims);
+  if (wq.tddPercent === 100 && wq.total > 0) {
+    strengths.push('TDD compliance at 100%.');
+  } else if (wq.tddPercent < 80 && wq.total > 0) {
+    weaknesses.push(`TDD compliance at ${wq.tddPercent}% — below 80% threshold.`);
+  }
+
+  if (strengths.length === 0) {
+    strengths.push('No notable strengths detected from available data.');
+  }
+  if (weaknesses.length === 0) {
+    weaknesses.push('No notable weaknesses detected from available data.');
+  }
+
+  return { strengths, weaknesses };
+}
+
+function buildRecommendations(doneClaims, verdicts, analytics) {
+  const recs = { brainstorm: [], prd: [], testSpec: [] };
+  const wq = computeWorkerQuality(doneClaims);
+
+  if (wq.tddPercent < 80 && wq.total > 0) {
+    recs.brainstorm.push('Recommend stricter TDD enforcement in worker prompts.');
+  }
+
+  const usFailCounts = {};
+  for (const v of verdicts) {
+    if (v.verdict === 'fail') {
+      usFailCounts[v.us_id] = (usFailCounts[v.us_id] ?? 0) + 1;
+    }
+  }
+  for (const [usId, count] of Object.entries(usFailCounts)) {
+    if (count >= 2) {
+      recs.prd.push(`${usId} failed ${count} times — consider splitting into smaller ACs.`);
+    }
+  }
+
+  const models = new Set(analytics.map((r) => r.worker_model));
+  if (models.size > 1) {
+    recs.testSpec.push(`Model upgrade occurred (${[...models].join(' -> ')}). Note which model handled what.`);
+  }
+
+  if (recs.brainstorm.length === 0) {
+    recs.brainstorm.push('No brainstorm recommendations.');
+  }
+  if (recs.prd.length === 0) {
+    recs.prd.push('No PRD recommendations.');
+  }
+  if (recs.testSpec.length === 0) {
+    recs.testSpec.push('No test-spec recommendations.');
+  }
+
+  return recs;
+}
+
+export async function generateSVReport({
+  slug,
+  logsDir,
+  prdFile: _prdFile,
+  testSpecFile,
+  analyticsFile,
+  outputDir,
+}) {
+  void _prdFile; // reserved for future use (PRD pattern extraction)
+  await fs.mkdir(outputDir, { recursive: true });
+
+  // Collect iteration files
+  const claimFiles = await collectIterFiles(logsDir, /^iter-\d+-done-claim\.json$/u);
+  const verdictFiles = await collectIterFiles(logsDir, /^iter-\d+-verify-verdict\.json$/u);
+
+  const doneClaims = [];
+  for (const file of claimFiles) {
+    const data = await readJsonIfExists(path.join(logsDir, file));
+    if (data) {
+      doneClaims.push(data);
+    }
+  }
+
+  const verdicts = [];
+  for (const file of verdictFiles) {
+    const data = await readJsonIfExists(path.join(logsDir, file));
+    if (data) {
+      verdicts.push(data);
+    }
+  }
+
+  const analytics = await readAnalytics(analyticsFile);
+
+  // Compute metrics
+  const workerQuality = computeWorkerQuality(doneClaims);
+  const verifierQuality = computeVerifierQuality(verdicts);
+  const acLifecycle = buildAcLifecycle(doneClaims, verdicts);
+  const patterns = extractPatterns(doneClaims, verdicts);
+  const recommendations = buildRecommendations(doneClaims, verdicts, analytics);
+
+  // Read test-spec for context
+  const testSpecContent = await fs.readFile(testSpecFile, 'utf8').catch(() => '');
+  const totalIterations = doneClaims.length;
+  const dataQuality = totalIterations > 0 ? 100 : 0;
+
+  // Section 1: Automated Validation Summary
+  const validationRows = analytics.length > 0
+    ? analytics.map((r) => `| ${r.iter} | ${r.us_id} | ${r.verdict} | ${r.worker_model} | ${r.duration}s |`)
+    : ['| - | - | - | - | - |'];
+
+  // Section 2: Failure Deep Dive
+  const failedVerdicts = verdicts.filter((v) => v.verdict === 'fail');
+  const failureLines = failedVerdicts.length > 0
+    ? failedVerdicts.map((v) => {
+      const issues = (v.issues ?? []).map((i) => `  - ${i.criterion_id ?? 'unknown'} [${i.severity ?? 'major'}]: ${i.summary ?? 'unspecified'}`).join('\n');
+      return `### Iteration ${v.iteration ?? '?'} — ${v.us_id ?? 'unknown'}\n${issues || '  - No structured issues.'}`;
+    })
+    : ['No failed iterations.'];
+
+  // Section 3: Worker Process Quality
+  const wqLines = totalIterations > 0
+    ? [
+      `- Total iterations analyzed: ${workerQuality.total}`,
+      `- Planning step: ${workerQuality.planPercent}%`,
+      `- TDD compliance: ${workerQuality.tddPercent}%`,
+      `- RED confirmation: ${workerQuality.redConfirmPercent}%`,
+    ]
+    : ['- No iteration data available.'];
+
+  // Section 4: Verifier Judgment Quality
+  const vqLines = verdicts.length > 0
+    ? [
+      `- Total verdicts analyzed: ${verifierQuality.total}`,
+      `- Reasoning completeness: ${verifierQuality.reasoningPercent}%`,
+      `- Independent verification: ${verifierQuality.independentPercent}%`,
+    ]
+    : ['- No verdict data available.'];
+
+  // Section 5: AC Lifecycle
+  const lifecycleEntries = Object.entries(acLifecycle);
+  const acLines = lifecycleEntries.length > 0
+    ? lifecycleEntries.map(([usId, lc]) =>
+      `| ${usId} | ${lc.firstClaimed} | ${lc.firstVerified ?? '-'} | ${lc.reopenCount} | ${lc.finalStatus} |`)
+    : ['| - | - | - | - | - |'];
+
+  // Section 6: Test-Spec Adherence
+  const specLines = testSpecContent
+    ? [`Test spec present (${testSpecContent.split('\n').length} lines).`]
+    : ['No test spec found.'];
+
+  // Section 9: Cost & Performance
+  const costLines = analytics.length > 0
+    ? [
+      `- Iteration records: ${analytics.length}`,
+      `- Total duration: ${analytics.reduce((sum, r) => sum + Number(r.duration ?? 0), 0)}s`,
+    ]
+    : ['- No cost data available.'];
+
+  // Build report
+  const now = new Date().toISOString();
+  const lines = [
+    `# Campaign Self-Verification Report: ${slug}`,
+    `Report Version: 1 | Generated: ${now} | Campaign: ${slug}`,
+    `Data Quality: ${dataQuality}% iterations complete`,
+    '',
+    '## 1. Automated Validation Summary',
+    '| Iter | US | Verdict | Model | Duration |',
+    '|------|-----|---------|-------|----------|',
+    ...validationRows,
+    '',
+    '## 2. Failure Deep Dive',
+    ...failureLines,
+    '',
+    '## 3. Worker Process Quality',
+    ...wqLines,
+    '',
+    '## 4. Verifier Judgment Quality',
+    ...vqLines,
+    '',
+    '## 5. AC Lifecycle',
+    '| US | First Claimed | First Verified | Reopen Count | Final Status |',
+    '|-----|--------------|----------------|--------------|--------------|',
+    ...acLines,
+    '',
+    '## 6. Test-Spec Adherence',
+    ...specLines,
+    '',
+    '## 7. Patterns: Strengths & Weaknesses',
+    '### Strengths',
+    ...patterns.strengths.map((s) => `- ${s}`),
+    '### Weaknesses',
+    ...patterns.weaknesses.map((w) => `- ${w}`),
+    '',
+    '## 8. Recommendations for Next Cycle',
+    '### Brainstorm',
+    ...recommendations.brainstorm.map((r) => `- ${r}`),
+    '### PRD',
+    ...recommendations.prd.map((r) => `- ${r}`),
+    '### Test-Spec',
+    ...recommendations.testSpec.map((r) => `- ${r}`),
+    '',
+    '## 9. Cost & Performance',
+    ...costLines,
+    '',
+    '## 10. Blind Spots',
+    '- Token counts are not available in tmux mode (estimated from file sizes).',
+    '- Source code inspection findings are excluded unless marked [source-inspection].',
+    '- Worker internal reasoning beyond execution_steps is not captured.',
+    '',
+  ];
+
+  // Version existing report
+  const reportPath = path.join(outputDir, 'self-verification-report.md');
+  const versionedPath = await versionFile(reportPath, svReportVersionPath);
+  const version = versionedPath ? Number(versionedPath.match(/-v(\d+)\.md$/)?.[1] ?? 0) + 1 : 1;
+
+  await fs.writeFile(reportPath, `${lines.join('\n')}\n`, 'utf8');
+
+  // Write structured data
+  const dataPath = path.join(outputDir, 'self-verification-data.json');
+  await fs.writeFile(dataPath, `${JSON.stringify({
+    slug,
+    generated: now,
+    worker_quality: workerQuality,
+    verifier_quality: verifierQuality,
+    ac_lifecycle: acLifecycle,
+    patterns,
+    recommendations,
+    analytics_count: analytics.length,
+  }, null, 2)}\n`, 'utf8');
+
+  // Build summary for campaign report
+  const passCount = verdicts.filter((v) => v.verdict === 'pass').length;
+  const failCount = verdicts.filter((v) => v.verdict === 'fail').length;
+  const summary = totalIterations > 0
+    ? `SV report: ${totalIterations} iterations analyzed. TDD compliance: ${workerQuality.tddPercent}%. Pass/Fail: ${passCount}/${failCount}. Report: ${reportPath}`
+    : `SV report generated with no iteration data. Report: ${reportPath}`;
+
+  return { reportPath, version, summary };
+}
+
 export async function readStatus(slug, options = {}) {
   const rootDir = path.resolve(options.rootDir ?? process.cwd());
   const statusFile = path.join(rootDir, '.claude', 'ralph-desk', 'logs', slug, 'runtime', 'status.json');

package/src/node/run.mjs

@@ -21,6 +21,8 @@ const RUN_DEFAULTS = {
   lockWorkerModel: false,
   autonomous: false,
   withSelfVerification: false,
+  flywheel: 'off',
+  flywheelModel: 'opus',
 };
 
 function write(stream, value) {
@@ -57,6 +59,8 @@ function buildHelpText() {
     '  --debug',
     '  --autonomous',
     '  --with-self-verification',
+    '  --flywheel off|on-fail',
+    '  --flywheel-model MODEL',
     '  --help',
   ].join('\n');
 }
@@ -142,6 +146,14 @@ function parseRunOptions(args, cwd) {
       case '--with-self-verification':
         options.withSelfVerification = true;
         break;
+      case '--flywheel':
+        options.flywheel = consumeValue(args, index, token);
+        index += 1;
+        break;
+      case '--flywheel-model':
+        options.flywheelModel = consumeValue(args, index, token);
+        index += 1;
+        break;
       default:
         throw new Error(`unknown option: ${token}`);
     }