@gajae-code/coding-agent 0.11.2 → 0.11.4

package/dist/types/tools/ask.d.ts

@@ -15,6 +15,7 @@
  *   - Questions may time out and auto-select the recommended option (configurable, disabled in plan mode)
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
 import { type Component } from "@gajae-code/tui";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -29,13 +30,19 @@ export declare const askSchema: z.ZodObject<{
         }, z.core.$strip>>;
         multi: z.ZodOptional<z.ZodBoolean>;
         recommended: z.ZodOptional<z.ZodNumber>;
-        deepInterview: z.ZodOptional<z.ZodObject<{
+        deepInterview: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             round_id: z.ZodOptional<z.ZodString>;
             round: z.ZodNumber;
             component: z.ZodString;
             dimension: z.ZodString;
             ambiguity: z.ZodNumber;
-            intent_contract: z.ZodOptional<z.ZodObject<{
+        }, z.core.$strict>, z.ZodObject<{
+            round_id: z.ZodOptional<z.ZodString>;
+            ambiguity: z.ZodNumber;
+            round: z.ZodLiteral<0>;
+            component: z.ZodLiteral<"review-topology">;
+            dimension: z.ZodLiteral<"topology">;
+            intent_contract: z.ZodObject<{
                 items: z.ZodArray<z.ZodObject<{
                     id: z.ZodString;
                     category: z.ZodEnum<{
@@ -47,8 +54,14 @@ export declare const askSchema: z.ZodObject<{
                     statement: z.ZodString;
                 }, z.core.$strict>>;
                 confirmation_options: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>>;
-            intent_review: z.ZodOptional<z.ZodObject<{
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            round_id: z.ZodOptional<z.ZodString>;
+            component: z.ZodString;
+            dimension: z.ZodString;
+            ambiguity: z.ZodNumber;
+            round: z.ZodNumber;
+            intent_review: z.ZodObject<{
                 observed_items: z.ZodArray<z.ZodObject<{
                     id: z.ZodString;
                     category: z.ZodEnum<{
@@ -65,8 +78,8 @@ export declare const askSchema: z.ZodObject<{
                     rationale: z.ZodString;
                 }, z.core.$strict>>;
                 approval_options: z.ZodArray<z.ZodString>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>;
         workflowGate: z.ZodOptional<z.ZodObject<{
             stage: z.ZodEnum<{
                 "deep-interview": "deep-interview";
@@ -82,6 +95,7 @@ export declare const askSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AskToolInput = z.infer<typeof askSchema>;
+declare function recoverRoundZeroIntentContract(arguments_: Record<string, unknown>): RawArgumentValidationResult;
 /** Result for a single question */
 export interface QuestionResult {
     id: string;
@@ -149,13 +163,19 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
             }, z.core.$strip>>;
             multi: z.ZodOptional<z.ZodBoolean>;
             recommended: z.ZodOptional<z.ZodNumber>;
-            deepInterview: z.ZodOptional<z.ZodObject<{
+            deepInterview: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                 round_id: z.ZodOptional<z.ZodString>;
                 round: z.ZodNumber;
                 component: z.ZodString;
                 dimension: z.ZodString;
                 ambiguity: z.ZodNumber;
-                intent_contract: z.ZodOptional<z.ZodObject<{
+            }, z.core.$strict>, z.ZodObject<{
+                round_id: z.ZodOptional<z.ZodString>;
+                ambiguity: z.ZodNumber;
+                round: z.ZodLiteral<0>;
+                component: z.ZodLiteral<"review-topology">;
+                dimension: z.ZodLiteral<"topology">;
+                intent_contract: z.ZodObject<{
                     items: z.ZodArray<z.ZodObject<{
                         id: z.ZodString;
                         category: z.ZodEnum<{
@@ -167,8 +187,14 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
                         statement: z.ZodString;
                     }, z.core.$strict>>;
                     confirmation_options: z.ZodArray<z.ZodString>;
-                }, z.core.$strict>>;
-                intent_review: z.ZodOptional<z.ZodObject<{
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                round_id: z.ZodOptional<z.ZodString>;
+                component: z.ZodString;
+                dimension: z.ZodString;
+                ambiguity: z.ZodNumber;
+                round: z.ZodNumber;
+                intent_review: z.ZodObject<{
                     observed_items: z.ZodArray<z.ZodObject<{
                         id: z.ZodString;
                         category: z.ZodEnum<{
@@ -185,8 +211,8 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
                         rationale: z.ZodString;
                     }, z.core.$strict>>;
                     approval_options: z.ZodArray<z.ZodString>;
-                }, z.core.$strict>>;
-            }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>>;
             workflowGate: z.ZodOptional<z.ZodObject<{
                 stage: z.ZodEnum<{
                     "deep-interview": "deep-interview";
@@ -201,6 +227,7 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
             }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    readonly rawArgumentValidation: typeof recoverRoundZeroIntentContract;
     readonly strict = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);

package/dist/types/tools/browser/screenshot-format.d.ts

@@ -0,0 +1,8 @@
+import { type ResizedImage } from "../../utils/image-resize";
+export declare function formatScreenshot(opts: {
+    saveFullRes: boolean;
+    savedMimeType: string;
+    savedByteLength: number;
+    dest: string;
+    resized: ResizedImage;
+}): string[];

package/dist/types/tools/browser/tab-protocol.d.ts

@@ -70,6 +70,10 @@ export type ToolReply = {
     error: RunErrorPayload;
 };
 export type WorkerInbound = {
+    type: "bootstrap";
+    version: 1;
+    mode: "native-free";
+} | {
     type: "init";
     payload: WorkerInitPayload;
 } | {
@@ -112,6 +116,13 @@ export interface RunErrorPayload {
     isAbort: boolean;
 }
 export type WorkerOutbound = {
+    type: "bootstrap-ready";
+    version: 1;
+    mode: "native-free";
+} | {
+    type: "bootstrap-failed";
+    error: string;
+} | {
     type: "ready";
     info: ReadyInfo;
 } | {

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -5,8 +5,8 @@ interface WorkerHandle {
     send(msg: WorkerInbound, transferList?: Transferable[]): void;
     onMessage(handler: (msg: WorkerOutbound) => void): () => void;
     onError(handler: (error: Error) => void): () => void;
+    onClose(handler: () => void): () => void;
     terminate(): Promise<void>;
-    readonly mode: "worker" | "inline";
 }
 export type DialogPolicy = "accept" | "dismiss";
 export interface PendingRun {

package/dist/types/tools/browser/tab-worker-path-resolver.d.ts

@@ -0,0 +1,2 @@
+/** Resolve filesystem-only worker inputs without evaluating the broad path utility module. */
+export declare function resolveTabWorkerPath(filePath: string, cwd: string): string;

package/dist/types/tools/browser/tab-worker-smoke.d.ts

@@ -0,0 +1,16 @@
+import type { WorkerInbound } from "./tab-protocol";
+interface SmokeWorkerHandle {
+    postMessage(message: WorkerInbound): void;
+    addEventListener(type: string, listener: EventListener): void;
+    removeEventListener(type: string, listener: EventListener): void;
+    terminate(): void;
+}
+/**
+ * Starts the real tab worker entry without connecting to a browser, then proves
+ * its bootstrap and shutdown protocol. The compiled branch deliberately keeps
+ * a static literal for Bun's --compile worker discovery.
+ */
+export declare function smokeTestTabWorker(timeoutMs?: number): Promise<void>;
+/** Test-only: verify the smoke handshake against a controlled worker transport. */
+export declare function smokeTestTabWorkerWithWorkerForTest(worker: SmokeWorkerHandle, timeoutMs: number): Promise<void>;
+export {};

package/dist/types/tools/path-utils.d.ts

@@ -7,21 +7,16 @@ export declare function splitPathAndSel(rawPath: string): {
 /**
  * Variant of {@link splitPathAndSel} for internal URLs (`scheme://...`).
  *
- * The filesystem-path splitter is intentionally conservative: it refuses to
- * peel a trailing `:<chunk>` unless that chunk matches the strict selector
- * grammar. That rule is right for filesystem paths (a file named `a:1-50` is
- * legal) but wrong for internal URLs, where any trailing `:<chunk>` after the
- * scheme is unambiguously a read-tool selector — even if malformed (e.g.
- * `artifact://3:raw:-100`).
- *
- * This function iteratively peels selector-shaped chunks (well-formed plus
- * common malformed shapes like `:-N`) so the rest of the read tool can pass a
- * clean URL to the protocol handler and surface selector errors via parseSel
- * instead of as misleading "host invalid" errors from the handler.
- *
- * Falls back to the input unchanged when nothing matches.
+ * Artifact authorities are generated identifiers, so their complete tail is
+ * unambiguously a selector and malformed selectors can be rejected before
+ * resolving the artifact. Other resources may legitimately use colons in
+ * their identities, so they only lose strict, recognized selector suffixes.
+ * Skill authorities additionally use the active registry to distinguish a
+ * skill name from its selector without making path-utils depend on skills.
  */
-export declare function splitInternalUrlSel(rawPath: string): {
+export declare function splitInternalUrlSel(rawPath: string, options?: {
+    activeSkillNames?: readonly string[];
+}): {
     path: string;
     sel?: string;
 };

package/dist/types/tools/read.d.ts

@@ -27,6 +27,8 @@ export interface ReadToolDetails {
     method?: string;
     notes?: string[];
     meta?: OutputMeta;
+    /** Whether this explicit content read may be spilled by output metadata. */
+    spillEligible?: boolean;
     /** Raw text + start line for user-visible TUI rendering, set when content is text-like.
      * Mirrors the same lines the model receives but without hashline/line-number prefixes,
      * so the TUI can render the file content with its own gutter without re-parsing the formatted text. */

package/dist/types/tools/render-utils.d.ts

@@ -8,9 +8,9 @@ import type { ToolCallContext } from "@gajae-code/agent-core";
 import type { Ellipsis } from "@gajae-code/natives";
 import type { Component } from "@gajae-code/tui";
 import type { Theme } from "../modes/theme/theme";
-import { type ResizedImage } from "../utils/image-resize";
 export { Ellipsis } from "@gajae-code/natives";
 export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "@gajae-code/tui";
+export { formatScreenshot } from "./browser/screenshot-format";
 /** Resolve inline image dimension caps from settings and viewport. */
 export declare function resolveImageOptions(): {
     maxWidthCells: number;
@@ -107,13 +107,6 @@ export declare function truncateDiffByHunk(diffText: string, maxHunks: number, m
 };
 export declare function shortenPath(filePath: string, homeDir?: string): string;
 export declare function formatToolWorkingDirectory(workdir: string | undefined, projectDir: string): string | undefined;
-export declare function formatScreenshot(opts: {
-    saveFullRes: boolean;
-    savedMimeType: string;
-    savedByteLength: number;
-    dest: string;
-    resized: ResizedImage;
-}): string[];
 export declare function wrapBrackets(text: string, theme: Theme): string;
 export declare const PARSE_ERRORS_LIMIT = 20;
 export declare function dedupeParseErrors(errors: string[] | undefined): string[];

package/dist/types/tools/resource-gc.d.ts

@@ -44,11 +44,25 @@ export interface ResourceGcRegistration {
 export declare function registerResourceGcSession(reg: ResourceGcRegistration): () => void;
 export declare function sweepOnce(d?: ResourceGcDeps): Promise<void>;
 export declare function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>): void;
+export declare function __setResourceGcSchedulerNowForTest(now: () => number): void;
 export declare function __runResourceGcTickForTest(): Promise<void>;
+export declare function __runResourceGcTimerCallbackForTest(owner: {
+    generation: number;
+    token: number;
+}, deadline: number): Promise<void>;
 export declare function __getResourceGcStateForTest(): {
     timerActive: boolean;
     sessionCount: number;
     rssWarningActive: boolean;
     inProgress: boolean;
+    generation: number;
+    pendingDeadline: number | null;
+    pendingOwner: {
+        generation: number;
+        token: number;
+    } | null;
+    deferredDeadline: number | null;
+    deferredGeneration: number | null;
+    activeGeneration: number | null;
 };
 export declare function __resetResourceGcForTest(): void;

package/dist/types/tools/subagent.d.ts

@@ -98,6 +98,7 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SubagentToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<SubagentToolDetails>>;
 }
+export declare function capCodePointsAndBytes(text: string, maxCodePoints: number, maxBytes: number): string;
 /**
  * Canonical, value-based rendered-state signature for the `subagent` await panel.
  *

package/dist/types/utils/file-mentions.d.ts

@@ -1,8 +1,8 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 /**
- * Default inline cap for auto-read file mentions, deliberately below the
- * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
- * injects a smaller snippet than an explicit `read`. Overridable per call.
+ * Default inline cap for auto-read file mentions, aligned with the read-tool's
+ * 10 KiB bare-read receipt so an incidental `@path` mention injects a bounded
+ * snippet. Overridable per call.
  */
 export declare const DEFAULT_FILE_MENTION_INLINE_BYTES: number;
 /** Extract all @filepath mentions from text */

package/dist/types/utils/image-loading.d.ts

@@ -8,6 +8,24 @@ export interface LoadImageInputOptions {
     maxBytes?: number;
     resolvedPath?: string;
     detectedMimeType?: string;
+    signal?: AbortSignal;
+}
+export interface LoadImageInputBytesOptions {
+    inputBuffer: Buffer;
+    resolvedPath: string;
+    mimeType: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    maxOutputBytes?: number;
+    signal?: AbortSignal;
+}
+export interface TransformedImageInput {
+    resolvedPath: string;
+    mimeType: string;
+    buffer: Uint8Array;
+    textNote: string;
+    dimensionNote?: string;
+    bytes: number;
 }
 export interface LoadedImageInput {
     resolvedPath: string;
@@ -23,4 +41,9 @@ export declare class ImageInputTooLargeError extends Error {
     constructor(bytes: number, maxBytes: number);
 }
 export declare function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null>;
+/** Transform trusted source bytes without materializing a base64 payload. */
+export declare function transformImageInputBytes(options: LoadImageInputBytesOptions): Promise<TransformedImageInput>;
+export declare function materializeImageInput(transformed: TransformedImageInput): LoadedImageInput;
+/** Build a model image payload from bytes already read through a trusted descriptor. */
+export declare function loadImageInputBytes(options: LoadImageInputBytesOptions): Promise<LoadedImageInput>;
 export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;

package/dist/types/utils/image-resize.d.ts

@@ -16,6 +16,7 @@ export interface ResizedImage {
     wasResized: boolean;
     get data(): string;
 }
+export declare const DEFAULT_IMAGE_RESIZE_MAX_BYTES: number;
 /**
  * Resize and recompress an image to fit within the specified max dimensions and file size.
  *
@@ -31,6 +32,7 @@ export interface ResizedImage {
  * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
  * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
+export declare function resizeImageBuffer(inputBuffer: Buffer, inputMimeType: string, options?: ImageResizeOptions): Promise<ResizedImage>;
 export declare function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage>;
 /**
  * Format a dimension note for resized images.

package/dist/types/utils/pasted-image-loading.d.ts

@@ -0,0 +1,39 @@
+import type { ImageContent } from "@gajae-code/ai";
+import { type LoadedImageInput, transformImageInputBytes } from "./image-loading";
+export declare const MAX_PASTED_IMAGE_SOURCE_BYTES: number;
+export declare const MAX_PASTED_IMAGE_OUTPUT_BYTES: number;
+export declare const MAX_PASTED_IMAGE_DIMENSION = 20000;
+export declare const MAX_PASTED_IMAGE_PIXELS = 40000000;
+export declare const MAX_PASTED_IMAGE_DECODED_BYTES: number;
+export type PastedImageBatchErrorCode = "too-many" | "unsafe-path" | "unsupported-image" | "source-aggregate-too-large" | "output-aggregate-too-large" | "dimensions-too-large";
+export declare class PastedImageBatchError extends Error {
+    readonly code: PastedImageBatchErrorCode;
+    readonly imagePath?: string | undefined;
+    constructor(code: PastedImageBatchErrorCode, message: string, imagePath?: string | undefined);
+}
+export interface LoadedPastedImageBatch {
+    images: ImageContent[];
+    loadedInputs: LoadedImageInput[];
+    sourcePaths: string[];
+}
+export interface PastedImageLoadingDependencies {
+    /** Synchronization hook used to exercise pathname swaps after descriptor open. */
+    afterDescriptorOpen?: (imagePath: string, index: number) => Promise<void> | void;
+    beforeDescriptorRead?: (imagePath: string, index: number) => Promise<void> | void;
+    transformImageBytes?: typeof transformImageInputBytes;
+}
+export type PastedImageSourcePolicy = "confirmed" | "automatic-temp";
+export interface LoadPastedImageBatchOptions {
+    paths: readonly string[];
+    autoResize: boolean;
+    signal: AbortSignal;
+    sourcePolicy?: PastedImageSourcePolicy;
+    maxImageBytes?: number;
+    maxSourceBytes?: number;
+    maxOutputBytes?: number;
+    maxDimension?: number;
+    maxPixels?: number;
+    maxDecodedBytes?: number;
+    dependencies?: PastedImageLoadingDependencies;
+}
+export declare function loadPastedImageBatch(options: LoadPastedImageBatchOptions): Promise<LoadedPastedImageBatch>;

package/dist/types/utils/pasted-image-path.d.ts

@@ -1,9 +1,8 @@
+export declare const MAX_PASTED_IMAGE_COUNT = 16;
+export declare const MAX_PASTED_IMAGE_PASTE_CHARACTERS: number;
+export declare const MAX_PASTED_IMAGE_PATH_CHARACTERS: number;
 export interface DecodePastedPathOptions {
-    /**
-     * Platform whose path semantics apply when decoding (shell unescaping,
-     * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
-     * injectable so tests can pin the win32 contract from any host.
-     */
+    /** Platform whose path and shell semantics apply. Defaults to `process.platform`. */
     platform?: NodeJS.Platform;
     /** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
     homedir?: string;
@@ -12,21 +11,24 @@ export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
     /** Base directory for relative paths. Defaults to `process.cwd()`. */
     cwd?: string;
 }
-/**
- * Decode pasted text into a filesystem path candidate. No filesystem access.
- *
- * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
- * win32 where `\` is the path separator), quoted paths, `file://` URIs
- * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
- * expansion. Returns `undefined` when the text is empty, spans multiple
- * lines, or is an invalid `file://` URI.
- */
+export type PastedImagePathParseResult = {
+    kind: "paths";
+    paths: string[];
+    requiresConfirmation: boolean;
+} | {
+    kind: "too-many";
+    maxCandidates: number;
+};
+/** Decode one pasted path candidate without filesystem access. */
 export declare function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined;
+/** Tokenize a bounded complete path list without filesystem access. */
+export declare function decodePastedPathCandidates(text: string, options?: DecodePastedPathOptions, maxCandidates?: number): string[] | undefined;
+/** Resolve one recognized clipboard-temp image path lexically, before any filesystem access. */
+export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;
 /**
- * Returns the resolved path when the whole pasted text is a recognized clipboard
- * temp path to an existing image file, otherwise `undefined` (the paste is
- * inserted as text). Arbitrary saved image paths are not auto-attached here;
- * users attach them explicitly with `@path/to/image.png`.
+ * Parse a complete image path paste without filesystem access. A single path
+ * keeps the clipboard-temp-only policy; multi-path saved-image pastes require
+ * explicit confirmation before any path is opened.
  */
-export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;
+export declare function parsePastedImagePaths(text: string, options?: ResolvePastedImagePathOptions): PastedImagePathParseResult | undefined;
 export declare function formatPastedImageReference(placeholder: string, imagePath: string): string;

package/dist/types/web/scrapers/html-to-markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert HTML to markdown using Turndown with GFM support.
+ * Strips script/style tags before conversion.
+ */
+export declare function htmlToBasicMarkdown(html: string): Promise<string>;

package/dist/types/web/scrapers/types.d.ts

@@ -44,11 +44,7 @@ export interface LoadPageResult {
  * Fetch a page with timeout and size limit
  */
 export declare function loadPage(url: string, options?: LoadPageOptions): Promise<LoadPageResult>;
-/**
- * Convert HTML to markdown using Turndown with GFM support.
- * Strips script/style tags before conversion.
- */
-export declare function htmlToBasicMarkdown(html: string): Promise<string>;
+export { htmlToBasicMarkdown } from "./html-to-markdown";
 /**
  * Build a RenderResult from markdown content. Calls finalizeOutput internally.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.11.2",
+	"version": "0.11.4",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -53,13 +53,13 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.11.2",
-		"@gajae-code/agent-core": "0.11.2",
-		"@gajae-code/ai": "0.11.2",
-		"@gajae-code/bridge-client": "0.11.2",
-		"@gajae-code/natives": "0.11.2",
-		"@gajae-code/tui": "0.11.2",
-		"@gajae-code/utils": "0.11.2",
+		"@gajae-code/stats": "0.11.4",
+		"@gajae-code/agent-core": "0.11.4",
+		"@gajae-code/ai": "0.11.4",
+		"@gajae-code/bridge-client": "0.11.4",
+		"@gajae-code/natives": "0.11.4",
+		"@gajae-code/tui": "0.11.4",
+		"@gajae-code/utils": "0.11.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -171,6 +171,14 @@
 			"types": "./dist/types/capability/*.d.ts",
 			"import": "./src/capability/*.ts"
 		},
+		"./cli/worktree-cli": {
+			"types": "./dist/types/cli/worktree-cli.d.ts",
+			"import": "./src/cli/worktree-cli.ts"
+		},
+		"./cli/worktree-cli.js": {
+			"types": "./dist/types/cli/worktree-cli.d.ts",
+			"import": "./src/cli/worktree-cli.ts"
+		},
 		"./cli/*": {
 			"types": "./dist/types/cli/*.d.ts",
 			"import": "./src/cli/*.ts"
@@ -187,6 +195,14 @@
 		"./commands/ultraqa": null,
 		"./commands/ultrawork": null,
 		"./commands/performance-goal": null,
+		"./commands/worktree": {
+			"types": "./dist/types/commands/worktree.d.ts",
+			"import": "./src/commands/worktree.ts"
+		},
+		"./commands/worktree.js": {
+			"types": "./dist/types/commands/worktree.d.ts",
+			"import": "./src/commands/worktree.ts"
+		},
 		"./commands/*": {
 			"types": "./dist/types/commands/*.d.ts",
 			"import": "./src/commands/*.ts"

package/scripts/run-threat-model-check.ts

@@ -14,6 +14,61 @@ function assert(condition: unknown, message: string): asserts condition {
 	if (!condition) throw new Error(message);
 }
 
+async function sourceFiles(root: string): Promise<string[]> {
+	const files: string[] = [];
+	for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+		const file = path.join(root, entry.name);
+		if (entry.isDirectory()) files.push(...(await sourceFiles(file)));
+		else if (/\.(?:ts|tsx|js|mjs|cjs)$/.test(entry.name)) files.push(file);
+	}
+	return files;
+}
+
+function hasDiscoverySignalAuthority(source: string): boolean {
+	return /(?:process\.)?kill\s*\(\s*(?:discovery|brokerDiscovery|record)\.pid\s*,\s*["']SIG(?:TERM|KILL)["']/m.test(
+		source,
+	);
+}
+
+async function assertNoDiscoverySignalAuthority(): Promise<void> {
+	const roots = [path.resolve(import.meta.dir, "../src/sdk"), path.resolve(import.meta.dir, "../test")];
+	const offenders: string[] = [];
+	for (const root of roots) {
+		for (const file of await sourceFiles(root)) {
+			if (hasDiscoverySignalAuthority(await fs.readFile(file, "utf8")))
+				offenders.push(path.relative(process.cwd(), file));
+		}
+	}
+	assert(offenders.length === 0, `Discovery-derived TERM/KILL authority remains in: ${offenders.join(", ")}`);
+	assert(
+		hasDiscoverySignalAuthority('process.kill(discovery.pid, "SIGTERM")'),
+		"Synthetic forbidden discovery signal was not detected",
+	);
+	assert(
+		!hasDiscoverySignalAuthority("process.kill(discovery.pid, 0)"),
+		"PID-zero observation was escalated to signal authority",
+	);
+}
+
+async function assertFixtureControlsStayTestOnly(): Promise<void> {
+	const productionRoot = path.resolve(import.meta.dir, "../src");
+	const offenders: string[] = [];
+	for (const file of await sourceFiles(productionRoot)) {
+		const source = await fs.readFile(file, "utf8");
+		if (/\b(?:GSF1|SSH1)\b/.test(source)) offenders.push(path.relative(process.cwd(), file));
+	}
+	assert(
+		offenders.length === 0,
+		`Fixture control frames are reachable from production source: ${offenders.join(", ")}`,
+	);
+	const ensureSource = await fs.readFile(path.resolve(import.meta.dir, "../src/sdk/broker/ensure.ts"), "utf8");
+	assert(
+		ensureSource.includes("startFixtureBrokerCommandWithLeaseForTest"),
+		"Dedicated fixture launch boundary is missing its explicit ForTest label",
+	);
+	assert(!/GJC_.*(?:GSF1|SSH1|SELF_REAP)/.test(ensureSource), "Production environment can select fixture controls");
+}
+
 async function rejectedWebSocket(url: string): Promise<void> {
 	const ws = new WebSocket(url);
 	await new Promise<void>((resolve, reject) => {
@@ -132,6 +187,11 @@ async function main(): Promise<void> {
 				assert(!discovery.url.includes("0.0.0.0"), "non-loopback broker URL exists");
 				await rejectedWebSocket(`${discovery.url}/?token=wrong-token`);
 			},
+			"broker-discovery-derived-signal-authority-forbidden": assertNoDiscoverySignalAuthority,
+			"broker-pid-zero-observation-allowed": async () => {
+				assert(!hasDiscoverySignalAuthority("process.kill(discovery.pid, 0)"), "PID-zero observation was rejected");
+			},
+			"broker-fixture-control-nonproduction-reachability": assertFixtureControlsStayTestOnly,
 		};
 		for (const check of manifest.checks) {
 			try {

package/src/cli/launch-disposition.ts

@@ -0,0 +1,42 @@
+export type LaunchMode = "text" | "json" | "acp";
+
+export interface LaunchDisposition {
+	autoPrint: boolean;
+	isInteractive: boolean;
+	/** Set when an interactive launch is impossible (non-TTY stdin, nothing to run). */
+	nonInteractiveError?: string;
+}
+
+/**
+ * Decides between interactive, auto-print, and fail-fast launches.
+ *
+ * A non-TTY stdin means the TUI can never receive input, so an interactive
+ * launch would execute the initial prompt and then block in the event loop
+ * forever. Prepared command-line input degrades to print mode; without any
+ * input to run we fail fast instead of hanging. Explicit `--print` and
+ * `--mode` launches are left untouched.
+ */
+export function resolveLaunchDisposition(args: {
+	stdinIsTTY: boolean | undefined;
+	pipedInput: string | undefined;
+	hasPreparedInput: boolean;
+	print: boolean;
+	mode: LaunchMode | undefined;
+}): LaunchDisposition {
+	const explicitNonInteractive = args.print || args.mode !== undefined;
+	const hasPreparedInput = args.pipedInput !== undefined || args.hasPreparedInput;
+	const hasNonTtyStdin = args.stdinIsTTY !== true;
+	const autoPrint = !explicitNonInteractive && hasNonTtyStdin && hasPreparedInput;
+	const isInteractive = !explicitNonInteractive && !autoPrint;
+
+	if (isInteractive && args.stdinIsTTY !== true) {
+		return {
+			autoPrint: false,
+			isInteractive: false,
+			nonInteractiveError:
+				"stdin is not a TTY and no prompt or prepared input was provided; use -p/--print (or pass a prompt or @file) for non-interactive runs.",
+		};
+	}
+
+	return { autoPrint, isInteractive };
+}