@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/call/context.js

@@ -1,53 +1,12 @@
-import * as fs from "fs/promises";
+import * as fs from "node:fs/promises";
 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, resolveCallWorktreeAddress, withResolvedAddress, } from "../addressing.js";
+import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveCallWorktreeAddressFromRead, resolveExplicitContractAddressFromRead, 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 { contractWorktreePathFromBind, stableRepoRoot } from "../worktree-path.js";
-async function findWorktreePathForContract(cwd, contractId) {
-    const git = createGit(cwd);
-    let output;
-    try {
-        output = await git.raw(["worktree", "list", "--porcelain"]);
-    }
-    catch (error) {
-        throw wrapGitError("worktree list --porcelain", error, cwd);
-    }
-    let currentPath;
-    for (const line of output.split(/\r?\n/)) {
-        if (line.startsWith("worktree ")) {
-            currentPath = line.slice("worktree ".length);
-            continue;
-        }
-        if (line === `branch refs/heads/keiyaku/${contractId}`) {
-            return currentPath;
-        }
-    }
-    return undefined;
-}
-async function resolveWorkspaceCwd(cwd, contractId, bind) {
-    const repoRoot = cwd;
-    if (bind.data.workspace === "here")
-        return repoRoot;
-    const listedWorktreePath = await findWorktreePathForContract(cwd, contractId);
-    const worktreePath = listedWorktreePath ?? await contractWorktreePathFromBind(repoRoot, contractId, bind);
-    let stat;
-    try {
-        stat = await fs.stat(worktreePath);
-    }
-    catch (error) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} worktree not found at ${worktreePath}`, { cause: error });
-    }
-    if (!stat.isDirectory()) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} worktree path is not a directory: ${worktreePath}`);
-    }
-    return worktreePath;
-}
-export async function readCallKeiyakuContext(executionCwd, input) {
+import { readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
+import { isTerminalState } from "../status/lifecycle.js";
+import { findRegisteredContractWorktreePathFromModel, stableRepoRoot, } from "../worktree-path.js";
+export async function readCallKeiyakuContext(executionCwd, input, ports = {}) {
     executionCwd = normalizeFilesystemCoordinate(executionCwd);
     input.repoCwd = input.repoCwd === undefined ? undefined : normalizeFilesystemCoordinate(input.repoCwd);
     const ledgerCandidate = input.repoCwd ?? executionCwd;
@@ -153,10 +112,23 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             }),
         };
     }
-    const address = input.contractId
-        ? await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource)
-        : await resolveCallWorktreeAddress(ledgerCwd, executionCwd);
-    if (!address) {
+    // This immutable admission is the only lifecycle observation allowed to
+    // influence selection, intent, pins, or returned address facts.
+    const repository = await (ports.readRepositoryLifecycle ?? readRepositoryLifecycle)(ledgerCwd);
+    const admitted = input.contractId === undefined
+        ? await resolveCallWorktreeAddressFromRead({
+            read: repository,
+            stableRoot: ledgerCwd,
+            workdir: executionCwd,
+        })
+        : resolveExplicitContractAddressFromRead({
+            read: repository,
+            stableRoot: ledgerCwd,
+            workdir: executionCwd,
+            raw: input.contractId,
+            source: input.contractAddressSource,
+        });
+    if (!admitted) {
         return {
             activeKeiyaku: false,
             effectiveCwd: executionCwd,
@@ -170,44 +142,47 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             }),
         };
     }
+    const { address, model } = admitted;
     return await withResolvedAddress(address, async () => {
-        const contractId = address.binding.commissionId;
-        const ledger = await readLedger(ledgerCwd, contractId);
-        if (!ledger) {
-            throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
-        }
-        const state = deriveContractState(ledger.entries);
-        if (state.state === "corrupt") {
-            throw new FlowError("INTERNAL_STATE", `contract ${contractId} is corrupt at entry ${state.at}: ${state.reason}`);
-        }
-        if (isTerminalState(state)) {
+        const contractId = model.contract;
+        if (isTerminalState(address.lifecycle)) {
             throw new FlowError("EMPTY_PARAM", `commission ${contractId} is terminal and cannot launch an Akuma`);
         }
-        const bind = ledger.entries.find((entry) => entry.kind === "bind");
-        if (!bind) {
+        const bind = model.history[0]?.entry;
+        if (!bind || bind.kind !== "bind") {
             throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger is missing bind entry`);
         }
-        const effectiveCwd = await resolveWorkspaceCwd(ledgerCwd, contractId, bind);
+        const effectiveCwd = model.resources.worktree
+            ? await findRegisteredContractWorktreePathFromModel(ledgerCwd, model)
+            : await fs.realpath(ledgerCwd);
+        if (!effectiveCwd) {
+            throw new FlowError("INTERNAL_STATE", `contract ${contractId} has no verified registered engine worktree`);
+        }
         const executionAddress = { ...address, workdir: effectiveCwd };
-        const openArc = findOpenArcView(ledger.entries);
+        const openArc = model.phase === "active" && model.history.some(({ entry }) => entry.kind === "arc")
+            ? model.intent
+            : null;
         const currentIntent = openArc
             ? {
                 source: "arc",
                 arc: openArc.arc,
                 title: openArc.title,
                 objective: openArc.objective,
-                brief: openArc.brief,
+                brief: openArc.brief ?? "",
             }
-            : ledger.entries.some((entry) => entry.kind === "arc")
+            : model.history.some(({ entry }) => entry.kind === "arc")
                 ? undefined
                 : {
                     source: "bind",
                     arc: 0,
-                    name: bind.data.name,
+                    title: bind.data.title,
+                    context: bind.data.context,
                     objective: bind.data.objective,
-                    scope: bind.data.scope,
-                    checks: bind.data.checks,
-                    extensions: bind.data.extensions,
+                    design: bind.data.design,
+                    scope: [...model.effectiveScope],
+                    criteria: [...bind.data.criteria],
+                    verification: [...bind.data.verification],
+                    extensions: bind.data.extensions.map((extension) => ({ ...extension })),
                 };
         return {
             activeKeiyaku: true,

package/build/core/call/prompt.js

@@ -1,7 +1,7 @@
 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.",
+    "Leave source changes uncommitted as a dirty working tree, then report changed files and verification run results.",
     "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(" ");
@@ -32,10 +32,13 @@ export function buildCallPrompt(input) {
         return [
             `You are a called ${ACTOR_IDENTITY} working inside derived default arc a0.`,
             "Stay within the contract scope and do the requested work directly.",
-            `Contract: ${bind.name}`,
+            `Contract: ${bind.title}`,
+            `Context:\n${bind.context}`,
             `Objective:\n${bind.objective}`,
+            `Design:\n${bind.design}`,
             `Scope:\n${bind.scope.map((value) => `- ${value}`).join("\n")}`,
-            `Checks:\n${bind.checks.map((value) => `- ${value}`).join("\n")}`,
+            `Criteria:\n${bind.criteria.map((value) => `- ${value}`).join("\n")}`,
+            `Verification:\n${bind.verification.map((value) => `- ${value}`).join("\n")}`,
             extensionsBlock,
             COMMISSIONED_DELIVERY_BOUNDARY,
             `Task:\n${input.task}`,

package/build/core/context.js

@@ -2,32 +2,41 @@ import { KEIYAKU_BRANCH_PREFIX } from "../keiyaku.js";
 import { FlowError } from "../flow-error.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 { activeContractBoundByEngineWorktree } from "./worktree-path.js";
-function isOperableLedger(entries) {
-    const state = deriveContractState(entries);
-    return state.state !== "corrupt" && !isTerminalState(state);
+import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
+import { currentContractBoundByWorktreeWitness, stableRepoRoot } from "./worktree-path.js";
+import { contractReadOutcomeError } from "./addressing.js";
+import { admitRepositoryLifecycleContract } from "./repository-ledger/admission.js";
+function isOperableContract(model) {
+    return model.phase !== "claimed" && model.phase !== "forfeited";
 }
-export async function operableContractIds(cwd) {
-    const ids = await listContractIds(cwd);
-    const ledgers = await Promise.all(ids.map(async (id) => ({ id, ledger: await readLedger(cwd, id) })));
-    return ledgers.flatMap(({ id, ledger }) => {
-        if (!ledger)
-            return [];
-        return isOperableLedger(ledger.entries) ? [id] : [];
-    });
+function operableContracts(read) {
+    return read.contracts.filter((model) => lookupCurrentContract(read, model.contract).status === "healthy" && isOperableContract(model));
 }
-async function isOperableContract(cwd, contractId) {
-    return (await operableContractIds(cwd)).includes(contractId);
+function potentiallyOperableContracts(read) {
+    return read.contracts.filter(isOperableContract);
 }
-export async function resolveImplicitCurrentContractId(cwd) {
+function admitOperableContractId(read, contractId) {
+    const outcome = admitRepositoryLifecycleContract(read, contractId);
+    if (outcome.status === "healthy")
+        return isOperableContract(outcome.model);
+    if (outcome.status === "absent")
+        return false;
+    throw contractReadOutcomeError(contractId, outcome);
+}
+export async function operableContractIds(cwd) {
+    const read = await readRepositoryLifecycle(cwd);
+    return operableContracts(read).map((model) => model.contract);
+}
+async function resolveImplicitCurrentContractIdFromRead(cwd, read) {
     // Prefer the verified engine-worktree binding (same tier as existing-commission verbs).
     try {
-        const bound = await activeContractBoundByEngineWorktree(cwd);
-        if (bound)
+        const stableRoot = await stableRepoRoot(cwd);
+        const bound = await currentContractBoundByWorktreeWitness({
+            cwd,
+            stableRoot,
+            contracts: potentiallyOperableContracts(read),
+        });
+        if (bound && admitOperableContractId(read, bound))
             return bound;
     }
     catch (error) {
@@ -40,7 +49,10 @@ export async function resolveImplicitCurrentContractId(cwd) {
         const branch = (await git.raw(["branch", "--show-current"])).trim();
         if (branch.startsWith("keiyaku/")) {
             const id = branch.slice("keiyaku/".length);
-            if (await isOperableContract(cwd, id))
+            const outcome = lookupCurrentContract(read, id);
+            if ((outcome.status === "healthy" || outcome.status === "diseased") &&
+                outcome.model.resources.worktree === null &&
+                admitOperableContractId(read, id))
                 return id;
         }
     }
@@ -51,40 +63,42 @@ export async function resolveImplicitCurrentContractId(cwd) {
     }
     return undefined;
 }
-export async function resolveCurrentContractId(cwd) {
-    const current = await resolveImplicitCurrentContractId(cwd);
+export async function resolveImplicitCurrentContractId(cwd) {
+    return resolveImplicitCurrentContractIdFromRead(cwd, await readRepositoryLifecycle(cwd));
+}
+async function resolveCurrentContractIdFromRead(cwd, read) {
+    const current = await resolveImplicitCurrentContractIdFromRead(cwd, read);
     if (current)
         return { status: "one", contractId: current };
-    const operable = (await operableContractIds(cwd)).sort();
+    const operable = operableContracts(read).map((model) => model.contract).sort();
     if (operable.length === 0)
         return { status: "none" };
     if (operable.length === 1)
         return { status: "one", contractId: operable[0] };
     throw new FlowError("CONTRACT_AMBIGUOUS", `multiple active contracts found: ${operable.join(", ")}`);
 }
+export async function resolveCurrentContractId(cwd) {
+    return resolveCurrentContractIdFromRead(cwd, await readRepositoryLifecycle(cwd));
+}
 export async function listLocalKeiyakuBranches(cwd) {
     return (await listLocalBranches(cwd)).filter((name) => name.startsWith(KEIYAKU_BRANCH_PREFIX));
 }
 export async function readCurrentContractContext(cwd) {
-    const resolution = await resolveCurrentContractId(cwd);
+    const read = await readRepositoryLifecycle(cwd);
+    const resolution = await resolveCurrentContractIdFromRead(cwd, read);
     if (resolution.status === "none")
         throw new FlowError("EMPTY_PARAM", "no active contract found");
     const contractId = resolution.contractId;
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger || isTerminalState(deriveContractState(ledger.entries))) {
+    const outcome = lookupCurrentContract(read, contractId);
+    if (outcome.status !== "healthy" || !isOperableContract(outcome.model)) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found or not active`);
     }
-    const base = latestBase(ledger.entries);
-    const bind = ledger.entries.find((entry) => entry.kind === "bind");
-    if (!base || !bind) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger is missing bind entry`);
-    }
     const currentBranch = await getCurrentBranch(cwd);
-    const baseBranch = bind.data.target.slice("refs/heads/".length);
+    const baseBranch = outcome.model.pins.target.ref.slice("refs/heads/".length);
     return {
         contractId,
         currentBranch,
         baseBranch,
-        base,
+        base: outcome.model.pins.base,
     };
 }