@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/core/bind.js

@@ -3,12 +3,12 @@ import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
 import { activeLedgerRef, appendEntry, appendWithRetry, readLedger } from "./ledger.js";
-import { parseBindDraft } from "./draft.js";
+import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
 import { assertValidContractId, buildContractId } from "./ids.js";
 import { registerScope, releaseScope } from "./registry.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { normalizeTargetRef } from "./target-ref.js";
-import { reconcileTaskForfeit, settleTaskBoardForBind } from "./task-contract.js";
+import { reconcileTaskForfeit, settleTaskBoardForBind } from "./task/index.js";
 import { bootstrapEntryDataFromObservation, isBootstrapSuccess, runWorktreeBootstrap, } from "./worktree-bootstrap.js";
 import { contractWorktreePathFromBind, stableRepoRoot } from "./worktree-path.js";
 import { allocateWorktreePlace, cleanupCreatedBindResources, createContractBranch, defaultCreateWorktree, materializeContractView, resolveTreeRoot, } from "./bind-workspace.js";
@@ -107,8 +107,40 @@ function makeBindEntry(input) {
         },
     };
 }
+function taskBindDefaults(task) {
+    const defaults = { name: task.title };
+    const objective = task.body.trim();
+    if (objective.length > 0)
+        defaults.objective = objective;
+    return defaults;
+}
+function incompleteTaskBindError(taskId, missing) {
+    const coordinate = taskId;
+    const template = renderMissingBindSectionsTemplate(missing);
+    const message = [
+        `task ${coordinate} carries no ${describeMissingBindSections(missing)}`,
+        `» keiyaku bind --task ${coordinate} - <<'KEIYAKU'`,
+        template,
+        "KEIYAKU",
+    ].join("\n");
+    return new FlowError("BIND_TASK_INCOMPLETE", message);
+}
+/**
+ * Section-level merge for `bind --task`: task title/body are name/objective
+ * defaults; stdin partial markdown sections override. Missing required sections
+ * fail with a paste-ready partial heredoc template.
+ */
+export function composeTaskBindDraft(input) {
+    const merged = mergeBindDraft(taskBindDefaults(input.task), parsePartialBindDraft(input.draft));
+    const missing = missingBindDraftSections(merged);
+    if (missing.length > 0) {
+        throw incompleteTaskBindError(input.task.id, missing);
+    }
+    return materializeBindDraft(merged);
+}
 export async function bindContract(input) {
-    const draft = parseBindDraft(input.draft);
+    const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
+    const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
     const workspace = input.workspace ?? "here";
     const at = new Date(input.nowMs).toISOString();
     const defaultBranch = await resolveDefaultBranch(input.cwd);
@@ -126,47 +158,60 @@ export async function bindContract(input) {
     for (let attempt = 0; attempt < 2; attempt += 1) {
         const randomBytes = input.randomBytes?.(attempt) ?? randomBytesDefault();
         const place = workspace === "worktree" ? await allocateWorktreePlace(input.cwd, randomBytes) : undefined;
-        const id = buildContractId({
-            name: draft.name,
-            nowMs: input.nowMs,
-            randomBytes,
-        });
-        await assertValidContractId(input.cwd, id);
-        const ref = activeLedgerRef(id);
         let settlement;
         try {
-            settlement = await settleTaskBoardForBind({
-                cwd: input.cwd,
-                ...(input.taskId === undefined ? {} : { taskId: input.taskId }),
-                contractId: id,
-                publishLedger: async (base) => {
-                    const entry = makeBindEntry({
-                        id,
-                        at,
-                        actor: input.actor,
-                        draft,
-                        base,
-                        target,
-                        after: input.after ?? [],
-                        workspace,
-                        place,
-                        bootstrap: bootstrapPlan,
+            const prepare = async (draft) => {
+                const id = buildContractId({ name: draft.name, nowMs: input.nowMs, randomBytes });
+                await assertValidContractId(input.cwd, id);
+                const ref = activeLedgerRef(id);
+                return {
+                    contractId: id,
+                    publishLedger: async (base) => {
+                        const entry = makeBindEntry({
+                            id,
+                            at,
+                            actor: input.actor,
+                            draft,
+                            base,
+                            target,
+                            after: input.after ?? [],
+                            workspace,
+                            place,
+                            bootstrap: bootstrapPlan,
+                        });
+                        const appended = await appendEntry(input.cwd, ref, entry, null);
+                        if (!appended.ok)
+                            throw new BindLedgerCollisionError(id);
+                        return { entry, appended };
+                    },
+                };
+            };
+            settlement = !isTaskBound
+                ? await (async () => {
+                    const prepared = await prepare(ordinaryDraft);
+                    return settleTaskBoardForBind({ cwd: input.cwd, signal: input.signal, ...prepared });
+                })()
+                : await (async () => {
+                    return settleTaskBoardForBind({
+                        cwd: input.cwd,
+                        taskIds: input.taskIds,
+                        signal: input.signal,
+                        prepare: async (tasks) => prepare(composeTaskBindDraft({ task: tasks[0], draft: input.draft })),
                     });
-                    const appended = await appendEntry(input.cwd, ref, entry, null);
-                    if (!appended.ok)
-                        throw new BindLedgerCollisionError(id);
-                    return { entry, appended };
-                },
-            });
+                })();
         }
         catch (error) {
             if (error instanceof BindLedgerCollisionError) {
-                collidedIds.push(id);
+                // The selected task's locked snapshot chose this attempted identity.
+                // Record the concrete id only when preparation reached publication.
+                collidedIds.push(error.contractId);
                 continue;
             }
             throw error;
         }
         const { entry, appended } = settlement.ledger;
+        const id = settlement.contractId;
+        const ref = activeLedgerRef(id);
         const base = settlement.boardCommit;
         const resources = { id };
         const branch = `keiyaku/${id}`;
@@ -179,7 +224,7 @@ export async function bindContract(input) {
             const tree = await resolveTreeRoot(input.cwd, workspace, id, entry);
             const registration = await registerScope(input.cwd, {
                 contractId: id,
-                scope: draft.scope,
+                scope: entry.data.scope,
                 tree,
                 actor: input.actor,
                 at,
@@ -219,11 +264,13 @@ export async function bindContract(input) {
             return {
                 id,
                 ref,
+                target,
+                place: workspace === "worktree" ? entry.data.place ?? null : null,
                 branch: workspace === "worktree" ? branch : undefined,
                 worktreePath: targetRoot,
                 workspace,
                 ledgerHead,
-                warnings: registration.warnings,
+                scopeOverlaps: registration.overlaps,
             };
         }
         catch (error) {

package/build/core/call/call.js

@@ -8,10 +8,8 @@ import { ACTOR_IDENTITY } from "../../keiyaku.js";
 import { appendDebugBlock } from "../../telemetry/debug-log.js";
 import { logInfo } from "../../telemetry/logger.js";
 import { withResolvedAddress } from "../addressing.js";
-import { assertProjectionAlias } from "../projection-alias.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "../projection-generation-launcher.js";
-import { observeProjectionLife } from "../projection-life-observer.js";
-import { waitForProjection } from "../projection-wait.js";
+import { assertProjectionAlias, PROJECTION_ADOPTION_TIMEOUT_MS, observeProjectionLife, waitForProjection, } from "../projection/index.js";
+import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { requireResumableArtifact } from "../transcripts.js";
 import { stableRepoRoot } from "../worktree-path.js";
 import { readCallKeiyakuContext } from "./context.js";
@@ -23,6 +21,9 @@ function renderSubagentWarning(warning) {
         const status = warning.errorStatus === null ? "no response" : String(warning.errorStatus);
         return `Provider warning: retry. attempt=${warning.attempt}, maxRetries=${warning.maxRetries}, retryDelayMs=${warning.retryDelayMs}, errorStatus=${status}`;
     }
+    if (warning.reason === "rate-limit") {
+        return "Provider warning: rate limit exhausted.";
+    }
     const modelTransition = warning.originalModel && warning.fallbackModel
         ? `${warning.originalModel} -> ${warning.fallbackModel}`
         : warning.originalModel ?? warning.fallbackModel;
@@ -42,18 +43,18 @@ export async function execSubagent(agentName, prompt, cwd, options) {
 export async function runCall(input) {
     const { signal, agent } = input;
     const reviveArtifact = input.reviveArtifact ? requireResumableArtifact(input.reviveArtifact) : undefined;
-    let rawCwd = input.cwd;
-    let rawRepo = input.repo;
+    let rawCwd = normalizeFilesystemCoordinate(input.cwd);
+    let rawRepo = input.repo === undefined ? undefined : normalizeFilesystemCoordinate(input.repo);
     if (reviveArtifact?.provenance.authority.kind === "user") {
         if (!("workdir" in reviveArtifact.provenance.evidence)) {
             throw new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${reviveArtifact.artifactId}': field 'provenance.evidence.workdir' is missing.`);
         }
-        rawCwd = reviveArtifact.provenance.evidence.workdir;
+        rawCwd = normalizeFilesystemCoordinate(reviveArtifact.provenance.evidence.workdir);
         rawRepo = undefined;
     }
     else if (reviveArtifact?.provenance.authority.kind === "repository") {
         const artifactHome = await fs.realpath(reviveArtifact.storageRoot);
-        const addressed = input.repo ?? input.cwd;
+        const addressed = normalizeFilesystemCoordinate(input.repo ?? input.cwd);
         const observation = await observeGitRepository(addressed);
         const coordinate = assertGitObservation(observation, "revive");
         if (coordinate === "repository") {
@@ -91,6 +92,7 @@ export async function runCall(input) {
             context: input.context,
             referenceFiles,
             currentIntent: keiyakuContext.currentIntent,
+            commissioned: keiyakuContext.address.binding.kind === "commission",
         });
         const launchSnapshot = reviveArtifact
             ? input.effort !== undefined
@@ -146,7 +148,11 @@ export async function runCall(input) {
                 ...(launched.projection.alias ? { alias: launched.projection.alias } : {}),
                 ...(launched.projection.previousAliasTarget ? { previousAliasTarget: launched.projection.previousAliasTarget } : {}),
             };
-            input.onLaunch?.({ address: keiyakuContext.address, projection: adoptedProjection });
+            input.onLaunch?.({
+                address: keiyakuContext.address,
+                projection: adoptedProjection,
+                akumaName: launchSnapshot.akuma.name,
+            });
             if (input.detach) {
                 return {
                     state: "launched",

package/build/core/call/context.js

@@ -3,10 +3,11 @@ import { FlowError } from "../../flow-error.js";
 import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
 import { createGit, wrapGitError } from "../../git/core.js";
 import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveContractAddress, withResolvedAddress, } from "../addressing.js";
+import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { findOpenArcView } from "../arc.js";
 import { readLedger } from "../ledger.js";
 import { deriveContractState, isTerminalState } from "../status/lifecycle.js";
-import { contractPresentedByWorktree, contractWorktreePathFromBind, stableRepoRoot } from "../worktree-path.js";
+import { contractWorktreePathFromBind, stableRepoRoot } from "../worktree-path.js";
 async function findWorktreePathForContract(cwd, contractId) {
     const git = createGit(cwd);
     let output;
@@ -47,6 +48,8 @@ async function resolveWorkspaceCwd(cwd, contractId, bind) {
     return worktreePath;
 }
 export async function readCallKeiyakuContext(executionCwd, input) {
+    executionCwd = normalizeFilesystemCoordinate(executionCwd);
+    input.repoCwd = input.repoCwd === undefined ? undefined : normalizeFilesystemCoordinate(input.repoCwd);
     const ledgerCandidate = input.repoCwd ?? executionCwd;
     const ledgerObservation = await observeGitRepository(ledgerCandidate);
     if (ledgerObservation.capability === "unknown")
@@ -136,7 +139,7 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             },
         }));
     }
-    if (input.bare) {
+    if (input.bare || !input.contractId) {
         return {
             activeKeiyaku: false,
             effectiveCwd: executionCwd,
@@ -150,55 +153,7 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             }),
         };
     }
-    let address;
-    if (input.contractId) {
-        address = await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource);
-    }
-    else {
-        const executionObservation = await observeGitRepository(executionCwd);
-        if (executionObservation.capability === "unknown")
-            throw executionObservation.error;
-        if (executionObservation.capability === "available" && executionObservation.coordinate === "repository") {
-            const executionRepo = await stableRepoRoot(executionCwd);
-            if (input.repoCwd && executionRepo !== ledgerCwd) {
-                const presented = await contractPresentedByWorktree(executionCwd);
-                if (presented) {
-                    throw new FlowError("EMPTY_PARAM", `cross-repository contract-worktree addressing is pending: -C presents @${presented} from ${executionRepo}, but --repo selects ${ledgerCwd}`);
-                }
-            }
-            else {
-                const presented = await contractPresentedByWorktree(executionCwd);
-                if (presented) {
-                    address = await resolveContractAddress(ledgerCwd, presented, "worktree-presented");
-                }
-            }
-        }
-    }
-    if (!address) {
-        try {
-            address = await resolveContractAddress(ledgerCwd);
-        }
-        catch (error) {
-            if (error instanceof AddressResolutionError
-                && error.code === "EMPTY_PARAM"
-                && error.attempt.expected === "commission"
-                && error.attempt.candidates.length === 0) {
-                return {
-                    activeKeiyaku: false,
-                    effectiveCwd: executionCwd,
-                    historyCwd: ledgerCwd,
-                    profileCwd: ledgerCwd,
-                    projectionCwd: ledgerCwd,
-                    address: buildUncommissionedRepositoryAddress({
-                        stableRoot: ledgerCwd,
-                        workdir: executionCwd,
-                        binding: "unbound",
-                    }),
-                };
-            }
-            throw error;
-        }
-    }
+    const address = await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
         const contractId = address.binding.commissionId;
         const ledger = await readLedger(ledgerCwd, contractId);

package/build/core/call/execution.js

@@ -3,14 +3,14 @@ import { createAbortError, restoreOutcome, SubagentFailure, } from "../../agents
 import { resolveAkumaLaunchSnapshot } from "../../agents/launch-snapshot/resolve.js";
 import { selectSubagent } from "../../agents/selector.js";
 import { FlowError } from "../../flow-error.js";
-import { assertProjectionAlias, moveProjectionAlias } from "../projection-alias.js";
-import { projectionDir } from "../projection-core.js";
-import { createProjectionExecutionId } from "../projection-generation-identity.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration } from "../projection-generation-launcher.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "../projection/generation/store.js";
-import { observeProjectionLife } from "../projection-life-observer.js";
-import { mintProjection, mintRepositoryProjection } from "../projection-mint.js";
-import { waitForProjection } from "../projection-wait.js";
+import { assertProjectionAlias, moveProjectionAlias } from "../projection/index.js";
+import { projectionDir } from "../projection/index.js";
+import { createProjectionExecutionId } from "../projection/index.js";
+import { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration } from "../projection/index.js";
+import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "../projection/index.js";
+import { observeProjectionLife } from "../projection/index.js";
+import { mintProjection, mintRepositoryProjection } from "../projection/index.js";
+import { waitForProjection } from "../projection/index.js";
 export function readCurrentGenerationOrThrow(projectionDirectory) {
     const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
     try {
@@ -148,7 +148,7 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
         };
         const minted = options.authority.kind === "repository"
             ? await mintRepositoryProjection({ ...mintInput, authority: { kind: "repository" } })
-            : mintProjection({ ...mintInput, authority: { kind: "user" } });
+            : await mintProjection({ ...mintInput, authority: { kind: "user" } });
         const executionId = createProjectionExecutionId();
         const launchFacts = JSON.parse(JSON.stringify({
             executionId,
@@ -159,6 +159,7 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
                 task: options.task ?? prompt,
                 launchSnapshot,
                 idleTimeoutMs: resolvedTerms.idleTimeoutMs,
+                executionTimeoutMs: resolvedTerms.executionTimeoutMs,
                 cwd,
                 historyCwd: options.historyStorageCwd ?? cwd,
                 ...(options.evidenceCwd !== undefined ? { evidenceCwd: options.evidenceCwd } : {}),
@@ -184,20 +185,19 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
         }
         const previousAliasTarget = options.alias === undefined
             ? undefined
-            : moveProjectionAlias(options.projectionCwd ?? cwd, assertProjectionAlias(options.alias), minted.id);
-        const previousAliasTargetStillRunning = previousAliasTarget === undefined
-            ? undefined
-            : (() => {
-                try {
-                    const phase = observeProjectionLife(projectionDir(options.projectionCwd ?? cwd, previousAliasTarget), { nowMs: Date.now(), startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS }).phase;
-                    return phase === "minting" || phase === "active" || phase === "quiescent"
-                        ? previousAliasTarget
-                        : undefined;
-                }
-                catch {
-                    return undefined;
+            : await moveProjectionAlias(options.projectionCwd ?? cwd, assertProjectionAlias(options.alias), minted.id);
+        let previousAliasTargetStillRunning;
+        if (previousAliasTarget !== undefined) {
+            try {
+                const phase = observeProjectionLife(await projectionDir(options.projectionCwd ?? cwd, previousAliasTarget), { nowMs: Date.now(), startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS }).phase;
+                if (phase === "minting" || phase === "active" || phase === "quiescent") {
+                    previousAliasTargetStillRunning = previousAliasTarget;
                 }
-            })();
+            }
+            catch {
+                previousAliasTargetStillRunning = undefined;
+            }
+        }
         return {
             id: minted.id,
             dir: minted.dir,

package/build/core/call/prompt.js

@@ -1,4 +1,10 @@
 import { ACTOR_IDENTITY } from "../../keiyaku.js";
+const COMMISSIONED_DELIVERY_BOUNDARY = [
+    "Delivery boundary: edit and test only inside this linked contract worktree.",
+    "Leave source changes uncommitted as a dirty working tree, then report changed files and checks run.",
+    "Do not run git add, git commit, or any command that writes Git metadata. A refused Git metadata write is not a failed delivery.",
+    "The host coordinator reviews and commits accepted bytes, then continues arc, renew, or petition settlement.",
+].join(" ");
 export function buildCallPrompt(input) {
     const references = [...new Set((input.referenceFiles ?? []).map((file) => file.trim()).filter(Boolean))];
     if (input.currentIntent?.source === "arc") {
@@ -9,6 +15,7 @@ export function buildCallPrompt(input) {
             `Title: ${arc.title}`,
             `Objective: ${arc.objective}`,
             `Brief:\n${arc.brief}`,
+            COMMISSIONED_DELIVERY_BOUNDARY,
             "",
             `Task:\n${input.task}`,
             `Context:\n${input.context?.trim() || "(none provided)"}`,
@@ -30,13 +37,19 @@ export function buildCallPrompt(input) {
             `Scope:\n${bind.scope.map((value) => `- ${value}`).join("\n")}`,
             `Checks:\n${bind.checks.map((value) => `- ${value}`).join("\n")}`,
             extensionsBlock,
+            COMMISSIONED_DELIVERY_BOUNDARY,
             `Task:\n${input.task}`,
             trimmedContext ? `Context:\n${trimmedContext}` : "",
             references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : "",
             "Provide the final result for the caller/main agent.",
         ].filter(Boolean).join("\n\n");
     }
-    return [input.task, input.context?.trim() ?? "", references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : ""]
+    return [
+        input.task,
+        input.context?.trim() ?? "",
+        input.commissioned ? COMMISSIONED_DELIVERY_BOUNDARY : "",
+        references.length > 0 ? `Reference files:\n${references.map((file) => `- ${file}`).join("\n")}` : "",
+    ]
         .filter(Boolean)
         .join("\n\n");
 }

package/build/core/command-markdown.js

@@ -0,0 +1,45 @@
+import { FlowError } from "../flow-error.js";
+import { parseMarkdownListSection, parseMarkdownStructure } from "./markdown/sections.js";
+import { KeiyakuParseError } from "./markdown/types.js";
+import { normalizeSectionTitle } from "./markdown/titles.js";
+export function parseCommandMarkdown(content) {
+    try {
+        const parsed = parseMarkdownStructure(content);
+        const sections = new Map();
+        for (const [key, lines] of parsed.sections.entries()) {
+            sections.set(key, lines.join("\n").trim());
+        }
+        return { title: parsed.title, sections };
+    }
+    catch (error) {
+        if (error instanceof KeiyakuParseError) {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message, { cause: error });
+        }
+        throw error;
+    }
+}
+export function requireMarkdownTextSection(parts, name) {
+    const normalized = normalizeSectionTitle(name);
+    const value = parts.sections.get(normalized)?.trim();
+    if (!value) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
+    }
+    return value;
+}
+export function requireMarkdownListSection(parts, name) {
+    const text = requireMarkdownTextSection(parts, name);
+    const items = parseMarkdownListSection(text)
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (items.length === 0) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
+    }
+    return items;
+}
+export function requireMarkdownTitle(parts) {
+    const title = parts.title?.trim();
+    if (!title) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "missing required title: # Title");
+    }
+    return title;
+}

package/build/core/context.js

@@ -1,13 +1,12 @@
-import * as path from "node:path";
 import { KEIYAKU_BRANCH_PREFIX } from "../keiyaku.js";
 import { FlowError } from "../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError } from "../git/core.js";
 import { getCurrentBranch, listLocalBranches } from "../git/branches.js";
 import { readLedger } from "./ledger.js";
 import { listContractIds } from "./ledger.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { latestBase } from "./status/drift.js";
-import { activeContractIdForWorktreeDir } from "./worktree-path.js";
+import { activeContractBoundByEngineWorktree } from "./worktree-path.js";
 function isOperableLedger(entries) {
     const state = deriveContractState(entries);
     return state.state !== "corrupt" && !isTerminalState(state);
@@ -25,6 +24,17 @@ async function isOperableContract(cwd, contractId) {
     return (await operableContractIds(cwd)).includes(contractId);
 }
 export async function resolveImplicitCurrentContractId(cwd) {
+    // Prefer the verified engine-worktree binding (same tier as existing-commission verbs).
+    try {
+        const bound = await activeContractBoundByEngineWorktree(cwd);
+        if (bound)
+            return bound;
+    }
+    catch (error) {
+        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
+            throw error;
+    }
+    // Branch remains a residual signal for workspace:here checkouts without an engine worktree.
     const git = createGit(cwd);
     try {
         const branch = (await git.raw(["branch", "--show-current"])).trim();
@@ -39,10 +49,6 @@ export async function resolveImplicitCurrentContractId(cwd) {
             throw wrapGitError("branch --show-current", error, cwd);
         }
     }
-    const worktreeId = path.basename(cwd);
-    const worktreeContractId = await activeContractIdForWorktreeDir(cwd, worktreeId);
-    if (worktreeContractId)
-        return worktreeContractId;
     return undefined;
 }
 export async function resolveCurrentContractId(cwd) {

package/build/core/contract-view.js

@@ -1,5 +1,11 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { FlowError } from "../flow-error.js";
 import { shortCommitHash } from "../git/commits.js";
+import { KEIYAKU_FILE } from "../keiyaku.js";
+import { readLedger } from "./ledger.js";
 import { deriveContractState } from "./status/lifecycle.js";
+import { renderScopeFragment } from "./scope.js";
 const VERB_COLUMN_WIDTH = 11;
 const TIME_COLUMN_WIDTH = 6;
 const ACTOR_COLUMN_WIDTH = 11;
@@ -36,8 +42,6 @@ function sealAggregate(entries) {
 function scopeStatusFact(entry) {
     if (entry.data.scopeAudit.violations.length === 0)
         return "scope ✓ clean";
-    if (entry.data.scopeAudit.waived)
-        return `scope ▲ waived ${entry.data.scopeAudit.violations.length}`;
     return `scope ✕ ${entry.data.scopeAudit.violations.length}`;
 }
 function formatDiffstat(insertions, deletions) {
@@ -208,6 +212,18 @@ export function renderVerticalLog(input) {
     }
     return renderLedgerRows(input.entries).join("\n");
 }
+/**
+ * Sole post-mutation KEIYAKU.md refresh: read the authoritative ledger at
+ * ledgerCwd, then write the projection at renderCwd. ledgerCwd and renderCwd
+ * are distinct coordinates (hub vs linked delivery worktree).
+ */
+export async function refreshContractView(input) {
+    const ledger = await readLedger(input.ledgerCwd, input.contractId);
+    if (!ledger) {
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared before render`);
+    }
+    await fs.writeFile(path.join(input.renderCwd, KEIYAKU_FILE), renderContractView({ id: input.contractId, entries: ledger.entries }), "utf8");
+}
 export function renderContractView(input) {
     const bind = input.entries.find((entry) => entry.kind === "bind");
     const state = deriveContractState(input.entries);
@@ -237,13 +253,13 @@ export function renderContractView(input) {
         `place: ${bind.data.place ?? "(none)"}`,
         `after: ${(bind.data.after ?? []).join(", ") || "(none)"}`,
         "",
-        "objective:",
+        "## Objective",
         bind.data.objective,
         "",
-        "scope:",
-        ...bind.data.scope.map((pattern) => `- ${pattern}`),
+        "## Scope",
+        ...renderScopeFragment(bind.data.scope).split("\n"),
         "",
-        "checks:",
+        "## Checks",
         ...bind.data.checks.map((check) => `- ${check}`),
         "",
         ...(bind.data.extensions.length > 0