@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/bind.js

@@ -1,100 +1,27 @@
 import * as crypto from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../config/settings.js";
+import { assertSettingsKnobUsable } from "../config/settings/disease.js";
+import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { createGit, wrapGitError } from "../git/core.js";
-import { activeLedgerRef, appendEntry, appendWithRetry, listContractIds, readLedger } from "./ledger.js";
+import { activeLedgerRef, appendEntry, appendWithRetry, readLedger } from "./ledger.js";
 import { parseBindDraft } from "./draft.js";
 import { assertValidContractId, buildContractId } from "./ids.js";
-import { CONTRACT_PLACES } from "./places.js";
-import { renderContractView } from "./render.js";
 import { registerScope, releaseScope } from "./registry.js";
-import { deriveContractState, isTerminalState, normalizeTargetRef, resolveDefaultBranch } from "./status.js";
+import { resolveDefaultBranch } from "./status/drift.js";
+import { normalizeTargetRef } from "./target-ref.js";
+import { reconcileTaskForfeit, settleTaskBoardForBind } from "./task-contract.js";
 import { bootstrapEntryDataFromObservation, isBootstrapSuccess, runWorktreeBootstrap, } from "./worktree-bootstrap.js";
-import { contractWorktreePathFromBind, findBindEntry } from "./worktree-path.js";
-function randomBytesDefault() {
-    return [...crypto.randomBytes(10)];
-}
-async function getHead(cwd) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "HEAD"])).trim();
-    }
-    catch (error) {
-        throw wrapGitError("rev-parse HEAD", error, cwd);
-    }
-}
-async function createBranch(cwd, branch, base) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["branch", branch, base]);
-    }
-    catch (error) {
-        throw wrapGitError(`branch ${branch} ${base}`, error, cwd);
-    }
-}
-async function defaultCreateWorktree(input) {
-    const git = createGit(input.cwd);
-    try {
-        await git.raw(["worktree", "add", input.worktreePath, input.branch]);
-    }
-    catch (error) {
-        throw wrapGitError(`worktree add ${input.worktreePath} ${input.branch}`, error, input.cwd);
-    }
-}
-async function resolveTreeRoot(cwd, workspace, contractId, bind) {
-    const repoRoot = await fs.realpath(cwd);
-    if (workspace === "here")
-        return repoRoot;
-    return await contractWorktreePathFromBind(repoRoot, contractId, bind);
-}
-async function removeWorktree(cwd, worktreePath) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["worktree", "remove", "--force", worktreePath]);
-    }
-    catch (error) {
-        throw wrapGitError(`worktree remove ${worktreePath}`, error, cwd);
+import { contractWorktreePathFromBind, stableRepoRoot } from "./worktree-path.js";
+import { allocateWorktreePlace, cleanupCreatedBindResources, createContractBranch, defaultCreateWorktree, materializeContractView, resolveTreeRoot, } from "./bind-workspace.js";
+class BindLedgerCollisionError extends Error {
+    contractId;
+    constructor(contractId) {
+        super(`contract ledger already exists for ${contractId}`);
+        this.contractId = contractId;
+        this.name = "BindLedgerCollisionError";
     }
 }
-async function deleteBranch(cwd, branch) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["branch", "-D", branch]);
-    }
-    catch (error) {
-        throw wrapGitError(`branch -D ${branch}`, error, cwd);
-    }
-}
-async function cleanupCreatedResources(cwd, resources) {
-    const failures = [];
-    if (resources.keiyakuPath) {
-        try {
-            await fs.rm(resources.keiyakuPath, { force: true });
-        }
-        catch (error) {
-            failures.push(`delete ${resources.keiyakuPath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (resources.worktreePath) {
-        try {
-            await removeWorktree(cwd, resources.worktreePath);
-        }
-        catch (error) {
-            failures.push(`remove worktree: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (resources.branch) {
-        try {
-            await deleteBranch(cwd, resources.branch);
-        }
-        catch (error) {
-            failures.push(`delete branch: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return failures;
+function randomBytesDefault() {
+    return [...crypto.randomBytes(10)];
 }
 async function appendBindFailedForfeit(cwd, id, actor, at) {
     const forfeit = {
@@ -108,11 +35,18 @@ async function appendBindFailedForfeit(cwd, id, actor, at) {
             by: actor,
         },
     };
-    const ref = activeLedgerRef(id);
-    const result = await appendWithRetry(cwd, ref, () => forfeit, { maxRetries: 1 });
-    if (!result.ok) {
-        throw new FlowError("INTERNAL_STATE", `BIND_FAILURE_FORFEIT_FAILED: failed to append bind-failed forfeit for ${id}: ${result.reason}`);
-    }
+    const stableRoot = await stableRepoRoot(cwd);
+    await reconcileTaskForfeit({
+        cwd: stableRoot,
+        contractId: id,
+        publishLedger: async () => {
+            const result = await appendWithRetry(stableRoot, activeLedgerRef(id), () => forfeit, { maxRetries: 1 });
+            if (!result.ok) {
+                throw new FlowError("INTERNAL_STATE", `BIND_FAILURE_FORFEIT_FAILED: failed to append bind-failed forfeit for ${id}: ${result.reason}`);
+            }
+            return result;
+        },
+    });
 }
 async function appendBootstrapEntry(cwd, id, actor, at, data) {
     const entry = {
@@ -151,41 +85,6 @@ function resolvedBootstrapPlan(settings) {
 function bootstrapProgressLine(command) {
     return `bootstrap » ${command.join(" ")}`;
 }
-async function occupiedWorktreePlaces(cwd) {
-    const occupied = new Set();
-    for (const id of await listContractIds(cwd)) {
-        const ledger = await readLedger(cwd, id);
-        if (!ledger || isTerminalState(deriveContractState(ledger.entries)))
-            continue;
-        const place = findBindEntry(ledger.entries)?.data.place;
-        if (place)
-            occupied.add(place);
-    }
-    return occupied;
-}
-function randomIndex(randomBytes, size) {
-    let value = 0;
-    for (const byte of randomBytes) {
-        value = (value * 256 + byte) % size;
-    }
-    return value;
-}
-function nextGenerationPlace(base, occupied) {
-    for (let generation = 2;; generation += 1) {
-        const candidate = `${base}${generation}`;
-        if (!occupied.has(candidate))
-            return candidate;
-    }
-}
-async function allocateWorktreePlace(cwd, randomBytes) {
-    const occupied = await occupiedWorktreePlaces(cwd);
-    const candidates = CONTRACT_PLACES.filter((place) => !occupied.has(place));
-    if (candidates.length > 0) {
-        return candidates[randomIndex(randomBytes, candidates.length)];
-    }
-    const base = CONTRACT_PLACES[randomIndex(randomBytes, CONTRACT_PLACES.length)];
-    return nextGenerationPlace(base, occupied);
-}
 function makeBindEntry(input) {
     return {
         v: 1,
@@ -197,6 +96,8 @@ function makeBindEntry(input) {
             name: input.draft.name,
             objective: input.draft.objective,
             scope: input.draft.scope,
+            checks: input.draft.checks,
+            extensions: input.draft.extensions,
             base: input.base,
             target: input.target,
             workspace: input.workspace,
@@ -210,7 +111,6 @@ export async function bindContract(input) {
     const draft = parseBindDraft(input.draft);
     const workspace = input.workspace ?? "here";
     const at = new Date(input.nowMs).toISOString();
-    const base = await getHead(input.cwd);
     const defaultBranch = await resolveDefaultBranch(input.cwd);
     if (!defaultBranch) {
         throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
@@ -232,30 +132,49 @@ export async function bindContract(input) {
             randomBytes,
         });
         await assertValidContractId(input.cwd, id);
-        const entry = makeBindEntry({
-            id,
-            at,
-            actor: input.actor,
-            draft,
-            base,
-            target,
-            after: input.after ?? [],
-            workspace,
-            place,
-            bootstrap: bootstrapPlan,
-        });
         const ref = activeLedgerRef(id);
-        const appended = await appendEntry(input.cwd, ref, entry, null);
-        if (!appended.ok) {
-            collidedIds.push(id);
-            continue;
+        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 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);
+                continue;
+            }
+            throw error;
+        }
+        const { entry, appended } = settlement.ledger;
+        const base = settlement.boardCommit;
         const resources = { id };
         const branch = `keiyaku/${id}`;
         const worktreePath = await contractWorktreePathFromBind(input.cwd, id, entry);
         const targetRoot = workspace === "here" ? input.cwd : worktreePath;
         let ledgerHead = appended.head;
         let bootstrapRecorded = false;
+        let registryRegistered = false;
         try {
             const tree = await resolveTreeRoot(input.cwd, workspace, id, entry);
             const registration = await registerScope(input.cwd, {
@@ -266,9 +185,9 @@ export async function bindContract(input) {
                 at,
                 exclusive: input.exclusive,
             });
-            resources.registry = true;
+            registryRegistered = true;
             if (workspace === "worktree") {
-                await createBranch(input.cwd, branch, base);
+                await createContractBranch(input.cwd, branch, base);
                 resources.branch = branch;
                 await (input.createWorktree ?? defaultCreateWorktree)({
                     cwd: input.cwd,
@@ -292,10 +211,11 @@ export async function bindContract(input) {
             const ledger = await readLedger(input.cwd, id);
             if (!ledger)
                 throw new FlowError("INTERNAL_STATE", `LEDGER_MISSING: ledger missing immediately after bind for ${id}`);
-            const keiyakuPath = path.join(targetRoot, KEIYAKU_FILE);
-            await fs.mkdir(path.dirname(keiyakuPath), { recursive: true });
-            await fs.writeFile(keiyakuPath, renderContractView({ id, entries: ledger.entries }), "utf8");
-            resources.keiyakuPath = keiyakuPath;
+            resources.keiyakuPath = await materializeContractView({
+                targetRoot,
+                id,
+                entries: ledger.entries,
+            });
             return {
                 id,
                 ref,
@@ -314,7 +234,7 @@ export async function bindContract(input) {
                 // Non-bootstrap failure: cleanup first remains compatible with prior path,
                 // then forfeit. When bootstrap already recorded its failed fact, forfeit
                 // must precede cleanup.
-                cleanupFailures.push(...(await cleanupCreatedResources(input.cwd, resources)));
+                cleanupFailures.push(...(await cleanupCreatedBindResources(input.cwd, resources)));
                 try {
                     await appendBindFailedForfeit(input.cwd, id, input.actor, at);
                 }
@@ -329,9 +249,9 @@ export async function bindContract(input) {
                 catch (forfeitError) {
                     cleanupFailures.push(forfeitError instanceof Error ? forfeitError.message : String(forfeitError));
                 }
-                cleanupFailures.push(...(await cleanupCreatedResources(input.cwd, resources)));
+                cleanupFailures.push(...(await cleanupCreatedBindResources(input.cwd, resources)));
             }
-            if (resources.registry) {
+            if (registryRegistered) {
                 try {
                     await releaseScope(input.cwd, { contractId: id, actor: input.actor, at });
                 }

package/build/core/call/call.js

@@ -0,0 +1,224 @@
+import * as fs from "fs/promises";
+import { selectSubagent } from "../../agents/selector.js";
+import { applySnapshotEffort } from "../../agents/launch-snapshot/model.js";
+import { resolveAkumaLaunchSnapshot } from "../../agents/launch-snapshot/resolve.js";
+import { FlowError, requireText } from "../../flow-error.js";
+import { isGitRepo } from "../../git/branches.js";
+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 { requireResumableArtifact } from "../transcripts.js";
+import { stableRepoRoot } from "../worktree-path.js";
+import { readCallKeiyakuContext } from "./context.js";
+import { executeSubagent, launchSubagentGeneration, } from "./execution.js";
+import { buildCallPrompt } from "./prompt.js";
+import { collectCallReferenceFiles } from "./reference.js";
+function renderSubagentWarning(warning) {
+    if (warning.reason === "retry") {
+        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}`;
+    }
+    const modelTransition = warning.originalModel && warning.fallbackModel
+        ? `${warning.originalModel} -> ${warning.fallbackModel}`
+        : warning.originalModel ?? warning.fallbackModel;
+    const details = [
+        modelTransition,
+        warning.direction ? `direction=${warning.direction}` : undefined,
+        warning.requestId !== undefined ? `requestId=${warning.requestId ?? "null"}` : undefined,
+        warning.signerModel ? `signerModel=${warning.signerModel}` : undefined,
+    ].filter((value) => Boolean(value));
+    const summary = warning.reason === "refusal" ? "Provider warning: model fallback." : "Provider warning: overload fallback.";
+    return details.length > 0 ? `${summary} ${details.join(", ")}` : summary;
+}
+export async function execSubagent(agentName, prompt, cwd, options) {
+    const { outcome } = await executeSubagent(agentName, prompt, cwd, options);
+    return outcome;
+}
+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;
+    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;
+        rawRepo = undefined;
+    }
+    else if (reviveArtifact?.provenance.authority.kind === "repository") {
+        const artifactHome = await fs.realpath(reviveArtifact.storageRoot);
+        const addressed = input.repo ?? input.cwd;
+        if (await isGitRepo(addressed)) {
+            const addressedRoot = await stableRepoRoot(addressed);
+            if (addressedRoot !== artifactHome) {
+                throw new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${reviveArtifact.artifactId}' belongs to ${artifactHome}, but the addressed repository is ${addressedRoot}.`);
+            }
+        }
+        rawCwd = artifactHome;
+        rawRepo = artifactHome;
+    }
+    const cwd = await fs.realpath(rawCwd);
+    const repoCwd = rawRepo ? await fs.realpath(rawRepo) : undefined;
+    const title = requireText("title", input.title);
+    const task = requireText("task", input.task);
+    if (input.incognito && reviveArtifact) {
+        throw new FlowError("EMPTY_PARAM", "Parameter 'incognito' cannot be used with 'reviveArtifact' — incognito calls cannot be revived or persist conversation history.");
+    }
+    const keiyakuContext = await readCallKeiyakuContext(cwd, {
+        bare: input.bare,
+        contractId: input.contractId,
+        contractAddressSource: input.contractAddressSource,
+        mode: input.mode ?? "call",
+        repoCwd,
+        reviveBinding: reviveArtifact?.provenance.binding,
+    });
+    return await withResolvedAddress(keiyakuContext.address, async () => {
+        const executionCwd = keiyakuContext.effectiveCwd;
+        const referenceFiles = await collectCallReferenceFiles(executionCwd, keiyakuContext);
+        const prompt = buildCallPrompt({
+            task,
+            context: input.context,
+            referenceFiles,
+            currentIntent: keiyakuContext.currentIntent,
+        });
+        const launchSnapshot = reviveArtifact
+            ? input.effort !== undefined
+                ? applySnapshotEffort(reviveArtifact.launchSnapshot, input.effort)
+                : reviveArtifact.launchSnapshot
+            : resolveAkumaLaunchSnapshot(await selectSubagent(agent, keiyakuContext.profileCwd), {
+                executionCwd,
+                projectRoot: keiyakuContext.profileCwd,
+                ...(input.model !== undefined ? { model: input.model } : {}),
+                ...(input.effort !== undefined ? { effort: input.effort } : {}),
+            });
+        const continuation = reviveArtifact
+            ? {
+                session: reviveArtifact.session,
+                resumePath: reviveArtifact.absolutePath,
+                sourceArtifactId: reviveArtifact.artifactId,
+            }
+            : undefined;
+        logInfo(`[${ACTOR_IDENTITY}] Running execution for '${launchSnapshot.akuma.name}' in ${executionCwd}`, {
+            cwd: executionCwd,
+            section: "script",
+            progressOnly: true,
+        });
+        // Storage coordinate: addressed repository stable root / caller cwd.
+        // Evidence coordinate: commission worktree for bound runs; execution cwd otherwise.
+        const historyStorageCwd = keiyakuContext.historyCwd;
+        const evidenceCwd = executionCwd;
+        const executionOptions = {
+            signal,
+            continuation,
+            task,
+            launchSnapshot,
+            persistProjectionResponse: !input.incognito,
+            historyStorageCwd,
+            evidenceCwd,
+            projectionCwd: keiyakuContext.projectionCwd,
+            authority: keiyakuContext.address.repo.kind === "repository"
+                ? { kind: "repository" }
+                : { kind: "user" },
+            binding: keiyakuContext.address.binding,
+            title,
+            context: input.context,
+            ...(input.mode === "call" && input.alias !== undefined ? { alias: assertProjectionAlias(input.alias) } : {}),
+        };
+        if ((input.mode ?? "call") === "call") {
+            const launched = await launchSubagentGeneration(launchSnapshot.akuma.name, prompt, executionCwd, executionOptions);
+            const adoptedProjection = {
+                id: launched.projection.id,
+                phase: observeProjectionLife(launched.projection.dir, {
+                    nowMs: Date.now(),
+                    startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+                }).phase,
+                ...(launched.projection.alias ? { alias: launched.projection.alias } : {}),
+                ...(launched.projection.previousAliasTarget ? { previousAliasTarget: launched.projection.previousAliasTarget } : {}),
+            };
+            input.onLaunch?.({ address: keiyakuContext.address, projection: adoptedProjection });
+            if (input.detach) {
+                return {
+                    state: "launched",
+                    summary: "",
+                    agent: launchSnapshot.akuma.name,
+                    launchSnapshot,
+                    projectionOwnsResponsePersistence: true,
+                    projection: adoptedProjection,
+                    address: keiyakuContext.address,
+                };
+            }
+            const joined = await waitForProjection({
+                projectionDirectory: launched.projection.dir,
+                signal,
+            });
+            if (joined.state !== "terminal") {
+                throw new FlowError("INTERNAL_STATE", "foreground call wait ended without a terminal projection verdict");
+            }
+            return {
+                state: "completed",
+                summary: joined.outcomeText || `${ACTOR_IDENTITY} completed successfully.`,
+                agent: launchSnapshot.akuma.name,
+                launchSnapshot,
+                ...(joined.snapshot.responsePath ? { responsePath: joined.snapshot.responsePath } : {}),
+                ...(joined.snapshot.artifactId ? { artifactId: joined.snapshot.artifactId } : {}),
+                projectionOwnsResponsePersistence: true,
+                meta: { effectivePolicy: launchSnapshot.akuma.policy },
+                projection: { id: launched.projection.id, phase: joined.snapshot.phase },
+                foregroundWait: joined,
+                address: keiyakuContext.address,
+            };
+        }
+        const execution = await executeSubagent(launchSnapshot.akuma.name, prompt, executionCwd, executionOptions);
+        const subagentOutcome = execution.outcome;
+        if (subagentOutcome.diagnostics.trim()) {
+            appendDebugBlock("subagent diagnostics", subagentOutcome.diagnostics, { cwd: executionCwd, section: "subagent-stderr" });
+        }
+        let projection;
+        let responsePath;
+        let artifactId;
+        if (execution.projection) {
+            responsePath = typeof execution.completionFacts?.responsePath === "string"
+                ? execution.completionFacts.responsePath
+                : undefined;
+            artifactId = typeof execution.completionFacts?.artifactId === "string"
+                ? execution.completionFacts.artifactId
+                : undefined;
+            try {
+                projection = {
+                    id: execution.projection.id,
+                    phase: observeProjectionLife(execution.projection.dir, {
+                        nowMs: Date.now(),
+                        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+                    }).phase,
+                };
+            }
+            catch {
+                // Projection observations are best-effort and must not reverse success.
+            }
+        }
+        return {
+            state: "completed",
+            summary: subagentOutcome.finalMessage || `${ACTOR_IDENTITY} completed successfully.`,
+            agent: launchSnapshot.akuma.name,
+            session: subagentOutcome.session,
+            launchSnapshot: subagentOutcome.launchSnapshot,
+            ...(responsePath ? { responsePath } : {}),
+            ...(artifactId ? { artifactId } : {}),
+            ...(reviveArtifact ? { revivedArtifactId: reviveArtifact.artifactId } : {}),
+            projectionOwnsResponsePersistence: execution.projection !== undefined,
+            meta: {
+                ...(subagentOutcome.warnings.length > 0 ? { warnings: subagentOutcome.warnings.map(renderSubagentWarning) } : {}),
+                effectivePolicy: subagentOutcome.launchSnapshot.akuma.policy,
+            },
+            ...(projection ? { projection } : {}),
+            address: keiyakuContext.address,
+            ...(input.incognito ? {} : { evidenceCwd }),
+        };
+    });
+}