@gajae-code/coding-agent 0.12.0 → 0.12.2

package/src/sdk/bus/kind-aware-reconciliation.ts

@@ -2,14 +2,13 @@
  * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
  * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
  */
+import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
 import {
 	PROMPT_RECONCILIATION_ACTIVE_CAPACITY,
 	PROMPT_RECONCILIATION_TERMINAL_CAPACITY,
 	PROMPT_RECONCILIATION_TERMINAL_TTL_MS,
 	type PromptCorrelation,
-	type PromptReconciliationStatus,
 	sanitizePromptFailure,
-	type TurnPromptReconciliation,
 } from "./prompt-reconciliation";
 import type { DurableReconciliationRecord, ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
 
@@ -33,6 +32,16 @@ export interface KindAwareReconciliation {
 		correlation: PromptCorrelation | undefined,
 		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
 	): Promise<void>;
+	claimPendingOutcome(
+		correlation: PromptCorrelation,
+		outcome: SdkPromptTerminalOutcome,
+	): Promise<SdkPromptTerminalOutcome>;
+	finalizePromptOutcome(
+		correlation: PromptCorrelation,
+		outcome?: SdkPromptTerminalOutcome,
+		recordError?: { code: string; message: string },
+	): Promise<void>;
+	peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
 	lookup(
 		kind: ReconciliationKind,
 		selector: { commandId?: string; turnId?: string; clientRef?: string },
@@ -48,48 +57,72 @@ export function createKindAwareReconciliation(
 ): KindAwareReconciliation {
 	const now = options.now ?? Date.now;
 	const store = options.store ?? null;
-	const records = new Map<string, DurableReconciliationRecord>();
-	const clientRefIndex = new Map<string, string>(); // `${kind}\0${clientRef}` -> key
+	let records = new Map<string, DurableReconciliationRecord>();
+	let clientRefIndex = new Map<string, string>();
 	const reservedClientRefs = new Map<ReconciliationKind, Set<string>>();
 	const reservations: Array<{ kind: ReconciliationKind; clientRef?: string }> = [];
+	let mutationChain: Promise<void> = Promise.resolve();
 
 	const keyOf = (kind: ReconciliationKind, correlation: PromptCorrelation) =>
 		`${kind}:${correlation.commandId}:${correlation.turnId}`;
 	const refKey = (kind: ReconciliationKind, clientRef: string) => `${kind}\0${clientRef}`;
 
-	const reservedFor = (kind: ReconciliationKind) => {
-		let set = reservedClientRefs.get(kind);
-		if (!set) {
-			set = new Set();
-			reservedClientRefs.set(kind, set);
-		}
-		return set;
-	};
-
-	const remove = (key: string) => {
-		const record = records.get(key);
-		if (!record) return;
-		records.delete(key);
-		if (record.clientRef !== undefined) {
-			const rk = refKey(record.kind, record.clientRef);
-			if (clientRefIndex.get(rk) === key) clientRefIndex.delete(rk);
-		}
+	const indexRecords = (source: Map<string, DurableReconciliationRecord>) => {
+		const index = new Map<string, string>();
+		for (const [key, record] of source)
+			if (record.clientRef !== undefined) index.set(refKey(record.kind, record.clientRef), key);
+		return index;
 	};
 
-	const cleanup = () => {
+	const cleanupRecords = (source: Map<string, DurableReconciliationRecord>) => {
 		const at = now();
-		for (const [key, record] of records)
+		for (const [key, record] of source)
 			if (record.terminalAt !== undefined && record.terminalAt + PROMPT_RECONCILIATION_TERMINAL_TTL_MS <= at)
-				remove(key);
+				source.delete(key);
 		for (const kind of ["prompt", "skill"] as const) {
-			const terminalEntries = [...records.entries()].filter(
+			const terminalEntries = [...source.entries()].filter(
 				([, record]) => record.kind === kind && record.terminalAt !== undefined,
 			);
 			if (terminalEntries.length <= PROMPT_RECONCILIATION_TERMINAL_CAPACITY) continue;
 			terminalEntries.sort((a, b) => (a[1].terminalAt as number) - (b[1].terminalAt as number));
 			for (const [key] of terminalEntries.slice(0, terminalEntries.length - PROMPT_RECONCILIATION_TERMINAL_CAPACITY))
-				remove(key);
+				source.delete(key);
+		}
+	};
+
+	const queueMutation = async <T>(
+		mutate: (candidate: Map<string, DurableReconciliationRecord>) => { value: T; changed: boolean },
+	): Promise<T> => {
+		const run = async () => {
+			const candidate = new Map([...records].map(([key, record]) => [key, { ...record }]));
+			const result = mutate(candidate);
+			if (!result.changed) return result.value;
+			const candidateIndex = indexRecords(candidate);
+			if (store) await store.transact(() => [...candidate.values()].map(record => ({ ...record })));
+			records = candidate;
+			clientRefIndex = candidateIndex;
+			return result.value;
+		};
+		const pending = mutationChain.then(run, run);
+		mutationChain = pending.then(
+			() => undefined,
+			() => undefined,
+		);
+		return await pending;
+	};
+
+	const reservedFor = (kind: ReconciliationKind) => {
+		let set = reservedClientRefs.get(kind);
+		if (!set) {
+			set = new Set();
+			reservedClientRefs.set(kind, set);
 		}
+		return set;
+	};
+
+	const cleanup = () => {
+		cleanupRecords(records);
+		clientRefIndex = indexRecords(records);
 	};
 
 	const activeCount = (kind: ReconciliationKind) => {
@@ -98,21 +131,19 @@ export function createKindAwareReconciliation(
 		return count;
 	};
 
-	const reservationCount = (kind: ReconciliationKind) => reservations.filter(r => r.kind === kind).length;
+	const reservationCount = (kind: ReconciliationKind) => reservations.filter(record => record.kind === kind).length;
 
 	const consumeReservation = (kind: ReconciliationKind, clientRef?: string) => {
-		const index = reservations.findIndex(r => r.kind === kind && r.clientRef === clientRef);
+		const index = reservations.findIndex(record => record.kind === kind && record.clientRef === clientRef);
 		if (index === -1) return;
 		reservations.splice(index, 1);
-		if (clientRef !== undefined && !reservations.some(r => r.kind === kind && r.clientRef === clientRef))
+		if (
+			clientRef !== undefined &&
+			!reservations.some(record => record.kind === kind && record.clientRef === clientRef)
+		)
 			reservedFor(kind).delete(clientRef);
 	};
 
-	const persist = async () => {
-		if (!store) return;
-		await store.transact(() => [...records.values()].map(r => ({ ...r })));
-	};
-
 	const admit = (kind: ReconciliationKind, clientRef?: string) => {
 		cleanup();
 		const reserved = reservedFor(kind);
@@ -139,22 +170,20 @@ export function createKindAwareReconciliation(
 		clientRef?: string,
 		extra?: { skillName?: string },
 	) => {
-		cleanup();
+		await queueMutation(candidate => {
+			cleanupRecords(candidate);
+			candidate.set(keyOf(kind, correlation), {
+				kind,
+				commandId: correlation.commandId,
+				turnId: correlation.turnId,
+				...(clientRef !== undefined ? { clientRef } : {}),
+				status: "accepted",
+				acceptedAt: now(),
+				...(extra?.skillName ? { skillName: extra.skillName } : {}),
+			});
+			return { value: undefined, changed: true };
+		});
 		consumeReservation(kind, clientRef);
-		const at = now();
-		const key = keyOf(kind, correlation);
-		const record: DurableReconciliationRecord = {
-			kind,
-			commandId: correlation.commandId,
-			turnId: correlation.turnId,
-			...(clientRef !== undefined ? { clientRef } : {}),
-			status: "accepted",
-			acceptedAt: at,
-			...(extra?.skillName ? { skillName: extra.skillName } : {}),
-		};
-		records.set(key, record);
-		if (clientRef !== undefined) clientRefIndex.set(refKey(kind, clientRef), key);
-		await persist();
 	};
 
 	const noteTransition = async (
@@ -163,27 +192,63 @@ export function createKindAwareReconciliation(
 		frame: { type: "agent_start" | "agent_end" } | { type: "agent_failed"; error: unknown },
 	) => {
 		if (!correlation) return;
-		const record = records.get(keyOf(kind, correlation));
-		if (!record || record.terminalAt !== undefined) return;
-		if (frame.type === "agent_start") {
-			if (record.status === "accepted") {
+		await queueMutation(candidate => {
+			const record = candidate.get(keyOf(kind, correlation));
+			if (!record || record.terminalAt !== undefined) return { value: undefined, changed: false };
+			if (frame.type === "agent_start") {
+				if (record.status !== "accepted") return { value: undefined, changed: false };
 				record.status = "in_flight";
 				record.startedAt = now();
-				await persist();
+				return { value: undefined, changed: true };
 			}
-			return;
-		}
-		record.terminalAt = now();
-		if (frame.type === "agent_failed") {
-			record.status = "failed";
-			record.error = sanitizePromptFailure(frame.error);
-		} else {
-			record.status = "terminal_ok";
-		}
-		cleanup();
-		await persist();
+			record.terminalAt = now();
+			if (frame.type === "agent_failed") {
+				record.status = "failed";
+				record.error = sanitizePromptFailure(frame.error);
+			} else record.status = "terminal_ok";
+			cleanupRecords(candidate);
+			return { value: undefined, changed: true };
+		});
+	};
+
+	const claimPendingOutcome = async (
+		correlation: PromptCorrelation,
+		outcome: SdkPromptTerminalOutcome,
+	): Promise<SdkPromptTerminalOutcome> =>
+		await queueMutation(candidate => {
+			const record = candidate.get(keyOf("prompt", correlation));
+			if (!record || record.terminalAt !== undefined || record.kind !== "prompt")
+				return { value: outcome, changed: false };
+			if (record.pendingOutcome !== undefined) return { value: record.pendingOutcome, changed: false };
+			record.pendingOutcome = outcome;
+			return { value: outcome, changed: true };
+		});
+
+	const finalizePromptOutcome = async (
+		correlation: PromptCorrelation,
+		outcome?: SdkPromptTerminalOutcome,
+		recordError?: { code: string; message: string },
+	) => {
+		await queueMutation(candidate => {
+			const record = candidate.get(keyOf("prompt", correlation));
+			if (!record || record.terminalAt !== undefined || record.kind !== "prompt")
+				return { value: undefined, changed: false };
+			const finalOutcome = outcome ?? record.pendingOutcome;
+			record.terminalAt = now();
+			if (finalOutcome?.kind === "failed") {
+				record.status = "failed";
+				record.error = recordError ?? { code: finalOutcome.code, message: finalOutcome.message };
+			} else record.status = "terminal_ok";
+			record.outcome = finalOutcome;
+			record.pendingOutcome = undefined;
+			cleanupRecords(candidate);
+			return { value: undefined, changed: true };
+		});
 	};
 
+	const peekPendingOutcome = (correlation: PromptCorrelation) =>
+		records.get(keyOf("prompt", correlation))?.pendingOutcome;
+
 	const lookup = (
 		kind: ReconciliationKind,
 		selector: { commandId?: string; turnId?: string; clientRef?: string },
@@ -210,6 +275,7 @@ export function createKindAwareReconciliation(
 			...identity,
 			...(record.startedAt !== undefined ? { startedAt: record.startedAt } : {}),
 			terminalAt: record.terminalAt as number,
+			...(record.outcome !== undefined ? { outcome: record.outcome } : {}),
 		};
 		if (record.status === "terminal_ok") return { status: "terminal_ok", ...terminal };
 		return { status: "failed", ...terminal, error: record.error ?? sanitizePromptFailure(undefined) };
@@ -217,14 +283,20 @@ export function createKindAwareReconciliation(
 
 	const hydrateFromStore = async () => {
 		if (!store) return;
-		const loaded = await store.load();
-		records.clear();
-		clientRefIndex.clear();
-		for (const record of loaded) {
-			const key = keyOf(record.kind, record);
-			records.set(key, record);
-			if (record.clientRef !== undefined) clientRefIndex.set(refKey(record.kind, record.clientRef), key);
-		}
+		const run = async () => {
+			const loaded = await store.load();
+			const candidate = new Map(loaded.map(record => [keyOf(record.kind, record), { ...record }] as const));
+			const candidateIndex = indexRecords(candidate);
+			await store.transact(() => [...candidate.values()].map(record => ({ ...record })));
+			records = candidate;
+			clientRefIndex = candidateIndex;
+		};
+		const pending = mutationChain.then(run, run);
+		mutationChain = pending.then(
+			() => undefined,
+			() => undefined,
+		);
+		await pending;
 	};
 
 	return {
@@ -232,6 +304,9 @@ export function createKindAwareReconciliation(
 		releaseAdmission,
 		noteAccepted,
 		noteTransition,
+		claimPendingOutcome,
+		finalizePromptOutcome,
+		peekPendingOutcome,
 		lookup,
 		cleanup,
 		activeCount,

package/src/sdk/bus/lifecycle-commands.ts

@@ -270,7 +270,10 @@ function isSafePath(value: string): boolean {
 	// relative are both allowed (full-trust chat), but not injection shapes.
 	if (value.length === 0 || value.length > 4096) return false;
 	if (/[\n\r\0]/.test(value)) return false;
-	return !/[;&|`$(){}<>*?!\\"']/.test(value);
+	// Backslash is a shell escape on POSIX but the native path separator on
+	// Windows; allow it there so absolute Windows paths validate correctly.
+	const metachars = process.platform === "win32" ? /[;&|`$(){}<>*?!"']/ : /[;&|`$(){}<>*?!\\"']/;
+	return !metachars.test(value);
 }
 
 function isSafeBranch(value: string): boolean {