@gajae-code/coding-agent 0.13.3 → 0.14.0

package/dist/types/setup/paseo/setup-deps.d.ts

@@ -0,0 +1,73 @@
+/** The five Paseo skills this setup links. `context-search` is deliberately excluded. */
+export declare const INSTALL_SKILL_NAMES: readonly ["paseo", "paseo-advisor", "paseo-committee", "paseo-handoff", "paseo-loop"];
+export type InstallSkillName = (typeof INSTALL_SKILL_NAMES)[number];
+/** Prefix used to enumerate Paseo-owned skills when scanning for drift. */
+export declare const PASEO_SKILL_PREFIX = "paseo";
+/** Base provider key written into `agents.providers`. */
+export declare const PROVIDER_KEY = "gjc";
+/** Paseo's undocumented provider inheritance contract, reverse-engineered from a hand-written config. */
+export declare const PROVIDER_EXTENDS = "acp";
+/**
+ * Role keys Paseo stores under `providers` in `orchestration-preferences.json`.
+ *
+ * Verified against a live file: the roles are nested, not top-level, and the
+ * sibling `preferences` array belongs to the user.
+ */
+export declare const ORCHESTRATION_ROLE_KEYS: readonly ["impl", "ui", "research", "planning", "audit"];
+export interface PaseoPaths {
+    /** `~/.paseo/config.json` */
+    readonly configJson: string;
+    /** `~/.paseo/orchestration-preferences.json` */
+    readonly orchestrationPreferences: string;
+    /** `~/.agents/skills` -- READ-ONLY, never written by this setup. */
+    readonly agentsSkillsDir: string;
+    /** `<agentDir>/paseo-skills` -- the bridge directory this setup owns. */
+    readonly bridgeDir: string;
+    /** `<agentDir>/paseo/provenance.json` -- GJC-side ownership ledger. */
+    readonly provenanceLedger: string;
+    /** `<agentDir>/paseo/intent.json` -- durable crash-recovery intent record. */
+    readonly intentRecord: string;
+    /** `<agentDir>/skills` -- second protected tree, never written by this setup. */
+    readonly gjcSkillsDir: string;
+}
+/** A provider row as `paseo provider ls --json` reports it. */
+export interface PaseoProviderRow {
+    readonly id: string;
+    /** Paseo reports `"available"` for a provider it can actually reach. */
+    readonly status?: string;
+}
+/** Distinct outcomes of probing `paseo provider ls --json`. Never collapsed into a boolean. */
+export type PaseoLsOutcome = {
+    readonly kind: "ok";
+    readonly providerIds: readonly string[];
+    readonly rows: readonly PaseoProviderRow[];
+} | {
+    readonly kind: "unavailable";
+    readonly detail: string;
+} | {
+    readonly kind: "timeout";
+    readonly timeoutMs: number;
+} | {
+    readonly kind: "malformed";
+    readonly detail: string;
+} | {
+    readonly kind: "nonzero-exit";
+    readonly exitCode: number;
+    readonly detail: string;
+};
+export interface PaseoSetupDependencies {
+    readonly paths: PaseoPaths;
+    /** Bounded probe of the Paseo daemon. MUST enforce `timeoutMs` and kill the child on expiry. */
+    runProviderLs(timeoutMs: number): Promise<PaseoLsOutcome>;
+    now(): Date;
+}
+export declare function createDefaultPaseoPaths(agentDir?: string, home?: string): PaseoPaths;
+/**
+ * Parse `paseo provider ls --json`.
+ *
+ * The measured shape is an array of `{ provider, label, status, ... }` rows.
+ * `id` and `name` are also accepted because the key is undocumented and has no
+ * stability guarantee, and a bare string array is accepted for the same reason.
+ */
+export declare function parseProviderLs(stdout: string): PaseoLsOutcome;
+export declare function createDefaultPaseoSetupDependencies(): PaseoSetupDependencies;

package/dist/types/setup/paseo/skills-bridge.d.ts

@@ -0,0 +1,44 @@
+import type { CasReceipt } from "../../config/atomic-yaml-patch";
+import type { Settings } from "../../config/settings";
+import type { DriftReason } from "./result-types";
+import { type InstallSkillName, type PaseoSetupDependencies } from "./setup-deps";
+type BridgeEntryAction = "create" | "noop" | "prune-and-recreate";
+type BridgeEntryPlan = {
+    readonly name: InstallSkillName;
+    readonly action: BridgeEntryAction;
+    readonly linkPath: string;
+    readonly targetPath: string;
+    /** The dangling link text captured during preflight, used as an unlink guard. */
+    readonly danglingTarget?: string;
+};
+/** Immutable preflight evidence consumed by the install saga and its inverse. */
+export interface SkillsBridgePreflight {
+    readonly bridgeDir: string;
+    readonly bridgeDirCreated: boolean;
+    readonly entries: Readonly<Record<InstallSkillName, BridgeEntryPlan>>;
+}
+/** What the forward operation actually created, rather than what preflight intended to create. */
+export interface SkillsBridgeInstallResult {
+    readonly createdEntries: readonly InstallSkillName[];
+    readonly bridgeDirCreated: boolean;
+}
+export declare class SkillsBridgeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Classify every allowlisted bridge entry without mutating either skill tree.
+ * All conflicts are accumulated so the caller can report them together.
+ */
+export declare function preflightSkillsBridge(deps: PaseoSetupDependencies): Promise<SkillsBridgePreflight>;
+/** Create only preflight-approved bridge links; symlink publication never replaces an existing entry. */
+export declare function installSkillsBridge(preflight: SkillsBridgePreflight): Promise<SkillsBridgeInstallResult>;
+/**
+ * Undo exactly the links this run created. A changed link is reported as a
+ * conflict rather than being deleted; this makes compensation safe after edits.
+ */
+export declare function inverseSkillsBridge(deps: PaseoSetupDependencies, result: SkillsBridgeInstallResult): Promise<void>;
+/** Find Paseo-prefixed bridge or source entries that the locked install allowlist does not repair. */
+export declare function scanSkillsBridgeDrift(deps: PaseoSetupDependencies): Promise<readonly DriftReason[]>;
+/** Append the bridge directory without discarding concurrent user config changes. */
+export declare function registerSkillsBridgeDirectory(settings: Settings, bridgeDir: string): Promise<CasReceipt>;
+export {};

package/dist/types/skill-state/active-state.d.ts

@@ -1,3 +1,4 @@
+import { type GuardedWriteResult } from "../gjc-runtime/state-writer";
 import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "./canonical-skills";
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
@@ -95,6 +96,8 @@ export interface SyncSkillActiveStateOptions {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     sourceRevision?: number;
+    /** Internal seed path: retain the authoritative entry receipt if snapshot rebuilding fails. */
+    bestEffortSnapshot?: boolean;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;
@@ -111,6 +114,7 @@ export declare function isWorkflowContinuationInert(skill: string, phase: string
 export declare function listActiveSkills(raw: unknown): SkillActiveEntry[];
 export declare function normalizeSkillActiveState(raw: unknown): SkillActiveState | null;
 export declare function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths;
+export declare function upstreamPlanningPipelineSkills(skill: string): string[];
 export declare function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]): SkillActiveEntry[];
 export type VisibleSkillActiveStateCacheTier = "security" | "hud";
 export interface ReadVisibleSkillActiveStateOptions {
@@ -132,7 +136,7 @@ interface ActiveStateSignature {
 export declare function computeActiveStateSignature(cwd: string, sessionId: string): Promise<ActiveStateSignature>;
 export declare function invalidateVisibleSkillActiveStateCache(cwd?: string, sessionId?: string): void;
 export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, opts?: ReadVisibleSkillActiveStateOptions): Promise<SkillActiveState | null>;
-export declare function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void>;
+export declare function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<GuardedWriteResult | undefined>;
 export interface ApplyHandoffOptions {
     cwd: string;
     caller: SyncSkillActiveStateOptions;

package/dist/types/slash-commands/acp-builtins.d.ts

@@ -14,5 +14,9 @@ export declare const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[];
  * - `{ consumed: true }` when the command handled the input entirely.
  * - `{ prompt }` when the command was handled but a residual prompt should be
  *   sent to the model.
+ * When `disabledOnly` is set, ACP-enabled builtins also return `false` so a
+ * transport can apply only the unavailable-over-ACP policy before forwarding.
  */
-export declare function executeAcpBuiltinSlashCommand(text: string, runtime: AcpBuiltinCommandRuntime): Promise<AcpBuiltinSlashCommandResult>;
+export declare function executeAcpBuiltinSlashCommand(text: string, runtime: AcpBuiltinCommandRuntime, options?: {
+    disabledOnly?: boolean;
+}): Promise<AcpBuiltinSlashCommandResult>;

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -36,6 +36,8 @@ export declare const BUILTIN_SLASH_COMMANDS_INTERNAL: ReadonlyArray<SlashCommand
  * but remaining text should be sent as a prompt.
  */
 export declare function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<string | boolean>;
+/** Dispatch a command explicitly authorized for trusted local non-interactive mode. */
+export declare function executeLocalHeadlessBuiltinSlashCommand(text: string, runtime: SlashCommandRuntime): Promise<false | Exclude<SlashCommandResult, undefined>>;
 /** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
 export declare function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined;
 export type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime };

package/dist/types/slash-commands/helpers/credential-switch.d.ts

@@ -0,0 +1,12 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * List every provider's stored OAuth accounts, marking which row each
+ * currently-tracked session is using.
+ */
+export declare function buildCredentialListText(runtime: SlashCommandRuntime): Promise<string>;
+/**
+ * Switch the running session's stored OAuth credential for a provider,
+ * independent of quota state. Returns the confirmation/error text to show
+ * the user; never throws.
+ */
+export declare function switchSessionCredentialCommand(runtime: SlashCommandRuntime, args: string): Promise<string>;

package/dist/types/slash-commands/helpers/usage-report.d.ts

@@ -1,7 +1,6 @@
 import type { SlashCommandRuntime } from "../types";
-/**
- * Build the `/usage` ACP-mode text. Prefers provider-reported limits when the
- * session exposes `fetchUsageReports`; otherwise falls back to the local
- * session-manager tallies.
- */
-export declare function buildUsageReportText(runtime: SlashCommandRuntime): Promise<string>;
+export interface UsageReportOptions {
+    check?: boolean;
+}
+/** Build `/usage`; plain mode is cache-only and never fetches or probes. */
+export declare function buildUsageReportText(runtime: SlashCommandRuntime, options?: UsageReportOptions): Promise<string>;

package/dist/types/slash-commands/types.d.ts

@@ -30,12 +30,14 @@ export interface ParsedSlashCommand {
  * Result returned by a slash-command handler.
  *
  * - `void` / `undefined` — command was handled and consumed; no further input.
- * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ consumed: true, exitCode?: number }` — explicit equivalent of the above;
+ *   trusted local headless mode applies an optional non-zero process status.
  * - `{ prompt: string }` — command handled, pass `prompt` through as the new
  *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
  */
 export type SlashCommandResult = undefined | {
     consumed: true;
+    exitCode?: number;
 } | {
     prompt: string;
 };
@@ -95,6 +97,10 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
      * not silently drop it from `available_commands_update`.
      */
     acpInputHint?: string;
+    /** Set false for trusted local commands that must never be advertised or dispatched through ACP. */
+    acp?: boolean;
+    /** Explicitly authorizes this handler in trusted local non-interactive print mode. */
+    localHeadless?: boolean;
     /**
      * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
      * and, via the TUI adapter, when no `handleTui` override is provided.

package/dist/types/task/executor.d.ts

@@ -5,6 +5,7 @@
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, type ServiceTier } from "@gajae-code/ai/core";
+import { AsyncJobManager } from "../async";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
@@ -96,6 +97,15 @@ export interface ExecutorOptions {
      */
     parentArtifactManager?: ArtifactManager;
     managedPersistence?: ManagedTaskPersistence;
+    /**
+     * The parent session's ENDPOINT-owned AsyncJobManager (resolved by the
+     * TaskTool via forEndpoint(sessionId) ?? instance()). Model metadata and
+     * live-handle state for THIS subagent are recorded in the SAME manager the
+     * task job runs in — with concurrent top-level sessions the process-global
+     * instance belongs to a different session and would surface this subagent
+     * under the wrong session's record (review thread P1).
+     */
+    asyncJobManager?: AsyncJobManager;
     parentHindsightSessionState?: HindsightSessionState;
     /**
      * Parent agent's OpenTelemetry configuration. When defined, the subagent's

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

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import type { Model } from "@gajae-code/ai/core";
+import { type SubagentRunOutcome } from "@gajae-code/coding-agent/async";
 import type { ToolSession } from "..";
-import { type SubagentRunOutcome } from "../async";
 import type { Theme } from "../modes/theme/theme";
 import { type SingleResult, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
@@ -48,5 +48,7 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
      * multi-repo workspaces fail closed prior to context/discovery (#2901).
      */
     static create(session: ToolSession): Promise<TaskTool>;
+    /** Create catalog metadata from bundled agents only, without ambient filesystem discovery. */
+    static createForToolCatalog(session: ToolSession): Promise<TaskTool>;
     execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
 }

package/dist/types/tools/ask-answer-registry.d.ts

@@ -3,15 +3,18 @@
  *
  * Decouples the `ask` tool (which reads the source via `AgentSession`) from the
  * notifications extension (which registers one), without threading a new method
- * through the extension/runner/controller wiring. A session has at most one
- * source; registering returns a disposer.
+ * through the extension/runner/controller wiring. A session may have multiple
+ * sources. A "protocol" source always takes precedence over an "interactive"
+ * source regardless of registration order; within the same kind, the most
+ * recently registered source wins. Registering returns a disposer.
  */
 /** Error code a remote ask source uses to signal that its own timeout fired. */
 export declare const GJC_ASK_TIMEOUT_CODE = "gjc.ask.timeout";
 import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { AskAnswerSource } from "./index";
+export type AskAnswerSourceKind = "protocol" | "interactive";
 /** Register `source` for `sessionId`. Returns a disposer that restores the prior source. */
-export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;
+export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource, kind?: AskAnswerSourceKind): () => void;
 /** The highest-priority answer source for `sessionId`, if one is registered. */
 export declare function getAskAnswerSource(sessionId: string): AskAnswerSource | undefined;
 /** Publish a session's current workflow-gate emitter after mode initialization. */

package/dist/types/tools/bash-sleep-advisory.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Detect a long blocking sleep in a bash command and return an advisory notice,
+ * or `undefined` if the command does not contain a qualifying sleep. The notice
+ * is appended to the bash result output; it never blocks execution.
+ *
+ * `timeoutSec` is the effective (already-clamped) execution timeout the command
+ * will run under, when known. The bash tool kills the command at this timeout
+ * whether the sleep fits inside it or not. Passing it lets the notice report
+ * the bounded effective silent wait the operator will actually observe, instead
+ * of the requested duration (which may be much longer and is never reached).
+ * When `timeoutSec` is `undefined` (no timeout known at the construction
+ * boundary), the notice reports only the requested duration and stays useful.
+ */
+export declare function longSleepAdvisory(command: string, timeoutSec?: number): string | undefined;

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

@@ -48,11 +48,6 @@ export interface BashToolDetails {
 export declare function summarizeBashToolActivity(kind: "args" | "result", value: unknown): string | undefined;
 export interface BashToolOptions {
 }
-/**
- * Bash tool implementation.
- *
- * Executes bash commands with optional timeout and working directory.
- */
 export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
     #private;
     private readonly session;
@@ -83,6 +78,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
         ownerId?: string;
         label?: string;
         ctx?: AgentToolContext;
+        toolCallId?: string;
         onRawLine?: (line: string, jobId: string) => void;
         shouldAcceptRawLine?: (jobId: string) => boolean;
         lifecycle?: import("../async").AsyncJobLifecycleCleanup;
@@ -91,7 +87,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
         label: string;
         commandCwd: string;
     }>;
-    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+    execute(toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
 }
 export interface BashRenderArgs {
     command?: string;

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

@@ -32,6 +32,16 @@ export declare function findRunningChromeProfile(exe: string, profile: {
     userDataDir: string;
     profileDirectory: string;
 }, signal?: AbortSignal): Promise<RunningChromeProfile | null>;
+interface ProfileProcessScanOptions {
+    platform?: NodeJS.Platform;
+    linuxPids?: readonly number[];
+    linuxExecutablePaths?: ReadonlyMap<number, string>;
+    signal?: AbortSignal;
+}
+export declare function findRunningChromeProfileForTest(exe: string, profile: {
+    userDataDir: string;
+    profileDirectory: string;
+}, options: ProfileProcessScanOptions): 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,
@@ -48,3 +58,4 @@ export declare function gracefulKillTreeOnce(pid: number, gracePeriodMs?: number
  * (single-instance apps may keep an orphan around) and tear them all down.
  */
 export declare function killExistingByPath(executablePath: string, signal?: AbortSignal): Promise<number>;
+export {};

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

@@ -19,7 +19,27 @@ export declare function resolveBrowserEnvOverridesForTest(): {
     proxy: string | undefined;
     proxyBypassLoopback: boolean;
     ignoreCertErrors: boolean;
+    programFiles: string | undefined;
+    programFilesX86: string | undefined;
+    localAppData: string | undefined;
 };
+/** True for a Microsoft Edge executable path (excluded from Chrome profile mode). */
+export declare function isEdgeExecutable(candidate: string): boolean;
+/** True only for executable names owned by Google Chrome or Chromium. */
+export declare function isChromeProfileExecutable(candidate: string): boolean;
+/**
+ * Validate the executable identity used for profile mode. Most symlinks are
+ * judged by their resolved target so a renamed cross-brand browser cannot pass
+ * by alias. Snap's canonical `/snap/bin/chromium` launcher is the exception:
+ * it resolves to the generic `/usr/bin/snap` dispatcher by design.
+ */
+export declare function isChromeProfileExecutableForLaunch(candidate: string, resolvedCandidate: string): boolean;
+/**
+ * Installed Chrome/Chromium executable for saved-profile mode, or undefined when
+ * none is present. Edge is excluded on purpose: a discovered Chrome user data
+ * directory must never be opened by a different browser brand.
+ */
+export declare function resolveSystemChromeForProfile(): string | undefined;
 export interface LaunchHeadlessOptions {
     headless: boolean;
     viewport?: {

package/dist/types/tools/browser/profile-discovery.d.ts

@@ -14,6 +14,12 @@ export interface DiscoveryEnv {
     exists: (p: string) => boolean;
     /** Windows LOCALAPPDATA override (tests / non-default installs). */
     localAppData?: string;
+    /** Linux Chrome-specific default user-data override. */
+    chromeUserDataDir?: string;
+    /** Linux Chrome config-home override (takes precedence over XDG_CONFIG_HOME). */
+    chromeConfigHome?: string;
+    /** Linux XDG config-home override. */
+    xdgConfigHome?: string;
 }
 /** Candidate Chrome user-data roots for the platform (most common first). */
 export declare function chromeUserDataRoots(env: DiscoveryEnv): string[];

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

@@ -35,6 +35,7 @@ interface BrowserRenderContext {
     expanded?: boolean;
     previewLines?: number;
 }
+export declare function describeBrowserForTest(args: BrowserRenderArgs, details: BrowserToolDetails | undefined): string | undefined;
 export declare const browserToolRenderer: {
     renderCall(args: BrowserRenderArgs, options: RenderResultOptions, theme: Theme): Component;
     renderResult(result: {

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

@@ -1,6 +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 DiscoveryEnv } from "./browser/profile-discovery";
 import { type BrowserKind, type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import type { OutputMeta } from "./output-meta";
@@ -107,7 +108,8 @@ export interface BrowserToolDetails {
     result?: string;
     meta?: OutputMeta;
 }
-export declare function resolveBrowserKindForTest(params: BrowserParams, session: ToolSession): BrowserKind;
+export declare function resolveBrowserKindForTest(params: BrowserParams, session: ToolSession, signal?: AbortSignal, discoveryEnv?: DiscoveryEnv): Promise<BrowserKind>;
+export declare function isDefaultChromeUserDataDirForTest(candidate: string, roots: readonly string[], platform?: NodeJS.Platform, signal?: AbortSignal): Promise<boolean>;
 /**
  * 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.

package/dist/types/tools/image-gen.d.ts

@@ -4,7 +4,14 @@ import { type ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 export declare function redactImageProviderText(value: unknown, activeApiKey?: string): string;
-type ImageProvider = "alibaba" | "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter" | (string & {});
+type ImageProvider = "alibaba" | "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
+export declare class UnsupportedImageProviderError extends Error {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly api: Model["api"];
+    readonly code: "unsupported_image_provider";
+    constructor(provider: string, modelId: string, api: Model["api"]);
+}
 declare const responseModalitySchema: z.ZodEnum<{
     IMAGE: "IMAGE";
     TEXT: "TEXT";
@@ -133,7 +140,7 @@ export declare function resolveImageRoleModel(settings: Settings, modelRegistry:
 export declare function resolveImageModel(provider: string, modelOverride: string | null): string;
 /** Test seam: the Google image key fallback as resolved from trusted env. */
 export declare function googleImageApiKeyFromEnvForTest(): string | undefined;
-export declare function isOpenAIHostedImageModel(model: Model | undefined): model is Model;
+export declare function isOpenAIHostedImageModel(model: Model | undefined): boolean;
 /** Test seam: the image-request base URL as resolved from trusted env. */
 export declare function getOpenAIImageBaseUrlForTest(model: Model, authCredentialType?: "api_key" | "oauth"): string;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;

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

@@ -1,5 +1,6 @@
 import type { AgentTelemetryConfig, AgentTool } from "@gajae-code/agent-core";
 import type { Model, ServiceTier, ToolChoice } from "@gajae-code/ai/core";
+import type { AsyncJobManager } from "../async";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -169,6 +170,8 @@ export interface ToolSession {
     hasForegroundBashBackgroundRequestHandler?: () => boolean;
     /** Request that the active managed foreground bash call fold into a background job, if supported. */
     requestForegroundBashBackground?: () => boolean;
+    /** Get the session-owned or inherited async job manager. */
+    getAsyncJobManager?: () => AsyncJobManager | undefined;
     /** Get session ID */
     getSessionId?: () => string | null;
     /** Get credential-selection session identity. */
@@ -234,6 +237,11 @@ export interface ToolSession {
     agentOutputManager?: AgentOutputManager;
     /** Settings instance for passing to subagents */
     settings: Settings;
+    /**
+     * The session's REQUESTED effective agent directory, independent of the
+     * global Settings singleton (which can be reused across sessions).
+     */
+    getSessionAgentDir?: () => string;
     /** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
     serviceTier?: ServiceTier;
     /** Whether the effective subagent tier grants fast mode for a resolved provider. */

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

@@ -49,6 +49,6 @@ export declare class MonitorTool implements AgentTool<typeof monitorSchema, Moni
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): MonitorTool | null;
-    execute(_toolCallId: string, params: MonitorParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<MonitorToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<MonitorToolDetails>>;
+    execute(toolCallId: string, params: MonitorParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<MonitorToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<MonitorToolDetails>>;
 }
 export {};

package/dist/types/tools/skill-discovery.d.ts

@@ -17,11 +17,18 @@ export interface SkillDiscoveryToolDetails {
     count: number;
     /**
      * Present only when zero candidates were returned AND discovery config gates
-     * (`skills.enabled` / `skills.enablePiProject` / `skills.enablePiUser`)
+     * (`skills.enabled` / `skills.trustProjectSkills` / `skills.trustUserSkills`)
      * prevented some or all of the requested scope from being searched. Without
      * this, a disabled config is indistinguishable from "no skills exist".
      */
     notice?: string;
+    /**
+     * Human-readable diagnostics for skills that were scanned but not
+     * advertised (protected-name collisions with bundled workflow skills,
+     * include/ignore/disable policy filters, invalid frontmatter, shadowing,
+     * scan failures). Bounded; empty when nothing was filtered.
+     */
+    diagnostics?: string[];
 }
 export declare class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
     #private;

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

@@ -114,6 +114,8 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
+    /** Test-only seam: substitute the liveness clock. Returns a restore function. */
+    withLivenessClock(nowMs: () => number): () => void;
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SubagentToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<SubagentToolDetails>>;
 }

package/dist/types/tools/ultragoal-ask-guard.d.ts

@@ -8,5 +8,5 @@ export interface UltragoalAskGuardContext {
     sessionId?: string | null;
 }
 export declare function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string;
-export declare function assertUltragoalAskAllowed(cwd: string, context?: UltragoalAskGuardContext): Promise<void>;
-export declare function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string, getContext?: () => UltragoalAskGuardContext): T;
+export declare function assertUltragoalAskAllowed(cwd: string, context?: UltragoalAskGuardContext, agentDir?: string): Promise<void>;
+export declare function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string, getContext?: () => UltragoalAskGuardContext, getSessionAgentDir?: () => string | undefined): T;

package/dist/types/utils/herdr-pane.d.ts

@@ -0,0 +1,76 @@
+export type HerdrAgentState = "idle" | "working" | "blocked";
+export interface HerdrPaneEnvironment {
+    paneId: string;
+    binPath: string;
+}
+export interface HerdrReportProcess {
+    exited: Promise<number>;
+    kill(): void;
+    unref(): void;
+}
+export interface HerdrReporterOptions {
+    env?: NodeJS.ProcessEnv;
+    which?: (command: string) => string | null;
+    spawn?: (command: string[], options: {
+        env: NodeJS.ProcessEnv;
+        stdin: "ignore";
+        stdout: "ignore";
+        stderr: "ignore";
+    }) => HerdrReportProcess;
+}
+/** Session event shape consumed by the reporter. Narrow on purpose: the state
+ * machine is driven only by lifecycle transitions, never by message content. */
+export interface HerdrSessionEvent {
+    type: string;
+    toolName?: string;
+}
+export interface HerdrReporter {
+    /** Report a new agent state. Deduplicated against the last reported state. */
+    report(state: HerdrAgentState): void;
+    /** Release this pane's lifecycle authority and stop listening. Idempotent. */
+    release(): void;
+    /** Current reported state, for tests and diagnostics. */
+    readonly state: HerdrAgentState | null;
+}
+/**
+ * Resolve the pane environment. Returns null unless gjc is demonstrably inside
+ * a Herdr pane AND a herdr binary is resolvable.
+ *
+ * `HERDR_BIN_PATH` is honored first because Herdr sets it for its own panes;
+ * otherwise the binary is resolved from PATH. No home-directory guessing: an
+ * unverified path scavenged from an install layout is a command this process
+ * would execute, and PATH/`HERDR_BIN_PATH` are the trust boundary Herdr itself
+ * documents.
+ */
+export declare function resolveHerdrPaneEnvironment(options?: HerdrReporterOptions): HerdrPaneEnvironment | null;
+/** Build the argv for a state report. Exported for tests. */
+export declare function buildHerdrReportArgs(paneId: string, state: HerdrAgentState, seq: number): string[];
+/** Build the argv for an authority release. Exported for tests. */
+export declare function buildHerdrReleaseArgs(paneId: string, seq: number): string[];
+/**
+ * Collapse a session name into a single-line pane title. Control characters are
+ * removed rather than escaped: the value reaches a terminal surface, and a
+ * model-generated session name must never be able to inject escapes.
+ */
+export declare function sanitizeHerdrPaneTitle(title: string | undefined): string | undefined;
+/** Build the argv for a pane title report. Exported for tests. */
+export declare function buildHerdrTitleArgs(paneId: string, title: string, seq: number): string[];
+/** Build the argv that retracts a previously reported pane title. Exported for tests. */
+export declare function buildHerdrClearTitleArgs(paneId: string, seq: number): string[];
+/**
+ * Report the current session title for this pane. No-op outside a Herdr pane or
+ * when the session has no usable name, so a pane keeps the last real title
+ * instead of flickering to a placeholder during startup or a rename.
+ */
+export declare function syncHerdrPaneTitle(sessionName: string | undefined, options?: HerdrReporterOptions): void;
+/**
+ * Create a reporter bound to a pane. `subscribe` supplies the session event
+ * stream and is parameterized so the state machine is testable without a live
+ * session.
+ */
+export declare function createHerdrReporter(paneEnv: HerdrPaneEnvironment, subscribe: (listener: (event: HerdrSessionEvent) => void) => () => void, options?: HerdrReporterOptions): HerdrReporter;
+/**
+ * Install the Herdr reporter for a running session. No-op outside a Herdr pane.
+ * Returns the reporter so callers can release it deterministically, or null.
+ */
+export declare function installHerdrReporter(subscribe: (listener: (event: HerdrSessionEvent) => void) => () => void, options?: HerdrReporterOptions): HerdrReporter | null;