@astrosheep/keiyaku 2.9.7 → 2.9.8

package/build/config/settings/disease.js

@@ -1,11 +1,10 @@
 import { FlowError } from "../../flow-error.js";
-import { SETTINGS_FILE } from "../../keiyaku.js";
 export function findSettingsDiseasesForKnob(diseases, knob) {
-    return diseases.filter((disease) => disease.knob === knob);
+    return diseases.filter((disease) => disease.knob === knob || disease.knob === undefined);
 }
 export function formatSettingsDiseases(diseases) {
     return diseases.map((disease) => {
-        const where = disease.knob ? `${disease.source}:${disease.knob}` : `${disease.source}:(root)`;
+        const where = disease.knob ? `${disease.coordinate}:${disease.knob}` : `${disease.coordinate}:(root)`;
         return `${where}: ${disease.reason}`;
     });
 }
@@ -20,11 +19,12 @@ export function assertSettingsKnobUsable(loaded, knob) {
     const hits = findSettingsDiseasesForKnob(loaded.diseases, knob);
     if (hits.length === 0)
         return;
-    throw new FlowError("INVALID_SETTINGS", `Invalid settings in ${SETTINGS_FILE} (diseased knob '${knob}').`, {
+    throw new FlowError("INVALID_SETTINGS", `Invalid settings for diseased knob '${knob}'.`, {
         facts: {
             kind: "invalid_settings",
             diseases: hits.map((disease) => ({
                 source: disease.source,
+                coordinate: disease.coordinate,
                 ...(disease.knob !== undefined ? { knob: disease.knob } : {}),
                 reason: disease.reason,
             })),

package/build/config/settings/loader.js

@@ -58,11 +58,11 @@ function formatProviderInstanceIssues(name, error) {
     })
         .join("; ");
 }
-function collectProviderCandidates(source, rawProviders) {
+function collectProviderCandidates(settingsSource, providerSource, rawProviders) {
     if (!isPlainObject(rawProviders)) {
         return {
             candidates: [],
-            disease: { source: source === "project" ? "local" : "global", knob: "providers", reason: "providers: must be a JSON object" },
+            disease: { ...settingsSource, knob: "providers", reason: "providers: must be a JSON object" },
         };
     }
     const candidates = [];
@@ -71,7 +71,8 @@ function collectProviderCandidates(source, rawProviders) {
         if (!nameResult.success) {
             candidates.push({
                 name,
-                source,
+                source: providerSource,
+                coordinate: settingsSource.coordinate,
                 reason: formatProviderInstanceIssues(name, nameResult.error),
             });
             continue;
@@ -80,7 +81,8 @@ function collectProviderCandidates(source, rawProviders) {
         if (!instanceResult.success) {
             candidates.push({
                 name,
-                source,
+                source: providerSource,
+                coordinate: settingsSource.coordinate,
                 reason: formatProviderInstanceIssues(name, instanceResult.error),
             });
             continue;
@@ -93,7 +95,7 @@ function collectProviderCandidates(source, rawProviders) {
             "writableRoots" in instance
             ? instance.writableRoots
             : undefined;
-        if (writableRoots !== undefined && source === "global") {
+        if (writableRoots !== undefined && providerSource === "global") {
             let relativeIndex;
             for (let i = 0; i < writableRoots.length; i++) {
                 if (!path.posix.isAbsolute(writableRoots[i])) {
@@ -104,13 +106,14 @@ function collectProviderCandidates(source, rawProviders) {
             if (relativeIndex !== undefined) {
                 candidates.push({
                     name,
-                    source,
+                    source: providerSource,
+                    coordinate: settingsSource.coordinate,
                     reason: `providers.${name}.writableRoots.${relativeIndex}: writableRoots item must be an absolute path for global provider instances`,
                 });
                 continue;
             }
         }
-        candidates.push({ name, source, instance: instanceResult.data });
+        candidates.push({ name, source: providerSource, coordinate: settingsSource.coordinate, instance: instanceResult.data });
     }
     return { candidates };
 }
@@ -126,21 +129,23 @@ function mergeProviderCandidates(catalog, candidates) {
     }
     return { selected, shadows };
 }
-function collectSourceDiseases(source, providerSource, read) {
+function collectSourceDiseases(settingsSource, providerSource, read) {
     if (!read.found) {
-        return { partial: {}, diseases: [], providerCandidates: [] };
+        return { settingsSource, partial: {}, diseases: [], providerCandidates: [] };
     }
     if (read.parseError !== undefined) {
         return {
+            settingsSource,
             partial: {},
-            diseases: [{ source, reason: `settings root is unreadable (${read.parseError})` }],
+            diseases: [{ ...settingsSource, reason: `settings root is unreadable (${read.parseError})` }],
             providerCandidates: [],
         };
     }
     if (!isPlainObject(read.raw)) {
         return {
+            settingsSource,
             partial: {},
-            diseases: [{ source, reason: "settings root must be a JSON object" }],
+            diseases: [{ ...settingsSource, reason: "settings root must be a JSON object" }],
             providerCandidates: [],
         };
     }
@@ -151,7 +156,7 @@ function collectSourceDiseases(source, providerSource, read) {
     for (const key of Object.keys(raw)) {
         if (!KNOWN_SETTINGS_ROOT_KEYS.includes(key)) {
             diseases.push({
-                source,
+                ...settingsSource,
                 knob: key,
                 reason: key === "agents"
                     ? 'settings key "agents" has been removed; define profiles in .keiyaku/akuma/<name>.md'
@@ -160,7 +165,7 @@ function collectSourceDiseases(source, providerSource, read) {
         }
     }
     if ("providers" in raw) {
-        const collectedProviders = collectProviderCandidates(providerSource, raw.providers);
+        const collectedProviders = collectProviderCandidates(settingsSource, providerSource, raw.providers);
         providerCandidates = collectedProviders.candidates;
         if (collectedProviders.disease !== undefined)
             diseases.push(collectedProviders.disease);
@@ -170,9 +175,9 @@ function collectSourceDiseases(source, providerSource, read) {
             continue;
         // worktreeBootstrap is project-layer only. Global/user presence is a named
         // disease and never contributes execution authority.
-        if (knob === "worktreeBootstrap" && source === "global") {
+        if (knob === "worktreeBootstrap" && settingsSource.source === "global") {
             diseases.push({
-                source,
+                ...settingsSource,
                 knob,
                 reason: "worktreeBootstrap is project-only and never supplies a value from global settings",
             });
@@ -182,7 +187,7 @@ function collectSourceDiseases(source, providerSource, read) {
         const result = schema.safeParse(raw[knob]);
         if (!result.success) {
             diseases.push({
-                source,
+                ...settingsSource,
                 knob,
                 reason: formatZodIssues(result.error),
             });
@@ -192,7 +197,7 @@ function collectSourceDiseases(source, providerSource, read) {
             continue;
         partial[knob] = result.data;
     }
-    return { partial, diseases, providerCandidates };
+    return { settingsSource, partial, diseases, providerCandidates };
 }
 function mergeSettingsKnobs(base, override) {
     // worktreeBootstrap is whole-value project authority; never field-merge it.
@@ -217,9 +222,21 @@ function mergeSettingsKnobs(base, override) {
         merged.worktreeBootstrap = bootstrap;
     return merged;
 }
+function collectKnobSources(global, local) {
+    const sources = {};
+    for (const knob of KNOWN_SETTINGS_KNOBS) {
+        if (global.partial[knob] !== undefined)
+            sources[knob] = global.settingsSource;
+        if (local.partial[knob] !== undefined)
+            sources[knob] = local.settingsSource;
+    }
+    return sources;
+}
 export async function loadKeiyakuSettings(cwd) {
     const localSettingsPath = path.join(cwd, SETTINGS_FILE);
     const globalSettingsPath = path.join(getKeiyakuHome(), path.basename(SETTINGS_FILE));
+    const globalSource = { source: "global", coordinate: globalSettingsPath };
+    const localSource = { source: "local", coordinate: localSettingsPath };
     let globalRead;
     let localRead;
     try {
@@ -233,12 +250,13 @@ export async function loadKeiyakuSettings(cwd) {
         const reason = error instanceof Error ? error.message : String(error);
         return {
             knobs: null,
-            diseases: [{ source: "local", reason: `settings root is unreadable (${reason})` }],
+            diseases: [{ ...localSource, reason: `settings root is unreadable (${reason})` }],
+            knobSources: {},
             providerInstances: builtinProviderInstanceCatalog(),
         };
     }
-    const globalCollected = collectSourceDiseases("global", "global", globalRead);
-    const localCollected = collectSourceDiseases("local", "project", localRead);
+    const globalCollected = collectSourceDiseases(globalSource, "global", globalRead);
+    const localCollected = collectSourceDiseases(localSource, "project", localRead);
     const diseases = [...globalCollected.diseases, ...localCollected.diseases];
     let providerInstances = builtinProviderInstanceCatalog();
     providerInstances = mergeProviderCandidates(providerInstances, globalCollected.providerCandidates);
@@ -248,5 +266,10 @@ export async function loadKeiyakuSettings(cwd) {
         knobs = mergeSettingsKnobs(globalCollected.partial, localCollected.partial);
     }
     // Empty object still means "settings files were present"; callers treat null as absent files.
-    return { knobs, diseases, providerInstances };
+    return {
+        knobs,
+        diseases,
+        knobSources: collectKnobSources(globalCollected, localCollected),
+        providerInstances,
+    };
 }

package/build/core/addressing.js

@@ -1,8 +1,8 @@
 import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
 import { errorContainsAnyPattern, NOT_GIT_REPOSITORY_PATTERNS } from "../git/core.js";
-import { commissionSlug, formatCommissionCoordinate } from "./ids.js";
-import { listContractIds, readLedger } from "./ledger.js";
+import { commissionSlug, formatCommissionCoordinate, isCommissionId } from "./ids.js";
+import { readAllLedgerSnapshots, readLedgerSnapshot } from "./ledger-batch.js";
 import { isResponseArtifactId } from "./response-artifact-id.js";
 import { activeContractBoundByEngineWorktree, stableRepoRoot } from "./worktree-path.js";
 import { assertNoRenewRecoverySession } from "./renew-session.js";
@@ -115,12 +115,8 @@ export class AddressResolutionError extends FlowError {
 function candidatePlace(candidate) {
     return candidate.bind.data.workspace === "worktree" ? candidate.bind.data.place ?? null : null;
 }
-async function commissionAddressCandidates(cwd) {
-    const ids = await listContractIds(cwd);
-    const ledgers = await Promise.all(ids.map(async (contractId) => readLedger(cwd, contractId)));
+function commissionAddressCandidatesFromLedgers(ledgers) {
     return ledgers.flatMap((ledger) => {
-        if (!ledger)
-            return [];
         const bind = ledger.entries.find((entry) => entry.kind === "bind");
         if (!bind || bind.contract !== ledger.contractId)
             return [];
@@ -133,6 +129,17 @@ async function commissionAddressCandidates(cwd) {
             }];
     });
 }
+async function commissionAddressCandidates(cwd, exactContractId) {
+    if (exactContractId) {
+        const ledger = await readLedgerSnapshot(cwd, exactContractId);
+        return ledger ? commissionAddressCandidatesFromLedgers([ledger]) : [];
+    }
+    const reads = await readAllLedgerSnapshots(cwd);
+    const failed = reads.find((read) => "error" in read);
+    if (failed && "error" in failed)
+        throw failed.error;
+    return commissionAddressCandidatesFromLedgers(reads.filter((read) => !("error" in read)));
+}
 function matchCommissionAddress(query, candidates) {
     return candidates.flatMap((candidate) => {
         const matches = [];
@@ -221,7 +228,7 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
                 actual: "artifact",
             });
         }
-        const candidates = await commissionAddressCandidates(repo.stableRoot);
+        const candidates = await commissionAddressCandidates(repo.stableRoot, isCommissionId(query) ? query : undefined);
         const matches = matchCommissionAddress(query, candidates);
         const attempt = {
             repo,
@@ -260,7 +267,7 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
     try {
         const effectiveRepo = await stableRepoRoot(workdir);
         if (effectiveRepo === repo.stableRoot) {
-            boundContractId = await activeContractBoundByEngineWorktree(workdir);
+            boundContractId = await activeContractBoundByEngineWorktree(workdir, effectiveRepo);
         }
     }
     catch (error) {
@@ -305,6 +312,30 @@ export async function resolveContractAddress(cwd, raw, source = raw?.startsWith(
         ? "no active commission found; pass @place, @slug, full @commission-id, or --contract <addr>"
         : "multiple active commissions found; pass @place, @slug, full @commission-id, or --contract <addr>", attempt);
 }
+/**
+ * `call` may inherit only the active commission proven by the selected
+ * engine-owned worktree. Unlike existing-contract resolution, this never
+ * considers sole-active cardinality.
+ */
+export async function resolveCallWorktreeAddress(cwd, effectiveDirectory = cwd) {
+    const repo = await resolvedRepository(cwd);
+    const workdir = path.resolve(effectiveDirectory);
+    let contractId;
+    try {
+        const effectiveRepo = await stableRepoRoot(workdir);
+        if (effectiveRepo !== repo.stableRoot)
+            return undefined;
+        contractId = await activeContractBoundByEngineWorktree(workdir, effectiveRepo);
+    }
+    catch (error) {
+        if (!errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS))
+            throw error;
+        return undefined;
+    }
+    if (!contractId)
+        return undefined;
+    return await resolveContractAddress(repo.stableRoot, contractId, "worktree-binding", workdir);
+}
 export async function resolveExistingContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag", effectiveDirectory = cwd) {
     const address = await resolveContractAddress(cwd, raw, source, effectiveDirectory);
     try {

package/build/core/amend.js

@@ -5,7 +5,7 @@ import { refreshContractView } from "./contract-view.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { resolveDefaultBranch } from "./status/drift.js";
-import { markdownSourceSections, normalizeScopePattern, validateScopeFragmentLines } from "./scope.js";
+import { markdownSourceSections, normalizeScopePattern, ScopePatternError, validateScopeFragmentLines } from "./scope.js";
 import { normalizeSectionTitle } from "./markdown/titles.js";
 import { resolveContractDeliveryCwd } from "./worktree-path.js";
 function amendScopeHeading(name) {
@@ -44,9 +44,25 @@ function scopePatterns(markdown, section) {
         emptyMessage: `amend input has an empty ${amendScopeHeading(section.name)} section`,
     });
 }
-export function buildAmendInput(markdown, cwd, contractId, contractAddressSource) {
+function normalizeAmendScopePatterns(patterns) {
+    try {
+        return patterns.map((pattern) => normalizeScopePattern(pattern));
+    }
+    catch (error) {
+        if (error instanceof ScopePatternError) {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
+        }
+        throw error;
+    }
+}
+export function buildAmendInput(markdown, cwd, contractId, contractAddressSource, appendScope) {
     const { sections, prose } = parseAmendScopeSections(markdown);
-    const append = sections.append ? scopePatterns(markdown, sections.append) : [];
+    if (sections.append && appendScope && appendScope.length > 0) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "amend input may use either --append-scope or ## Scope Append, not both");
+    }
+    const append = sections.append
+        ? scopePatterns(markdown, sections.append)
+        : normalizeAmendScopePatterns(appendScope ?? []);
     if (!prose.trim()) {
         throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
     }
@@ -55,7 +71,7 @@ export function buildAmendInput(markdown, cwd, contractId, contractAddressSource
         ...(contractId ? { contractId } : {}),
         ...(contractAddressSource ? { contractAddressSource } : {}),
         amendment: prose,
-        ...(sections.append ? { scopeDelta: { add: append } } : {}),
+        ...(append.length > 0 ? { scopeDelta: { add: append } } : {}),
     };
 }
 function requireAmendment(value) {
@@ -76,7 +92,7 @@ function normalizeScopeDelta(scopeDelta) {
     if (!scopeDelta)
         return undefined;
     // Scope patterns are gitignore text; do not requireText/trim, or escaped trailing spaces die.
-    const add = scopeDelta.add.map((pattern) => normalizeScopePattern(pattern));
+    const add = normalizeAmendScopePatterns(scopeDelta.add);
     if (add.length === 0)
         return undefined;
     return { add };

package/build/core/call/context.js

@@ -2,7 +2,7 @@ import * as fs from "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, withResolvedAddress, } from "../addressing.js";
+import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveContractAddress, resolveCallWorktreeAddress, withResolvedAddress, } from "../addressing.js";
 import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { findOpenArcView } from "../arc.js";
 import { readLedger } from "../ledger.js";
@@ -139,7 +139,24 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             },
         }));
     }
-    if (input.bare || !input.contractId) {
+    if (input.bare) {
+        return {
+            activeKeiyaku: false,
+            effectiveCwd: executionCwd,
+            historyCwd: ledgerCwd,
+            profileCwd: ledgerCwd,
+            projectionCwd: ledgerCwd,
+            address: buildUncommissionedRepositoryAddress({
+                stableRoot: ledgerCwd,
+                workdir: executionCwd,
+                binding: "bare",
+            }),
+        };
+    }
+    const address = input.contractId
+        ? await resolveContractAddress(ledgerCwd, input.contractId, input.contractAddressSource)
+        : await resolveCallWorktreeAddress(ledgerCwd, executionCwd);
+    if (!address) {
         return {
             activeKeiyaku: false,
             effectiveCwd: executionCwd,
@@ -153,7 +170,6 @@ export async function readCallKeiyakuContext(executionCwd, input) {
             }),
         };
     }
-    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

@@ -7,7 +7,7 @@ import { assertProjectionAlias, moveProjectionAlias } from "../projection/index.
 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 { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, acquireProjectionRunnerLock, } from "../projection/index.js";
 import { observeProjectionLife } from "../projection/index.js";
 import { mintProjection, mintRepositoryProjection } from "../projection/index.js";
 import { waitForProjection } from "../projection/index.js";
@@ -60,13 +60,29 @@ export function outcomeFromGeneration(current) {
     return restoreOutcome(record);
 }
 export async function executeSubagent(agentName, prompt, cwd, options) {
-    const { projection: projectionCoordinate, launchSnapshot } = await buildCallConfig(agentName, prompt, cwd, options);
+    const { projection: projectionCoordinate, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
     if (!projectionCoordinate) {
         throw new FlowError("INTERNAL_STATE", "durable execution requires a projection coordinate");
     }
-    const launched = await startProjectionGeneration(projectionCoordinate.dir, projectionCoordinate.executionId);
-    if (launched.status === "failed") {
-        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.detail);
+    const launchOwnership = acquireProjectionRunnerLock(projectionCoordinate.dir);
+    const launched = await startProjectionGeneration(projectionCoordinate.dir, projectionCoordinate.executionId, {
+        commitLaunch: () => {
+            const store = openProjectionGenerationStore(projectionCoordinate.dir);
+            try {
+                return store.launchIfSettled({ executionId: projectionCoordinate.executionId, facts: launchFacts }).status === "committed";
+            }
+            finally {
+                store.close();
+            }
+        },
+        launchOwnership,
+    });
+    launchOwnership.close();
+    if (launched.status !== "adopted") {
+        const detail = launched.status === "pending"
+            ? "runner retained startup ownership without adopting before the bounded launch wait"
+            : launched.detail;
+        throw new FlowError("SUBAGENT_EXEC_ERROR", detail);
     }
     const joined = await waitForProjection({
         projectionDirectory: projectionCoordinate.dir,
@@ -111,13 +127,28 @@ export async function executeSubagent(agentName, prompt, cwd, options) {
     throw new FlowError("INTERNAL_STATE", "Unhandled subagent outcome state.");
 }
 export async function launchSubagentGeneration(agentName, prompt, cwd, options) {
-    const { projection, launchSnapshot } = await buildCallConfig(agentName, prompt, cwd, options);
+    const { projection, launchSnapshot, launchFacts } = await buildCallConfig(agentName, prompt, cwd, options);
     if (!projection) {
         throw new FlowError("INTERNAL_STATE", "durable launch requires a projection coordinate");
     }
-    const launched = await startProjectionGeneration(projection.dir, projection.executionId);
-    if (launched.status === "failed") {
-        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.detail);
+    const launchOwnership = acquireProjectionRunnerLock(projection.dir);
+    const launched = await startProjectionGeneration(projection.dir, projection.executionId, {
+        commitLaunch: () => {
+            const store = openProjectionGenerationStore(projection.dir);
+            try {
+                return store.launchIfSettled({ executionId: projection.executionId, facts: launchFacts }).status === "committed";
+            }
+            finally {
+                store.close();
+            }
+        },
+        launchOwnership,
+    });
+    launchOwnership.close();
+    if (launched.status !== "adopted") {
+        throw new FlowError("SUBAGENT_EXEC_ERROR", launched.status === "pending"
+            ? "runner retained startup ownership without adopting before the bounded launch wait"
+            : launched.detail);
     }
     return { projection, launchSnapshot };
 }
@@ -173,16 +204,6 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
                 } : {}),
             },
         }));
-        const store = openProjectionGenerationStore(minted.dir);
-        try {
-            const launch = store.launchIfSettled({ executionId, facts: launchFacts });
-            if (launch.status !== "committed") {
-                throw new FlowError("INTERNAL_STATE", `initial generation launch rejected: ${launch.reason}`);
-            }
-        }
-        finally {
-            store.close();
-        }
         const previousAliasTarget = options.alias === undefined
             ? undefined
             : await moveProjectionAlias(options.projectionCwd ?? cwd, assertProjectionAlias(options.alias), minted.id);
@@ -202,6 +223,7 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
             id: minted.id,
             dir: minted.dir,
             executionId,
+            launchFacts,
             ...(options.alias ? { alias: options.alias } : {}),
             ...(previousAliasTargetStillRunning ? { previousAliasTarget: previousAliasTargetStillRunning } : {}),
         };
@@ -209,9 +231,10 @@ export async function buildCallConfig(agentName, prompt, cwd, options) {
     // Every public launch has one durable projection object. Repository-free
     // authority changes the storage owner, not whether the object exists; mint
     // failure is therefore a launch failure rather than an in-process fallback.
-    const projectionCoordinate = await publishProjection();
+    const { launchFacts, ...projectionCoordinate } = await publishProjection();
     return {
         projection: projectionCoordinate,
         launchSnapshot,
+        launchFacts,
     };
 }