@davesheffer/hunch 1.7.1 → 1.8.0

package/dist/constitution/g3Conformance.js

@@ -11,22 +11,38 @@ export const G3_CONFORMANCE_TEST = {
     file: "test/behavior-workspace.test.ts",
     name: "CLI, MCP, and check share one non-blocking working-snapshot receipt without public leakage",
 };
+/** The certifiable client profiles. Each maps a HUMAN-SELECTED client set to the
+ *  ONE executable fixture that exercises every named surface end-to-end and
+ *  asserts receipt equality + zero private leaks. The vscode profile executes the
+ *  extension's real spawn seam (vscode-extension/src/spawnCore.ts) against an
+ *  npm-style shim — naming a client never certifies it; only its fixture does. */
+export const G3_CONFORMANCE_PROFILES = [
+    { clients: G3_CONFORMANCE_CLIENTS, test: G3_CONFORMANCE_TEST },
+    {
+        clients: ["ci", "cli", "mcp", "vscode"],
+        test: {
+            file: "test/behavior-workspace.test.ts",
+            name: "CLI, MCP, check, and the VS Code seam share one non-blocking working-snapshot receipt without public leakage",
+        },
+    },
+];
 export function g3ConformanceSourceHash(root) {
     return canonicalHash(readFileSync(join(root, G3_CONFORMANCE_TEST.file), "utf8"));
 }
 function sameClients(left, right) {
     return canonicalHash([...left].sort()) === canonicalHash([...right].sort());
 }
-/** Execute the real CLI/MCP/CI fixture selected by the first G3 conformance profile.
- * Unsupported human-selected client sets return an error receipt rather than being
- * silently treated as equivalent to the built-in three-surface profile. */
+/** Execute the real end-to-end fixture matching the plan's human-selected client
+ * profile. Unsupported client sets return an error receipt rather than being
+ * silently treated as equivalent to a certified profile. */
 export function executeG3AdapterConformance(root, plan, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 180_000;
     if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 300_000)
         throw new Error("G3 conformance timeout must be a positive integer no greater than 300000");
     const sourceHash = g3ConformanceSourceHash(root);
     const isolationFlag = nodeTestIsolationFlag();
-    if (!sameClients(plan.clients, G3_CONFORMANCE_CLIENTS)) {
+    const profile = G3_CONFORMANCE_PROFILES.find((candidate) => sameClients(plan.clients, candidate.clients));
+    if (!profile) {
         return compileAdapterConformanceReceipt({
             plan_id: plan.id,
             clients: plan.clients,
@@ -38,10 +54,11 @@ export function executeG3AdapterConformance(root, plan, opts = {}) {
             verdict_agreement: null,
             confirmed_private_leaks: null,
             error_code: "unsupported-client-profile",
-            log_hash: canonicalHash({ supported: G3_CONFORMANCE_CLIENTS, selected: plan.clients }),
+            log_hash: canonicalHash({ supported: G3_CONFORMANCE_PROFILES.map((candidate) => candidate.clients), selected: plan.clients }),
             supersedes: opts.supersedes ?? null,
         }, { now: opts.now });
     }
+    const selectedTest = profile.test;
     const session = mkdtempSync(join(tmpdir(), "hunch-g3-conformance-"));
     const reporter = join(session, "reporter.mjs");
     writeFileSync(reporter, NODE_TEST_REPORTER_SOURCE);
@@ -63,10 +80,10 @@ export function executeG3AdapterConformance(root, plan, opts = {}) {
         tsx,
         "--test",
         isolationFlag,
-        `--test-name-pattern=${exactNodeTestPattern(G3_CONFORMANCE_TEST.name)}`,
+        `--test-name-pattern=${exactNodeTestPattern(selectedTest.name)}`,
         `--test-reporter=${pathToFileURL(reporter).href}`,
         "--test-reporter-destination=stdout",
-        G3_CONFORMANCE_TEST.file,
+        selectedTest.file,
     ], {
         cwd: root,
         env,
@@ -79,7 +96,7 @@ export function executeG3AdapterConformance(root, plan, opts = {}) {
     rmSync(session, { recursive: true, force: true });
     const stdout = run.stdout ?? "";
     const stderr = run.stderr ?? "";
-    const events = nodeTestReporterEvents(stdout).filter((event) => event.name === G3_CONFORMANCE_TEST.name && !event.skip && !event.todo);
+    const events = nodeTestReporterEvents(stdout).filter((event) => event.name === selectedTest.name && !event.skip && !event.todo);
     const selectedEvent = events.length === 1 ? (events[0].type === "test:pass" ? "passed" : "failed") : null;
     let result = "error";
     let errorCode;
@@ -100,7 +117,7 @@ export function executeG3AdapterConformance(root, plan, opts = {}) {
     return compileAdapterConformanceReceipt({
         plan_id: plan.id,
         clients: plan.clients,
-        test: { ...G3_CONFORMANCE_TEST, source_hash: sourceHash },
+        test: { ...selectedTest, source_hash: sourceHash },
         runner: { name: "node-test-tsx", isolation_flag: isolationFlag },
         result,
         exit_code: run.status ?? null,

package/dist/constitution/lifecycle.js

@@ -186,4 +186,39 @@ export function demotePolicy(policy, actor, reason, at) {
         audit: [...policy.audit, { action: "demoted", actor_kind: "human", actor, at, reason, proof: policy.proof }],
     };
 }
+/** Targeted advisory withdrawal (the §57 gap): pull the human authority back and
+ *  return the policy to `proposed`. It stops surfacing as an active rule and
+ *  RE-ENTERS the inline escalation loop ("activate or reject?") — the reversible
+ *  half of retirement. History is append-only; nothing is erased. */
+export function withdrawPolicy(policy, actor, reason, at) {
+    requireHuman(actor);
+    if (policy.state !== "active_advisory")
+        throw new Error(`policy ${policy.id} is ${policy.state}; only active advisory policy can be withdrawn to proposed`);
+    return {
+        ...policy,
+        revision: policy.revision + 1,
+        state: "proposed",
+        authority: null,
+        updated_at: at,
+        audit: [...policy.audit, { action: "withdrawn", actor_kind: "human", actor, at, reason, proof: policy.proof }],
+    };
+}
+/** Permanent retirement: the rule is deliberately DONE — it stops surfacing
+ *  anywhere (active rules, escalations) but its full history and audit trail stay
+ *  (supersede-never-erase, HC-08). Closes the valid-time window. */
+export function retirePolicy(policy, actor, reason, at) {
+    requireHuman(actor);
+    if (policy.state !== "active_advisory" && policy.state !== "active_blocking" && policy.state !== "proposed") {
+        throw new Error(`policy ${policy.id} is ${policy.state}; only an active or proposed policy can be retired`);
+    }
+    return {
+        ...policy,
+        revision: policy.revision + 1,
+        state: "retired",
+        authority: null,
+        valid_to: at,
+        updated_at: at,
+        audit: [...policy.audit, { action: "retired", actor_kind: "human", actor, at, reason, proof: policy.proof }],
+    };
+}
 //# sourceMappingURL=lifecycle.js.map

package/dist/constitution/repairPolicies.js

@@ -0,0 +1,78 @@
+/** Rewrite the file part of a `symbol:<file>:<name>` selector when it EXACTLY
+ *  matches a renamed path; every other selector form passes through unchanged. */
+function repairSelector(raw, map) {
+    if (!raw.startsWith("symbol:"))
+        return raw;
+    const target = raw.slice("symbol:".length);
+    const split = target.lastIndexOf(":");
+    if (split <= 0)
+        return raw; // bare symbol name — no file identity to heal
+    const file = target.slice(0, split);
+    const to = map.get(file);
+    return to ? `symbol:${to}:${target.slice(split + 1)}` : raw;
+}
+function isExactPath(entry) {
+    return !/[*?[\]{}]/.test(entry);
+}
+/** Live policies only — a superseded/retired/rejected policy's history stays as
+ *  written. Returns the rewrites; empty when the renames touch nothing exactly. */
+export function planPolicyRepair(renames, policies) {
+    const map = new Map(renames.map((r) => [r.before, r.after]));
+    const rewrites = [];
+    if (!map.size)
+        return rewrites;
+    for (const p of policies) {
+        if (p.state === "superseded" || p.state === "retired" || p.state === "rejected")
+            continue;
+        for (const path of p.scope.paths) {
+            const to = isExactPath(path) ? map.get(path) : undefined;
+            if (to)
+                rewrites.push({ id: p.id, field: "scope.paths", from: path, to });
+        }
+        if (p.assertion.kind !== "executable-behavior") {
+            const selectors = p.assertion.kind === "exists"
+                ? [p.assertion.subject.selector]
+                : [p.assertion.subject.selector, p.assertion.object.selector];
+            for (const raw of selectors) {
+                const healed = repairSelector(raw, map);
+                if (healed !== raw)
+                    rewrites.push({ id: p.id, field: "assertion.selector", from: raw, to: healed });
+            }
+        }
+    }
+    return rewrites;
+}
+/** Apply a policy's rewrites (pure): revision+1, system-actor audit, updated_at.
+ *  Returns the original reference when nothing in the plan touches this policy. */
+export function repairPolicySpec(policy, rewrites, at) {
+    const mine = rewrites.filter((r) => r.id === policy.id);
+    if (!mine.length)
+        return policy;
+    const subPath = (value) => mine.find((r) => r.field === "scope.paths" && r.from === value)?.to ?? value;
+    const subSelector = (value) => mine.find((r) => r.field === "assertion.selector" && r.from === value)?.to ?? value;
+    const assertion = policy.assertion.kind === "executable-behavior"
+        ? policy.assertion
+        : policy.assertion.kind === "exists"
+            ? { ...policy.assertion, subject: { selector: subSelector(policy.assertion.subject.selector) } }
+            : {
+                ...policy.assertion,
+                subject: { selector: subSelector(policy.assertion.subject.selector) },
+                object: { selector: subSelector(policy.assertion.object.selector) },
+            };
+    return {
+        ...policy,
+        revision: policy.revision + 1,
+        scope: { ...policy.scope, paths: policy.scope.paths.map(subPath) },
+        assertion,
+        updated_at: at,
+        audit: [...policy.audit, {
+                action: "repaired",
+                actor_kind: "system",
+                actor: "system:repair",
+                at,
+                reason: mine.map((r) => `${r.field}: ${r.from} -> ${r.to}`).join("; "),
+                proof: policy.proof,
+            }],
+    };
+}
+//# sourceMappingURL=repairPolicies.js.map

package/dist/constitution/schema.js

@@ -182,7 +182,7 @@ export const PolicyAssertionSchema = z.discriminatedUnion("kind", [
     ExecutableBehaviorAssertionSchema,
 ]);
 export const PolicyAuditEventSchema = z.object({
-    action: z.enum(["compiled", "enriched", "linked_exception", "proved", "approved_advisory", "approved_blocking", "demoted", "retired", "rejected"]),
+    action: z.enum(["compiled", "enriched", "linked_exception", "proved", "approved_advisory", "approved_blocking", "demoted", "withdrawn", "retired", "rejected", "repaired"]),
     actor_kind: z.enum(["system", "human"]),
     actor: z.string().min(1),
     at: z.string().datetime({ offset: true }),

package/dist/constitution/service.js

@@ -4,7 +4,7 @@ import { canonicalHash, canonicalJson } from "./canonical.js";
 import { shortHash } from "../core/ids.js";
 import { compileDecisionPolicy } from "./compiler.js";
 import { evaluatePolicy, policyBlocks, policyIsActive } from "./evaluator.js";
-import { approvePolicy, blockingProofError, demotePolicy, linkPolicyException, proposeProvedPolicy } from "./lifecycle.js";
+import { approvePolicy, blockingProofError, demotePolicy, linkPolicyException, proposeProvedPolicy, retirePolicy, withdrawPolicy } from "./lifecycle.js";
 import { provePolicy } from "./proof.js";
 import { PolicyRepository } from "./repository.js";
 import { bootstrapPolicies } from "./bootstrap.js";
@@ -31,7 +31,7 @@ import { evaluateExecutableBehaviorPolicy } from "./behaviorEvaluator.js";
 import { executeG2OperationalDrill } from "./g2Drills.js";
 import { G3_REQUIRED_EXPERIMENTS, G3EvidenceRepository, compileExperimentPreregistration, compileG3Plan, compileProofReviewMeasurement, scoreG3Readiness, } from "./g3.js";
 import { executeG3AdapterConformance, g3ConformanceSourceHash } from "./g3Conformance.js";
-import { ExperimentRepository, assignmentTreatment, buildExperimentReport, compileExperimentCaseBank, compileExperimentFollowup, compileExperimentOutcome, compileExperimentReviewStart, compileExperimentRun, compileExperimentStop, currentExperimentOutcomes, normalizedEditDistance, } from "./experiment.js";
+import { ExperimentRepository, assignmentTreatment, buildExperimentReport, compileExperimentCaseBank, compileExperimentFollowup, compileExperimentOutcome, compileExperimentReviewStart, compileExperimentRun, compileExperimentStop, compileExp03ReviewResponse, currentExperimentOutcomes, normalizedEditDistance, } from "./experiment.js";
 import { executeExp01Assignment } from "./experimentRunner.js";
 function relationSummary(policy) {
     return {
@@ -492,6 +492,17 @@ export class ConstitutionService {
         const bank = this.experimentRepository.listCaseBanks().find((item) => item.id === run.case_bank_id);
         if (!bank)
             throw new Error(`run ${run.id} is missing exact case bank ${run.case_bank_id}`);
+        // Single-operator mitigation (expreg_9c9617cd13, revision >= 3): at least 48 hours
+        // must separate the case-bank lock from the FIRST review start — enforced, not
+        // merely auditable, so a violation is impossible rather than post-hoc visible.
+        const prereg = this.g3Repository.listExperiments().find((item) => item.id === run.preregistration_id);
+        if (prereg && prereg.revision >= 3) {
+            const elapsed = Date.parse(opts.now ?? new Date().toISOString()) - Date.parse(bank.locked_at);
+            const hasStart = this.experimentRepository.listReviewStarts().some((item) => item.run_id === run.id);
+            if (!hasStart && elapsed < 48 * 3_600_000) {
+                throw new Error(`the preregistered single-operator protocol requires at least 48 hours between the case-bank lock (${bank.locked_at}) and the first review start; ${Math.ceil((48 * 3_600_000 - elapsed) / 3_600_000)}h remain`);
+            }
+        }
         const current = new Set(currentExperimentOutcomes(this.experimentRepository.listOutcomes()).filter((item) => item.run_id === run.id).map((item) => item.assignment_id));
         const starts = this.experimentRepository.listReviewStarts().filter((item) => item.run_id === run.id);
         const existing = starts.find((item) => item.reviewer === reviewer && !current.has(item.assignment_id));
@@ -509,25 +520,63 @@ export class ConstitutionService {
         const start = existing ?? this.experimentRepository.putReviewStart(compileExperimentReviewStart(run, assignment, reviewer, opts));
         return { start, assignment, treatment: assignmentTreatment(bank, run, assignment) };
     }
-    submitExperimentReview(runId, assignmentId, input, opts = {}) {
+    /** Resolve an EXP-03 run/assignment/case triple (the shared lookup for both
+     *  review-submission dialects). */
+    resolveExp03Assignment(runId, assignmentId) {
         const run = this.experimentRun(runId);
         if (run.experiment !== "EXP-03")
             throw new Error("human review submission is available only for EXP-03");
-        const start = this.experimentRepository.listReviewStarts().find((item) => item.run_id === run.id && item.assignment_id === assignmentId);
+        const assignment = run.assignments.find((entry) => entry.id === assignmentId);
+        const bank = this.experimentRepository.listCaseBanks().find((entry) => entry.id === run.case_bank_id);
+        const item = bank?.cases.find((candidate) => candidate.id === assignment?.case_id);
+        if (!assignment || !bank || !item || !("compiler_candidate" in item))
+            throw new Error("review submission cannot resolve the exact assigned case and treatment");
+        return { run, assignment, item };
+    }
+    /** Raw metrics-vocabulary submission — the ORIGINAL revision-1 contract, kept
+     *  byte-identical for the append-only pilot. Revision-2 cases are refused here:
+     *  they must go through the standardized plain-language template (dec_0be4fd3717)
+     *  so the presented question and the recorded outcome cannot drift apart. */
+    submitExperimentReview(runId, assignmentId, input, opts = {}) {
+        const { run, assignment, item } = this.resolveExp03Assignment(runId, assignmentId);
+        // Revision-2 reviewer ANSWERS travel only through the template; the raw path
+        // stays open solely for the non-answer terminal states the preregistration
+        // requires retained (abandoned/timeout bookkeeping — expreg_ba6aef4ecd).
+        if (item.required_relationship && input.decision !== "abandoned" && input.decision !== "timeout") {
+            throw new Error(`assignment ${assignmentId} is a revision-2 plain-language case; submit it with the standardized response template (hunch experiment respond)`);
+        }
+        return this.completeExp03Review(run, assignment, item, input, opts);
+    }
+    /** Revision-2 standardized submission: the reviewer answers in the SAME
+     *  plain-language vocabulary the treatment presented (choice + rule + one
+     *  sentence); the deterministic mapper translates it into canonical metrics.
+     *  Revision-1 cases are refused (the mapper throws) — they keep the raw path. */
+    respondExperimentReview(runId, assignmentId, input, opts = {}) {
+        const { run, assignment, item } = this.resolveExp03Assignment(runId, assignmentId);
+        const mapped = compileExp03ReviewResponse(item, assignment.arm, input);
+        return this.completeExp03Review(run, assignment, item, {
+            reviewer: input.reviewer,
+            ...mapped,
+            confirmed_private_leak: !!input.confirmed_private_leak,
+            data_loss_or_corruption: !!input.data_loss_or_corruption,
+            unsafe_evaluator_behavior: !!input.unsafe_evaluator_behavior,
+            reason: input.reason,
+        }, opts);
+    }
+    /** The shared review-completion core: machine-owned timing, append-only dedup,
+     *  derived edit distance, and the outcome write. Both dialects land here. */
+    completeExp03Review(run, assignment, item, input, opts = {}) {
+        const assignmentId = assignment.id;
+        const start = this.experimentRepository.listReviewStarts().find((entry) => entry.run_id === run.id && entry.assignment_id === assignmentId);
         if (!start || start.reviewer !== input.reviewer)
             throw new Error("review submission must bind the machine-recorded start and exact reviewer");
         const recordedAt = opts.now ?? new Date().toISOString();
         const duration = Date.parse(recordedAt) - Date.parse(start.started_at);
         if (!Number.isFinite(duration) || duration < 1)
             throw new Error("review completion must occur after the machine-recorded start");
-        const current = currentExperimentOutcomes(this.experimentRepository.listOutcomes()).find((item) => item.run_id === run.id && item.assignment_id === assignmentId);
+        const current = currentExperimentOutcomes(this.experimentRepository.listOutcomes()).find((entry) => entry.run_id === run.id && entry.assignment_id === assignmentId);
         if (current)
             throw new Error(`assignment ${assignmentId} already has current outcome ${current.id}; use an explicit append-only correction workflow`);
-        const assignment = run.assignments.find((item) => item.id === assignmentId);
-        const bank = this.experimentRepository.listCaseBanks().find((item) => item.id === run.case_bank_id);
-        const item = bank?.cases.find((candidate) => candidate.id === assignment?.case_id);
-        if (!assignment || !bank || !item || !("compiler_candidate" in item))
-            throw new Error("review submission cannot resolve the exact assigned case and treatment");
         const accepted = input.decision.startsWith("accepted");
         const result = input.result?.trim() || null;
         if (accepted !== (result !== null))
@@ -1024,6 +1073,19 @@ export class ConstitutionService {
         const demoted = demotePolicy(policy, actor, reason, opts.now ?? new Date().toISOString());
         return this.repository.putPolicy(demoted);
     }
+    /** Targeted advisory withdrawal (§57): active_advisory → proposed; authority
+     *  returns to the human pool and the policy re-enters the escalation loop. */
+    withdraw(id, actor, reason, opts = {}) {
+        const policy = this.get(id);
+        const withdrawn = withdrawPolicy(policy, actor, reason, opts.now ?? new Date().toISOString());
+        return this.repository.putPolicy(withdrawn);
+    }
+    /** Permanent retirement: active/proposed → retired; window closed, history kept. */
+    retire(id, actor, reason, opts = {}) {
+        const policy = this.get(id);
+        const retired = retirePolicy(policy, actor, reason, opts.now ?? new Date().toISOString());
+        return this.repository.putPolicy(retired);
+    }
     linkException(id, parentId, actor, reason, opts = {}) {
         const child = this.get(id);
         const parent = this.get(parentId);

package/dist/core/escalations.js

@@ -0,0 +1,65 @@
+import { topicCollisions } from "./topics.js";
+/** The decisions a human must make NOW, to be asked INLINE. Empty in a healthy graph. */
+export function pendingEscalations(decisions) {
+    const out = [];
+    for (const [topic, decs] of topicCollisions(decisions)) {
+        out.push({
+            kind: "topic-conflict",
+            topic,
+            decisionIds: decs.map((d) => d.id),
+            question: `Topic "${topic}" has ${decs.length} live decisions — which one is current?`,
+            detail: decs.map((d) => `${d.id} — "${d.title}"`).join("  ·  "),
+            resolution: `supersede the others: re-record the chosen one with supersedes:<other-id>, or split the topic.`,
+        });
+    }
+    return out;
+}
+/** The Constitution's genuine human moments (§59.5.3), framed as inline questions:
+ *  a candidate awaiting review, and a proposed policy whose next step (prove, or
+ *  accept/reject) is a human call. Machine conclusions never appear here as
+ *  approvals — every entry is a QUESTION with its explicit resolution verb. */
+export function policyEscalations(policies) {
+    const out = [];
+    const clip = (s) => (s.length > 90 ? s.slice(0, 89).trimEnd() + "…" : s);
+    for (const p of policies) {
+        // An auto-repaired policy asks FIRST (and only once): its bindings moved, so
+        // its proof is stale by construction — the human moment is "re-prove it".
+        if (p.last_action === "repaired" && (p.state === "proposed" || p.state === "active_advisory" || p.state === "active_blocking")) {
+            out.push({
+                kind: "policy-repaired",
+                topic: p.id,
+                decisionIds: [p.id],
+                question: `Rule "${clip(p.statement)}" (${p.id}) was auto-repaired after a rename — its proof is stale; re-prove it?`,
+                detail: `state ${p.state} · last action repaired · ${p.proof ? `proof ${p.proof} (stale)` : "no proof"}`,
+                resolution: `hunch policy prove ${p.id} — blocking stays fail-safe until the fresh proof lands`,
+            });
+            continue;
+        }
+        if (p.state === "compiled" || p.state === "validating") {
+            out.push({
+                kind: "policy-candidate",
+                topic: p.id,
+                decisionIds: [p.id],
+                question: `Candidate rule "${clip(p.statement)}" (${p.id}) awaits your review — keep it moving or reject it?`,
+                detail: `state ${p.state} · authority none · not yet proved`,
+                resolution: `hunch policy prove ${p.id} — then accept/reject; or hunch policy reject ${p.id} --reason "..."`,
+            });
+        }
+        else if (p.state === "proposed") {
+            out.push({
+                kind: "policy-proposal",
+                topic: p.id,
+                decisionIds: [p.id],
+                question: p.proof
+                    ? `Proposed rule "${clip(p.statement)}" (${p.id}) carries its proof — activate it (advisory/blocking) or reject it?`
+                    : `Proposed rule "${clip(p.statement)}" (${p.id}) has no current proof — prove it, then decide.`,
+                detail: `state proposed · ${p.proof ? `proof ${p.proof}` : "no proof"} · authority none`,
+                resolution: p.proof
+                    ? `inspect: hunch policy card ${p.id} — then hunch policy accept ${p.id} --advisory|--blocking --actor human:<you>, or reject`
+                    : `hunch policy prove ${p.id}`,
+            });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=escalations.js.map

package/dist/core/memorylog.js

@@ -0,0 +1,69 @@
+/**
+ * The memory-move timeline — the data behind `hunch log` and the VS Code "Hunch
+ * Source Control" view. Every commit that touched `.hunch/` is one MOVE (a capture,
+ * adoption, supersession, or prune), classified deterministically from git's own
+ * name-status. Pure parsing — no LLM, no judgment — so the panel shows exactly what
+ * git recorded and each move maps back to a real, revertable commit.
+ *
+ * The parser is split from the git shell-out (extractors/git.gitMemoryLog) so it is
+ * unit-testable with canned `git log` output.
+ */
+/** The record-header separator we ask `git log --format` to emit, so header lines
+ *  are unambiguous against the name-status lines that follow each commit. */
+export const MEMLOG_HEADER = "@@@";
+/** The `--format` string that pairs with {@link parseMemoryLog}. */
+export const MEMLOG_FORMAT = `${MEMLOG_HEADER}%H\t%h\t%cI\t%s`;
+const ID_RE = /\/((?:dec|bug|con|cmp|pol)_[0-9a-f]+)\.json$/;
+/** Parse `git log <MEMLOG_FORMAT> --name-status -- .hunch/` output into classified
+ *  moves, newest first (git's order). */
+export function parseMemoryLog(raw) {
+    const moves = [];
+    let cur = null;
+    for (const line of raw.split("\n")) {
+        if (line.startsWith(MEMLOG_HEADER)) {
+            if (cur)
+                moves.push(classify(cur));
+            const f = line.slice(MEMLOG_HEADER.length).split("\t");
+            cur = {
+                sha: f[0] ?? "", shortSha: f[1] ?? "", date: f[2] ?? "", subject: f.slice(3).join("\t"),
+                kind: "edit", decisionIds: [], otherIds: [], added: 0, modified: 0, deleted: 0, files: [],
+            };
+            continue;
+        }
+        if (!cur || !line.trim())
+            continue;
+        // name-status: "A\tpath", "M\tpath", "D\tpath", or rename "R100\told\tnew".
+        const parts = line.split("\t");
+        const status = parts[0]?.[0];
+        const path = parts[parts.length - 1];
+        if (!path || !path.startsWith(".hunch/"))
+            continue;
+        cur.files.push(path);
+        if (status === "A")
+            cur.added++;
+        else if (status === "D")
+            cur.deleted++;
+        else
+            cur.modified++;
+        const id = ID_RE.exec(path)?.[1];
+        if (id)
+            (id.startsWith("dec_") ? cur.decisionIds : cur.otherIds).push(id);
+    }
+    if (cur)
+        moves.push(classify(cur));
+    return moves;
+}
+/** Deterministic move kind from the subject + the add/modify/delete shape. */
+function classify(m) {
+    const s = m.subject.toLowerCase();
+    m.kind =
+        /\brepair\b/.test(s) ? "repair"
+            : /\badopt/.test(s) ? "adopt"
+                : /supersed/.test(s) ? "supersede"
+                    : m.deleted > 0 && m.added === 0 && m.modified === 0 ? "prune"
+                        : m.added > 0 && m.modified === 0 && m.deleted === 0 ? "capture"
+                            : /\bcapture\b/.test(s) ? "capture"
+                                : "edit";
+    return m;
+}
+//# sourceMappingURL=memorylog.js.map

package/dist/core/repair.js

@@ -0,0 +1,71 @@
+/** A scope entry is exact (rewritable) only when it contains no glob syntax. */
+function isExactPath(entry) {
+    return !/[*?[\]{}]/.test(entry);
+}
+/** Extract the rename pairs from a commit's change records (already 1:1 by git -M). */
+export function renamesOf(changes) {
+    return changes
+        .filter((c) => c.status === "renamed" && c.before && c.after && c.before !== c.after)
+        .map((c) => ({ before: c.before, after: c.after }));
+}
+/** Plan every safe rewrite. Only exact matches against a git-confirmed rename move;
+ *  live records only (a superseded/retired record's history stays as written). */
+export function planRepair(renames, decisions, constraints) {
+    const map = new Map(renames.map((r) => [r.before, r.after]));
+    const rewrites = [];
+    if (!map.size)
+        return { rewrites, records: [] };
+    for (const d of decisions) {
+        if (d.status === "superseded" || d.status === "rejected")
+            continue;
+        for (const f of d.related_files ?? []) {
+            const to = map.get(f);
+            if (to)
+                rewrites.push({ kind: "decisions", id: d.id, field: "related_files", from: f, to });
+        }
+        for (const tw of d.rejected_tripwires ?? []) {
+            for (const s of tw.scope ?? []) {
+                const to = isExactPath(s) ? map.get(s) : undefined;
+                if (to)
+                    rewrites.push({ kind: "decisions", id: d.id, field: "tripwire.scope", from: s, to });
+            }
+        }
+    }
+    for (const c of constraints) {
+        if (c.status && c.status !== "active")
+            continue;
+        for (const s of c.scope ?? []) {
+            const to = isExactPath(s) ? map.get(s) : undefined;
+            if (to)
+                rewrites.push({ kind: "constraints", id: c.id, field: "scope", from: s, to });
+        }
+    }
+    return { rewrites, records: [...new Set(rewrites.map((r) => `${r.kind}:${r.id}`))] };
+}
+/** Apply a plan's rewrites to one decision (pure — returns the healed copy, or the
+ *  original reference when nothing in the plan touches it). */
+export function repairDecision(d, plan) {
+    const mine = plan.rewrites.filter((r) => r.kind === "decisions" && r.id === d.id);
+    if (!mine.length)
+        return d;
+    const sub = (field, value) => mine.find((r) => r.field === field && r.from === value)?.to ?? value;
+    return {
+        ...d,
+        related_files: (d.related_files ?? []).map((f) => sub("related_files", f)),
+        rejected_tripwires: (d.rejected_tripwires ?? []).map((tw) => ({
+            ...tw,
+            scope: (tw.scope ?? []).map((s) => sub("tripwire.scope", s)),
+        })),
+    };
+}
+/** Apply a plan's rewrites to one constraint (pure). */
+export function repairConstraint(c, plan) {
+    const mine = plan.rewrites.filter((r) => r.kind === "constraints" && r.id === c.id);
+    if (!mine.length)
+        return c;
+    return {
+        ...c,
+        scope: (c.scope ?? []).map((s) => mine.find((r) => r.field === "scope" && r.from === s)?.to ?? s),
+    };
+}
+//# sourceMappingURL=repair.js.map

package/dist/core/reviewqueue.js

@@ -24,6 +24,17 @@ export function parseSynth(evidence) {
 }
 /** Grounded-ness at/above which a Critic-verified draft is a "quick yes". */
 export const READY_MIN_GROUNDED = 0.7;
+/** Whether a decision is an un-vouched draft still awaiting a human — the ONLY thing
+ *  the review path surfaces under the auto-trust model.
+ *
+ *  Low confidence NO LONGER makes a draft: captured memory is trusted-advisory the
+ *  moment it lands (status `accepted`, source `llm_draft`), so it grounds and ranks
+ *  but never nags. Only a DELIBERATE, not-yet-human-vouched `proposed` record — an
+ *  explicit roadmap/intent entry a human hasn't confirmed — counts as a review draft.
+ *  (Enforcement authority is granted INLINE, not by draining a background queue.) */
+export function isReviewDraft(d) {
+    return d.status === "proposed" && !d.provenance.source.includes("human_confirmed");
+}
 /** A draft is "ready to confirm" only when the Critic actually audited it (source
  *  includes "verified") AND judged it well-grounded. A high confidence number alone
  *  is NOT enough — an un-audited draft always needs human eyes. */

package/dist/extractors/git.js

@@ -3,6 +3,7 @@
 import { execFileSync } from "node:child_process";
 import { isAbsolute, resolve, join, basename, dirname } from "node:path";
 import { mkdirSync, rmSync, statSync, realpathSync, readFileSync } from "node:fs";
+import { MEMLOG_FORMAT } from "../core/memorylog.js";
 function git(args, cwd, maxBuffer = 64 * 1024 * 1024) {
     // stdio: capture stdout, silence stderr (so "no commits yet" etc. don't leak).
     return execFileSync("git", args, {
@@ -295,6 +296,44 @@ export function commitFiles(sha, cwd) {
     const out = gitSafe(["diff-tree", "--no-commit-id", "--name-only", "-r", "--root", sha], cwd);
     return out ? out.split("\n").filter(Boolean) : [];
 }
+/** Raw `git log` over `.hunch/`, paired with parseMemoryLog — the memory-move
+ *  timeline (each commit that changed the graph). Newest first; empty on any error
+ *  (no repo / no history), so the caller degrades to an empty timeline. */
+export function gitMemoryLog(root, limit = 200) {
+    return gitSafe(["log", `--max-count=${limit}`, "--no-color", `--format=${MEMLOG_FORMAT}`, "--name-status", "--", ".hunch/"], root);
+}
+/** The diff of a single commit restricted to `.hunch/` — what one memory move
+ *  actually changed, for the click-through popup. Empty on error. */
+export function memoryMoveDiff(sha, root) {
+    return gitSafe(["show", "--no-color", "--format=%H%n%an%n%cI%n%s%n", sha, "--", ".hunch/"], root);
+}
+/** Push the current branch to its remote (the "approve-to-push" step — public
+ *  memory rides the repo, so this is a plain branch push). Returns true on success;
+ *  false when there is no upstream / offline / not a repo. */
+export function pushCurrentBranch(root) {
+    try {
+        execFileSync("git", ["-C", root, "push"], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Revert a single memory move locally (no push). Returns true on success. A
+ *  conflicting revert is aborted so the working tree is never left half-reverted. */
+export function revertMemoryMove(sha, root) {
+    try {
+        execFileSync("git", ["-C", root, "revert", "--no-edit", sha], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        try {
+            execFileSync("git", ["-C", root, "revert", "--abort"], { stdio: "ignore" });
+        }
+        catch { /* nothing to abort */ }
+        return false;
+    }
+}
 /** Full metadata + changed files for a commit. */
 export function commitMeta(sha, cwd) {
     const raw = gitSafe(["show", "-s", "--format=%H%x1f%h%x1f%s%x1f%b%x1f%an%x1f%aI", sha], cwd);