@polderlabs/bizar-omp 0.8.0 → 0.9.0

package/dist/extension.js

@@ -10,10 +10,21 @@ import { result } from "./tools/result.js";
 import { runVerification } from "./tools/verify.js";
 import { runWorkflow } from "./tools/workflow.js";
 import { analyzeRecipe } from "./services/recipes.js";
-import { freezeCheckSpec } from "./core/acceptance.js";
+import { admittedRequirements, freezeCheckSpec, receiptIntegrityHash } from "./core/acceptance.js";
+import { completableObjective } from "./services/run-contract.js";
 import { freezeObjective } from "./core/transitions.js";
 import { runCandidateCheck } from "./services/candidate-verify.js";
+import { admitNativeTasks, settleNativeCall } from "./omp/dispatch-lifecycle.js";
+import { readStructuredOutput } from "./services/specialist-contracts.js";
+import { detectStall } from "./services/stall-detector.js";
+import { lessonForNativeLearn, proposeLessons } from "./services/lesson-extraction.js";
+import { analyzeChangeImpact } from "./services/change-impact.js";
+import { createEfficiencyRecorder, recommendFromRoles, recommendFromTimeline, roleCostByDispatch } from "./services/efficiency.js";
+import { captureSnapshot, listSnapshots, previewSnapshot, restoreSnapshot, sealSnapshot } from "./services/snapshots.js";
 import { inspectEvidence } from "./services/inspector.js";
+import { addHypothesis, attachEvidence, readyToImplement, recordRepair, requiresLedger, setHypothesisStatus } from "./services/hypothesis-ledger.js";
+import { SCENARIOS, scoreAll, scoreScenario } from "./services/benchmarks.js";
+import { auxiliaryWork, emptyShepherd, observeChecks, observeReviews, recordMerge, recordPush, recordRepair as recordShepherdRepair } from "./services/pr-shepherd.js";
 import { projectWorkflow } from "./services/projection.js";
 import { capabilityReport } from "./omp/capabilities.js";
 import { repositoryIdentity, statePath, workingTreeDigest } from "./storage/repository-identity.js";
@@ -21,10 +32,12 @@ import { Journal } from "./storage/journal.js";
 import { nativeSessionReference } from "./omp/context.js";
 import { findOnPath } from "./omp/tmux.js";
 import { acquireOmpSessionLease, clearOmbSessionReference, indexOmbSessionFile, isOmbSessionName, readOmbJournalNativeId, sameOmpSessionFile } from "./omp/omb-sessions.js";
+import { normalizeRequestedModelSelectors } from "./omp/task-model-selector.js";
+import { readJournalSessionId } from "./omp/session-ownership.js";
 import { clearOmbHostGeneration, rebindOmbHostGeneration } from "./omp/tmux.js";
 import { createSessionTitleController, resolveSessionTitleLabel } from "./omp/terminal-title.js";
 import { bindSession } from "./omp/lifecycle.js";
-import { BIZAR_MODEL_ROLE_AGENT_PROMPT, BIZAR_MODEL_ROLE_TOOL, BIZAR_MODEL_ROLES, BIZAR_MODEL_TAGS, buildAgentEvaluationRequest, clipOperatorNotice, commitRolePlan, diffCatalog, formatCatalogDelta, formatRoleAssignmentPlan, planBizarModelRoles, planFromRecommendations, recordOf, reviewRoleRecommendations, roleAssignmentRoute, snapshotCatalog, isOpaqueOmniRouteCombo, omniRouteFailureGuidance, } from "./omp/model-role-assignment.js";
+import { BIZAR_MODEL_ROLE_AGENT_PROMPT, BIZAR_MODEL_ROLE_TOOL, BIZAR_MODEL_ROLES, buildAgentEvaluationRequest, clipOperatorNotice, commitRolePlan, diffCatalog, formatCatalogDelta, formatRoleAssignmentPlan, planBizarModelRoles, planFromRecommendations, recordOf, reviewRoleRecommendations, roleAssignmentRoute, snapshotCatalog, isOpaqueOmniRouteCombo, omniRouteFailureGuidance, } from "./omp/model-role-assignment.js";
 import { AGENT_ROLES } from "./omp/model-roles.js";
 import { loadOmbSettings, recordCatalogObservation } from "./omp/omb-settings.js";
 import { isRunPhaseActive } from "./core/types.js";
@@ -202,18 +215,6 @@ function applyBizarModelRoles(pi, assignments) {
         settings.setModelRole(assignment.role, assignment.selector);
     return "global";
 }
-async function setNativeSetting(pi, settings, key, value, cwd) {
-    if (settings?.set) {
-        settings.set(key, value);
-        return;
-    }
-    if (!pi.exec)
-        throw new ContractError(`OMP cannot update ${key}: its settings writer is unavailable`);
-    const command = findOnPath("omp", process.env) ?? "omp";
-    const result = await pi.exec(command, ["config", "set", key, JSON.stringify(value)], { cwd });
-    if (result.code !== 0)
-        throw new ContractError(`OMP could not update ${key} through its config command (exit ${result.code ?? "unknown"})`);
-}
 async function getNativeSetting(pi, settings, key, cwd) {
     if (settings?.get)
         return settings.get(key);
@@ -230,33 +231,6 @@ async function getNativeSetting(pi, settings, key, cwd) {
         throw new ContractError(`OMP returned invalid JSON while reading ${key}`);
     }
 }
-async function ensureBizarModelRoles(pi, cwd) {
-    const settings = pi.pi?.settings;
-    if (!settings && !pi.exec)
-        return;
-    const currentRoles = recordOf(await getNativeSetting(pi, settings, "modelRoles", cwd));
-    const missingRoles = Object.entries(BIZAR_MODEL_ROLES).filter(([role]) => typeof currentRoles[role] !== "string");
-    const projectStorage = await getNativeSetting(pi, settings, "modelRoleStorage", cwd) === "project";
-    const roleSetter = projectStorage ? settings?.setProjectModelRole : settings?.setModelRole;
-    if (roleSetter) {
-        for (const [role, selector] of missingRoles)
-            roleSetter.call(settings, role, selector);
-    }
-    const currentTags = recordOf(await getNativeSetting(pi, settings, "modelTags", cwd));
-    const nextTags = { ...currentTags };
-    for (const [role, tag] of Object.entries(BIZAR_MODEL_TAGS))
-        if (!Object.hasOwn(nextTags, role))
-            nextTags[role] = tag;
-    if (JSON.stringify(nextTags) !== JSON.stringify(currentTags))
-        await setNativeSetting(pi, settings, "modelTags", nextTags, cwd);
-    const currentCycle = await getNativeSetting(pi, settings, "cycleOrder", cwd);
-    const nextCycle = Array.isArray(currentCycle) ? currentCycle.filter((role) => typeof role === "string") : [];
-    for (const role of Object.keys(BIZAR_MODEL_ROLES))
-        if (!nextCycle.includes(role))
-            nextCycle.push(role);
-    if (JSON.stringify(nextCycle) !== JSON.stringify(currentCycle))
-        await setNativeSetting(pi, settings, "cycleOrder", nextCycle, cwd);
-}
 async function modelRoleHealth(pi, ctx, routeResponses) {
     const settings = pi.pi?.settings;
     if (!settings?.get && !pi.exec)
@@ -427,11 +401,30 @@ function applyOrchestratorPolicy(systemPrompt) {
     }
     return [MAIN_ORCHESTRATOR_POLICY];
 }
+/** Remove only Bizar's exact main-session block from a reused native prompt. */
+function removeOrchestratorPolicy(systemPrompt) {
+    if (typeof systemPrompt === "string")
+        return systemPrompt.replace(MAIN_ORCHESTRATOR_POLICY, "");
+    if (Array.isArray(systemPrompt))
+        return systemPrompt.map(String).filter(prompt => prompt !== MAIN_ORCHESTRATOR_POLICY);
+    return [];
+}
+/**
+ * OMP's public extension context identifies both the session class and its
+ * host-owned session id. Do not substitute task depth, agent names, or process
+ * state: `/tan` children have depth zero and extension factories are rebound.
+ */
+function mainSessionId(ctx) {
+    if (ctx.agent?.kind !== "main")
+        return undefined;
+    const id = ctx.sessionManager?.getSessionId?.();
+    return typeof id === "string" && id.length > 0 ? id : undefined;
+}
 export default function bizarExtension(pi) {
     pi.setLabel?.("Bizar Orchestrator");
     let binding;
     // Main orchestrator role is opt-in: task children must NEVER see it.
-    let orchestratorActive = false;
+    let orchestratorSessionId;
     // The tab title is owned here because an extension override is rendered
     // verbatim: OMP's own run-state spinner would never animate it. A Bizar host
     // would otherwise show the bare binary name in every tab, with nothing to
@@ -487,7 +480,7 @@ export default function bizarExtension(pi) {
     });
     pi.on("session_start", async (_event, ctx) => {
         binding = undefined;
-        orchestratorActive = false;
+        orchestratorSessionId = undefined;
         releaseNativeLease();
         extensionUi = ctx.ui;
         // The tab should name the conversation. OMP's own session name is the bare
@@ -497,6 +490,16 @@ export default function bizarExtension(pi) {
         sessionTitle.setLabel(sessionTitleLabel(ctx));
         const file = ctx.sessionManager?.getSessionFile?.();
         if (file && existsSync(file)) {
+            // OMP has created this journal but has not written its session header
+            // yet. Ownership is keyed on that header, so there is no ownership
+            // domain to claim and no second writer to exclude; refusing here would
+            // shut down a healthy new session. It is registered instead, and OMP
+            // keeps writing until its header lands.
+            if (!readJournalSessionId(file)) {
+                currentNativeFile = file;
+                await registerNativeFile(ctx, file);
+                return;
+            }
             try {
                 nativeLease = acquireOmpSessionLease(file);
                 currentNativeFile = file;
@@ -507,12 +510,6 @@ export default function bizarExtension(pi) {
                 ctx.shutdown?.();
             }
         }
-        try {
-            await ensureBizarModelRoles(pi, ctx.cwd ?? process.cwd());
-        }
-        catch (error) {
-            ctx.ui?.notify(`Bizar could not apply its OMP settings; continuing without the failed setting update. ${error instanceof Error ? error.message : String(error)}`, "warning");
-        }
     });
     pi.on("session_before_switch", async (event, ctx) => {
         binding = undefined;
@@ -540,6 +537,9 @@ export default function bizarExtension(pi) {
         }
     });
     pi.on("session_switch", async (_event, ctx) => {
+        // OMP only emits this after a switch commits. Keep activation intact when a
+        // preflight is cancelled, but never carry it across a committed session.
+        orchestratorSessionId = undefined;
         const file = ctx.sessionManager?.getSessionFile?.();
         if (!file || !existsSync(file)) {
             try {
@@ -626,17 +626,20 @@ export default function bizarExtension(pi) {
     pi.on("session_shutdown", async () => {
         releaseNativeLease();
         binding = undefined;
-        orchestratorActive = false;
+        orchestratorSessionId = undefined;
         sessionTitle.dispose();
         extensionUi = undefined;
     });
     pi.on("before_agent_start", (event, ctx) => {
         extensionUi = ctx?.ui ?? extensionUi;
         sessionTitle.setState("working");
+        const sessionId = mainSessionId(ctx ?? {});
+        const systemPrompt = paramsOf(event).systemPrompt;
+        const active = orchestratorSessionId !== undefined && orchestratorSessionId === sessionId;
         return {
-            systemPrompt: appendUserIdentityInvariant(orchestratorActive
-                ? applyOrchestratorPolicy(appendBizarInvariant(paramsOf(event).systemPrompt))
-                : appendBizarInvariant(paramsOf(event).systemPrompt)),
+            systemPrompt: appendUserIdentityInvariant(active
+                ? applyOrchestratorPolicy(appendBizarInvariant(systemPrompt))
+                : appendBizarInvariant(removeOrchestratorPolicy(systemPrompt))),
         };
     });
     pi.on("agent_end", (event, ctx) => {
@@ -658,6 +661,26 @@ export default function bizarExtension(pi) {
     // previously carried its own underscored copy, so every valid call to a real
     // packaged specialist was refused as a non-packaged agent.
     const BIZAR_PACKAGED_AGENTS = Object.fromEntries(AGENT_ROLES.map(name => [name, true]));
+    /** Normalize one `task` item the way the host will read it, keeping every routing-relevant field. */
+    const requestedTask = (raw) => {
+        const entry = paramsOf(raw);
+        const requested = entry.model;
+        return {
+            name: typeof entry.name === "string" ? entry.name : undefined,
+            agent: typeof entry.agent === "string" ? entry.agent : "",
+            isolated: entry.isolated === true,
+            task: typeof entry.task === "string" ? entry.task : undefined,
+            solutionSpace: typeof entry.solutionSpace === "string" ? entry.solutionSpace : undefined,
+            // OMP 18.5 carries a per-item model selector that outranks the exact-agent
+            // override and the agent's own frontmatter. Dropping it would journal a
+            // Bizar-computed role while the host ran something else. The array is
+            // forwarded as sent rather than coerced, so a non-string entry is refused
+            // by the selector validator instead of being journaled as "[object Object]".
+            ...(typeof requested === "string" ? { model: requested } : Array.isArray(requested) ? { model: requested } : {}),
+            ...(typeof entry.effort === "string" ? { effort: entry.effort } : {}),
+            ...(Array.isArray(entry.tools) ? { tools: entry.tools.map(toolName => String(toolName)) } : {}),
+        };
+    };
     /**
      * Every task in one call, in the shape the model sent it.
      *
@@ -667,15 +690,7 @@ export default function bizarExtension(pi) {
      * it, and treated a batch of individually-valid tasks as unadmitted because
      * the top-level fields were absent.
      */
-    const requestedTasks = (input) => {
-        if (!Array.isArray(input.tasks)) {
-            return [{ agent: typeof input.agent === "string" ? input.agent : "", isolated: input.isolated === true }];
-        }
-        return input.tasks.map(entry => {
-            const task = paramsOf(entry);
-            return { agent: typeof task.agent === "string" ? task.agent : "", isolated: task.isolated === true };
-        });
-    };
+    const requestedTasks = (input) => Array.isArray(input.tasks) ? input.tasks.map(requestedTask) : [requestedTask(input)];
     /**
      * Name the run that closed the gate and how to reopen it.
      *
@@ -698,13 +713,55 @@ export default function bizarExtension(pi) {
             const run = active.journal.snapshot().run;
             if (!isRunPhaseActive(run?.phase))
                 return;
+            // OMP rejects a batch-container `model` rather than dropping it. A managed
+            // run has to refuse it too, because the enclosing `catch` below treats an
+            // exception as "no opinion" and would otherwise let the call through with
+            // a selector Bizar never saw.
+            if (Array.isArray(paramsOf(params.input).tasks) && paramsOf(params.input).model !== undefined) {
+                return { block: true, reason: `A002: a batch \`task\` call cannot carry a top-level \`model\`; OMP rejects it instead of dropping it. Put \`model\` on each \`tasks[]\` item.${managedRunNotice(run)}` };
+            }
             const tasks = requestedTasks(paramsOf(params.input));
             for (const task of tasks) {
                 if (!task.isolated)
                     return { block: true, reason: `A002: managed workflow is active; native \`task\` calls must declare \`isolated: true\` on every task.${managedRunNotice(run)}` };
                 if (!BIZAR_PACKAGED_AGENTS[task.agent])
                     return { block: true, reason: `A002: managed workflow refused native \`task\` to non-packaged agent ${task.agent || "(unspecified)"}; only packaged Bizar specialists are admitted.${managedRunNotice(run)}` };
+                try {
+                    normalizeRequestedModelSelectors(task.model);
+                }
+                catch (error) {
+                    return { block: true, reason: `A002: ${error instanceof Error ? error.message : String(error)}.${managedRunNotice(run)}` };
+                }
+            }
+            // A002: the dispatch is journaled only once every task in the call is
+            // admitted, and before OMP runs any of them. A refused call leaves no
+            // dispatch behind, so nothing waits on work that will never happen.
+            try {
+                admitNativeTasks(active, run, tasks, String(params.toolCallId ?? ""));
             }
+            catch (error) {
+                return { block: true, reason: `A002: ${error instanceof Error ? error.message : String(error)}.${managedRunNotice(run)}` };
+            }
+            return;
+        }
+        catch {
+            return;
+        }
+    });
+    // A002: settle on OMP's own tool result. The recorded outcome is the host's,
+    // never the model's, so a task that errored cannot settle as success.
+    pi.on("tool_result", (event, ctx) => {
+        try {
+            const params = paramsOf(event);
+            const toolCallId = String(params.toolCallId ?? "");
+            if (!toolCallId)
+                return;
+            const active = currentBinding(ctx);
+            const run = active.journal.snapshot().run;
+            if (!run || !isRunPhaseActive(run.phase))
+                return;
+            recorderFor(run.runId).callEnded(toolCallId, params.isError === true);
+            settleNativeCall(active, run, toolCallId, { isError: params.isError === true, ...readStructuredOutput(params.details), details: params.details });
         }
         catch {
             return;
@@ -732,12 +789,81 @@ export default function bizarExtension(pi) {
             return;
         }
     });
+    // A005: notice a repeating call before it burns more turns. This never blocks
+    // a call — a stalled agent is the one least able to recover from being
+    // refused — but the notice names the repetition and the way out.
+    const recentCalls = new Map();
+    const efficiency = new Map();
+    const recorderFor = (runId) => {
+        const existing = efficiency.get(runId);
+        if (existing)
+            return existing;
+        const recorder = createEfficiencyRecorder(runId);
+        efficiency.set(runId, recorder);
+        return recorder;
+    };
+    pi.on("tool_call", (event, ctx) => {
+        try {
+            const params = paramsOf(event);
+            const toolName = String(params.toolName ?? "");
+            if (!toolName)
+                return;
+            const active = currentBinding(ctx);
+            const run = active.journal.snapshot().run;
+            if (!isRunPhaseActive(run?.phase))
+                return;
+            // The fingerprint is a digest: the input may carry a credential, and the
+            // detector needs to compare calls, never to retain what they contained.
+            const fingerprint = createHash("sha256").update(JSON.stringify(params.input ?? null)).digest("hex").slice(0, 16);
+            // Only an admitted call is timed: a call the gates refused never ran, and
+            // charging the run for it would understate what it actually cost.
+            if (params.toolCallId)
+                recorderFor(run.runId).callStarted(String(params.toolCallId), toolName, fingerprint);
+            const history = [...(recentCalls.get(run.runId) ?? []), { toolName, fingerprint }].slice(-8);
+            recentCalls.set(run.runId, history);
+            const signal = detectStall(history);
+            if (signal)
+                ctx.ui?.notify(`${signal.message} ${signal.advice}`, "warning");
+        }
+        catch {
+            return;
+        }
+    });
+    // A006: compaction is where Bizar's contract leaves the context window. It
+    // lives in the run journal, so it survives — but an agent working from a
+    // summary is working from something the gate never admitted. After a
+    // compaction that actually completed, say what the authoritative source is.
+    let compactionStarted;
+    pi.on("auto_compaction_start", (event) => {
+        const params = paramsOf(event);
+        compactionStarted = { reason: String(params.reason ?? "unknown"), action: String(params.action ?? "unknown") };
+    });
+    pi.on("auto_compaction_end", (event, ctx) => {
+        const params = paramsOf(event);
+        const started = compactionStarted;
+        compactionStarted = undefined;
+        if (params.aborted === true)
+            return;
+        const active = currentBinding(ctx);
+        const run = active.journal.snapshot().run;
+        if (!run || !isRunPhaseActive(run.phase))
+            return;
+        recorderFor(run.runId).compaction(started ? started.action : String(params.action ?? "auto"), false);
+        // Counted from the admitted objective rather than through the working-tree
+        // digest, so a session outside a repository still gets the pointer.
+        const admitted = run.objective.checkSpecs?.length ? run.objective.checkSpecs : run.objective.verificationPlan;
+        const criteria = (run.objective.criteria ?? []).filter(criterion => criterion.applicable).length;
+        ctx.ui?.notify(`Context compacted (${started ? `${started.reason}/${started.action}` : "auto"}). The admitted contract is in the run journal, not in this context: re-read it with bizar_inspect before continuing — ${admitted.length} admitted checks, ${criteria} criteria.`, "warning");
+    });
     pi.registerTool({
         name: "bizar_apply_main_orchestrator_role", label: "Bizar Apply Main Orchestrator Role",
         description: "Activate the main orchestrator role in this session; required so that before_agent_start injects the orchestrator policy. Task children must never invoke this.",
         parameters: pi.zod.object({}),
-        async execute(_id, _raw, _signal, _onUpdate, _ctx) {
-            orchestratorActive = true;
+        async execute(_id, _raw, _signal, _onUpdate, ctx) {
+            const sessionId = mainSessionId(ctx);
+            if (!sessionId)
+                return failure(new ContractError("The main orchestrator role can only be activated from an identified OMP main session; subagents and hosts without a native session identity are refused."));
+            orchestratorSessionId = sessionId;
             return result({ orchestratorActive: true, scope: "main-session-only", note: "Main orchestrator policy will be appended to subsequent agent system prompts in this session. Task children must not invoke this tool." });
         },
     });
@@ -778,15 +904,17 @@ export default function bizarExtension(pi) {
                 const receiptId = `receipt_${randomUUID()}`;
                 const issuedAt = new Date().toISOString();
                 const verdict = String(p.verdict);
-                const signedContent = JSON.stringify({ workItemId: p.workItemId, evidenceId, verdict, operatorId, issuedAt });
-                const signedContentHash = createHash("sha256").update(signedContent).digest("hex");
                 const receipt = {
                     id: receiptId, runId: state.run.runId, workItemId: String(p.workItemId),
                     evidenceId, verdict, rationale: String(p.rationale),
-                    operatorId, signedContentHash, issuedAt,
+                    operatorId, signedContentHash: "", issuedAt,
+                    authority: "environment-configured-identity",
                 };
+                // Hash the assembled receipt so the digest covers every field the
+                // verdict asserts, and acceptance can re-derive it later.
+                receipt.signedContentHash = receiptIntegrityHash(receipt);
                 active.journal.append({ type: "operator.receipt.recorded", runId: state.run.runId, receipt }, `receipt:${receiptId}`, state.revision);
-                return result({ receiptId, verdict, operatorId, signedContentHash });
+                return result({ receiptId, verdict, operatorId, signedContentHash: receipt.signedContentHash, authority: receipt.authority });
             }
             catch (error) {
                 return failure(error);
@@ -796,7 +924,7 @@ export default function bizarExtension(pi) {
     pi.registerTool({
         name: "bizar_workflow", label: "Bizar Workflow", description: "Create, inspect, and advance a typed Bizar workflow; transitions are journaled and revision checked.",
         parameters: pi.zod.object({
-            action: pi.zod.enum(["start", "status", "transition", "add-work", "accept-work", "complete", "cancel", "next", "amend-objective"]),
+            action: pi.zod.enum(["start", "status", "transition", "add-work", "accept-work", "complete", "cancel", "next", "next-batch", "amend-objective"]),
             objective: pi.zod.union([pi.zod.string(), objectiveSchema(pi.zod)]).optional(),
             to: pi.zod.string().optional(),
             reason: pi.zod.string().optional(),
@@ -805,13 +933,14 @@ export default function bizarExtension(pi) {
             evidenceIds: pi.zod.array(pi.zod.string()).optional(),
             requiredChecks: pi.zod.array(pi.zod.string()).optional(),
             by: pi.zod.enum(["criterion", "check-spec"]).optional(),
+            capacity: pi.zod.number().optional(),
         }),
         async execute(_id, raw, _signal, _onUpdate, ctx) {
             try {
                 const active = currentBinding(ctx);
                 const p = paramsOf(raw);
                 const action = String(p.action);
-                const payload = action === "start" ? { ...p, objective: objectiveOf(p.objective) } : p;
+                const payload = action === "start" ? { ...p, objective: completableObjective(objectiveOf(p.objective), ctx.cwd ?? active.cwd) } : p;
                 return result(runWorkflow(active, action, payload));
             }
             catch (error) {
@@ -928,16 +1057,225 @@ export default function bizarExtension(pi) {
             }
         },
     });
+    pi.registerTool({
+        name: "bizar_propose_lesson", label: "Bizar Propose Lesson",
+        description: "Derive post-run lessons from accepted work and the evidence that proved it. Hand each returned rule to OMP's native `learn` tool; OMP owns memory, Bizar owns the derivation.",
+        parameters: pi.zod.object({}),
+        async execute(_id, _raw, _signal, _onUpdate, ctx) {
+            try {
+                const active = currentBinding(ctx);
+                const state = active.journal.snapshot();
+                if (!state.run)
+                    throw new ContractError("No workflow run exists; start one first");
+                const lessons = proposeLessons(state, state.run);
+                return result({
+                    count: lessons.length,
+                    lessons: lessons.map(lessonForNativeLearn),
+                    source: lessons,
+                    note: lessons.length
+                        ? "Pass each rule to OMP's `learn` tool; Bizar derives lessons from evidence and never writes memory itself."
+                        : "No accepted work carries passing evidence yet, so there is nothing to learn from without laundering an assertion.",
+                });
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
     pi.registerTool({
         name: "bizar_inspect", label: "Bizar Inspector", description: "Explain acceptance blockers and evidence lineage using the same decision function as completion.",
-        parameters: pi.zod.object({ requiredChecks: pi.zod.array(pi.zod.string()), targetDigest: pi.zod.string() }),
+        parameters: pi.zod.object({}),
         async execute(_id, raw, _signal, _onUpdate, ctx) {
             try {
                 const active = currentBinding(ctx);
-                const p = paramsOf(raw);
-                const checks = Array.isArray(p.requiredChecks) ? p.requiredChecks.map(String) : [];
-                const target = String(p.targetDigest);
-                return result({ inspection: inspectEvidence(active.journal.snapshot(), { requiredChecks: checks, targetDigest: target }), projection: projectWorkflow(active.journal.snapshot(), { requiredChecks: checks, targetDigest: target }) });
+                const state = active.journal.snapshot();
+                if (!state.run)
+                    throw new ContractError("No workflow run exists; start one first");
+                // The admitted contract, not the caller's list. A caller able to narrow
+                // the requirement set could report a run as unblocked that completion
+                // will refuse.
+                const requirements = admittedRequirements(state.run, state.run.workItems, workingTreeDigest(active.cwd));
+                return result({ inspection: inspectEvidence(state, requirements, active), projection: projectWorkflow(state, requirements) });
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
+    pi.registerTool({
+        name: "bizar_change_impact", label: "Bizar Change Impact",
+        description: "Read the changed paths' blast radius from the tree: trust boundaries, entry points, workspace crossings and the method tier that follows.",
+        parameters: pi.zod.object({}),
+        async execute(_id, _raw, _signal, _onUpdate, ctx) {
+            try {
+                return result(analyzeChangeImpact(ctx.cwd ?? process.cwd()));
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
+    pi.registerTool({
+        name: "bizar_run_efficiency", label: "Bizar Run Efficiency",
+        description: "Report what this managed run actually spent time on: call durations, failures, repeated inputs and compactions, with advisory recommendations and the signals the host cannot expose.",
+        parameters: pi.zod.object({}),
+        async execute(_id, _raw, _signal, _onUpdate, ctx) {
+            try {
+                const active = currentBinding(ctx);
+                const state = active.journal.snapshot();
+                if (!state.run)
+                    throw new ContractError("No workflow run exists; start one first");
+                const timeline = recorderFor(state.run.runId).timeline();
+                const costs = roleCostByDispatch(timeline, state.dispatches);
+                return result({ ...timeline, recommendations: recommendFromTimeline(timeline), roleCosts: costs, roleRecommendations: recommendFromRoles(costs) });
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
+    pi.registerTool({
+        name: "bizar_edit_snapshot", label: "Bizar Edit Snapshot",
+        description: "Capture a bounded pre-edit baseline for the paths a focused task will touch, seal it after the edit, and undo exactly those paths when the change turns out to be wrong.",
+        parameters: pi.zod.object({
+            action: pi.zod.enum(["capture", "seal", "preview", "restore", "list"]),
+            id: pi.zod.string().optional(),
+            paths: pi.zod.array(pi.zod.string()).optional(),
+        }),
+        async execute(_id, raw, _signal, _onUpdate, ctx) {
+            try {
+                const cwd = ctx.cwd ?? process.cwd();
+                const params = paramsOf(raw);
+                const action = String(params.action);
+                if (action === "list")
+                    return result({ snapshots: listSnapshots(cwd) });
+                if (action === "capture") {
+                    if (!Array.isArray(params.paths) || params.paths.length === 0)
+                        throw new ContractError("capture needs the paths the task will edit");
+                    return result({ snapshot: captureSnapshot(cwd, params.paths.map(String), { runId: currentBinding(ctx).journal.snapshot().run?.runId }) });
+                }
+                const snapshotId = String(params.id ?? "");
+                if (!snapshotId)
+                    throw new ContractError(`The ${action} action needs a snapshot id`);
+                if (action === "seal")
+                    return result({ snapshot: sealSnapshot(cwd, snapshotId) });
+                if (action === "preview")
+                    return result(previewSnapshot(cwd, snapshotId));
+                return result(restoreSnapshot(cwd, snapshotId));
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
+    /** Run-scoped ledgers. Survives compaction and session switch; does not outlive the host process. */
+    const hypothesisLedgers = new Map();
+    /** Run-scoped shepherd state. Bizar holds policy here; the host owns the GitHub calls. */
+    const shepherds = new Map();
+    pi.registerTool({
+        name: "bizar_hypothesis_ledger", label: "Bizar Hypothesis Ledger",
+        description: "Track competing root-cause hypotheses and the repairs attempted against them, so an unknown-cause bug stops turning into patch churn.",
+        parameters: pi.zod.object({
+            action: pi.zod.enum(["required", "add", "attach", "support", "refute", "repair", "status"]),
+            statement: pi.zod.string().optional(),
+            hypothesisId: pi.zod.string().optional(),
+            evidenceIds: pi.zod.array(pi.zod.string()).optional(),
+            outcome: pi.zod.enum(["failed", "confirmed", "inconclusive"]).optional(),
+            note: pi.zod.string().optional(),
+            text: pi.zod.string().optional(),
+        }),
+        async execute(_id, raw, _signal, _onUpdate, ctx) {
+            try {
+                const params = paramsOf(raw);
+                const action = String(params.action);
+                if (action === "required")
+                    return result({ required: requiresLedger({ text: String(params.text ?? "") }) });
+                const active = currentBinding(ctx);
+                const state = active.journal.snapshot();
+                if (!state.run)
+                    throw new ContractError("No workflow run exists; start one first");
+                const runId = state.run.runId;
+                const ledgers = hypothesisLedgers.get(runId) ?? { hypotheses: [], attempts: [] };
+                const evidenceIds = Array.isArray(params.evidenceIds) ? params.evidenceIds.map(String) : [];
+                const hypothesisId = String(params.hypothesisId ?? "");
+                const save = (ledger, extra = {}) => { hypothesisLedgers.set(runId, ledger); return result({ ledger, readyToImplement: readyToImplement(ledger), ...extra }); };
+                if (action === "status")
+                    return save(ledgers);
+                if (action === "add")
+                    return save(addHypothesis(ledgers, String(params.statement ?? ""), evidenceIds));
+                if (action === "attach")
+                    return save(attachEvidence(ledgers, hypothesisId, evidenceIds));
+                if (action === "support" || action === "refute")
+                    return save(setHypothesisStatus(ledgers, hypothesisId, action === "support" ? "supported" : "refuted", String(params.note ?? "")));
+                const outcome = recordRepair(ledgers, hypothesisId, params.outcome === "confirmed" || params.outcome === "inconclusive" ? params.outcome : "failed", String(params.note ?? ""));
+                return save(outcome.ledger, { advice: outcome.advice });
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
+    pi.registerTool({
+        name: "bizar_benchmarks", label: "Bizar Behaviour Benchmarks",
+        description: "Score this run's observed behaviour against the scenarios the operator actually pays for: avoidable spawns, repeated calls, retry loops and repository-wide gates.",
+        parameters: pi.zod.object({ scenarioId: pi.zod.string().optional() }),
+        async execute(_id, raw, _signal, _onUpdate, ctx) {
+            try {
+                const active = currentBinding(ctx);
+                const state = active.journal.snapshot();
+                if (!state.run)
+                    throw new ContractError("No workflow run exists; start one first");
+                const timeline = recorderFor(state.run.runId).timeline();
+                const observed = {
+                    toolCalls: timeline.entries.filter(entry => entry.kind === "tool" && entry.tool !== undefined).map(entry => ({ tool: entry.tool, fingerprint: entry.fingerprint ?? "", ...(entry.failed === undefined ? {} : { failed: entry.failed }) })),
+                    spawnedAgents: state.dispatches.length,
+                    validatedChecks: [...new Set(state.evidence.map(record => record.checkId))],
+                    totals: timeline.totals,
+                };
+                const requested = String(paramsOf(raw).scenarioId ?? "");
+                const scores = requested ? SCENARIOS.filter(entry => entry.id === requested).map(entry => scoreScenario(entry, observed)) : scoreAll(observed);
+                if (requested && !scores.length)
+                    throw new ContractError(`No benchmark scenario named ${requested}`);
+                return result({ scores, passed: scores.every(entry => entry.passed) });
+            }
+            catch (error) {
+                return failure(error);
+            }
+        },
+    });
+    pi.registerTool({
+        name: "bizar_pr_shepherd", label: "Bizar PR Shepherd",
+        description: "Track the pull-request lifecycle as a state machine: the exact SHA under review, observed checks and reviews, a bounded repair budget, and the next condition to wait for. Bizar does not talk to GitHub; report what the host's native tool saw.",
+        parameters: pi.zod.object({
+            action: pi.zod.enum(["status", "push", "checks", "reviews", "repair", "merge", "auxiliary"]),
+            pullRequest: pi.zod.number().optional(),
+            sha: pi.zod.string().optional(),
+            mergeability: pi.zod.enum(["mergeable", "blocked", "conflicted", "unknown"]).optional(),
+            checks: pi.zod.array(pi.zod.object({ name: pi.zod.string(), required: pi.zod.boolean(), state: pi.zod.enum(["pending", "passing", "failing"]) })).optional(),
+            reviews: pi.zod.array(pi.zod.object({ id: pi.zod.string(), blocking: pi.zod.boolean(), resolved: pi.zod.boolean(), summary: pi.zod.string() })).optional(),
+            note: pi.zod.string().optional(),
+        }),
+        async execute(_id, raw, _signal, _onUpdate, ctx) {
+            try {
+                const params = paramsOf(raw);
+                const action = String(params.action);
+                const active = currentBinding(ctx);
+                const runId = active.journal.snapshot().run?.runId ?? "no-run";
+                const store = shepherds.get(runId) ?? emptyShepherd(active.cwd, currentBinding(ctx).journal.snapshot().run?.objective ? "current" : "unknown");
+                const save = (state, extra = {}) => { shepherds.set(runId, state); return result({ ...state, ...extra }); };
+                if (action === "status")
+                    return save(store);
+                if (action === "auxiliary")
+                    return save(store, { auxiliaryWork: auxiliaryWork(store) });
+                if (action === "push")
+                    return save(recordPush(store, { sha: String(params.sha ?? ""), pullRequest: Number(params.pullRequest ?? 0), mergeability: params.mergeability }));
+                if (action === "checks")
+                    return save(observeChecks(store, { sha: String(params.sha ?? ""), checks: Array.isArray(params.checks) ? params.checks : [], mergeability: params.mergeability }));
+                if (action === "reviews")
+                    return save(observeReviews(store, Array.isArray(params.reviews) ? params.reviews : []));
+                if (action === "repair")
+                    return save(recordShepherdRepair(store, { sha: String(params.sha ?? ""), note: String(params.note ?? "") }));
+                return save(recordMerge(store));
             }
             catch (error) {
                 return failure(error);
@@ -1012,7 +1350,7 @@ export default function bizarExtension(pi) {
                 else {
                     const active = currentBinding(ctx);
                     if (command === "run" || command === "init")
-                        value = runWorkflow(active, "start", { objective: objectiveOf(words.join(" ")) });
+                        value = runWorkflow(active, "start", { objective: completableObjective(objectiveOf(words.join(" ")), active.cwd) });
                     else if (command === "status" || command === "next")
                         value = runWorkflow(active, command === "next" ? "next" : "status", {});
                     else if (command === "cancel")
@@ -1021,8 +1359,12 @@ export default function bizarExtension(pi) {
                         value = listEvidence(active);
                     else if (command === "recipe")
                         value = analyzeRecipe(active.cwd, objectiveOf(words.join(" ")));
-                    else if (command === "inspect")
-                        value = projectWorkflow(active.journal.snapshot(), { requiredChecks: active.journal.snapshot().run?.objective.verificationPlan ?? [], targetDigest: workingTreeDigest(active.cwd) });
+                    else if (command === "inspect") {
+                        const state = active.journal.snapshot();
+                        if (!state.run)
+                            throw new ContractError("No workflow run exists; start one first");
+                        value = projectWorkflow(state, admittedRequirements(state.run, state.run.workItems, workingTreeDigest(active.cwd)));
+                    }
                     else
                         throw new ContractError(`Unknown /bizar command: ${command}`);
                 }