framein 0.0.4 → 0.0.5

package/dist/disagree.js

@@ -1,85 +1,106 @@
-// Disagreement Protocol (F-LOOP-5, ADR-0008): bound model-vs-model debate so it converges instead
-// of looping. A proposal is met with at most `maxRounds` blocking challenges; the reviewer returns
-// CLAIMS + a required change (never edits — the lead keeps control); no agreement after the cap
-// escalates to the human with exactly two options. Pure state machine; the model-authored content
-// of each turn is the deferred live path.
-import { PLAIN } from './ui/theme.js';
-export const MAX_ROUNDS = 2;
-export function newDebate(topic, proposal, maxRounds = MAX_ROUNDS) {
-    return { topic, entries: [{ kind: 'proposal', proposal }], maxRounds };
-}
-export function challengeCount(d) {
-    return d.entries.filter((e) => e.kind === 'challenge').length;
-}
-function leadPosition(d) {
-    for (let i = d.entries.length - 1; i >= 0; i--) {
-        const e = d.entries[i];
-        if (e.kind === 'revision')
-            return e.revision.text || d.topic;
-        if (e.kind === 'proposal')
-            return e.proposal.text;
-    }
-    return d.topic;
-}
-function reviewerRequirement(d) {
-    for (let i = d.entries.length - 1; i >= 0; i--) {
-        const e = d.entries[i];
-        if (e.kind === 'challenge' && e.challenge.verdict === 'challenge')
-            return e.challenge.requiredChange ?? e.challenge.claim;
-    }
-    return undefined;
-}
-export function debateStatus(d) {
-    const last = d.entries[d.entries.length - 1];
-    const rounds = challengeCount(d);
-    const escalate = () => ({
-        state: 'escalate',
-        reason: `no agreement after ${rounds} round${rounds === 1 ? '' : 's'} (max ${d.maxRounds})`,
-        options: [`A: ${leadPosition(d)}`, `B: ${reviewerRequirement(d) ?? 'reviewer change'}`],
-    });
-    if (!last || last.kind === 'proposal')
-        return { state: 'awaiting-challenge' };
-    if (last.kind === 'challenge') {
-        if (last.challenge.verdict === 'accept')
-            return { state: 'resolved', how: 'accepted-by-reviewer' };
-        if (rounds >= d.maxRounds)
-            return escalate();
-        return { state: 'awaiting-revision', required: last.challenge.requiredChange };
-    }
-    // last is a revision
-    if (last.revision.accepted)
-        return { state: 'resolved', how: 'lead-accepted' };
-    if (rounds >= d.maxRounds)
-        return escalate();
-    return { state: 'awaiting-challenge' };
-}
-export function renderDebate(d, ui = PLAIN) {
-    const lines = [`Debate: ${d.topic}`, ''];
-    for (const e of d.entries) {
-        if (e.kind === 'proposal')
-            lines.push(`proposal${e.proposal.by ? ` (${e.proposal.by})` : ''}: ${e.proposal.text}`);
-        else if (e.kind === 'challenge') {
-            const c = e.challenge;
-            lines.push(c.verdict === 'accept'
-                ? `challenge${c.by ? ` (${c.by})` : ''}: accept`
-                : `challenge${c.by ? ` (${c.by})` : ''}: ${c.claim ?? ''}${c.requiredChange ? ` → require: ${c.requiredChange}` : ''}`);
-        }
-        else {
-            lines.push(`revision: ${e.revision.accepted ? 'accepted' : 'rejected'}${e.revision.text ? ` — ${e.revision.text}` : ''}`);
-        }
-    }
-    lines.push('');
-    const st = debateStatus(d);
-    if (st.state === 'resolved')
-        lines.push(ui.tone(`Resolved (${st.how}).`, 'success'));
-    else if (st.state === 'escalate') {
-        lines.push(ui.tone(`Escalate to human — ${st.reason}:`, 'warning'));
-        for (const o of st.options)
-            lines.push(`  ${o}`);
-    }
-    else if (st.state === 'awaiting-revision')
-        lines.push(ui.tone(`Awaiting lead revision${st.required ? ` (required: ${st.required})` : ''}.`, 'info'));
-    else
-        lines.push(ui.tone('Awaiting reviewer challenge.', 'info'));
-    return lines.join('\n');
-}
+// Disagreement Protocol (F-LOOP-5, ADR-0008): bound model-vs-model debate so it converges instead
+// of looping. A proposal is met with at most `maxRounds` blocking challenges; the reviewer returns
+// CLAIMS + a required change (never edits — the lead keeps control); no agreement after the cap
+// escalates to the human with exactly two options. Pure state machine; the model-authored content
+// of each turn is the deferred live path.
+import { PLAIN } from './ui/theme.js';
+export const MAX_ROUNDS = 2;
+export function newDebate(topic, proposal, maxRounds = MAX_ROUNDS) {
+    return { topic, entries: [{ kind: 'proposal', proposal }], maxRounds };
+}
+export function challengeCount(d) {
+    return d.entries.filter((e) => e.kind === 'challenge').length;
+}
+function leadPosition(d) {
+    for (let i = d.entries.length - 1; i >= 0; i--) {
+        const e = d.entries[i];
+        if (e.kind === 'revision')
+            return e.revision.text || d.topic;
+        if (e.kind === 'response')
+            return e.response.proposedRevision ?? e.response.text ?? d.topic;
+        if (e.kind === 'proposal')
+            return e.proposal.text;
+    }
+    return d.topic;
+}
+function reviewerRequirement(d) {
+    for (let i = d.entries.length - 1; i >= 0; i--) {
+        const e = d.entries[i];
+        if (e.kind === 'challenge' && e.challenge.verdict === 'challenge')
+            return e.challenge.requiredChange ?? e.challenge.claim;
+    }
+    return undefined;
+}
+export function debateStatus(d) {
+    const last = d.entries[d.entries.length - 1];
+    const rounds = challengeCount(d);
+    const escalate = () => ({
+        state: 'escalate',
+        reason: `no agreement after ${rounds} round${rounds === 1 ? '' : 's'} (max ${d.maxRounds})`,
+        options: [`A: ${leadPosition(d)}`, `B: ${reviewerRequirement(d) ?? 'reviewer change'}`],
+    });
+    if (!last || last.kind === 'proposal')
+        return { state: 'awaiting-challenge' };
+    if (last.kind === 'challenge') {
+        if (last.challenge.verdict === 'accept')
+            return { state: 'resolved', how: 'accepted-by-reviewer' };
+        if (rounds >= d.maxRounds)
+            return escalate();
+        return { state: 'awaiting-revision', required: last.challenge.requiredChange };
+    }
+    if (last.kind === 'response') {
+        if (rounds >= d.maxRounds)
+            return escalate();
+        return { state: 'awaiting-decision', required: reviewerRequirement(d) };
+    }
+    // last is a revision
+    if (last.revision.accepted)
+        return { state: 'resolved', how: 'lead-accepted' };
+    if (rounds >= d.maxRounds)
+        return escalate();
+    return { state: 'awaiting-challenge' };
+}
+export function renderDebate(d, ui = PLAIN) {
+    const lines = [`Debate: ${d.topic}`, ''];
+    for (const e of d.entries) {
+        if (e.kind === 'proposal')
+            lines.push(`proposal${e.proposal.by ? ` (${e.proposal.by})` : ''}: ${e.proposal.text}`);
+        else if (e.kind === 'challenge') {
+            const c = e.challenge;
+            lines.push(c.verdict === 'accept'
+                ? `challenge${c.by ? ` (${c.by})` : ''}: accept`
+                : `challenge${c.by ? ` (${c.by})` : ''}: ${c.claim ?? ''}${c.requiredChange ? ` → require: ${c.requiredChange}` : ''}`);
+            if (c.basis?.length)
+                lines.push(`  basis: ${c.basis.join(', ')}`);
+            if (c.missingEvidence?.length)
+                lines.push(`  missing_evidence: ${c.missingEvidence.join('; ')}`);
+        }
+        else if (e.kind === 'response') {
+            const r = e.response;
+            lines.push(`response${r.by ? ` (${r.by})` : ''}: ${r.text}`);
+            if (r.proposedRevision)
+                lines.push(`  proposed_revision: ${r.proposedRevision}`);
+            if (r.acceptsRequiredChange !== undefined)
+                lines.push(`  accepts_required_change: ${r.acceptsRequiredChange ? 'yes' : 'no'}`);
+        }
+        else {
+            lines.push(`revision: ${e.revision.accepted ? 'accepted' : 'rejected'}${e.revision.text ? ` — ${e.revision.text}` : ''}`);
+        }
+    }
+    lines.push('');
+    const st = debateStatus(d);
+    if (st.state === 'resolved')
+        lines.push(ui.tone(`Resolved (${st.how}).`, 'success'));
+    else if (st.state === 'escalate') {
+        lines.push(ui.tone(`Escalate to human — ${st.reason}:`, 'warning'));
+        for (const o of st.options)
+            lines.push(`  ${o}`);
+    }
+    else if (st.state === 'awaiting-decision')
+        lines.push(ui.tone(`Awaiting lead decision${st.required ? ` (reviewer requires: ${st.required})` : ''}.`, 'info'));
+    else if (st.state === 'awaiting-revision')
+        lines.push(ui.tone(`Awaiting lead revision${st.required ? ` (required: ${st.required})` : ''}.`, 'info'));
+    else
+        lines.push(ui.tone('Awaiting reviewer challenge.', 'info'));
+    return lines.join('\n');
+}

package/dist/evidence.js

@@ -1,72 +1,72 @@
-// Validation Gate (F-LOOP-2, ADR-0008): "done" is a verified check bundle, not a natural-language
-// claim. Pure logic — parse a test runner's output, gate the bundle against the Task Contract, and
-// render the ship summary. Actually RUNNING build/test (local, deterministic) and the reviewer's
-// model call live in cli.ts; only the latter is the deferred live path.
-import { contractIssues } from './task.js';
-import { PLAIN, statusTone } from './ui/theme.js';
-/** Parse pass/fail counts from common runners (node:test "pass N", jest/vitest "N passed"). */
-export function parseTestSummary(output) {
-    const t = output ?? '';
-    const num = (re) => { const m = t.match(re); return m ? Number(m[1]) : null; };
-    const passed = num(/\bpass(?:ed|ing)?\s+(\d+)\b/i) ?? num(/\b(\d+)\s+pass(?:ed|ing)?\b/i);
-    const failed = num(/\bfail(?:ed|ing|ures)?\s+(\d+)\b/i) ?? num(/\b(\d+)\s+fail(?:ed|ing|ures)?\b/i);
-    if (passed === null && failed === null)
-        return null;
-    return { passed: passed ?? 0, failed: failed ?? 0 };
-}
-/**
- * Gate the evidence against the contract. Hard checks (build, tests) decide `ready`; the contract's
- * acceptance criteria and unresolved items surface as warnings (they need a reviewer/human, which
- * the gate never auto-claims as verified).
- */
-export function gate(contract, bundle) {
-    const checks = [];
-    const warnings = [];
-    if (bundle.build)
-        checks.push({ label: 'Build', ok: bundle.build.exitCode === 0, detail: bundle.build.command });
-    if (bundle.tests) {
-        const s = bundle.tests.summary;
-        const ok = bundle.tests.exitCode === 0 && (!s || s.failed === 0);
-        checks.push({ label: 'Tests', ok, detail: s ? `${s.passed} passed, ${s.failed} failed` : `exit ${bundle.tests.exitCode}` });
-    }
-    if (checks.length === 0)
-        warnings.push('no build/test commands found — nothing was actually verified');
-    if (contract) {
-        for (const issue of contractIssues(contract))
-            warnings.push(`contract: ${issue}`);
-        if (contract.acceptance.length)
-            warnings.push(`${contract.acceptance.length} acceptance criteria need verification (reviewer/human)`);
-    }
-    else {
-        warnings.push('no task contract — run `frame start <goal>` to define "done"');
-    }
-    for (const u of bundle.unresolved ?? [])
-        warnings.push(`unresolved: ${u}`);
-    return { ready: checks.length > 0 && checks.every((c) => c.ok), checks, warnings };
-}
-function header(r) {
-    if (!r.ready)
-        return 'NOT READY';
-    return r.warnings.length ? `READY WITH ${r.warnings.length} WARNING${r.warnings.length > 1 ? 'S' : ''}` : 'READY';
-}
-/** Shared gate body: header + checks + warnings (used by `frame verify`). */
-export function renderGate(r, ui = PLAIN) {
-    const h = header(r);
-    const lines = [ui.tone(h, statusTone(h)), ''];
-    for (const c of r.checks) {
-        const mark = c.ok ? ui.tone(ui.sym.pass, 'success') : ui.tone(ui.sym.fail, 'danger');
-        lines.push(`${mark} ${c.label}${c.detail ? ': ' + c.detail : ''}`);
-    }
-    for (const w of r.warnings)
-        lines.push(`${ui.tone(ui.sym.warn, 'warning')} ${w}`);
-    return lines.join('\n');
-}
-/** Gate body + commit/deploy guidance (used by `frame ship`). */
-export function renderShip(r, ui = PLAIN) {
-    return [
-        renderGate(r, ui),
-        '',
-        `Safe to commit: ${r.ready ? 'yes' : 'no'}`,
-        `Safe to deploy: ${r.ready ? 'requires human confirmation' : 'no'}`,
-    ].join('\n');
-}
+// Validation Gate (F-LOOP-2, ADR-0008): "done" is a verified check bundle, not a natural-language
+// claim. Pure logic — parse a test runner's output, gate the bundle against the Task Contract, and
+// render the ship summary. Actually RUNNING build/test (local, deterministic) and the reviewer's
+// model call live in cli.ts; only the latter is the deferred live path.
+import { contractIssues } from './task.js';
+import { PLAIN, statusTone } from './ui/theme.js';
+/** Parse pass/fail counts from common runners (node:test "pass N", jest/vitest "N passed"). */
+export function parseTestSummary(output) {
+    const t = output ?? '';
+    const num = (re) => { const m = t.match(re); return m ? Number(m[1]) : null; };
+    const passed = num(/\bpass(?:ed|ing)?\s+(\d+)\b/i) ?? num(/\b(\d+)\s+pass(?:ed|ing)?\b/i);
+    const failed = num(/\bfail(?:ed|ing|ures)?\s+(\d+)\b/i) ?? num(/\b(\d+)\s+fail(?:ed|ing|ures)?\b/i);
+    if (passed === null && failed === null)
+        return null;
+    return { passed: passed ?? 0, failed: failed ?? 0 };
+}
+/**
+ * Gate the evidence against the contract. Hard checks (build, tests) decide `ready`; the contract's
+ * acceptance criteria and unresolved items surface as warnings (they need a reviewer/human, which
+ * the gate never auto-claims as verified).
+ */
+export function gate(contract, bundle) {
+    const checks = [];
+    const warnings = [];
+    if (bundle.build)
+        checks.push({ label: 'Build', ok: bundle.build.exitCode === 0, detail: bundle.build.command });
+    if (bundle.tests) {
+        const s = bundle.tests.summary;
+        const ok = bundle.tests.exitCode === 0 && (!s || s.failed === 0);
+        checks.push({ label: 'Tests', ok, detail: s ? `${s.passed} passed, ${s.failed} failed` : `exit ${bundle.tests.exitCode}` });
+    }
+    if (checks.length === 0)
+        warnings.push('no build/test commands found — nothing was actually verified');
+    if (contract) {
+        for (const issue of contractIssues(contract))
+            warnings.push(`contract: ${issue}`);
+        if (contract.acceptance.length)
+            warnings.push(`${contract.acceptance.length} acceptance criteria need verification (reviewer/human)`);
+    }
+    else {
+        warnings.push('no task contract — run `frame start <goal>` to define "done"');
+    }
+    for (const u of bundle.unresolved ?? [])
+        warnings.push(`unresolved: ${u}`);
+    return { ready: checks.length > 0 && checks.every((c) => c.ok), checks, warnings };
+}
+function header(r) {
+    if (!r.ready)
+        return 'NOT READY';
+    return r.warnings.length ? `READY WITH ${r.warnings.length} WARNING${r.warnings.length > 1 ? 'S' : ''}` : 'READY';
+}
+/** Shared gate body: header + checks + warnings (used by `frame verify`). */
+export function renderGate(r, ui = PLAIN) {
+    const h = header(r);
+    const lines = [ui.tone(h, statusTone(h)), ''];
+    for (const c of r.checks) {
+        const mark = c.ok ? ui.tone(ui.sym.pass, 'success') : ui.tone(ui.sym.fail, 'danger');
+        lines.push(`${mark} ${c.label}${c.detail ? ': ' + c.detail : ''}`);
+    }
+    for (const w of r.warnings)
+        lines.push(`${ui.tone(ui.sym.warn, 'warning')} ${w}`);
+    return lines.join('\n');
+}
+/** Gate body + commit/deploy guidance (used by `frame ship`). */
+export function renderShip(r, ui = PLAIN) {
+    return [
+        renderGate(r, ui),
+        '',
+        `Safe to commit: ${r.ready ? 'yes' : 'no'}`,
+        `Safe to deploy: ${r.ready ? 'requires human confirmation' : 'no'}`,
+    ].join('\n');
+}

package/dist/fileWriter.js

@@ -1,35 +1,35 @@
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { renderManagedBlock } from './projector.js';
-import { upsertManagedBlock } from './managedBlock.js';
-const NATIVE_FILES = [
-    ['CLAUDE.md', 'CLAUDE.md'],
-    ['AGENTS.md', 'AGENTS.md'],
-    ['GEMINI.md', 'GEMINI.md'],
-];
-/** Compute what each native file WOULD become (managed-block upsert), without writing. */
-export function planNativeFiles(dir, state) {
-    const managed = renderManagedBlock(state);
-    return NATIVE_FILES.map(([name, title]) => {
-        const path = join(dir, name);
-        const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
-        const content = upsertManagedBlock(existing, title, managed);
-        return { path, content, existed: existing != null, changed: existing !== content };
-    });
-}
-/**
- * Upsert the managed block into the three native files, preserving any user content
- * outside the framein markers. Only files whose content actually changes are written
- * (no mtime churn / spurious file-watcher events). Returns the written paths.
- */
-export function writeNativeFiles(dir, state) {
-    mkdirSync(dir, { recursive: true });
-    const written = [];
-    for (const p of planNativeFiles(dir, state)) {
-        if (p.changed) {
-            writeFileSync(p.path, p.content, 'utf8');
-            written.push(p.path);
-        }
-    }
-    return written;
-}
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { renderManagedBlock } from './projector.js';
+import { upsertManagedBlock } from './managedBlock.js';
+const NATIVE_FILES = [
+    ['CLAUDE.md', 'CLAUDE.md'],
+    ['AGENTS.md', 'AGENTS.md'],
+    ['GEMINI.md', 'GEMINI.md'],
+];
+/** Compute what each native file WOULD become (managed-block upsert), without writing. */
+export function planNativeFiles(dir, state) {
+    const managed = renderManagedBlock(state);
+    return NATIVE_FILES.map(([name, title]) => {
+        const path = join(dir, name);
+        const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
+        const content = upsertManagedBlock(existing, title, managed);
+        return { path, content, existed: existing != null, changed: existing !== content };
+    });
+}
+/**
+ * Upsert the managed block into the three native files, preserving any user content
+ * outside the framein markers. Only files whose content actually changes are written
+ * (no mtime churn / spurious file-watcher events). Returns the written paths.
+ */
+export function writeNativeFiles(dir, state) {
+    mkdirSync(dir, { recursive: true });
+    const written = [];
+    for (const p of planNativeFiles(dir, state)) {
+        if (p.changed) {
+            writeFileSync(p.path, p.content, 'utf8');
+            written.push(p.path);
+        }
+    }
+    return written;
+}

package/dist/ingest.js

@@ -1,38 +1,38 @@
-// Structured ingest (F-LOOP-5, live): pull a JSON object out of a model's free-form reply so its
-// answer becomes structured framein state (e.g. a reviewer verdict -> a Challenge). Models wrap
-// JSON in prose / ```json fences, so scan for the first balanced, string-aware {...} that parses.
-// Pure; the live model call that produces the text lives in cli.ts.
-export function extractJson(text) {
-    const s = text ?? '';
-    for (let i = s.indexOf('{'); i !== -1; i = s.indexOf('{', i + 1)) {
-        let depth = 0, inStr = false, esc = false;
-        for (let j = i; j < s.length; j++) {
-            const c = s[j];
-            if (inStr) {
-                if (esc)
-                    esc = false;
-                else if (c === '\\')
-                    esc = true;
-                else if (c === '"')
-                    inStr = false;
-                continue;
-            }
-            if (c === '"')
-                inStr = true;
-            else if (c === '{')
-                depth++;
-            else if (c === '}') {
-                if (--depth === 0) {
-                    try {
-                        const o = JSON.parse(s.slice(i, j + 1));
-                        if (o && typeof o === 'object' && !Array.isArray(o))
-                            return o;
-                    }
-                    catch { /* not valid JSON — fall through and try the next `{` */ }
-                    break;
-                }
-            }
-        }
-    }
-    return null;
-}
+// Structured ingest (F-LOOP-5, live): pull a JSON object out of a model's free-form reply so its
+// answer becomes structured framein state (e.g. a reviewer verdict -> a Challenge). Models wrap
+// JSON in prose / ```json fences, so scan for the first balanced, string-aware {...} that parses.
+// Pure; the live model call that produces the text lives in cli.ts.
+export function extractJson(text) {
+    const s = text ?? '';
+    for (let i = s.indexOf('{'); i !== -1; i = s.indexOf('{', i + 1)) {
+        let depth = 0, inStr = false, esc = false;
+        for (let j = i; j < s.length; j++) {
+            const c = s[j];
+            if (inStr) {
+                if (esc)
+                    esc = false;
+                else if (c === '\\')
+                    esc = true;
+                else if (c === '"')
+                    inStr = false;
+                continue;
+            }
+            if (c === '"')
+                inStr = true;
+            else if (c === '{')
+                depth++;
+            else if (c === '}') {
+                if (--depth === 0) {
+                    try {
+                        const o = JSON.parse(s.slice(i, j + 1));
+                        if (o && typeof o === 'object' && !Array.isArray(o))
+                            return o;
+                    }
+                    catch { /* not valid JSON — fall through and try the next `{` */ }
+                    break;
+                }
+            }
+        }
+    }
+    return null;
+}