@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/internal-urls/registry-helpers.ts

@@ -2,10 +2,7 @@
  * Shared helpers for internal-url protocol handlers that resolve session-scoped
  * artifact IDs.
  */
-
-import * as fs from "node:fs";
 import * as path from "node:path";
-import { openRecoveryFsRoot, type RecoveryFsRoot } from "@gajae-code/natives";
 import type { ResolveContext } from "./types";
 
 function addDir(dirs: string[], dir: string | null | undefined): void {
@@ -29,62 +26,3 @@ export function authorizedArtifactsDirsFromContext(context?: ResolveContext): st
 	for (const dir of context?.getAuthorizedArtifactsDirs?.() ?? []) addDir(dirs, dir);
 	return dirs;
 }
-
-export interface AuthorizedArtifactsRoot {
-	readonly directory: string;
-	readonly dev: bigint;
-	readonly ino: bigint;
-	readonly authority: RecoveryFsRoot;
-}
-
-export interface AuthorizedArtifactSnapshot {
-	bytes: Buffer;
-	size: number;
-}
-
-export function openAuthorizedArtifactsRoot(directory: string): AuthorizedArtifactsRoot {
-	if (process.platform !== "linux") throw new Error("artifact_authority_unavailable");
-	const named = fs.lstatSync(directory, { bigint: true });
-	if (!named.isDirectory() || named.isSymbolicLink()) throw new Error("unsafe_artifacts_root");
-	const authority = openRecoveryFsRoot(directory);
-	const retained = authority.identity();
-	if (
-		!retained.ok ||
-		!retained.identity ||
-		retained.identity.dev !== named.dev.toString() ||
-		retained.identity.ino !== named.ino.toString()
-	) {
-		authority.close();
-		throw new Error("unsafe_artifacts_root");
-	}
-	return { directory, dev: named.dev, ino: named.ino, authority };
-}
-
-export function closeAuthorizedArtifactsRoot(root: AuthorizedArtifactsRoot): void {
-	root.authority.close();
-}
-
-export function readAuthorizedArtifactFile(
-	root: AuthorizedArtifactsRoot,
-	filename: string,
-	maxBytes: number,
-): AuthorizedArtifactSnapshot | null {
-	if (
-		path.basename(filename) !== filename ||
-		!Number.isSafeInteger(maxBytes) ||
-		maxBytes < 0 ||
-		maxBytes > 16 * 1024 * 1024
-	) {
-		throw new Error("unsafe_artifact_leaf");
-	}
-	if (!root.authority) throw new Error("artifact_authority_unavailable");
-	const captured = root.authority.read(filename, maxBytes);
-	if (!captured.ok) {
-		if (captured.code === "not_found") return null;
-		throw new Error(`unsafe_artifact_leaf:${captured.code ?? "capture_failed"}`);
-	}
-	if (!captured.data || !captured.identity) throw new Error("unsafe_artifact_leaf:missing_evidence");
-	const size = Number(captured.identity.size);
-	if (!Number.isSafeInteger(size) || size < 0) throw new Error("unsafe_artifact_leaf:invalid_size");
-	return { bytes: Buffer.from(captured.data), size };
-}

package/src/main.ts

@@ -57,10 +57,11 @@ import {
 	discoverAuthStorage,
 } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
-
+import { SessionMigrationBusyError } from "./session/internal/session-open-errors";
 import {
 	type ResumeSessionIdentity,
 	resolveResumableSession,
+	SessionArtifactCapacityError,
 	type SessionDestination,
 	type SessionDirectoryMigrationPolicy,
 	type SessionInfo,
@@ -562,6 +563,22 @@ export function resolveManagedAgentDirForScope(_cwd: string): string {
 	return getAgentDir();
 }
 export const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
+const SESSION_ARTIFACT_CAPACITY_RECOVERY_MESSAGE =
+	"The selected legacy session's artifacts exceed the supported migration capacity. Archive or remove only that legacy session's artifacts after confirming they are no longer needed, then retry.";
+
+function operatorFacingSessionOpenMessage(value: unknown): string | undefined {
+	const code =
+		value instanceof SessionArtifactCapacityError
+			? value.code
+			: value instanceof SessionMigrationBusyError
+				? value.code
+				: typeof value === "string"
+					? value
+					: undefined;
+	if (code === "artifact_capacity_exceeded") return SESSION_ARTIFACT_CAPACITY_RECOVERY_MESSAGE;
+	if (code === "migration_busy") return new SessionMigrationBusyError().message;
+	return undefined;
+}
 
 function isBareResume(parsed: Args): boolean {
 	return (
@@ -1072,6 +1089,7 @@ type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promis
 
 export interface RunRootCommandDependencies {
 	createAgentSession?: typeof createAgentSession;
+	createSessionManager?: typeof createSessionManager;
 	discoverAuthStorage?: typeof discoverAuthStorage;
 	runAcpMode?: (options?: { agentDir?: string }) => Promise<void>;
 	settings?: Settings;
@@ -1208,13 +1226,13 @@ export async function runRootCommand(
 				undefined,
 				resumeMigrationPolicy,
 			);
-		} catch {
-			process.stderr.write(`${BARE_RESUME_OPEN_ERROR}\n`);
+		} catch (error) {
+			process.stderr.write(`${operatorFacingSessionOpenMessage(error) ?? BARE_RESUME_OPEN_ERROR}\n`);
 			if (!deps.suppressProcessExit) process.exitCode = 1;
 			return;
 		}
 		if (opened.kind === "error") {
-			process.stderr.write(`${BARE_RESUME_OPEN_ERROR}\n`);
+			process.stderr.write(`${operatorFacingSessionOpenMessage(opened.reason) ?? BARE_RESUME_OPEN_ERROR}\n`);
 			if (!deps.suppressProcessExit) process.exitCode = 1;
 			return;
 		}
@@ -1381,9 +1399,27 @@ export async function runRootCommand(
 
 	// Create session manager based on CLI flags. A bare resume was strictly opened
 	// before startup discovery, so it never reaches create-or-open behavior here.
-	const sessionManager =
-		bareResumeSessionManager ??
-		(await logger.time("createSessionManager", createSessionManager, parsedArgs, cwd, settingsInstance));
+	let sessionManager: SessionManager | undefined = bareResumeSessionManager;
+	if (!sessionManager) {
+		try {
+			sessionManager = await logger.time(
+				"createSessionManager",
+				deps.createSessionManager ?? createSessionManager,
+				parsedArgs,
+				cwd,
+				settingsInstance,
+			);
+		} catch (error) {
+			const message = operatorFacingSessionOpenMessage(error);
+			if (!message) throw error;
+			process.stderr.write(`${message}\n`);
+			if (!deps.suppressProcessExit) process.exitCode = 1;
+			authStorage.close();
+			stopThemeWatcher();
+			await postmortem.cleanup();
+			return;
+		}
+	}
 
 	// Restore the resumed session's working directory so the HUD branch, the
 	// project path, and the agent's tools all match where the session was

package/src/modes/DESIGN.md

@@ -187,21 +187,21 @@ combine, or substitute them.
 
 | State ID | Required condition represented |
 | --- | --- |
-| `home-unconfigured` | No configured notification destination. |
-| `home-configured-inactive` | Credentials/configuration exist; current session is inactive. |
+| `home-unconfigured` | No complete notification provider. |
+| `home-configured-inactive` | Provider configuration and desired intent exist; current session is inactive. |
 | `home-runtime-active` | Current session endpoint is active. |
 | `home-local-off` | Current session is explicitly locally disabled. |
-| `home-env-off` | Environment hard-off suppresses the surface/runtime. |
-| `home-env-on` | Explicit environment opt-in enables the current session. |
-| `home-discord-only` | Global Discord configuration without Telegram setup. |
-| `home-slack-only` | Global Slack configuration without Telegram setup. |
-| `setup-provider` | Provider choice is focused. |
+| `home-env-off` | Process-level environment hard-off suppresses the surface/runtime. |
+| `home-env-on` | Explicit environment opt-in enables automatic current-session admission. |
+| `home-discord-only` | Discord is complete, desired on, and effective without Telegram. |
+| `home-slack-only` | Slack is complete, desired on, and effective without Telegram. |
+| `setup-provider` | First-class Telegram, Discord, and Slack provider choice is focused. |
 | `setup-chat-entry` | Telegram chat ID field is focused. |
 | `setup-token-entry` | Masked Telegram token field is focused. |
 | `setup-validating` | Token/destination validation is pending. |
 | `setup-threaded-warning` | Threaded mode compatibility warning is visible. |
 | `setup-pairing` | Cancellable private-chat pairing/discovery is pending. |
-| `setup-review` | Sanitized setup choices await explicit save. |
+| `setup-review` | Sanitized provider, secret action, desired intent, and destination await explicit save. |
 | `saving` | Durable atomic save is in progress and guarded. |
 | `health-probing` | Non-cancellable health probe is in progress and guarded. |
 | `health-ok` | Health report is successful. |
@@ -211,12 +211,12 @@ combine, or substitute them.
 | `recovering` | Recovery action is in progress and guarded. |
 | `reconnecting` | Reconnect action is in progress and guarded. |
 | `navigation-locked` | A guarded operation explains why Tab/Escape cannot leave. |
-| `confirmation-remove` | Adapter-local Telegram removal awaits confirmation. |
-| `confirmation-disable` | Global disable awaits confirmation. |
+| `confirmation-remove` | Adapter-local Telegram removal awaits confirmation; sibling/global state is preserved. |
+| `confirmation-disable` | Global disable awaits confirmation and preserves provider credentials/intent. |
 | `success` | A completed operation has concise success copy. |
 | `preferences` | Notification preferences are visible and editable. |
 | `error` | A sanitized operation failure has recovery guidance. |
-| `foreign-blocked` | A foreign/unknown daemon identity blocks activation safely. |
+| `foreign-blocked` | Telegram is excluded from the shared endpoint while effective chat siblings use isolated discovery. |
 | `blocked-restore-retain` | A blocked post-save identity race requires Restore or Retain before navigation. |
 | `cancellation` | A cancellable setup/pairing action was cancelled and restored. |
 | `narrow-cjk` | Narrow localized CJK content exercises semantic line wrapping. |

package/src/modes/acp/acp-agent.ts

@@ -660,10 +660,6 @@ export function createAcpReverseConnection(connection: AgentSideConnection, sess
 		"fs.readTextFile": "fs/read_text_file",
 		"fs.writeTextFile": "fs/write_text_file",
 		"terminal.create": "terminal/create",
-		"terminal.output": "terminal/output",
-		"terminal.waitForExit": "terminal/wait_for_exit",
-		"terminal.kill": "terminal/kill",
-		"terminal.release": "terminal/release",
 		"ui.elicit": "elicitation/create",
 	};
 	return {
@@ -672,26 +668,6 @@ export function createAcpReverseConnection(connection: AgentSideConnection, sess
 			params: JsonObject,
 			options?: { cancellationSignal?: AbortSignal },
 		): Promise<unknown> => {
-			if (method === "terminal.publish") {
-				const toolCallId = typeof params.toolCallId === "string" ? params.toolCallId : undefined;
-				const terminalId = typeof params.terminalId === "string" ? params.terminalId : undefined;
-				if (!toolCallId || !terminalId) {
-					throw new AcpSdkAdapterError(
-						"invalid_params",
-						"ACP terminal publication requires toolCallId and terminalId.",
-					);
-				}
-				await connection.sessionUpdate({
-					sessionId,
-					update: {
-						sessionUpdate: "tool_call_update",
-						toolCallId,
-						status: "in_progress",
-						content: [{ type: "terminal", terminalId }],
-					},
-				});
-				return {};
-			}
 			const name = methods[method];
 			if (!name)
 				throw new AcpSdkAdapterError("acp_reverse_unavailable", `ACP reverse method is unavailable: ${method}`);

package/src/modes/acp/acp-client-bridge.ts

@@ -4,8 +4,6 @@
  * `AgentSession`) can route through the client when it advertises the
  * relevant capabilities at `initialize` time.
  */
-
-import { randomUUID } from "node:crypto";
 import type {
 	PermissionOption as AcpPermissionOption,
 	TerminalHandle as AcpTerminalHandle,
@@ -21,25 +19,10 @@ import type {
 	ClientBridgePermissionOption,
 	ClientBridgePermissionOutcome,
 	ClientBridgePermissionToolCall,
-	ClientBridgeProviderLeaseIdentity,
 	ClientBridgeTerminalHandle,
 } from "../../session/client-bridge";
 import { resolveAcpPermissionMode } from "./permission-mode";
 
-const ACP_TERMINAL_PUBLICATION_WAIT_MS = 500;
-
-async function settleTerminalCleanup(operation: () => Promise<unknown>): Promise<boolean> {
-	return await Promise.race([
-		Promise.resolve()
-			.then(operation)
-			.then(
-				() => true,
-				() => false,
-			),
-		Bun.sleep(ACP_TERMINAL_PUBLICATION_WAIT_MS).then(() => false),
-	]);
-}
-
 export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
 
 export function createAcpClientBridge(
@@ -56,15 +39,6 @@ export function createAcpClientBridge(
 	};
 
 	const bridge: ClientBridge = { capabilities, deferAgentInitiatedTurns: true };
-	const connectionId = `acp:${sessionId}`;
-	const connectionGeneration = 1;
-	const terminalProviderLeaseId = `${connectionId}:${randomUUID()}`;
-	const terminalProviderIdentity: ClientBridgeProviderLeaseIdentity = {
-		leaseId: terminalProviderLeaseId,
-		connectionId,
-		connectionGeneration,
-		fence: randomUUID(),
-	};
 
 	if (capabilities.readTextFile) {
 		bridge.readTextFile = async params => {
@@ -89,49 +63,8 @@ export function createAcpClientBridge(
 	}
 
 	if (capabilities.terminal) {
-		let terminalPublicationFailed = false;
-		bridge.quarantineProviderLease = async (providerLease, _reason) => {
-			if (
-				typeof providerLease === "string" ||
-				providerLease.leaseId !== terminalProviderIdentity.leaseId ||
-				providerLease.connectionId !== terminalProviderIdentity.connectionId ||
-				providerLease.connectionGeneration !== terminalProviderIdentity.connectionGeneration ||
-				providerLease.fence !== terminalProviderIdentity.fence
-			)
-				throw new Error("terminal provider lease mismatch");
-			terminalPublicationFailed = true;
-		};
-		let terminalCreationTail = Promise.resolve();
-		const withTerminalCreationAdmission = async <T>(operation: () => Promise<T>): Promise<T> => {
-			const previous = terminalCreationTail;
-			const release = Promise.withResolvers<void>();
-			terminalCreationTail = previous.then(() => release.promise);
-			await previous;
-			try {
-				return await operation();
-			} finally {
-				release.resolve();
-			}
-		};
 		bridge.createTerminal = (params: ClientBridgeCreateTerminalParams) =>
-			withTerminalCreationAdmission(async () => {
-				if (terminalPublicationFailed) throw new Error("terminal provider quarantined after publication failure");
-				const creationTimeout = AbortSignal.timeout(ACP_TERMINAL_PUBLICATION_WAIT_MS);
-				const creationSignal = params.signal ? AbortSignal.any([params.signal, creationTimeout]) : creationTimeout;
-				return await createTerminalHandle(
-					connection,
-					sessionId,
-					params,
-					creationSignal,
-					terminalProviderIdentity,
-					() => {
-						terminalPublicationFailed = true;
-					},
-					() => {
-						terminalPublicationFailed = true;
-					},
-				);
-			});
+			createTerminalHandle(connection, sessionId, params);
 	}
 
 	if (promptPermission) {
@@ -146,97 +79,21 @@ async function createTerminalHandle(
 	connection: AgentSideConnection,
 	sessionId: string,
 	params: ClientBridgeCreateTerminalParams,
-	creationSignal: AbortSignal,
-	providerIdentity: ClientBridgeProviderLeaseIdentity,
-	onCreationUncertain: () => void,
-	onPublicationFailure: () => void,
 ): Promise<ClientBridgeTerminalHandle> {
-	if (creationSignal.aborted) throw new Error("terminal creation aborted");
-	const creation = Promise.resolve().then(() =>
-		connection.createTerminal({
-			sessionId,
-			command: params.command,
-			...(params.args ? { args: params.args } : {}),
-			...(params.env ? { env: params.env } : {}),
-			...(params.cwd ? { cwd: params.cwd } : {}),
-			...(typeof params.outputByteLimit === "number" ? { outputByteLimit: params.outputByteLimit } : {}),
-		}),
-	);
-	const creationAborted = Promise.withResolvers<"aborted">();
-	const onCreationAbort = () => creationAborted.resolve("aborted");
-	creationSignal.addEventListener("abort", onCreationAbort, { once: true });
-	if (creationSignal.aborted) creationAborted.resolve("aborted");
-	const creationOutcome = await Promise.race([
-		creation.then(
-			handle => ({ status: "created" as const, handle }),
-			error => ({ status: "failed" as const, error }),
-		),
-		creationAborted.promise.then(() => ({ status: "aborted" as const })),
-	]);
-	creationSignal.removeEventListener("abort", onCreationAbort);
-	if (creationOutcome.status === "aborted") {
-		onCreationUncertain();
-		void creation.then(
-			async handle => {
-				await settleTerminalCleanup(() => handle.kill());
-				await settleTerminalCleanup(() => handle.release());
-			},
-			() => undefined,
-		);
-		throw new Error("terminal creation aborted");
-	}
-	if (creationOutcome.status === "failed") {
-		onCreationUncertain();
-		throw creationOutcome.error;
-	}
-	const handle = creationOutcome.handle;
-	const publication = Promise.resolve().then(() =>
-		connection.sessionUpdate({
-			sessionId,
-			update: {
-				sessionUpdate: "tool_call_update",
-				toolCallId: params.toolCallId,
-				status: "in_progress",
-				content: [{ type: "terminal", terminalId: handle.id }],
-			},
-		}),
-	);
-	const aborted = Promise.withResolvers<"aborted">();
-	const onAbort = () => aborted.resolve("aborted");
-	params.signal?.addEventListener("abort", onAbort, { once: true });
-	if (params.signal?.aborted) aborted.resolve("aborted");
-	const outcome = await Promise.race([
-		publication.then(
-			() => ({ status: "published" as const }),
-			error => ({ status: "failed" as const, error }),
-		),
-		Bun.sleep(ACP_TERMINAL_PUBLICATION_WAIT_MS).then(() => ({ status: "timeout" as const })),
-		aborted.promise.then(() => ({ status: "aborted" as const })),
-	]);
-	params.signal?.removeEventListener("abort", onAbort);
-	if (outcome.status !== "published") {
-		const killed = await settleTerminalCleanup(() => handle.kill());
-		const released = await settleTerminalCleanup(() => handle.release());
-		if (!params.signal?.aborted || !killed || !released) onPublicationFailure();
-		if (outcome.status === "failed") throw outcome.error;
-		throw new Error(
-			outcome.status === "aborted"
-				? "terminal publication aborted"
-				: `terminal publication did not settle within ${ACP_TERMINAL_PUBLICATION_WAIT_MS}ms`,
-		);
-	}
-	return wrapTerminalHandle(handle, providerIdentity.leaseId, providerIdentity);
+	const handle = await connection.createTerminal({
+		sessionId,
+		command: params.command,
+		...(params.args ? { args: params.args } : {}),
+		...(params.env ? { env: params.env } : {}),
+		...(params.cwd ? { cwd: params.cwd } : {}),
+		...(typeof params.outputByteLimit === "number" ? { outputByteLimit: params.outputByteLimit } : {}),
+	});
+	return wrapTerminalHandle(handle);
 }
 
-function wrapTerminalHandle(
-	handle: AcpTerminalHandle,
-	providerLeaseId: string,
-	providerLeaseIdentity: ClientBridgeProviderLeaseIdentity,
-): ClientBridgeTerminalHandle {
+function wrapTerminalHandle(handle: AcpTerminalHandle): ClientBridgeTerminalHandle {
 	return {
 		terminalId: handle.id,
-		providerLeaseId,
-		providerLeaseIdentity,
 		async currentOutput() {
 			const out = await handle.currentOutput();
 			return {