@gajae-code/coding-agent 0.7.6 → 0.7.8

package/dist/types/gjc-runtime/launch-tmux.d.ts

@@ -1,6 +1,6 @@
 import type { Args } from "../cli/args";
-import { buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, type GjcTmuxProfileCommand } from "./tmux-common";
-export { buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
+import { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, type GjcTmuxProfileCommand } from "./tmux-common";
+export { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
 export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
 export declare const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export declare const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;

package/dist/types/gjc-runtime/state-renderer.d.ts

@@ -39,6 +39,11 @@ export declare function renderUltragoalStatusMarkdown(summary: {
     };
     counts: Record<string, number>;
     goals: unknown[];
+    nudgeBudget?: number;
+    nudgeCount?: number;
+    nudgeRemaining?: number;
+    nudgeGoalId?: string;
+    nudgeTargetKind?: string;
 }): string;
 export declare function renderTeamStatusMarkdown(snapshot: {
     team_name: string;

package/dist/types/gjc-runtime/team-runtime.d.ts

@@ -280,7 +280,7 @@ export declare function pruneTeamWorkerGcRecord(record: GcRecord, probe: GcPidPr
 export declare function persistGjcTeamModeStateSummary(snapshot: GjcTeamSnapshot, cwd?: string): Promise<void>;
 export declare function recoverGjcTeamStaleClaims(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamLivenessRecoveryResult>;
 type GjcTeamTaskMetadataInput = Partial<Pick<GjcTeamTask, "owner" | "lane" | "required_role" | "allowed_roles" | "depends_on" | "blocked_by">>;
-export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv): string;
+export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, argv?: string[], execPath?: string): string;
 /** @internal Exported for unit tests. */
 export declare function buildWorkerCommand(config: GjcTeamConfig, worker: GjcTeamWorker, platform?: NodeJS.Platform): string;
 export type GjcWorkerCheckpointClassification = {

package/dist/types/gjc-runtime/tmux-common.d.ts

@@ -60,6 +60,18 @@ export declare function buildGjcTmuxExactOptionTarget(sessionName: string, opts?
     platform?: NodeJS.Platform;
     binary?: ResolvedTmuxBinary;
 }): string;
+/**
+ * Build the exact-session target for tmux *session-scoped* commands such as
+ * `attach-session` and `kill-session`. Native tmux accepts `=NAME` for an
+ * exact session match, but Windows psmux 3.3.x rejects that target form for
+ * session commands even though the bare `NAME` resolves. Keep native tmux on
+ * exact targets and intentionally use the bare session name for psmux.
+ */
+export declare function buildGjcTmuxExactSessionTarget(sessionName: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    binary?: ResolvedTmuxBinary;
+}): string;
 export declare const GJC_TMUX_UNTAGGED_REASON = "gjc_tmux_session_untagged";
 export declare function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string;
 export declare function buildGjcTmuxUntaggedSessionError(sessionName: string, tmuxCommand: string): string;

package/dist/types/gjc-runtime/ultragoal-guard.d.ts

@@ -1,4 +1,4 @@
-import { type UltragoalGoal, type UltragoalLedgerEvent, type UltragoalPlan, type UltragoalReceiptKind } from "./ultragoal-runtime";
+import { type UltragoalGoal, type UltragoalLedgerEvent, type UltragoalNudgeSurface, type UltragoalPlan, type UltragoalReceiptKind } from "./ultragoal-runtime";
 export type UltragoalGuardState = "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
 export interface UltragoalGuardDiagnostic {
     state: UltragoalGuardState;
@@ -30,6 +30,29 @@ export declare function readUltragoalVerificationState(input: {
     sessionId?: string | null;
 }): Promise<UltragoalGuardDiagnostic>;
 export declare function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic>;
+/**
+ * Escalating per-attempt refusal text. Deliberately avoids every
+ * `isUltragoalBypassPrompt` trigger: no `update_goal(`, no "skip/weaken verification",
+ * no "mark ... complete", no "--status complete", and the word "complete" never
+ * appears (so the `goal` ... `complete` proximity rule cannot match).
+ */
+export declare function formatUltragoalNudgeMessage(input: {
+    surface: UltragoalNudgeSurface;
+    attempt: number;
+    budget: number;
+    goalId: string;
+}): string;
+/**
+ * Assert-path entry for the `ask` surface (the ask guard lives in another module).
+ * Resolves the active (leader) Ultragoal session so subagent/headless asks consume
+ * the leader run's budget rather than a fresh child ledger.
+ */
+export declare function consumeUltragoalAskNudge(cwd: string, sessionId?: string | null): Promise<{
+    nudged: true;
+    message: string;
+} | {
+    nudged: false;
+}>;
 export declare function assertCanCompleteCurrentGoal(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
@@ -49,3 +72,16 @@ export interface UltragoalPauseBlockDiagnostic {
  */
 export declare function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPauseBlockDiagnostic>;
 export declare function assertUltragoalPauseAllowed(cwd: string): Promise<void>;
+/**
+ * Guard `goal({"op":"drop"})` during an active Ultragoal run. A *real give-up* (an
+ * aggregate run still mid-flight with incomplete required stories) is nudged while
+ * budget remains; once exhausted it falls through to today's drop behavior. Legitimate
+ * aggregate-reset drops — no durable run, unrelated goal, an already dropped/stale
+ * aggregate, or an all-stories-complete run — are never nudged. If durable state
+ * exists but cannot be read to classify the drop, fail closed.
+ */
+export declare function assertUltragoalDropAllowed(input: {
+    cwd: string;
+    currentGoal?: CurrentGoalLike | null;
+    sessionId?: string | null;
+}): Promise<void>;

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -53,6 +53,41 @@ export interface UltragoalLedgerEvent extends JsonObject {
     goalId?: string;
     timestamp?: string;
 }
+export type UltragoalNudgeSurface = "pause" | "drop" | "ask" | "premature_complete";
+export type UltragoalNudgeTargetKind = "story" | "final_aggregate_receipt";
+export interface UltragoalNudgeLedgerEvent extends UltragoalLedgerEvent {
+    event: "nudge";
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+    surface: UltragoalNudgeSurface;
+    attempt: number;
+    budget: number;
+    reason: string;
+    currentGoalObjective?: string;
+}
+export interface UltragoalNudgeTarget {
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+}
+export type UltragoalNudgeOutcome = {
+    nudged: true;
+    attempt: number;
+    budget: number;
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+    event: UltragoalNudgeLedgerEvent;
+} | {
+    nudged: false;
+    exhausted: true;
+    count: number;
+    budget: number;
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+} | {
+    nudged: false;
+    inactive: true;
+    reason: string;
+};
 export interface UltragoalPaths {
     dir: string;
     briefPath: string;
@@ -67,6 +102,11 @@ export interface UltragoalStatusSummary {
     currentGoal?: UltragoalGoal;
     counts: Record<UltragoalGoalStatus, number>;
     goals: UltragoalGoal[];
+    nudgeBudget?: number;
+    nudgeCount?: number;
+    nudgeRemaining?: number;
+    nudgeGoalId?: string;
+    nudgeTargetKind?: UltragoalNudgeTargetKind;
 }
 export interface UltragoalCommandResult {
     reviewBlockerGoalIds?: string[];
@@ -82,6 +122,46 @@ interface JsonObject {
 export declare function hashStructuredValue(value: unknown): string;
 export declare function getUltragoalPaths(cwd: string, sessionId?: string | null): UltragoalPaths;
 export declare function readUltragoalLedger(cwd: string, sessionId?: string | null): Promise<UltragoalLedgerEvent[]>;
+export declare const DEFAULT_ULTRAGOAL_NUDGE_BUDGET = 10;
+/** Pure: count ledger `nudge` rows for an exact goalId. */
+export declare function countUltragoalNudges(ledger: readonly UltragoalLedgerEvent[], goalId: string): number;
+/**
+ * Resolve the per-story nudge budget. Project `./.gjc/settings.json` overrides the
+ * user settings (`$GJC_CONFIG_DIR/settings.json` or `~/.gjc/settings.json`), else the
+ * default. Mirrors the `gjc.deepInterview.ambiguityThreshold` user+project precedence.
+ */
+export declare function resolveUltragoalNudgeBudget(cwd: string): Promise<{
+    budget: number;
+    source: string;
+}>;
+/**
+ * Pure canonical selector shared by guards and status so `nudgeGoalId` can never
+ * diverge between what a guard consumes and what status displays. Prefers the active
+ * current-goal objective, then active > pending > failed (matching `chooseNextGoal`),
+ * then the aggregate final-receipt target when all stories are complete but the
+ * aggregate run still needs a final receipt. Returns null for verified-complete or
+ * absent/unrelated plans.
+ */
+export declare function selectUltragoalNudgeTarget(plan: UltragoalPlan, options?: {
+    currentGoalObjective?: string;
+    retryFailed?: boolean;
+}): UltragoalNudgeTarget | null;
+/**
+ * Atomic consuming writer. Locks the ledger path, rereads + counts nudge rows for the
+ * target story, and appends exactly one `nudge` row inside the same critical section
+ * only while budget remains. Reuses the lockless `appendLedger` inside the lock (it
+ * does not acquire a conflicting lock), so concurrent guarded attempts cannot both
+ * observe `count = budget - 1` and overshoot the budget.
+ */
+export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
+    cwd: string;
+    sessionId?: string | null;
+    target: UltragoalNudgeTarget;
+    surface: UltragoalNudgeSurface;
+    budget: number;
+    reason: string;
+    currentGoalObjective?: string;
+}): Promise<UltragoalNudgeOutcome>;
 export declare function computeUltragoalPlanGeneration(input: {
     plan: UltragoalPlan;
     ledger: readonly UltragoalLedgerEvent[];

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

@@ -6,7 +6,7 @@ export interface CustomModelPresetWizardSubmit {
 }
 export declare class CustomModelPresetWizardComponent extends Container {
     #private;
-    constructor(onSubmit: (input: CustomModelPresetWizardSubmit) => void, onCancel: () => void, onRender?: () => void);
+    constructor(snapshot: ModelProfileConfig, 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

@@ -3,6 +3,7 @@ import { type Model } from "@gajae-code/ai";
 import { Container, Input, type TUI } from "@gajae-code/tui";
 import type { GjcModelAssignmentTargetId, ModelRegistry } from "../../config/model-registry";
 import { type ScopedModelSelection } from "../../config/model-resolver";
+import type { ModelProfileConfig } from "../../config/models-config-schema";
 import type { Settings } from "../../config/settings";
 type ScopedModelItem = ScopedModelSelection;
 export type ModelSelectorSelection = {
@@ -17,6 +18,7 @@ export type ModelSelectorSelection = {
     setDefault: boolean;
 } | {
     kind: "createProfile";
+    profile: ModelProfileConfig;
 };
 type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
 /**

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

@@ -4,6 +4,7 @@ import { Container, SettingsList } from "@gajae-code/tui";
 import { type SettingPath } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { PluginSettingsComponent } from "./plugin-settings";
+import type { StatusLineSegmentOptions } from "./status-line";
 /**
  * Dynamic context for settings that need runtime data.
  * Some settings (like thinking level) are managed by the session, not Settings.
@@ -24,6 +25,8 @@ export interface StatusLinePreviewSettings {
     leftSegments?: StatusLineSegmentId[];
     rightSegments?: StatusLineSegmentId[];
     separator?: StatusLineSeparatorStyle;
+    segmentOptions?: StatusLineSegmentOptions;
+    previewHighlightSegment?: StatusLineSegmentId;
     sessionAccent?: boolean;
 }
 export interface SettingsCallbacks {
@@ -36,7 +39,7 @@ export interface SettingsCallbacks {
     /** Called for status line preview while configuring */
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */
-    getStatusLinePreview?: () => string;
+    getStatusLinePreview?: (width?: number) => string;
     /** Called when plugins change */
     onPluginsChanged?: () => void;
     /** Called when settings panel is closed */

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

@@ -44,14 +44,12 @@ export interface SegmentContext {
         } | null;
     };
     usage: {
-        fiveHour?: {
+        windows: Array<{
+            label: string;
             percent: number;
-            resetMinutes?: number;
-        };
-        sevenDay?: {
-            percent: number;
-            resetHours?: number;
-        };
+            resetValue?: number;
+            resetUnit?: "m" | "h";
+        }>;
     } | null;
 }
 export interface RenderedSegment {

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

@@ -29,6 +29,7 @@ export interface StatusLineSettings {
     rightSegments?: StatusLineSegmentId[];
     separator?: StatusLineSeparatorStyle;
     segmentOptions?: StatusLineSegmentOptions;
+    previewHighlightSegment?: StatusLineSegmentId;
     showHookStatus?: boolean;
     showSkillHud?: boolean;
     sessionAccent?: boolean;
@@ -59,9 +60,9 @@ export declare class StatusLineComponent implements Component {
     dispose(): void;
     invalidate(): void;
     /**
-     * Background-refresh the Anthropic OAuth quota report. Guarded by a 5-min
-     * TTL on both success (cache lifetime) and error (backoff). Exposed
-     * (non-private) so unit tests can verify the backoff invariant.
+     * Background-refresh the OAuth quota report. Guarded by a 5-min TTL on both
+     * success (cache lifetime) and error (backoff). Exposed (non-private) so
+     * unit tests can verify the backoff invariant.
      */
     refreshUsageInBackground(): void;
     /**

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

@@ -32,6 +32,7 @@ export declare class InputController {
         temporary?: boolean;
     }): Promise<void>;
     toggleToolOutputExpansion(): void;
+    scrollTmuxToPreviousUserInput(): void;
     setToolsExpanded(expanded: boolean): void;
     toggleThinkingBlockVisibility(): void;
     openExternalEditor(): Promise<void>;

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

@@ -1,4 +1,5 @@
 import type { Component } from "@gajae-code/tui";
+import type { ModelProfileConfig } from "../../config/models-config-schema";
 import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
 import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
@@ -15,7 +16,7 @@ export declare class SelectorController {
         focus: Component;
     }): void;
     showProviderOnboarding(): void;
-    showCustomModelPresetWizard(): void;
+    showCustomModelPresetWizard(snapshot: ModelProfileConfig): void;
     showCustomProviderWizard(): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;

package/dist/types/modes/prompt-action-autocomplete.d.ts

@@ -14,6 +14,7 @@ interface PromptActionAutocompleteOptions {
     copyCurrentLine: () => void;
     copyPrompt: () => void;
     pasteImage: () => void;
+    scrollTmuxToPreviousUserInput: () => void;
     undo: (prefix: string) => void;
     moveCursorToMessageEnd: () => void;
     moveCursorToMessageStart: () => void;

package/dist/types/modes/tmux-scroll.d.ts

@@ -0,0 +1,18 @@
+export declare const TMUX_PREVIOUS_USER_INPUT_SEARCH_PATTERN = "^ *user *$";
+type TmuxScrollFailureReason = "not_inside_tmux" | "tmux_command_failed" | "copy_mode_failed" | "history_bottom_failed" | "search_failed";
+export type TmuxScrollToPreviousUserInputResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: TmuxScrollFailureReason;
+    error?: string;
+};
+interface TmuxSpawnResult {
+    exitCode: number | null;
+    stderr?: {
+        toString(): string;
+    };
+}
+type TmuxSpawnSync = (command: string, args: string[], env: NodeJS.ProcessEnv) => TmuxSpawnResult;
+export declare function scrollTmuxToPreviousUserInput(env?: NodeJS.ProcessEnv, spawnSync?: TmuxSpawnSync): TmuxScrollToPreviousUserInputResult;
+export {};

package/dist/types/modes/utils/terminal-bell.d.ts

@@ -0,0 +1,3 @@
+export type TerminalBellEvent = "complete" | "approval" | "ask";
+export declare function ringTerminalBell(event: TerminalBellEvent, output?: Pick<NodeJS.WriteStream, "write">): void;
+export declare function classifyHookSelectorBellEvent(title: string): TerminalBellEvent;

package/dist/types/notifications/telegram-daemon-cli.d.ts

@@ -1,10 +1,21 @@
-import { Settings } from "../config/settings";
+import type { Settings } from "../config/settings";
 import { TelegramNotificationDaemon } from "./telegram-daemon";
 export interface RunDaemonInternalDeps {
-    SettingsImpl?: Pick<typeof Settings, "init">;
+    SettingsImpl?: {
+        init: (options?: {
+            agentDir?: string;
+        }) => Promise<Pick<Settings, "get" | "getAgentDir">>;
+    };
     DaemonImpl?: typeof TelegramNotificationDaemon;
     processPid?: number;
+    pidAlive?: (pid: number) => boolean;
 }
+export declare function createLightweightDaemonSettings(input: {
+    agentDir: string;
+    rawConfig?: unknown;
+}): Pick<Settings, "get" | "getAgentDir">;
+export declare function loadLightweightDaemonSettings(agentDir: string): Promise<Pick<Settings, "get" | "getAgentDir">>;
+export declare function ownerPidFromOwnerId(ownerId: string): number | undefined;
 export declare function runDaemonSmoke(opts?: {
     agentDir?: string;
 }): Promise<void>;

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

@@ -28,6 +28,10 @@ export interface TabSession {
     kindTag: BrowserKindTag;
     /** Session that acquired this tab; used for session-scoped teardown (F13). */
     ownerId?: string;
+    /** Unix-ms timestamp of the last acquire/run activity; drives GC idle + LRU ordering. */
+    lastUsedAt: number;
+    /** Set synchronously by the shared begin-release guard so concurrent release is a no-op. */
+    releasing?: boolean;
 }
 export interface AcquireTabOptions {
     url?: string;
@@ -58,6 +62,33 @@ export interface ReleaseTabOptions {
     kill?: boolean;
 }
 export declare function getTab(name: string): TabSession | undefined;
+/** Read-only, GC-facing projection of a live tab. Never exposes the mutable `tabs` map. */
+export interface TabGcSnapshot {
+    name: string;
+    ownerId?: string;
+    state: TabSession["state"];
+    pendingCount: number;
+    kindTag: BrowserKindTag;
+    lastUsedAt: number;
+    browserRefCount: number;
+}
+export interface BrowserGcEligibilityPolicy {
+    now: () => number;
+    idleMs: number;
+}
+/** Snapshot every live tab for GC ordering/diagnostics. */
+export declare function listTabsForGc(): TabGcSnapshot[];
+/**
+ * Evict a tab only if it is still GC-eligible against the LIVE supervisor state. The full
+ * predicate is checked synchronously and `releaseTab` is invoked with no intervening await,
+ * so a tab that became busy after a GC snapshot cannot be closed (its run rejected). Returns
+ * true only when the tab was actually released.
+ */
+export declare function releaseTabIfGcEligible(name: string, policy: BrowserGcEligibilityPolicy): Promise<boolean>;
+/** Test-only: install a fabricated tab session. */
+export declare function setTabForTest(tab: TabSession): void;
+/** Test-only: clear the tab registry between cases. */
+export declare function clearTabsForTest(): void;
 export declare function acquireTab(name: string, browser: BrowserHandle, opts: AcquireTabOptions): Promise<AcquireTabResult>;
 export declare function runInTab(name: string, opts: RunInTabOptions): Promise<RunResultOk>;
 export declare function releaseTab(name: string, opts?: ReleaseTabOptions): Promise<boolean>;

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

@@ -0,0 +1,23 @@
+/** Prefix of every computer-use screenshot fallback directory created under the OS temp dir. */
+export declare const SCREENSHOT_FALLBACK_DIR_PREFIX = "gjc-computer-screenshots-";
+/** Lazy-arm marker: called when the first screenshot fallback dir is created this process. */
+export declare function markScreenshotFallbackDirCreatedForGc(): void;
+/** Whether any screenshot fallback dir has been created this process (GC lazy-arm gate). */
+export declare function hasCreatedScreenshotFallbackDir(): boolean;
+/** Test-only: reset the lazy-arm marker between cases. */
+export declare function resetScreenshotFallbackGcForTest(): void;
+export interface ScreenshotGcOptions {
+    now: () => number;
+    staleMs: number;
+    /** Base dir to scan; defaults to os.tmpdir(). Injectable for tests. */
+    tmpDir?: string;
+}
+/**
+ * Disk-only GC for stale computer-use screenshot fallback directories. Scans the temp dir for
+ * `gjc-computer-screenshots-*` directories and removes those whose mtime is older than `staleMs`.
+ * Never throws on a per-directory failure; the whole sweep is best-effort.
+ */
+export declare function cleanupStaleScreenshotFallbackDirs(options: ScreenshotGcOptions): Promise<{
+    scanned: number;
+    removed: number;
+}>;

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

@@ -5,18 +5,18 @@ import type { ToolSession } from "./index";
 export declare const MAX_CRON_TASKS_PER_OWNER = 50;
 /** Recurring tasks auto-expire 7 days after creation (mirrors upstream). */
 export declare const CRON_RECURRING_MAX_AGE_MS: number;
-declare const cronCreateSchema: z.ZodObject<{
-    cron_expression: z.ZodString;
-    prompt: z.ZodString;
-    recurring: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export type CronCreateParams = z.infer<typeof cronCreateSchema>;
-declare const cronListSchema: z.ZodObject<{}, z.core.$strip>;
-export type CronListParams = z.infer<typeof cronListSchema>;
-declare const cronDeleteSchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-export type CronDeleteParams = z.infer<typeof cronDeleteSchema>;
+declare const cronSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        list: "list";
+    }>;
+    cron_expression: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    recurring: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CronParams = z.infer<typeof cronSchema>;
 export interface CronJobSnapshot {
     id: string;
     cron_expression: string;
@@ -35,18 +35,14 @@ export interface CronListJobDetails {
     prompt: string;
     humanSchedule: string;
 }
-export interface CronCreateToolDetails {
-    id: string;
-    cron_expression: string;
-    recurring: boolean;
+export interface CronToolDetails {
+    op: "create" | "list" | "delete";
+    id?: string;
+    cron_expression?: string;
+    recurring?: boolean;
     nextFireAt?: number;
-}
-export interface CronListToolDetails {
-    jobs: CronListJobDetails[];
-}
-export interface CronDeleteToolDetails {
-    id: string;
-    deleted: boolean;
+    jobs?: CronListJobDetails[];
+    deleted?: boolean;
 }
 /** Clear every schedule for an owner. Exported for tests + lifecycle teardown. */
 export declare function clearOwnerSchedules(ownerId: string | undefined): void;
@@ -68,49 +64,28 @@ export declare function calculateCronFireTimeMs(params: {
     nowMs: number;
     expiresAt?: number;
 }): number;
-export declare class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCreateToolDetails> {
-    private readonly session;
-    readonly name = "CronCreate";
-    readonly label = "CronCreate";
-    readonly summary = "Schedule a prompt on a 5-field cron expression";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        cron_expression: z.ZodString;
-        prompt: z.ZodString;
-        recurring: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>;
-    readonly strict = true;
-    readonly loadMode = "discoverable";
-    constructor(session: ToolSession);
-    static createIf(session: ToolSession): CronCreateTool | null;
-    execute(_toolCallId: string, params: CronCreateParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronCreateToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronCreateToolDetails>>;
-}
-export declare class CronListTool implements AgentTool<typeof cronListSchema, CronListToolDetails> {
-    private readonly session;
-    readonly name = "CronList";
-    readonly label = "CronList";
-    readonly summary = "List scheduled cron jobs";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{}, z.core.$strip>;
-    readonly strict = true;
-    readonly loadMode = "discoverable";
-    constructor(session: ToolSession);
-    static createIf(session: ToolSession): CronListTool | null;
-    execute(_toolCallId: string, _params: CronListParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronListToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronListToolDetails>>;
-}
-export declare class CronDeleteTool implements AgentTool<typeof cronDeleteSchema, CronDeleteToolDetails> {
+export declare class CronTool implements AgentTool<typeof cronSchema, CronToolDetails> {
+    #private;
     private readonly session;
-    readonly name = "CronDelete";
-    readonly label = "CronDelete";
-    readonly summary = "Cancel a scheduled cron job by ID";
+    readonly name = "cron";
+    readonly label = "Cron";
+    readonly summary = "Schedule, list, and cancel cron-style prompts (op: create | list | delete)";
     readonly description: string;
     readonly parameters: z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>;
+        op: z.ZodEnum<{
+            create: "create";
+            delete: "delete";
+            list: "list";
+        }>;
+        cron_expression: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        recurring: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): CronDeleteTool | null;
-    execute(_toolCallId: string, params: CronDeleteParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronDeleteToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronDeleteToolDetails>>;
+    static createIf(session: ToolSession): CronTool | null;
+    execute(_toolCallId: string, params: CronParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronToolDetails>>;
 }
 export {};

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

@@ -41,7 +41,6 @@ export * from "./eval";
 export * from "./find";
 export * from "./gh";
 export * from "./image-gen";
-export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
 export * from "./monitor";

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

@@ -0,0 +1,54 @@
+import type { Settings } from "../config/settings";
+import { type TabGcSnapshot } from "./browser/tab-supervisor";
+export interface BrowserGcPolicy {
+    enabled: boolean;
+    idleMs: number;
+    rssLimitBytes: number;
+}
+export interface ComputerGcPolicy {
+    enabled: boolean;
+    staleMs: number;
+    scanIntervalMs: number;
+}
+export declare function resolveBrowserGcPolicy(settings: Settings): BrowserGcPolicy;
+export declare function resolveComputerGcPolicy(settings: Settings): ComputerGcPolicy;
+export declare function resolveSweepIntervalMs(settings: Settings): number;
+/** Injectable seams so the controller is fully testable without real browsers/filesystem/RSS. */
+export interface ResourceGcDeps {
+    now: () => number;
+    rssBytes: () => number;
+    logWarn: (msg: string, meta?: Record<string, unknown>) => void;
+    listTabs: () => TabGcSnapshot[];
+    releaseTab: (name: string, policy: {
+        now: () => number;
+        idleMs: number;
+    }) => Promise<boolean>;
+    cleanupScreenshots: (opts: {
+        now: () => number;
+        staleMs: number;
+    }) => Promise<{
+        scanned: number;
+        removed: number;
+    }>;
+    screenshotArmed: () => boolean;
+}
+export interface ResourceGcRegistration {
+    sessionId: string;
+    settings: Settings;
+}
+/**
+ * Register a session with the resource GC. Starts the single shared timer on the first
+ * registration. Returns an idempotent unregister function; the timer stops only when the last
+ * session unregisters.
+ */
+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 __runResourceGcTickForTest(): Promise<void>;
+export declare function __getResourceGcStateForTest(): {
+    timerActive: boolean;
+    sessionCount: number;
+    rssWarningActive: boolean;
+    inProgress: boolean;
+};
+export declare function __resetResourceGcForTest(): void;

package/dist/types/web/search/index.d.ts

@@ -111,5 +111,6 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
 export declare const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails>;
 export declare function getSearchTools(): CustomTool<any, any>[];
 export { getSearchProvider, setPreferredSearchProvider, setSearchFallbackProviders } from "./provider";
+export { setSearchHardTimeoutMs } from "./providers/utils";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
 export { isConfigurableSearchProviderId, isSearchProviderPreference } from "./types";