@astrosheep/keiyaku 4.6.11 → 4.6.13

package/build/src/git/process.js

@@ -15,6 +15,21 @@ export class GitPlumbingError extends Error {
     }
 }
 const GIT_STDERR_BYTES = 16 * 1024;
+export function gitChildEnvironment(environment) {
+    const inherited = { ...process.env };
+    for (const variable of [
+        "GIT_DIR",
+        "GIT_WORK_TREE",
+        "GIT_INDEX_FILE",
+        "GIT_OBJECT_DIRECTORY",
+        "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+        "GIT_COMMON_DIR",
+        "GIT_NAMESPACE",
+    ]) {
+        delete inherited[variable];
+    }
+    return { ...inherited, ...environment };
+}
 function commandError(command, error) {
     const candidate = error;
     const stderr = candidate.stderr === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stderr);
@@ -39,7 +54,7 @@ export async function executeGit(repository, args, input, environment) {
     const owned = spawnCancellableProcess({
         argv: [repository.gitPath, ...args],
         cwd: repository.effectiveCwd,
-        ...(environment === undefined ? {} : { env: { ...process.env, ...environment } }),
+        env: gitChildEnvironment(environment),
         ...(repository.signal === undefined ? {} : { signal: repository.signal }),
     });
     const child = owned.child;
@@ -115,6 +130,7 @@ export async function runGitPipe(repository, sourceArgs, sinkArgs) {
         const owned = spawnCancellableProcess({
             argv: [repository.gitPath, ...args],
             cwd: repository.effectiveCwd,
+            env: gitChildEnvironment(),
             ...(repository.signal === undefined ? {} : { signal: repository.signal }),
         });
         processes.push(owned);
@@ -186,6 +202,7 @@ export async function consumeGitStdout(repository, args, consume) {
     const result = await consumeProcessStdout({
         argv: [repository.gitPath, ...args],
         cwd: repository.effectiveCwd,
+        env: gitChildEnvironment(),
         ...(repository.signal === undefined ? {} : { signal: repository.signal }),
     }, consume);
     const { outcome } = result;

package/build/src/git/read-observation.js

@@ -3,7 +3,7 @@ import { spawnCancellableProcess } from "../runtime/proc/run.js";
 import { gitObjectId } from "./identity.js";
 import { parseTreeObject, validPath } from "./tree.js";
 import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readRef } from "./repository.js";
-import { GitPlumbingError } from "./process.js";
+import { gitChildEnvironment, GitPlumbingError } from "./process.js";
 const gitReadObservationBrand = Symbol("GitReadObservation");
 const gitDecodeChannelBrand = Symbol("GitDecodeChannel");
 const BATCH_RETIREMENT_GRACE_MS = 5_000;
@@ -54,6 +54,7 @@ function batchChild(repository) {
     return spawnCancellableProcess({
         argv: [repository.gitPath, "cat-file", "--batch"],
         cwd: repository.effectiveCwd,
+        env: gitChildEnvironment(),
         ...(repository.signal === undefined ? {} : { signal: repository.signal }),
     });
 }

package/build/src/git/scratch.d.ts

@@ -10,9 +10,13 @@ export declare const worktreeLeakSchema: z.ZodObject<{
     diagnostic: z.ZodString;
 }, z.core.$strict>;
 export type WorktreeLeak = z.infer<typeof worktreeLeakSchema>;
+export declare class ScratchMaterializationError extends Error {
+    readonly leak: WorktreeLeak;
+    constructor(cause: unknown, leak: WorktreeLeak);
+}
 type CollectableScratchRemoval = Readonly<{
     path: string;
-    /** False only when Git removed the path and absence was confirmed; retained removals own a diagnostic. */
+    /** False only when scratch custody is confirmed absent; retained removals own a diagnostic. */
     retained: boolean;
     diagnostic?: string;
 }>;

package/build/src/git/scratch.js

@@ -6,12 +6,21 @@ import { basename, dirname, join } from "node:path";
 import { acquireSqliteTransactionLock, tryAcquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { contractLocator, gitRefLocator, gitObjectIdForSnapshot } from "./identity.js";
 import { executeGit } from "./process.js";
+import { registeredWorktreePaths } from "./repository.js";
 const SCRATCH_PREFIX = "keiyaku-v4-verify-";
 const SCRATCH_ROOT = await realpath(tmpdir());
 const SCRATCH_PATTERN = /^keiyaku-v4-verify-([0-9a-f]{24}|[0-9a-f]{64}-[0-9a-f]{64})$/;
 /** One bounded removal attempt per scratch; expiry is reported, never retried inside this call. */
 const SCRATCH_REMOVAL_TIMEOUT_MS = 120_000;
 export const worktreeLeakSchema = z.object({ path: z.string().optional(), diagnostic: z.string() }).strict();
+export class ScratchMaterializationError extends Error {
+    leak;
+    constructor(cause, leak) {
+        super(`${cause instanceof Error ? cause.message : String(cause)}; scratch cleanup failed at ${leak.path}: ${leak.diagnostic}`, { cause });
+        this.name = "ScratchMaterializationError";
+        this.leak = { ...leak, diagnostic: this.message };
+    }
+}
 function scratchPath() {
     return join(SCRATCH_ROOT, `${SCRATCH_PREFIX}${randomBytes(12).toString("hex")}`);
 }
@@ -58,22 +67,34 @@ async function pathExists(path) {
 }
 async function removeScratch(repository, path) {
     const removal = AbortSignal.timeout(SCRATCH_REMOVAL_TIMEOUT_MS);
+    const retirementRepository = { ...repository, signal: removal };
+    let present = true;
+    let absenceDiagnostic;
+    try {
+        present = await pathExists(path);
+        if (!present && !(await registeredWorktreePaths(retirementRepository)).includes(path)) {
+            present = await pathExists(path);
+            if (!present)
+                return null;
+        }
+    }
+    catch (error) {
+        absenceDiagnostic = `scratch absence could not be confirmed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    let diagnostic;
     try {
-        const present = await pathExists(path);
-        await executeGit({ ...repository, signal: removal }, ["worktree", "remove", ...(present ? ["--force"] : []), path]);
-        return (await pathExists(path))
-            ? { path, diagnostic: `Git reported scratch worktree removal but the path remains: ${path}` }
-            : null;
+        await executeGit(retirementRepository, ["worktree", "remove", ...(present ? ["--force"] : []), path]);
+        if (!(await pathExists(path)))
+            return null;
+        diagnostic = `Git reported scratch worktree removal but the path remains: ${path}`;
     }
     catch (error) {
         const original = error instanceof Error ? error.message : String(error);
-        return {
-            path,
-            diagnostic: removal.aborted
-                ? `scratch worktree removal timed out after ${SCRATCH_REMOVAL_TIMEOUT_MS}ms: ${original}`
-                : original,
-        };
+        diagnostic = removal.aborted
+            ? `scratch worktree removal timed out after ${SCRATCH_REMOVAL_TIMEOUT_MS}ms: ${original}`
+            : original;
     }
+    return { path, diagnostic: absenceDiagnostic === undefined ? diagnostic : `${absenceDiagnostic}; ${diagnostic}` };
 }
 /** Remove only abandoned Verification scratch worktrees whose ownership locks are held. */
 export async function removeCollectableScratchWorktrees(repository, paths, terminalContract) {
@@ -158,7 +179,15 @@ export async function materializeScratchCandidate(repository, candidate, contrac
         await executeGit(repository, ["worktree", "add", "--detach", cwd, gitObjectIdForSnapshot(candidate)]);
     }
     catch (error) {
-        ownership.close();
+        let leak;
+        try {
+            leak = await removeScratch(repository, cwd);
+        }
+        finally {
+            ownership.close();
+        }
+        if (leak !== null)
+            throw new ScratchMaterializationError(error, leak);
         await removeOwnershipLock(lockPath);
         throw error;
     }

package/build/src/git/target-placement.d.ts

@@ -72,19 +72,37 @@ type TargetPlacementObservationInput = Readonly<{
     predecessor: SnapshotId;
     candidate: SnapshotId;
 }>;
+declare const targetCheckoutObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"followable">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"not-followable">;
+    path: z.ZodString;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;
+type TargetCheckoutObservation = z.infer<typeof targetCheckoutObservationSchema>;
 type TargetPlacementObservation = Readonly<{
     kind: "ready";
     arms: readonly FollowArm[];
+    checkouts: readonly TargetCheckoutObservation[];
 }> | Readonly<{
     kind: "refused";
     refusal: TargetPlacementRefusal;
 }>;
 /** Observe whether registered target checkouts can follow a predecessor-to-candidate movement. */
 export declare function observeTargetPlacement(repository: GitRepository, input: TargetPlacementObservationInput, changes?: TargetPlacementChanges): Promise<TargetPlacementObservation>;
-export declare const auditTargetAnswerSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const previewTargetAnswerSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"placeable">;
     ref: z.ZodString;
     head: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    checkouts: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"followable">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"not-followable">;
+        path: z.ZodString;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"moved">;
     ref: z.ZodString;
@@ -104,9 +122,9 @@ export declare const auditTargetAnswerSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"failed">;
     diagnostic: z.ZodString;
 }, z.core.$strict>]>;
-type AuditTargetAnswer = z.infer<typeof auditTargetAnswerSchema>;
-/** Adjudicate the complete post-Verification audit target answer without placing. */
-export declare function adjudicateAuditTarget(repository: GitRepository, input: TargetPlacementObservationInput): Promise<AuditTargetAnswer>;
+type PreviewTargetAnswer = z.infer<typeof previewTargetAnswerSchema>;
+/** Adjudicate prospective target followability without placing or running Verification. */
+export declare function adjudicatePreviewTarget(repository: GitRepository, input: TargetPlacementObservationInput): Promise<PreviewTargetAnswer>;
 export declare function prepareTargetPlacement(repository: GitRepository, state: ContractState, target: RefOperation, changes?: TargetPlacementChanges): Promise<TargetPlacementPreparation>;
 export declare function followTargetPlacement(repository: GitRepository, prepared: PreparedTargetPlacement, onPhysical?: (report: TargetPlacementPhysicalResult) => void): Promise<TargetPlacementPhysicalResult>;
 /** Judge the target-checkout shape without mutating refs, worktrees, or indexes. */

package/build/src/git/target-placement.js

@@ -183,9 +183,8 @@ async function matchesTreeOnPaths(repository, path, command, trees, paths) {
     return (await gitPaths(repository, path, args)).length === 0;
 }
 /**
- * A checkout that git cannot carry is judged by the physical follow, which records its own lag.
- * The one collision read-tree cannot report is a candidate write over an ignored worktree entry:
- * git carries that by silently destroying the entry, so it is refused here instead.
+ * Retain the single dry-run's followability observation separately from ref-placement legality.
+ * Only a candidate write that silently destroys an ignored entry refuses placement here.
  */
 async function ordinaryPrecheck(repository, contractId, target, path, changes) {
     const predecessor = gitObjectIdForSnapshot(target.expectedOid);
@@ -197,10 +196,11 @@ async function ordinaryPrecheck(repository, contractId, target, path, changes) {
     catch (error) {
         if (!(error instanceof GitPlumbingError) || repository.signal?.aborted === true)
             throw error;
-        return null;
+        return { kind: "not-followable", diagnostic: error.message };
     }
     const scopes = await destructionScopes(path, changes.writes);
-    return await untrackedRefusalWithinScopes(observation, scopes);
+    const refusal = await untrackedRefusalWithinScopes(observation, scopes);
+    return refusal === null ? { kind: "followable" } : { kind: "refused", refusal };
 }
 export async function acquireTargetPlacementFence(repository, target) {
     const locator = gitRefLocator(target);
@@ -211,6 +211,10 @@ export async function acquireTargetPlacementFence(repository, target) {
         ...(repository.signal === undefined ? {} : { signal: repository.signal }),
     });
 }
+const targetCheckoutObservationSchema = z.union([
+    z.object({ kind: z.literal("followable"), path: z.string().min(1) }).strict(),
+    z.object({ kind: z.literal("not-followable"), path: z.string().min(1), diagnostic: z.string().min(1) }).strict(),
+]);
 /** Observe whether registered target checkouts can follow a predecessor-to-candidate movement. */
 export async function observeTargetPlacement(repository, input, changes) {
     const target = {
@@ -225,20 +229,23 @@ export async function observeTargetPlacement(repository, input, changes) {
         .filter((worktree) => worktree.branch === target.target)
         .sort((left, right) => left.path.localeCompare(right.path));
     const arms = [];
+    const checkouts = [];
     for (const worktree of worktrees) {
-        const refusal = await ordinaryPrecheck(repository, input.contractId, target, worktree.path, changes);
-        if (refusal !== null)
-            return { kind: "refused", refusal };
+        const precheck = await ordinaryPrecheck(repository, input.contractId, target, worktree.path, changes);
+        if (precheck.kind === "refused")
+            return precheck;
+        checkouts.push({ ...precheck, path: worktree.path });
         arms.push({ kind: "ordinary", path: worktree.path });
     }
-    return { kind: "ready", arms };
+    return { kind: "ready", arms, checkouts };
 }
-export const auditTargetAnswerSchema = z.union([
+export const previewTargetAnswerSchema = z.union([
     z
         .object({
         kind: z.literal("placeable"),
         ref: z.string().refine((value) => value.trim() !== ""),
         head: snapshotIdSchema,
+        checkouts: z.array(targetCheckoutObservationSchema).readonly(),
     })
         .strict(),
     z
@@ -252,8 +259,8 @@ export const auditTargetAnswerSchema = z.union([
     z.object({ kind: z.literal("refused"), refusal: checkoutNotFollowableRefusalSchema }).strict(),
     z.object({ kind: z.literal("failed"), diagnostic: z.string().refine((value) => value.trim() !== "") }).strict(),
 ]);
-/** Adjudicate the complete post-Verification audit target answer without placing. */
-export async function adjudicateAuditTarget(repository, input) {
+/** Adjudicate prospective target followability without placing or running Verification. */
+export async function adjudicatePreviewTarget(repository, input) {
     const ref = input.coordinates.target;
     const expected = input.predecessor;
     try {
@@ -266,11 +273,12 @@ export async function adjudicateAuditTarget(repository, input) {
             return { kind: "moved", ref, expected, observed };
         return follow.kind === "refused"
             ? { kind: "refused", refusal: follow.refusal }
-            : { kind: "placeable", ref, head: expected };
+            : { kind: "placeable", ref, head: expected, checkouts: follow.checkouts };
     }
     catch (error) {
         if (!(error instanceof GitPlumbingError))
             throw error;
+        repository.signal?.throwIfAborted();
         return { kind: "failed", diagnostic: error.message };
     }
 }
@@ -345,9 +353,9 @@ export async function observeTargetCheckoutShape(repository, input) {
 async function recoverCheckout(input) {
     const classified = await classifyCheckout(input);
     if (classified.kind === "complete")
-        return "complete";
+        return { kind: "complete" };
     if (classified.kind === "retained")
-        return "retained";
+        return { kind: "retained", diagnostic: "target checkout entries are neither predecessor nor candidate" };
     const { repository, path, predecessor, candidate } = input;
     if (classified.action === "index-merge") {
         await executeGit(repository, [
@@ -359,8 +367,15 @@ async function recoverCheckout(input) {
             gitObjectIdForSnapshot(predecessor),
             gitObjectIdForSnapshot(candidate),
         ]);
-        return "recovered";
+        return { kind: "recovered" };
     }
+    const scopes = await destructionScopes(path, input.changes.writes);
+    const refusal = await untrackedRefusalWithinScopes(input, scopes);
+    if (refusal !== null)
+        return {
+            kind: "retained",
+            diagnostic: `target checkout would overwrite ignored local entries: ${refusal.paths.join(", ")}`,
+        };
     await executeGit(repository, [
         "-C",
         path,
@@ -370,7 +385,7 @@ async function recoverCheckout(input) {
         gitObjectIdForSnapshot(predecessor),
         gitObjectIdForSnapshot(candidate),
     ]);
-    return "recovered";
+    return { kind: "recovered" };
 }
 export async function recoverTargetPlacement(repository, state, onPhysical) {
     const target = state.coordinates.target;
@@ -380,6 +395,12 @@ export async function recoverTargetPlacement(repository, state, onPhysical) {
     const integration = state.currentIntegration;
     if (integration === null || (await readRef(repository, target)) !== integration.snapshot)
         return { effects: [], lag: [] };
+    const movement = {
+        target,
+        expectedOid: integration.predecessor,
+        newOid: integration.snapshot,
+    };
+    const changes = await prepareTargetPlacementChanges(repository, movement);
     const candidateTree = await commitTree(repository, integration.snapshot);
     const predecessorTree = await commitTree(repository, integration.predecessor);
     const worktrees = (await registeredWorktrees(repository))
@@ -392,18 +413,21 @@ export async function recoverTargetPlacement(repository, state, onPhysical) {
         try {
             const recovery = await recoverCheckout({
                 repository,
+                contractId: state.id,
+                target: movement,
+                changes,
                 path: worktree.path,
                 predecessor: integration.predecessor,
                 candidate: integration.snapshot,
                 predecessorTree,
                 candidateTree,
             });
-            if (recovery === "retained") {
-                lag.push(recoveryLag(worktree.path, target, "target checkout entries are neither predecessor nor candidate"));
+            if (recovery.kind === "retained") {
+                lag.push(recoveryLag(worktree.path, target, recovery.diagnostic));
                 onPhysical?.({ effects: [], lag: lag.slice(beforeLag) });
                 continue;
             }
-            if (recovery === "recovered") {
+            if (recovery.kind === "recovered") {
                 effects.push({ kind: "target-checkout", path: worktree.path, target, action: "recovered" });
             }
         }

package/build/src/index.d.ts

@@ -54,7 +54,7 @@ export { AkumaAddressError, AkumaWorldScopeError, Akumas } from "./library/akuma
 export type { AkumaAddressInput, AkumaAskInput, AkumaHistoryInput, AkumaHistoryResult, AkumaKillInput, AkumaKillResult, AkumaList, AkumaListInput, AkumaObservation, AkumaObservationStage, AkumaTellInput, AkumaWaitInput, AkumaWaitResult, AkumaWorldScopeRefusal, CallInput, CallResult, CallWaitHead, CreatedDebtObservation, DispatchAssociation, DispatchStage, ForkInput, ForkResult, TellResult, TellWake, } from "./library/akumas.js";
 export type { ContinuationReport } from "./library/continuation.js";
 export type { KeiyakuLibrary, ReconcileInput } from "./library/contract-composition.js";
-export type { AbandonOutcome, AmendOutcome, ArcOutcome, AuditOutcome, BindOutcome, BindResult, DeliverOutcome, ReviewOutcome, } from "./library/contract-outcomes.js";
+export type { AbandonOutcome, AmendOutcome, ArcOutcome, DeliveryPreviewInput, DeliveryPreviewOutcome, BindOutcome, BindResult, DeliverOutcome, ReviewOutcome, } from "./library/contract-outcomes.js";
 export type { AbandonInput, AmendInput, ArcInput, BindInput, ContractHistory, ContractHistoryEvent, ContractList, ContractListInput, ContractObservationInput, ContractResolveInput, ContractResolution, ContractSelectorRefusal, DeliverInput, KeiyakuSelectInput, LocalContractComposition, ReviewInput, } from "./library/contract-types.js";
 export { nukeKeiyaku as nuke } from "./library/nuke.js";
 export type { NukeInput, NukeResult } from "./library/nuke.js";
@@ -64,7 +64,7 @@ export type { KeiyakuRefusal, KeiyakuRetryReason, NukeConfirmationRefusal, NukeC
 export type { RegionOverlap } from "./library/region.js";
 export type { RepoAtInput } from "./library/repo.js";
 export type { KeiyakuPlugin, PluginAkumaCaller, PluginAkumaOrigin, PluginBodyEnd, PluginContext, PluginHooks, PluginInstance, PluginManifest, PluginOutcome, PluginSignal, PluginSignalMap, } from "./plugin/public.js";
-export type { AuditReport } from "./protocol/audit.js";
+export type { DeliveryPreviewReport } from "./protocol/delivery-preview.js";
 export type { IntegrationConflictMaterialized, VerificationReuse } from "./protocol/deliver.js";
 export type { ExecutionObservation, ExecutionObserver } from "./protocol/execution-observation.js";
 export type { PlacementStop, VerificationStop } from "./protocol/operations.js";