@gajae-code/coding-agent 0.17.4 → 0.17.6

package/src/sdk/broker/ensure.ts

@@ -18,13 +18,25 @@ import {
 	resolveSdkInternalSpawnCommand,
 	type SdkInternalSpawnCommand,
 } from "./runtime";
-import { BrokerStartupError, clearBrokerStartupFailureMarker, readBrokerStartupFailureMarker } from "./startup-failure";
+import {
+	BrokerStartupError,
+	type BrokerStartupFailureMarker,
+	brokerStartupFailureCleanupTargetsLock,
+	clearBrokerStartupFailureMarker,
+	readBrokerStartupFailureMarker,
+} from "./startup-failure";
 
 function resolveExpectedBrokerGeneration(): string {
 	const v = (packageJson as { version?: unknown }).version;
 	return typeof v === "string" && v.length > 0 ? v : "unknown";
 }
 
+function brokerStartupFailureReason(marker: BrokerStartupFailureMarker | undefined): string {
+	if (!marker) return "Detached SDK broker exited before publishing discovery.";
+	if (marker.cleanupCommand && marker.reason.endsWith(": ")) return `${marker.reason}${marker.cleanupCommand}`;
+	return marker.reason;
+}
+
 export function isBrokerGenerationCompatible(discovery: BrokerDiscovery | null): boolean {
 	if (!discovery) return false;
 	return discovery.packageGeneration === resolveExpectedBrokerGeneration();
@@ -69,6 +81,34 @@ const SPAWN_LOCK_WAIT_MS = STALE_BROKER_RETIREMENT_TIMEOUT_MS + DISCOVERY_TIMEOU
 const SPAWN_LOCK_RETRY_DELAY_MS = 50;
 const SPAWN_LOCK_TARGET_NAME = "broker.spawn";
 const STARTUP_LOCK_TARGET_NAME = "broker.startup";
+const BROKER_SESSION_ENV_NAMES = new Set([
+	"GJC_SESSION_FILE",
+	"GJC_SESSION_ID",
+	"GJC_SESSION_CWD",
+	"GJC_SESSION_PROMPT_ACCEPTED_JSON",
+	"GJC_SESSION_WORKTREE_BASELINE_DIRTY",
+	"GJC_TMUX_ACTIVE_SESSION",
+	"GJC_TMUX_LAUNCHED",
+	"TMUX",
+	"TMUX_PANE",
+	"GJC_LIFECYCLE_REQUEST_ID",
+	"GJC_SDK_LIFECYCLE_REQUEST",
+	"GJC_STATE_ROOT",
+	"GJC_MASTER_CAPABILITY",
+	"GJC_MASTER_OWNER_SESSION_ID",
+]);
+const BROKER_SESSION_ENV_PRESERVED_NAMES = new Set([
+	"GJC_SESSION_CONTEXT_BUDGET_BYTES",
+	"GJC_SESSION_MEMORY_GC_STRATEGY",
+	"GJC_SESSION_MEMORY_SECONDARY_ARTIFACT_MODE",
+]);
+const BROKER_SESSION_ENV_PREFIXES = [
+	"GJC_SESSION_",
+	"GJC_COORDINATOR_SESSION_",
+	"GJC_COORDINATOR_SIDECAR_",
+	"GJC_TMUX_OWNER_",
+	"GJC_MANAGED_OWNER_",
+] as const;
 
 export interface BrokerStartupLockTestHooks {
 	onAcquired?: () => void;
@@ -445,11 +485,22 @@ function registerBrokerOwner(
 function brokerSpawnEnvironment(command: SdkInternalSpawnCommand, override?: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
 	const environment = { ...(override ?? command.env) };
 	delete environment.BUN_OPTIONS;
-	// The master capability is a transient in-memory dispatch input. A broker
-	// cold-started from the master's own Bash environment would otherwise inherit
-	// it and pass it on to every substrate child it later launches, so it is
-	// stripped at the lifecycle boundary exactly as lifecycle children strip it.
-	delete environment.GJC_MASTER_CAPABILITY;
+	// Master capability and owner-session markers are matched by the normalized
+	// identity-name set below, including differently-cased Windows environment keys.
+	// The broker outlives the TUI session that happened to start it. Never let
+	// that session's identity or coordinator/tmux ownership markers flow through
+	// the broker's process.env into unrelated session hosts. Keep user tmux
+	// configuration (for example GJC_TMUX_SESSION, GJC_TMUX_COMMAND, GJC_MOUSE,
+	// and GJC_TMUX_PROFILE) intact. Windows environment names are case-insensitive.
+	for (const name of Object.keys(environment)) {
+		const normalizedName = name.toUpperCase();
+		if (BROKER_SESSION_ENV_PRESERVED_NAMES.has(normalizedName)) continue;
+		if (
+			BROKER_SESSION_ENV_NAMES.has(normalizedName) ||
+			BROKER_SESSION_ENV_PREFIXES.some(prefix => normalizedName.startsWith(prefix))
+		)
+			delete environment[name];
+	}
 	if (command.kind === "bun-source") {
 		delete environment.PI_COMPILED;
 		delete environment.GJC_COMPILED;
@@ -712,7 +763,8 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 		const startupLockPath = path.join(settings.agentDir, "sdk", STARTUP_LOCK_TARGET_NAME);
 		let startupFenceContention =
 			exitedBeforeDiscovery &&
-			trustedMarker?.reason.startsWith(`Failed to acquire lock for ${startupLockPath} after `) === true;
+			(trustedMarker?.reason.startsWith(`Failed to acquire lock for ${startupLockPath} after `) === true ||
+				brokerStartupFailureCleanupTargetsLock(trustedMarker, `${startupLockPath}.lock`));
 		if (!startupFenceContention && exitedBeforeDiscovery && child.exitCode !== 0) {
 			try {
 				startupFenceContention = (await fs.stat(`${startupLockPath}.lock`)).isDirectory();
@@ -760,7 +812,7 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 				? new BrokerStartupError({
 						exitCode: child.exitCode,
 						signal: child.signalCode,
-						reason: trustedMarker?.reason ?? "Detached SDK broker exited before publishing discovery.",
+						reason: brokerStartupFailureReason(trustedMarker),
 						stderrExcerpt: spawnLogTail.length > 0 ? spawnLogTail : undefined,
 					})
 				: discoveryError
@@ -889,3 +941,8 @@ export function registerBrokerOwnerForTest(
 ): BrokerOwner {
 	return registerBrokerOwner(agentDir, child, timing);
 }
+
+/** Test hook: exercises the same trusted-marker reason reconstruction used by ensureBroker. */
+export function brokerStartupFailureReasonForTest(marker: BrokerStartupFailureMarker | undefined): string {
+	return brokerStartupFailureReason(marker);
+}

package/src/sdk/broker/identity.ts

@@ -51,6 +51,19 @@ export async function deriveIdempotencyIdentity(
 		.digest("hex");
 }
 
+/** Native identity for an idempotency key reserved inside one managed control root. */
+export async function deriveScopedIdempotencyIdentity(
+	agentDir: string,
+	operation: string,
+	callerKey: string,
+	scope: string,
+): Promise<string> {
+	const key = await getBrokerIdentityKey(agentDir);
+	return createHmac("sha256", Buffer.from(key, "hex"))
+		.update(JSON.stringify(["managed-spawn-v1", operation, callerKey, scope]))
+		.digest("hex");
+}
+
 /** Identity format used by lifecycle rows written before target binding. */
 export async function deriveLegacyIdentity(agentDir: string, operation: string, callerKey: string): Promise<string> {
 	const key = await getBrokerIdentityKey(agentDir);

package/src/sdk/broker/lifecycle-ledger.ts

@@ -711,13 +711,25 @@ export class LifecycleLedger {
 		return [...this.#byIdentity.values()].findLast(entry => entry.operationKey === operationKey);
 	}
 	/**
-	 * Legacy target-inclusive rows predate the operation/key index. Their opaque
+	 * Live or uncertain legacy rows predate the operation/key index. Their opaque
 	 * identities cannot establish that a different target is safe, so callers
-	 * must reject rather than create a second admission.
+	 * must reject rather than create a second admission. A fresh session.create
+	 * may ignore completed terminal legacy rows so old successful operations do
+	 * not block coordinator startup. Other operations retain the legacy fence
+	 * because target-bound legacy identities cannot prove key uniqueness. For
+	 * target-bound terminal creates, the opaque legacy identity also cannot reveal
+	 * the original caller key, so this exception retires that legacy key history;
+	 * exact key-only legacy creates are still rejected by the earlier lookup.
 	 */
-	hasLegacyIdentity(excludedIdentities?: ReadonlySet<string>): boolean {
+	hasLegacyIdentity(
+		excludedIdentities?: ReadonlySet<string>,
+		options: { ignoreTerminalRows?: boolean } = {},
+	): boolean {
 		return [...this.#byIdentity.values()].some(
-			entry => entry.operationKey === undefined && !excludedIdentities?.has(entry.identity),
+			entry =>
+				entry.operationKey === undefined &&
+				!(options.ignoreTerminalRows && terminal(entry.state)) &&
+				!excludedIdentities?.has(entry.identity),
 		);
 	}
 	async migrateIdentity(