@gajae-code/coding-agent 0.5.4 → 0.6.1

package/dist/types/main.d.ts

@@ -48,11 +48,22 @@ export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof
  * tool registry and shadow the client-supplied servers (issue #1234).
  */
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+/**
+ * Research-mode (RLM) preset hook. Lets `gjc rlm` augment the session options
+ * (system prompt, restricted toolset, custom python tool) and assert the tool
+ * boundary once the session's tool registry is fully assembled.
+ */
+export interface RlmPreset {
+    applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
+    onSessionCreated?: (session: AgentSession) => void | Promise<void>;
+}
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
     runAcpMode?: (createSession: AcpSessionFactory) => Promise<void>;
     settings?: Settings;
+    rlmPreset?: RlmPreset;
+    suppressProcessExit?: boolean;
 }
 export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
 export declare function main(args: string[]): Promise<void>;

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@gajae-code/tui";
 import type { AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 type PastePendingClearReason = "timeout" | "queue-limit";
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
@@ -39,13 +39,15 @@ export declare class CustomEditor extends Editor {
     onPastePendingInputCleared?: (reason: PastePendingClearReason, droppedInputCount: number) => void;
     /** Called when the configured dequeue shortcut is pressed. */
     onDequeue?: () => void;
+    /** Called when the configured queue shortcut is pressed. */
+    onQueue?: () => void;
     /** Called when Caps Lock is pressed. */
     onCapsLock?: () => void;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
     /**
      * Register a custom key handler. Extensions use this for shortcuts.
      */
-    setCustomKeyHandler(key: KeyId, handler: () => void): void;
+    setCustomKeyHandler(key: KeyId, handler: () => boolean | undefined): void;
     /**
      * Remove a custom key handler.
      */

package/dist/types/modes/components/custom-model-preset-wizard.d.ts

@@ -0,0 +1,12 @@
+import { Container } from "@gajae-code/tui";
+import type { ModelProfileConfig } from "../../config/models-config-schema";
+export interface CustomModelPresetWizardSubmit {
+    name: string;
+    profile: ModelProfileConfig;
+}
+export declare class CustomModelPresetWizardComponent extends Container {
+    #private;
+    constructor(onSubmit: (input: CustomModelPresetWizardSubmit) => void, onCancel: () => void, onRender?: () => void);
+    setSubmitError(error: string): void;
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/model-selector.d.ts

@@ -15,12 +15,15 @@ export type ModelSelectorSelection = {
     kind: "profile";
     profileName: string;
     setDefault: boolean;
+} | {
+    kind: "createProfile";
 };
 type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
 /**
  * Component that renders a canonical model selector with provider tabs.
- * - Tab/Arrow Left/Right: Switch between provider tabs
- * - Arrow Up/Down: Navigate model list
+ * - Preset landing Left/Right: Collapse/expand selected provider
+ * - Model browser Tab/Arrow Left/Right: Switch between provider tabs
+ * - Arrow Up/Down: Navigate rows
  * - Enter: Open assignment actions for default plus GJC role-agent models
  * - Escape: Close selector
  */

package/dist/types/modes/components/status-line.d.ts

@@ -33,10 +33,13 @@ export interface StatusLineSettings {
     showSkillHud?: boolean;
     sessionAccent?: boolean;
 }
+export interface StatusLineComponentOptions {
+    version?: string;
+}
 export declare class StatusLineComponent implements Component {
     #private;
     private readonly session;
-    constructor(session: AgentSession);
+    constructor(session: AgentSession, options?: StatusLineComponentOptions);
     updateSettings(settings: StatusLineSettings): void;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -12,11 +12,14 @@ export declare class InputController {
     handleDequeue(): void;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;
+    /** Send editor text explicitly as a queued next-turn message. */
+    handleQueueSubmit(): Promise<void>;
     restoreQueuedMessagesToEditor(options?: {
         abort?: boolean;
         currentText?: string;
     }): number;
     handleBackgroundCommand(): void;
+    handleForegroundToolBackgroundFold(): boolean;
     handleTextPaste(text: string): boolean | Promise<boolean>;
     handleImagePaste(): Promise<boolean>;
     createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -15,6 +15,7 @@ export declare class SelectorController {
         focus: Component;
     }): void;
     showProviderOnboarding(): void;
+    showCustomModelPresetWizard(): void;
     showCustomProviderWizard(): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;

package/dist/types/modes/print-mode.d.ts

@@ -19,6 +19,12 @@ export interface PrintModeOptions {
     initialMessage?: string;
     /** Images to attach to the initial message */
     initialImages?: ImageContent[];
+    /**
+     * When true, an assistant error/abort does not call process.exit(); print mode
+     * returns instead so the caller (e.g. RLM autonomous mode) can run its own
+     * finalization/cleanup before the process exits.
+     */
+    suppressProcessExit?: boolean;
 }
 /**
  * Run in print (single-shot) mode.

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -10,6 +10,14 @@ import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";
 import type { RpcExtensionUIRequest, RpcGetStateInclude, RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution } from "./rpc-types";
 export interface RpcClientOptions {
+    /** Dial an existing Unix-domain socket instead of spawning a stdio child. */
+    socketPath?: string;
+    /** Explicit transport selector; defaults to uds when socketPath is set, otherwise stdio. */
+    transport?: "stdio" | "uds";
+    /** Observe transport close/error state. */
+    onTransportClose?: (error?: Error) => void;
+    /** Alias for transport close/error observation. */
+    onTransportError?: (error: Error) => void;
     /** Path to the CLI entry point (default: searches for dist/cli.js) */
     cliPath?: string;
     /** Working directory for the agent */
@@ -40,6 +48,13 @@ export interface RpcClientCustomTool<TParams extends Record<string, unknown> = R
     execute(params: TParams, context: RpcClientToolContext<TDetails>): Promise<RpcClientToolResult<TDetails>> | RpcClientToolResult<TDetails>;
 }
 export declare function defineRpcClientTool<TParams extends Record<string, unknown> = Record<string, unknown>, TDetails = unknown>(tool: RpcClientCustomTool<TParams, TDetails>): RpcClientCustomTool<TParams, TDetails>;
+export interface RpcTransport {
+    readonly kind: "stdio" | "uds";
+    start(onFrame: (frame: unknown) => void, onClose: (error?: Error) => void): Promise<void>;
+    write(frame: unknown): void;
+    stop(): void;
+    getStderr(): string;
+}
 export declare class RpcClient {
     #private;
     private options;
@@ -73,6 +88,10 @@ export declare class RpcClient {
      * input / editor / confirm). Returns an unsubscribe function.
      */
     onExtensionUiRequest(listener: (req: RpcExtensionUIRequest) => void): () => void;
+    /** Respond to an extension UI request over the live transport. */
+    respondExtensionUi(response: import("./rpc-types").RpcExtensionUIResponse): void;
+    /** Observe transport close/error notifications. */
+    onTransportError(listener: (error: Error) => void): () => void;
     /**
      * Enter unattended mode by declaring budget + scopes + action allowlist.
      * Returns the accepted declaration, or rejects (fail-closed) on refusal.
@@ -116,6 +135,8 @@ export declare class RpcClient {
      * Get current session state.
      */
     getState(include?: RpcGetStateInclude[]): Promise<RpcSessionState>;
+    /** Return unresolved workflow gates persisted by the RPC session. */
+    getPendingWorkflowGates(): Promise<RpcWorkflowGate[]>;
     /**
      * Set model by provider and ID.
      */

package/dist/types/modes/rpc/rpc-socket-security.d.ts

@@ -0,0 +1,7 @@
+export declare class RpcSocketSecurityError extends Error {
+    constructor(message: string);
+}
+export declare function prepareRpcSocketPath(socketPath: string): Promise<void>;
+export declare function assertSafeClientSocket(socketPath: string): Promise<void>;
+export declare function verifyRpcSocketAfterListen(socketPath: string): Promise<void>;
+export declare function probeUnixSocketAlive(socketPath: string): Promise<boolean>;

package/dist/types/modes/rpc/rpc-types.d.ts

@@ -56,6 +56,9 @@ export type RpcCommand = {
     id?: string;
     type: "set_host_uri_schemes";
     schemes: RpcHostUriSchemeDefinition[];
+} | {
+    id?: string;
+    type: "get_pending_workflow_gates";
 } | {
     id?: string;
     type: "set_model";
@@ -247,6 +250,14 @@ export type RpcResponse = {
     data: {
         schemes: string[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_pending_workflow_gates";
+    success: true;
+    data: {
+        gates: RpcWorkflowGate[];
+    };
 } | {
     id?: string;
     type: "response";
@@ -647,6 +658,8 @@ export interface RpcWorkflowGateOption {
 }
 export interface RpcWorkflowGateContext {
     title?: string;
+    plan?: string;
+    source?: string;
     prompt?: string;
     summary?: string;
     stage_state?: Record<string, unknown>;

package/dist/types/modes/shared/agent-wire/command-dispatch.d.ts

@@ -19,6 +19,8 @@ export interface RpcUnattendedControlPlane {
     negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted;
     /** Resolve a pending workflow gate with the agent's answer. */
     resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    /** List unresolved durable workflow gates for reconnect replay. */
+    listPendingGates?(): import("../../rpc/rpc-types").RpcWorkflowGate[];
     isUnattended?(): boolean;
     preflightCommand?(command: RpcCommand): void;
     reconcileUsage?(phase?: string): void;

package/dist/types/modes/shared/agent-wire/unattended-session.d.ts

@@ -66,6 +66,7 @@ export declare class UnattendedSessionControlPlane implements RpcUnattendedContr
     preflightCommand(command: RpcCommand): void;
     reconcileUsage(phase?: string): void;
     resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    listPendingGates(): import("../../rpc/rpc-types").RpcWorkflowGate[];
     emitGate(input: OpenGateInput): Promise<unknown>;
     recover(): Promise<void>;
 }

package/dist/types/rlm/artifacts.d.ts

@@ -0,0 +1,9 @@
+import type { RlmArtifactPaths } from "./types";
+export declare const RLM_DIR_SEGMENT: string;
+export declare function isValidRlmSessionId(sessionId: string): boolean;
+/** Generate a filesystem-safe, sortable session id (timestamp + random suffix). */
+export declare function generateRlmSessionId(now?: Date): string;
+export declare function resolveRlmArtifactPaths(cwd: string, sessionId: string): RlmArtifactPaths;
+export declare function ensureRlmSessionDir(paths: RlmArtifactPaths): Promise<void>;
+export declare function rlmSessionExists(cwd: string, sessionId: string): Promise<boolean>;
+export declare function readRlmNotebookIfPresent(cwd: string, sessionId: string): Promise<import("../edit/notebook").NotebookDocument | undefined>;

package/dist/types/rlm/complete-research-tool.d.ts

@@ -0,0 +1,35 @@
+/**
+ * RLM completion/report tool.
+ *
+ * This is the model-facing stop/report seam for autonomous research mode. It
+ * writes the deterministic report from the live notebook and, for final
+ * completion, marks the RLM controller complete so the existing agent loop can
+ * pause through CreateAgentSessionOptions.shouldPause.
+ */
+import * as z from "zod/v4";
+import type { NotebookDocument } from "../edit/notebook";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { RlmNotebookWriter } from "./notebook";
+import type { RlmArtifactPaths } from "./types";
+export declare const RLM_COMPLETE_RESEARCH_TOOL_NAME = "complete_research";
+declare const paramsSchema: z.ZodObject<{
+    summary: z.ZodString;
+    final: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface RlmReportWriteInput {
+    paths: RlmArtifactPaths;
+    notebook: RlmNotebookWriter;
+    title: string;
+    summary?: string;
+    dataPath?: string | null;
+}
+export interface RlmCompleteResearchContext extends RlmReportWriteInput {
+    minSuccessfulRuns?: number;
+    getGoalStatus?: () => string | undefined;
+    markCompleted?: (summary: string) => void;
+}
+export declare function countSuccessfulNotebookRuns(notebook: NotebookDocument): number;
+export declare function summarizeNotebookForReplay(notebook: NotebookDocument, maxChars?: number): string;
+export declare function writeRlmReport(input: RlmReportWriteInput): Promise<string>;
+export declare function createRlmCompleteResearchTool(context: RlmCompleteResearchContext): CustomTool<typeof paramsSchema>;
+export {};

package/dist/types/rlm/data-context.d.ts

@@ -0,0 +1,6 @@
+export interface RlmDataContext {
+    /** Absolute path the content was loaded from. */
+    path: string;
+    content: string;
+}
+export declare function loadRlmDataContext(cwd: string, dataFlag: string | undefined): Promise<RlmDataContext | null>;

package/dist/types/rlm/index.d.ts

@@ -0,0 +1,35 @@
+import { type Args } from "../cli/args";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import { type RlmPreset } from "../main";
+import type { AgentSession } from "../session/agent-session";
+import { type RlmDataContext } from "./data-context";
+interface ExtractedRlmFlags {
+    dataPath: string | undefined;
+    resumeSessionId: string | undefined;
+    minSuccessfulRuns: number;
+    rest: string[];
+}
+export interface RlmPresetOptions {
+    dataContext: RlmDataContext | null;
+    pythonTool: CustomTool;
+    completeResearchTool?: CustomTool;
+    objective?: string;
+    resumeContext?: string;
+    onSessionReady?: (session: AgentSession) => void;
+}
+/** Pull RLM-owned flags out of argv; the remainder is forwarded to the root command. */
+export declare function extractRlmFlags(argv: string[]): ExtractedRlmFlags;
+/** @deprecated use extractRlmFlags; retained for tests and compatibility. */
+export declare function extractDataFlag(argv: string[]): {
+    dataPath: string | undefined;
+    rest: string[];
+};
+export declare function createRlmPreset({ dataContext, pythonTool, completeResearchTool, objective, resumeContext, onSessionReady }: RlmPresetOptions): RlmPreset;
+export declare function buildRlmGoalObjective(input: {
+    messages: readonly string[];
+    dataContext: RlmDataContext | null;
+}): string;
+export declare function isRlmAutonomousRun(parsed: Pick<Args, "print" | "mode" | "messages">, pipedStdin: boolean): boolean;
+export declare function prepareRlmLaunchMode(parsed: Args, pipedStdin: boolean): boolean;
+export declare function runRlmCommand(argv: string[]): Promise<void>;
+export {};

package/dist/types/rlm/notebook.d.ts

@@ -0,0 +1,12 @@
+import { type NotebookDocument } from "../edit/notebook";
+import type { RlmCellResult } from "./types";
+export declare class RlmNotebookWriter {
+    #private;
+    constructor(notebookPath: string, initial?: NotebookDocument);
+    get document(): NotebookDocument;
+    get cellCount(): number;
+    appendMarkdown(source: string): Promise<void>;
+    appendCode(code: string, result: RlmCellResult): Promise<void>;
+    /** Resolve once all queued writes have flushed. */
+    flush(): Promise<void>;
+}

package/dist/types/rlm/preset.d.ts

@@ -0,0 +1,23 @@
+import type { RlmDataContext } from "./data-context";
+/**
+ * tool; `read` and `web_search` are the existing built-ins. `bash` is exposed
+ * through the read-only restriction profile below for inspection commands only,
+ * and `goal` is required so RLM sessions cannot finish without explicit goal
+ * completion. Everything else (edit, write, task, skill, browser, eval-js, ...) is excluded.
+ */
+export declare const RLM_READ_ONLY_BASH_PREFIXES: readonly string[];
+export declare const RLM_TOOL_ALLOWLIST: readonly string[];
+export declare function isRlmToolAllowed(name: string): boolean;
+/**
+ * Hard boundary: throws if any active tool is outside the allowlist. Call this
+ * after the session's tool registry is fully assembled and before running, so a
+ * tool leaked in by defaults/discovery/extensions fails the launch loudly.
+ */
+export declare function assertRlmToolAllowlist(activeToolNames: readonly string[]): void;
+/** The research prompt text (exported for testing / prompt assembly). */
+export declare const RLM_RESEARCH_PROMPT: string;
+/**
+ * Build the systemPrompt transform for createAgentSession: appends the research
+ * prompt, data context, and prior-notebook replay context to the default blocks.
+ */
+export declare function buildRlmSystemPrompt(dataContext: RlmDataContext | null, resumeContext?: string): (defaultPrompt: string[]) => string[];

package/dist/types/rlm/python-tool.d.ts

@@ -0,0 +1,16 @@
+import { z } from "@gajae-code/ai";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { RlmNotebookWriter } from "./notebook";
+export declare const RLM_PYTHON_TOOL_NAME = "python";
+export interface RlmPythonToolContext {
+    cwd: string;
+    sessionId: string;
+    artifactsDir: string;
+    notebook: RlmNotebookWriter;
+    managedWorkspaceVenv?: boolean;
+}
+declare const paramsSchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare function createRlmPythonTool(rlm: RlmPythonToolContext): CustomTool<typeof paramsSchema>;
+export {};

package/dist/types/rlm/report.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic RLM report synthesis: turns the accumulated notebook (plus an
+ * optional model-provided summary) into a Markdown research report.
+ */
+import type { NotebookDocument } from "../edit/notebook";
+export interface RlmReportInput {
+    title: string;
+    summary?: string;
+    notebook: NotebookDocument;
+    dataPath?: string | null;
+    generatedAt?: string;
+    maxOutputChars?: number;
+}
+export declare function synthesizeRlmReport(input: RlmReportInput): string;

package/dist/types/rlm/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared types for RLM (research) mode.
+ */
+import type { KernelDisplayOutput } from "../eval/py/kernel";
+export interface RlmArtifactPaths {
+    /** Absolute session directory: <cwd>/.gjc/rlm/<sessionId>/ */
+    dir: string;
+    /** Absolute path to the live notebook.ipynb */
+    notebookPath: string;
+    /** Absolute path to the synthesized report.md */
+    reportPath: string;
+    /** Absolute path to the session metadata.json */
+    metadataPath: string;
+    /** Directory for the underlying GJC conversation session files. */
+    agentSessionDir: string;
+}
+/** Outcome of a single RLM python cell execution. */
+export interface RlmCellResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    displayOutputs: KernelDisplayOutput[];
+}
+export interface RlmSessionMetadata {
+    sessionId: string;
+    createdAt: string;
+    cwd: string;
+    dataPath: string | null;
+    cellCount: number;
+    mode?: "interactive" | "autonomous";
+    resumedFrom?: string | null;
+    completedAt?: string | null;
+    finalSummary?: string | null;
+    minSuccessfulRuns?: number;
+    successfulRuns?: number;
+}

package/dist/types/sdk.d.ts

@@ -5,6 +5,7 @@ import { ModelRegistry } from "./config/model-registry";
 import { type ScopedModelSelection } from "./config/model-resolver";
 import { type PromptTemplate } from "./config/prompt-templates";
 import { Settings, type SkillsSettings } from "./config/settings";
+import type { BashRestrictionProfile } from "./tools/bash-allowed-prefixes";
 import "./discovery";
 import type { CustomCommandsLoadResult } from "./extensibility/custom-commands";
 import type { CustomTool } from "./extensibility/custom-tools/types";
@@ -115,6 +116,12 @@ export interface CreateAgentSessionOptions {
     agentDisplayName?: string;
     /** Optional restricted bash command prefixes for read-only role agents. */
     bashAllowedPrefixes?: string[];
+    /** Restriction policy paired with bashAllowedPrefixes. */
+    bashRestrictionProfile?: BashRestrictionProfile;
+    /** Optional per-session restriction for goal tool operations. */
+    goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
+    /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
+    discoverableToolAllowedNames?: readonly string[];
     /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
     agentRegistry?: AgentRegistry;
     /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */

package/dist/types/session/agent-session.d.ts

@@ -197,6 +197,8 @@ export interface AgentSessionConfig {
     /** Rebuild the SSH tool from current capability discovery results. */
     reloadSshTool?: () => Promise<AgentTool | null>;
     requestedToolNames?: ReadonlySet<string>;
+    /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
+    discoverableToolAllowedNames?: readonly string[];
     /**
      * Optional accessor for live MCP server instructions. Read by the session's
      * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
@@ -450,6 +452,25 @@ export declare class AgentSession {
      * Get a tool by name from the registry.
      */
     getToolByName(name: string): AgentTool | undefined;
+    /**
+     * Register a UI/control-plane request handler for a currently foregrounded
+     * managed bash execution. This is intentionally narrower than generic
+     * process/job control: unsupported tool types simply do not register a
+     * handler, so Ctrl+B-style folding fails closed instead of aborting or
+     * shell-suspending arbitrary work.
+     */
+    registerForegroundBashBackgroundRequestHandler(handler: () => void): () => void;
+    /**
+     * Returns whether a managed foreground bash call is currently backgroundable.
+     * UI key handlers use this to avoid consuming normal editor shortcuts when
+     * no fold target exists.
+     */
+    hasForegroundBashBackgroundRequestHandler(): boolean;
+    /**
+     * Ask the active managed foreground bash call to return as a background job.
+     * Returns false when no supported foreground tool is currently backgroundable.
+     */
+    requestForegroundBashBackground(): boolean;
     /**
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */

package/dist/types/tools/bash-allowed-prefixes.d.ts

@@ -2,4 +2,9 @@ export interface BashAllowedPrefixesCheck {
     allowed: boolean;
     reason?: string;
 }
-export declare function checkBashAllowedPrefixes(command: string, allowedPrefixes: readonly string[] | undefined): BashAllowedPrefixesCheck;
+export type BashRestrictionProfile = "workflow" | "read-only";
+export interface BashRestrictionOptions {
+    profile?: BashRestrictionProfile;
+}
+export declare function normalizeReadOnlyBashCommand(command: string): string | undefined;
+export declare function checkBashAllowedPrefixes(command: string, allowedPrefixes: readonly string[] | undefined, options?: BashRestrictionOptions): BashAllowedPrefixesCheck;

package/dist/types/tools/browser/attach.d.ts

@@ -8,14 +8,30 @@ export declare function findFreeCdpPort(): Promise<number>;
 /** Poll `${cdpUrl}/json/version` until it responds with 200, with abort + timeout support. */
 export declare function waitForCdp(cdpUrl: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
 /**
- * If any running instance of `exe` was launched with `--remote-debugging-port`
- * and that endpoint actually answers, return it so attach can reuse it instead
- * of killing and respawning. Idempotent re-attaches are the common case.
+ * Pull a `--remote-debugging-port=<n>` value out of an argv array (Chromium
+ * accepts both `--flag=value` and `--flag value`). Returns null if absent or
+ * malformed.
  */
+export declare function findCdpPortInArgsForTest(args: string[]): number | null;
+export declare function findCdpAddressInArgsForTest(args: readonly string[]): string | null;
+export declare function isSafeCdpAddressForTest(address: string | null): boolean;
+export declare function argsMatchChromeProfileForTest(args: readonly string[], profile: {
+    userDataDir: string;
+    profileDirectory: string;
+}): boolean;
 export declare function findReusableCdp(exe: string, signal?: AbortSignal): Promise<{
     cdpUrl: string;
     pid: number;
 } | null>;
+export interface RunningChromeProfile {
+    pid: number;
+    cdpUrl: string | null;
+    unsafeCdpReason?: string;
+}
+export declare function findRunningChromeProfile(exe: string, profile: {
+    userDataDir: string;
+    profileDirectory: string;
+}, signal?: AbortSignal): Promise<RunningChromeProfile | null>;
 /**
  * Pick the best page target on an attached browser. Without a matcher, prefer
  * a page that doesn't look like a helper window (devtools, request handler,

package/dist/types/tools/browser/registry.d.ts

@@ -7,6 +7,14 @@ export type BrowserKind = {
 } | {
     kind: "spawned";
     path: string;
+} | {
+    kind: "chrome-profile";
+    path: string;
+    userDataDir: string;
+    profileDirectory: string;
+    background: boolean;
+    noFocus: boolean;
+    cdpPort?: number;
 } | {
     kind: "connected";
     cdpUrl: string;
@@ -25,6 +33,9 @@ export interface BrowserHandle {
         override: UserAgentOverride | null;
     };
 }
+type SpawnedChromeProfileKind = Extract<BrowserKind, {
+    kind: "chrome-profile";
+}>;
 export interface AcquireBrowserOptions {
     cwd: string;
     viewport?: {
@@ -36,7 +47,11 @@ export interface AcquireBrowserOptions {
     signal?: AbortSignal;
 }
 export declare function acquireBrowser(kind: BrowserKind, opts: AcquireBrowserOptions): Promise<BrowserHandle>;
+export declare function buildChromeProfileLaunchArgs(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];
+export declare function buildChromeProfileLaunchArgsForTest(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];
+export declare function openChromeProfileHandle(kind: SpawnedChromeProfileKind, opts: AcquireBrowserOptions): Promise<BrowserHandle>;
 export declare function holdBrowser(handle: BrowserHandle): void;
 export declare function releaseBrowser(handle: BrowserHandle, opts: {
     kill: boolean;
 }): Promise<void>;
+export {};

package/dist/types/tools/browser/render.d.ts

@@ -19,6 +19,9 @@ interface BrowserRenderArgs {
     app?: {
         path?: string;
         cdp_url?: string;
+        browser?: string;
+        user_data_dir?: string;
+        profile_directory?: string;
         target?: string;
     };
     viewport?: {

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

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import * as z from "zod/v4";
 import type { ToolSession } from "../sdk";
-import { type BrowserKindTag } from "./browser/registry";
+import { type BrowserKind, type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import type { OutputMeta } from "./output-meta";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";
@@ -18,6 +18,14 @@ declare const browserSchema: z.ZodObject<{
     app: z.ZodOptional<z.ZodObject<{
         path: z.ZodOptional<z.ZodString>;
         cdp_url: z.ZodOptional<z.ZodString>;
+        browser: z.ZodOptional<z.ZodEnum<{
+            chrome: "chrome";
+        }>>;
+        user_data_dir: z.ZodOptional<z.ZodString>;
+        profile_directory: z.ZodOptional<z.ZodString>;
+        background: z.ZodOptional<z.ZodBoolean>;
+        no_focus: z.ZodOptional<z.ZodBoolean>;
+        cdp_port: z.ZodOptional<z.ZodNumber>;
         args: z.ZodOptional<z.ZodArray<z.ZodString>>;
         target: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
@@ -98,6 +106,7 @@ export interface BrowserToolDetails {
     result?: string;
     meta?: OutputMeta;
 }
+export declare function resolveBrowserKindForTest(params: BrowserParams, session: ToolSession): BrowserKind;
 /**
  * Browser tool: stateful, multi-tab. Three actions:
  * - `open`  → acquire/create a named tab on a browser kind (headless | spawned | connected) and optionally goto a url.
@@ -123,6 +132,14 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
         app: z.ZodOptional<z.ZodObject<{
             path: z.ZodOptional<z.ZodString>;
             cdp_url: z.ZodOptional<z.ZodString>;
+            browser: z.ZodOptional<z.ZodEnum<{
+                chrome: "chrome";
+            }>>;
+            user_data_dir: z.ZodOptional<z.ZodString>;
+            profile_directory: z.ZodOptional<z.ZodString>;
+            background: z.ZodOptional<z.ZodBoolean>;
+            no_focus: z.ZodOptional<z.ZodBoolean>;
+            cdp_port: z.ZodOptional<z.ZodNumber>;
             args: z.ZodOptional<z.ZodArray<z.ZodString>>;
             target: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;