@sayknow-cli/coding-agent 0.3.1 → 0.3.4

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

@@ -1,3 +1,4 @@
+import type { ResolvedTmuxBinary } from "./psmux-detect";
 export declare const SKC_DEFAULT_TMUX_SESSION = "sayknow_cli";
 export declare const SKC_TMUX_SESSION_PREFIX = "sayknow_cli_";
 export declare const SKC_TMUX_COMMAND_ENV = "SKC_TMUX_COMMAND";
@@ -11,6 +12,7 @@ export declare const SKC_TMUX_PROJECT_OPTION = "@skc-project";
 export declare const SKC_TMUX_SESSION_ID_OPTION = "@skc-session-id";
 export declare const SKC_TMUX_SESSION_STATE_FILE_OPTION = "@skc-session-state-file";
 export declare const SKC_TMUX_VERSION_OPTION = "@skc-version";
+export declare const SKC_PSMUX_PROFILE_FORCE_ENV = "SKC_PSMUX_PROFILE_FORCE";
 export interface SkcTmuxProfileCommand {
     description: string;
     args: string[];
@@ -23,7 +25,26 @@ export interface TmuxCommandResult {
 }
 export type TmuxCommandRunner = (args: string[]) => TmuxCommandResult;
 export declare function envDisabled(value: string | undefined): boolean;
-export declare function resolveSkcTmuxCommand(env?: NodeJS.ProcessEnv): string;
+/**
+ * Resolve the tmux (or tmux-compatible multiplexer) command SKC should invoke.
+ *
+ * This is the shared entry point used by every SKC code path that needs to talk
+ * to a multiplexer: `skc --tmux` planning, `skc session ...`, `skc team ...`,
+ * the lifecycle controller, and the harness resident owner. Routing all of
+ * them through the same resolver means a single `SKC_TMUX_COMMAND` override or
+ * a single Windows psmux / pmux detection wins for the whole process — the
+ * failure mode where `skc --tmux` creates a psmux-backed session and then
+ * `skc session status` fails because it queries literal `tmux` is closed off.
+ *
+ * Explicit `SKC_TMUX_COMMAND` / `SKC_TEAM_TMUX_COMMAND` overrides are honored on
+ * every platform. On native Windows without an override the resolver walks
+ * `psmux`, then `pmux`, then `tmux` and uses the first binary present on PATH.
+ * On POSIX the resolver returns `tmux` (the historical default) and only
+ * falls through to the platform-aware walker if the caller opts in.
+ */
+export declare function resolveSkcTmuxCommand(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export type { PsmuxProbe, ResolvedTmuxBinary, ResolveSkcTmuxBinaryOptions } from "./psmux-detect";
+export { clearPsmuxDetectionCache, detectPsmux, probePsmux, resolveSkcTmuxBinary } from "./psmux-detect";
 /**
  * Build the exact-session target for tmux *option* commands
  * (`show-options` / `set-option`) and `display-message -t`.
@@ -34,7 +55,11 @@ export declare function resolveSkcTmuxCommand(env?: NodeJS.ProcessEnv): string;
  * keeps the exact-session match while giving tmux the window-qualified target
  * those commands require. See sayknow-cli#580.
  */
-export declare function buildSkcTmuxExactOptionTarget(sessionName: string): string;
+export declare function buildSkcTmuxExactOptionTarget(sessionName: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    binary?: ResolvedTmuxBinary;
+}): string;
 export declare const SKC_TMUX_UNTAGGED_REASON = "skc_tmux_session_untagged";
 export declare function buildSkcTmuxUntaggedSessionHint(tmuxCommand: string): string;
 export declare function buildSkcTmuxUntaggedSessionError(sessionName: string, tmuxCommand: string): string;
@@ -60,5 +85,8 @@ export declare function buildSkcTmuxProfileCommands(target: string, env?: NodeJS
     sessionId?: string | null;
     sessionStateFile?: string | null;
     version?: string | null;
+}, opts?: {
+    platform?: NodeJS.Platform;
+    tmuxCommand?: string;
 }): SkcTmuxProfileCommand[];
 export declare function normalizeTmuxCreatedAt(raw: string): string;

package/dist/types/skc-runtime/tmux-sessions.d.ts

@@ -41,4 +41,22 @@ export declare function createSkcTmuxSession(env?: NodeJS.ProcessEnv): SkcTmuxSe
 /** @internal */
 export declare function readTmuxSessionTagsForGc(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionTagsForGc;
 export declare function removeSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus;
+/**
+ * Force-close a SKC-managed tmux session, even if a live pane is attached.
+ *
+ * This is the lifecycle-control counterpart to {@link removeSkcTmuxSession}: it
+ * intentionally does NOT refuse live/attached panes (hard-kill is the contract),
+ * but it keeps every safety check so it can only ever kill a genuinely
+ * SKC-managed session:
+ * - re-reads the exact tmux profile immediately before kill (never a non-SKC
+ *   session, even one that collides by name);
+ * - when `expectedSessionId` is given, requires the `@skc-session-id` tag match;
+ * - when `expectedStateFile` is given, requires the `@skc-session-state-file`
+ *   tag match.
+ *
+ * Returns the prior status (for audit). Throws a tagged error otherwise:
+ * `skc_tmux_session_not_found`, `skc_tmux_session_not_managed`,
+ * `skc_tmux_session_id_mismatch`, or `skc_tmux_session_state_file_mismatch`.
+ */
+export declare function forceCloseSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string): SkcTmuxSessionStatus;
 export declare function attachSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): never;

package/dist/types/skc-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/skc-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 `./.skc/settings.json` overrides the
+ * user settings (`$SKC_CONFIG_DIR/settings.json` or `~/.skc/settings.json`), else the
+ * default. Mirrors the `skc.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/slash-commands/helpers/fast-status-report.d.ts

@@ -37,6 +37,12 @@ export interface FastStatusSessionLike {
     readonly model?: Model;
     /** Fast predicate against the main session tier (current model + `modelRoles`). */
     isFastForProvider(provider?: string): boolean;
+    /**
+     * Current-model EFFECTIVE fast state (intent minus any provider auto-disable).
+     * Used for the current-model row so it matches what the next request does.
+     * Optional so lightweight fakes can omit it; falls back to `isFastForProvider`.
+     */
+    isFastModeActive?(): boolean;
     /** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
     isFastForSubagentProvider(provider?: string): boolean;
     resolveRoleModelWithThinking(role: string): {

package/dist/types/system-prompt.d.ts

@@ -47,6 +47,8 @@ export interface BuildSystemPromptOptions {
     toolNames?: string[];
     /** Text to append to system prompt. */
     appendSystemPrompt?: string;
+    /** Rendered SKC plugin system-appendix blocks (lower-authority, appended last). */
+    pluginAppendices?: string;
     /** Repeat full tool descriptions in system prompt. Default: false */
     repeatToolDescriptions?: boolean;
     /** Skills settings for discovery. */

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

@@ -4,6 +4,7 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@sayknow-cli/agent-core";
+import type { ServiceTier } from "@sayknow-cli/ai";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
@@ -58,6 +59,13 @@ export interface ExecutorOptions {
     authStorage?: AuthStorage;
     modelRegistry?: ModelRegistry;
     settings?: Settings;
+    /**
+     * Live service-tier intent of the parent session (`AgentSession.serviceTier`),
+     * used as the inherited tier when `task.serviceTier === "inherit"`. Passing the
+     * live value (not the stale settings snapshot) lets a runtime `/fast on` reach
+     * subagents, and a main-model fast-mode auto-disable does not clobber it.
+     */
+    inheritedServiceTier?: ServiceTier;
     /** Override local:// protocol options so subagent shares parent's local:// root */
     localProtocolOptions?: LocalProtocolOptions;
     /**
@@ -105,7 +113,7 @@ interface FinalizeSubprocessOutputResult {
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
-export declare function createSubagentSettings(baseSettings: Settings): Settings;
+export declare function createSubagentSettings(baseSettings: Settings, inheritedServiceTier?: ServiceTier): Settings;
 /**
  * Run a single agent in-process.
  */

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/composer-bash-policy.d.ts

@@ -0,0 +1,14 @@
+export declare const COMPOSER_BASH_POLICY_ERROR = "Composer bash policy blocked repository file I/O. Use find, search, read, and edit tools for file discovery, file inspection, and file mutation.";
+type ComposerBashPolicyResult = {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: string;
+    message: string;
+};
+export declare function isComposerBashPolicyModel(modelId: string | undefined): boolean;
+export declare function checkComposerBashPolicy(input: {
+    modelId?: string;
+    commands: readonly string[];
+}): ComposerBashPolicyResult;
+export {};

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 = "skc-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
+ * `skc-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

@@ -1,5 +1,5 @@
 import type { AgentTelemetryConfig, AgentTool } from "@sayknow-cli/agent-core";
-import type { Model, ToolChoice } from "@sayknow-cli/ai";
+import type { Model, ServiceTier, ToolChoice } from "@sayknow-cli/ai";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -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";
@@ -173,6 +172,8 @@ export interface ToolSession {
     agentOutputManager?: AgentOutputManager;
     /** Settings instance for passing to subagents */
     settings: Settings;
+    /** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
+    serviceTier?: ServiceTier;
     /** Plan mode state (if active) */
     getPlanModeState?: () => PlanModeState | undefined;
     /** Goal mode state (if active or paused) */

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/utils/changelog.d.ts

@@ -25,6 +25,7 @@ export declare function parseChangelog(changelogPath: string): Promise<Changelog
  * binary-identity changelog).
  */
 export declare function getDisplayChangelogEntries(): ChangelogEntry[];
+export declare function getInstalledVersionChangelogEntry(entries: readonly ChangelogEntry[], installedVersion: string): ChangelogEntry | undefined;
 /**
  * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
  */

package/dist/types/web/insane/url-guard.d.ts

@@ -13,10 +13,13 @@ export type AddressResolver = (hostname: string) => Promise<string[]>;
 /** True for any address that is not a routable public unicast address. */
 export declare function isPrivateOrSpecialAddress(address: string): boolean;
 /**
- * Validate that `rawUrl` is a public http/https target safe to hand to the
- * insane-search engine. Resolves DNS names and rejects any that map to a
- * private/special address. Never throws; returns a discriminated result.
+ * Validate that `rawUrl` is a public http/https target. Resolves DNS names and
+ * rejects any that map to a private/special address. Never throws; returns a
+ * discriminated result.
  */
+export declare function validatePublicHttpUrl(rawUrl: string, options?: {
+    resolver?: AddressResolver;
+}): Promise<PublicUrlResult>;
 export declare function validatePublicHttpUrlForInsane(rawUrl: string, options?: {
     resolver?: AddressResolver;
 }): Promise<PublicUrlResult>;

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

@@ -1,4 +1,5 @@
 import type { AgentStorage } from "../../session/agent-storage";
+import type { AddressResolver } from "../insane/url-guard";
 export { formatNumber } from "@sayknow-cli/utils";
 export interface RenderResult {
     url: string;
@@ -27,6 +28,9 @@ export interface LoadPageOptions {
     body?: string;
     maxBytes?: number;
     signal?: AbortSignal;
+    publicUrlGuard?: boolean;
+    resolver?: AddressResolver;
+    maxRedirects?: number;
 }
 export interface LoadPageResult {
     content: string;
@@ -34,6 +38,7 @@ export interface LoadPageResult {
     finalUrl: string;
     ok: boolean;
     status?: number;
+    error?: string;
 }
 /**
  * Fetch a page with timeout and size limit

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

@@ -1,5 +1,6 @@
 import { isRecord } from "@sayknow-cli/utils";
 export { isRecord };
+import type { AddressResolver } from "../insane/url-guard";
 export declare function asRecord(value: unknown): Record<string, unknown> | null;
 export declare function asString(value: unknown): string | null;
 export declare function asNumber(value: unknown): number | null;
@@ -12,10 +13,15 @@ export type BinaryFetchResult = BinaryFetchSuccess | {
     ok: false;
     error?: string;
 };
+export interface FetchBinaryOptions {
+    publicUrlGuard?: boolean;
+    resolver?: AddressResolver;
+    maxRedirects?: number;
+}
 /**
  * Fetch binary content from a URL
  */
-export declare function fetchBinary(url: string, timeout?: number, signal?: AbortSignal): Promise<BinaryFetchResult>;
+export declare function fetchBinary(url: string, timeout?: number, signal?: AbortSignal, options?: FetchBinaryOptions): Promise<BinaryFetchResult>;
 /**
  * Convert binary content to markdown using markit.
  */