@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/arc.js

@@ -2,63 +2,18 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { requireText, FlowError } from "../flow-error.js";
 import { getCurrentBranch, requireGitRepository } from "../git/branches.js";
-import { DIRTY_FILE_CATEGORY, getDirtyFiles, renderDirtyFileStatusLine } from "../git/worktree.js";
+import { assertCleanTrackedWorkingTree } from "../git/worktree.js";
 import { KEIYAKU_FILE, ACTOR_IDENTITY } from "../keiyaku.js";
-import { buildDirtyWorktreeArtifactHint } from "./hints.js";
 import { normalizeInlineTitle } from "./markdown/titles.js";
-import { parseCommandMarkdown, requireMarkdownTextSection, requireMarkdownTitle, } from "./command-io.js";
+import { parseCommandMarkdown, requireMarkdownTextSection, requireMarkdownTitle, } from "./command-markdown.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { renderContractView } from "./contract-view.js";
+import { refreshContractView } from "./contract-view.js";
 import { findOpenArc, getMaxArc, sealCurrentArc } from "./seal.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { persistResponseHistory } from "./transcripts.js";
-const DIRTY_WORKTREE_LIST_LIMIT = 10;
-const KEIYAKU_ARTIFACT_DIR_PREFIX = ".keiyaku/";
-function normalizePathForDirtyMatch(cwd, filePath) {
-    const normalizedPath = filePath.trim();
-    if (!normalizedPath)
-        return "";
-    const repoRelativePath = path.isAbsolute(normalizedPath) ? path.relative(cwd, normalizedPath) : normalizedPath;
-    const platformNormalizedPath = path.normalize(repoRelativePath.replace(/[\\/]+/g, path.sep));
-    return platformNormalizedPath.split(path.sep).join("/").replace(/^\.\/+/, "").replace(/^\/+/, "");
-}
-function pathSegments(normalizedPath) {
-    return normalizedPath.split("/").filter((segment) => segment.length > 0 && segment !== ".");
-}
-function matchesIgnorePattern(filePath, ignorePattern) {
-    const patternSegments = pathSegments(ignorePattern);
-    const fileSegments = pathSegments(filePath);
-    return patternSegments.length > 0
-        && fileSegments.length >= patternSegments.length
-        && patternSegments.every((segment, index) => fileSegments[index] === segment);
-}
-export function filterDirtyFilesByAllowlist(cwd, dirtyFiles, ignorePatterns) {
-    const ignoredPaths = Array.from(new Set((ignorePatterns ?? []).map((pattern) => normalizePathForDirtyMatch(cwd, pattern)).filter(Boolean)));
-    return {
-        dirtyFiles: dirtyFiles.filter((file) => {
-            const normalizedFilePath = normalizePathForDirtyMatch(cwd, file.path);
-            return !ignoredPaths.some((ignoredPath) => matchesIgnorePattern(normalizedFilePath, ignoredPath));
-        }),
-        ignoredPaths,
-    };
-}
-export function filterBlockingDirtyFiles(dirtyFiles) {
-    return dirtyFiles.filter((file) => file.category !== DIRTY_FILE_CATEGORY.untracked);
-}
-export async function assertCleanWorkingTree(cwd, ignorePatterns) {
-    const blockingDirtyFiles = filterBlockingDirtyFiles(await getDirtyFiles(cwd));
-    const { dirtyFiles } = filterDirtyFilesByAllowlist(cwd, blockingDirtyFiles, ignorePatterns);
-    if (dirtyFiles.length === 0)
-        return;
-    const hasDirtyKeiyakuArtifacts = dirtyFiles.some((file) => normalizePathForDirtyMatch(cwd, file.path).startsWith(KEIYAKU_ARTIFACT_DIR_PREFIX));
-    const shown = dirtyFiles.slice(0, DIRTY_WORKTREE_LIST_LIMIT);
-    const list = shown.map((file) => `  ${renderDirtyFileStatusLine(file)}`).join("\n");
-    const overflowCount = dirtyFiles.length - shown.length;
-    const overflowLine = overflowCount > 0 ? `\n  ... (+${overflowCount} more)` : "";
-    throw new FlowError("DIRTY_WORKTREE", `Uncommitted changes detected in working tree:\n${list}${overflowLine}\n\nBlocking changes must be committed or stashed before proceeding.`, hasDirtyKeiyakuArtifacts ? { hints: [buildDirtyWorktreeArtifactHint()] } : undefined);
-}
+import { resolveContractDeliveryCwd } from "./worktree-path.js";
 export function buildArcViews(entries) {
     const arcs = new Map();
     for (const entry of entries) {
@@ -96,25 +51,20 @@ function assertArcOpenable(contractId, entries) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot open arc from state ${state.state}`);
     }
 }
-async function renderUpdatedContract(cwd, contractId) {
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger disappeared before render`);
-    }
-    await fs.writeFile(path.join(cwd, KEIYAKU_FILE), renderContractView({ id: contractId, entries: ledger.entries }), "utf8");
-}
 export async function openArc(input) {
     const title = requireText("title", input.title);
     const objective = requireText("objective", input.objective);
     const brief = requireText("brief", input.brief);
+    const renderCwd = input.renderCwd ?? input.cwd;
     const ledger = await readLedger(input.cwd, input.contractId);
     if (!ledger) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertArcOpenable(input.contractId, ledger.entries);
+    // Seal capture needs delivery HEAD; ledger append may use hub or delivery (shared refs).
     const sealed = await sealCurrentArc({
-        cwd: input.cwd,
-        renderCwd: input.cwd,
+        cwd: renderCwd,
+        renderCwd,
         contractId: input.contractId,
         sealedBy: "arc",
         nowMs: input.nowMs,
@@ -140,7 +90,7 @@ export async function openArc(input) {
     if (!result.ok || arcNumber === 0) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} active ledger disappeared during arc`);
     }
-    await renderUpdatedContract(input.cwd, input.contractId);
+    await refreshContractView({ ledgerCwd: input.cwd, renderCwd, contractId: input.contractId });
     return { contractId: input.contractId, arc: arcNumber, ledgerHead: result.head, sealed };
 }
 export function buildArcInput(content, cwd, waivePaths = [], contractId, contractAddressSource) {
@@ -162,11 +112,13 @@ async function readBranchLabels(cwd) {
 }
 export async function arcKeiyaku(input) {
     await requireGitRepository(input.cwd, "arc");
-    const address = await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
+    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
     return await withResolvedAddress(address, async () => {
-        await assertCleanWorkingTree(input.cwd, []);
+        const contractId = address.binding.commissionId;
+        const renderCwd = await resolveContractDeliveryCwd(input.cwd, contractId);
+        await assertCleanTrackedWorkingTree(renderCwd);
         try {
-            await fs.access(path.join(input.cwd, KEIYAKU_FILE));
+            await fs.access(path.join(renderCwd, KEIYAKU_FILE));
         }
         catch {
             throw new FlowError("MISSING_PROTOCOL_FILES", `missing protocol file for current keiyaku (${KEIYAKU_FILE})`);
@@ -174,9 +126,9 @@ export async function arcKeiyaku(input) {
         const title = normalizeInlineTitle(requireText("title", input.title));
         const objective = requireText("objective", input.objective);
         const brief = requireText("brief", input.brief);
-        const contractId = address.binding.commissionId;
         const opened = await openArc({
             cwd: input.cwd,
+            renderCwd,
             contractId,
             actor: ACTOR_IDENTITY,
             nowMs: Date.now(),
@@ -185,11 +137,10 @@ export async function arcKeiyaku(input) {
             brief,
             waivePaths: input.waivePaths,
         });
-        const { currentBranch, baseBranch } = await readBranchLabels(input.cwd);
+        const { currentBranch, baseBranch } = await readBranchLabels(renderCwd);
         const summary = opened.sealed
             ? `a${opened.sealed.arc} sealed; a${opened.arc} open: ${title}.`
             : `a${opened.arc} open: ${title}.`;
-        const diff = opened.sealed?.incrementalDiff ?? "working tree untouched";
         let responsePath;
         let artifactId;
         try {
@@ -202,7 +153,7 @@ export async function arcKeiyaku(input) {
                 brief,
                 ledgerCommit: opened.ledgerHead,
                 summary,
-                diff,
+                emptyDiffLabel: "working tree untouched",
                 ...(opened.sealed ? { sealed: opened.sealed } : {}),
             });
             responsePath = persisted.responsePath;
@@ -217,7 +168,8 @@ export async function arcKeiyaku(input) {
             currentBranch,
             baseBranch,
             commit: opened.ledgerHead,
-            diff,
+            // CLI/render synthesizes public face bytes from sealed typed facts.
+            diff: "",
             summary,
             title,
             objective,

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,
@@ -184,20 +184,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;
+}