@sayknow-cli/coding-agent 0.2.7 → 0.3.1

package/dist/types/notifications/threaded-render.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pure rendering of threaded-session frames into Telegram send specs.
+ *
+ * The daemon receives the additive `ServerMessage` frames (identity_header,
+ * context_update, turn_stream, image_attachment, config_update) over the session
+ * WS and must turn each into a Bot API call scoped to the session's forum topic
+ * (`message_thread_id`), throttled through the shared rate-limit pool. This
+ * module is the pure frame→send mapping (including the priority lane and live-
+ * edit coalesce key), so rendering is unit-testable without a live Bot API.
+ */
+import type { RateLimitLane } from "./rate-limit-pool";
+/** A Telegram send derived from a threaded frame (topic id is applied by the daemon). */
+export interface ThreadedSend {
+    method: "sendMessage" | "sendPhoto" | "sendDocument";
+    /** Rate-limit lane for prioritisation/fairness. */
+    lane: RateLimitLane;
+    /** Message text (sendMessage) or photo caption (sendPhoto). */
+    text?: string;
+    /** Base64 image bytes for sendPhoto. */
+    photoBase64?: string;
+    /** Base64 file bytes for sendDocument. */
+    documentBase64?: string;
+    /** Image MIME type for sendPhoto. */
+    mime?: string;
+    /** Suggested document filename. */
+    fileName?: string;
+    /** Coalesce key for live edits (same key collapses to the latest). */
+    coalesceKey?: string;
+    /** True for the one-time identity header (the daemon pins it once). */
+    identity?: boolean;
+}
+interface ThreadedFrame {
+    type?: unknown;
+    sessionId?: unknown;
+    repo?: unknown;
+    branch?: unknown;
+    machine?: unknown;
+    title?: unknown;
+    lastMessage?: unknown;
+    task?: unknown;
+    goal?: unknown;
+    tokenUsage?: unknown;
+    model?: unknown;
+    diff?: unknown;
+    phase?: unknown;
+    text?: unknown;
+    messageRef?: unknown;
+    source?: unknown;
+    data?: unknown;
+    mime?: unknown;
+    caption?: unknown;
+    name?: unknown;
+    verbosity?: unknown;
+    redact?: unknown;
+}
+/** Format the one-time identity header as pinned bullets. */
+export declare function formatIdentityHeader(frame: {
+    repo?: unknown;
+    branch?: unknown;
+    machine?: unknown;
+    sessionId?: unknown;
+    title?: unknown;
+}): string;
+/** Format a streamed context update into a compact block (omitting empty fields). */
+export declare function formatContextUpdate(frame: ThreadedFrame): string | undefined;
+/**
+ * Map a threaded frame to a Telegram send spec, or `undefined` when there is
+ * nothing to send (e.g. an empty context update or an unknown frame type).
+ */
+export declare function renderThreadedFrame(frame: ThreadedFrame): ThreadedSend | undefined;
+export {};

package/dist/types/notifications/topic-registry.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Per-session forum-topic registry for the threaded session surface.
+ *
+ * Each SKC session owns exactly one Telegram forum topic in the paired private
+ * DM. The topic is created once (via `createForumTopic`) and REUSED on resume,
+ * keyed by session id, so a resumed session streams back into its existing
+ * thread/history. The registry also tracks whether the one-time identity header
+ * has already been pinned, so it is sent exactly once per topic even across
+ * reconnects.
+ *
+ * State is a plain serialisable map persisted beside the daemon state files;
+ * topic creation is injected so this module is pure and unit-testable without a
+ * live Bot API.
+ */
+/** Persisted record for one session's topic. */
+export interface TopicRecord {
+    /** Telegram forum topic id (message_thread_id). */
+    topicId: string;
+    /** Whether the one-time identity header has been sent/pinned. */
+    identitySent: boolean;
+    /** Creation timestamp (ms epoch). */
+    createdAt: number;
+    /** Last applied topic title (for rename detection). */
+    name?: string;
+}
+/** Serialisable shape persisted to disk. */
+export interface TopicRegistryState {
+    /** sessionId -> record. */
+    topics: Record<string, TopicRecord>;
+}
+export declare function emptyTopicRegistryState(): TopicRegistryState;
+/**
+ * In-memory registry over a serialisable state. Topic creation is injected via
+ * `getOrCreateTopic`'s `create` callback (the daemon supplies a real
+ * `createForumTopic` call); reuse-on-resume is automatic when a record exists.
+ */
+export declare class TopicRegistry {
+    private readonly topics;
+    /** Maps topicId -> sessionId for fast inbound routing. */
+    private readonly byTopic;
+    /** In-flight create promises, keyed by session, to dedupe concurrent creates. */
+    private readonly inflight;
+    constructor(state?: TopicRegistryState);
+    /** Merge a serialized state into this registry, preserving all persisted fields. */
+    load(state: TopicRegistryState): void;
+    /** Resolve the owning session for a topic id (for fail-closed inbound routing). */
+    sessionForTopic(topicId: string): string | undefined;
+    /** The existing topic record for a session, if any. */
+    get(sessionId: string): TopicRecord | undefined;
+    /**
+     * Return the existing topic for `sessionId`, or create one via `create`
+     * (called only on first use). Reuse-on-resume: an existing record is
+     * returned without invoking `create`.
+     */
+    getOrCreateTopic(sessionId: string, create: () => Promise<string>, now?: () => number): Promise<TopicRecord>;
+    /** Mark the identity header as sent for a session. Idempotent. */
+    markIdentitySent(sessionId: string): void;
+    /** Whether the identity header still needs sending for this session. */
+    needsIdentity(sessionId: string): boolean;
+    /**
+     * Record the topic's applied title. Returns `true` when it changed (so the
+     * caller should `editForumTopic`), `false` when already current or unknown.
+     */
+    applyName(sessionId: string, name: string): boolean;
+    /** Serialise for atomic persistence beside the daemon state. */
+    serialize(): TopicRegistryState;
+}

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

@@ -31,5 +31,17 @@ export declare function buildRlmGoalObjective(input: {
 }): string;
 export declare function isRlmAutonomousRun(parsed: Pick<Args, "print" | "mode" | "messages">, pipedStdin: boolean): boolean;
 export declare function prepareRlmLaunchMode(parsed: Args, pipedStdin: boolean): boolean;
+/**
+ * RLM artifacts are scoped under a SKC session directory and resolving their
+ * paths is a *write* (it must pick a concrete session). When `skc rlm` runs
+ * standalone — no parent agent, no `SKC_SESSION_ID` in the environment — there is
+ * no session to resolve and `resolveSkcSessionForWrite` throws
+ * `missing_for_write`. Establish a dedicated SKC session id in that case and pin
+ * it into the environment so artifact-path resolution, the per-session activity
+ * marker, and the child agent's workflow state all share one writable session.
+ *
+ * Returns the resolved (existing or freshly generated) SKC session id.
+ */
+export declare function ensureRlmSkcSessionId(): string;
 export declare function runRlmCommand(argv: string[]): Promise<void>;
 export {};

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

@@ -71,7 +71,7 @@ import { type AgentRegistry } from "../registry/agent-registry";
 import { type DiscoverableMCPSearchIndex, type DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 import { type SecretObfuscator } from "../secrets/obfuscator";
 import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
-import type { ToolSession } from "../tools";
+import type { AskAnswerSource, ToolSession } from "../tools";
 import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
 import type { ClientBridge } from "./client-bridge";
@@ -81,6 +81,7 @@ import type { BranchSummaryEntry, NewSessionOptions, SessionContext, SessionMana
 import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
 /** Session-specific events that extend the core AgentEvent */
+export type AutoCompactionContinuationSkipReason = "auto_continue_disabled_non_resumable_tail";
 export type AgentSessionEvent = AgentEvent | {
     type: "auto_compaction_start";
     reason: "threshold" | "overflow" | "idle";
@@ -94,6 +95,7 @@ export type AgentSessionEvent = AgentEvent | {
     errorMessage?: string;
     /** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
     skipped?: boolean;
+    continuationSkipReason?: AutoCompactionContinuationSkipReason;
 } | {
     type: "auto_retry_start";
     attempt: number;
@@ -128,6 +130,9 @@ export type AgentSessionEvent = AgentEvent | {
 } | {
     type: "irc_message";
     message: CustomMessage;
+} | {
+    type: "subagent_steer_message";
+    message: CustomMessage;
 } | {
     type: "notice";
     level: "info" | "warning" | "error";
@@ -558,6 +563,7 @@ export declare class AgentSession {
     getGoalModeState(): GoalModeState | undefined;
     setGoalModeState(state: GoalModeState | undefined): void;
     getWorkflowGateEmitter(): WorkflowGateEmitter | undefined;
+    getAskAnswerSource(): AskAnswerSource | undefined;
     setWorkflowGateEmitter(emitter: WorkflowGateEmitter | undefined): void;
     get goalRuntime(): GoalRuntime;
     markPlanReferenceSent(): void;
@@ -713,12 +719,38 @@ export declare class AgentSession {
     }): Promise<void>;
     setActiveModelProfile(name: string | undefined): void;
     getActiveModelProfile(): string | undefined;
+    /**
+     * The model selector ("provider/id") that resume restores as the session
+     * default — the latest session-log `model_change` with role="default".
+     * Model-profile activation snapshots this before mutating the session so a
+     * failed-activation rollback can restore the pre-activation resume default
+     * instead of promoting a transient runtime model to the resume default.
+     */
+    getSessionDefaultModelSelector(): string | undefined;
+    /**
+     * Re-assert the session resume default ("provider/id") in the session log
+     * WITHOUT touching the live runtime model. Appends a `model_change` with
+     * role="default"; never writes to global settings (apply-for-this-session
+     * semantics). Used by model-profile activation rollback to neutralize the
+     * profile main model the failed activation already recorded as the default.
+     */
+    recordResumeDefaultModel(selector: string): void;
     /**
      * Set model temporarily (for this session only).
      * Validates API key, saves to session log but NOT to settings.
+     *
+     * The change is recorded in the session log as `role: "temporary"` by
+     * default, which means it is NOT restored as the session default on resume —
+     * transient retry/fallback/context-promotion/plan switches must not clobber
+     * the user's explicit pick (issue #849). Model-profile activation passes
+     * `persistAsSessionDefault: true` so the profile's main model becomes the
+     * session default and survives resume, while still not being written to
+     * global settings (new sessions keep the global default).
      * @throws Error if no API key available for the model
      */
-    setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel): Promise<void>;
+    setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel, options?: {
+        persistAsSessionDefault?: boolean;
+    }): Promise<void>;
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -946,6 +978,13 @@ export declare class AgentSession {
      * Does not persist the record to history. Public so other sessions can forward.
      */
     emitIrcRelayObservation(record: CustomMessage): void;
+    emitSubagentSteerObservation(args: {
+        from: string;
+        to: string;
+        body: string;
+        timestamp?: number;
+    }): void;
+    emitSubagentSteerRelayObservation(record: CustomMessage): void;
     /**
      * Run a single ephemeral side-channel turn against this session's current
      * model + system prompt + history.  No tools are used; the side request

package/dist/types/session/auth-storage.d.ts

@@ -2,5 +2,5 @@
  * Re-exports from @sayknow-cli/ai.
  * All credential storage types and the AuthStorage class now live in the ai package.
  */
-export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialStore, AuthStorageData, AuthStorageOptions, OAuthCredential, SerializedAuthStorage, StoredAuthCredential, } from "@sayknow-cli/ai";
+export type { ApiKeyCredential, AuthCredential, AuthCredentialEntry, AuthCredentialIfAbsentReason, AuthCredentialIfAbsentResult, AuthCredentialIfAbsentSnapshotResult, AuthCredentialStore, AuthStorageData, AuthStorageOptions, OAuthCredential, SerializedAuthStorage, StoredAuthCredential, } from "@sayknow-cli/ai";
 export { AuthBrokerClient, AuthStorage, REMOTE_REFRESH_SENTINEL, RemoteAuthCredentialStore, SqliteAuthCredentialStore, } from "@sayknow-cli/ai";

package/dist/types/setup/credential-auto-import.d.ts

@@ -0,0 +1,63 @@
+import type { AuthCredentialIfAbsentReason, AuthCredentialIfAbsentSnapshotResult, AuthStorage } from "@sayknow-cli/ai";
+import type { ModelRegistry } from "../config/model-registry";
+import { type CredentialDiscoveryResult, type CredentialOrigin, type DiscoveryOptions, type ImportableCredential } from "./credential-import";
+export declare const CREDENTIAL_AUTO_IMPORT_ROTATION_WARNING = "Refreshing in skc may log out the Claude/Codex CLI because OAuth refresh tokens can rotate.";
+export type CredentialAutoImportSourceLabel = "claude-code-file" | "claude-code-keychain" | "codex-file";
+export type CredentialAutoImportTrigger = "startup" | "bare-login" | "setup-cli";
+export declare function getCredentialAutoImportStatePath(agentDir?: string): string;
+export declare function readCredentialImportMarker(agentDir?: string): Promise<string | undefined>;
+export declare function writeCredentialImportMarker(version: string, agentDir?: string): Promise<boolean>;
+export declare enum CredentialAutoImportFailureClass {
+    DiscoveryUnavailable = "discovery-unavailable",
+    SourceUnreadable = "source-unreadable",
+    SourceMalformed = "source-malformed",
+    KeychainDenied = "keychain-denied",
+    WriteInvalid = "write-invalid",
+    WriteConflict = "write-conflict",
+    BrokerUnavailable = "broker-unavailable",
+    BrokerUnsupported = "broker-unsupported",
+    Unknown = "unknown"
+}
+export interface CredentialAutoImportSkipped {
+    credential: ImportableCredential;
+    reason: AuthCredentialIfAbsentReason;
+    entries: AuthCredentialIfAbsentSnapshotResult["entries"];
+}
+export interface CredentialAutoImportFailure {
+    credential?: ImportableCredential;
+    origin?: CredentialOrigin;
+    source?: string;
+    failureClass: CredentialAutoImportFailureClass;
+}
+export interface CredentialAutoImportResult {
+    imported: ImportableCredential[];
+    skipped: CredentialAutoImportSkipped[];
+    failures: CredentialAutoImportFailure[];
+    discovered: boolean;
+    discovery?: CredentialDiscoveryResult;
+    globalDiscoveryFailure?: CredentialAutoImportFailure;
+}
+export type CredentialAutoImportAuthStorage = Pick<AuthStorage, "importCredentialIfAbsent">;
+export interface CredentialAutoImportOptions {
+    authStorage: CredentialAutoImportAuthStorage;
+    discover?: (options?: DiscoveryOptions) => Promise<CredentialDiscoveryResult>;
+    discoveryOptions?: DiscoveryOptions;
+    trigger: CredentialAutoImportTrigger;
+    sourceLabel?: CredentialAutoImportSourceLabel;
+}
+export declare function runExternalCredentialAutoImport({ authStorage, discover, discoveryOptions }: CredentialAutoImportOptions): Promise<CredentialAutoImportResult>;
+export declare function buildCredentialAutoImportNotice(result: Pick<CredentialAutoImportResult, "imported">): string | undefined;
+export declare function formatCredentialAutoImportResult(result: CredentialAutoImportResult): string[];
+export interface CredentialImportMarkerStore {
+    read: () => Promise<string | undefined> | string | undefined;
+    write: (version: string) => Promise<boolean> | boolean;
+}
+export interface StartupCredentialAutoImportOptions {
+    authStorage: CredentialAutoImportOptions["authStorage"];
+    modelRegistry: Pick<ModelRegistry, "refresh">;
+    discover?: CredentialAutoImportOptions["discover"];
+    version?: string;
+    agentDir?: string;
+    markerStore?: CredentialImportMarkerStore;
+}
+export declare function runStartupCredentialAutoImportIfNeeded({ authStorage: activeAuthStorage, modelRegistry: activeModelRegistry, discover, version, agentDir, markerStore }: StartupCredentialAutoImportOptions): Promise<string | undefined>;

package/dist/types/setup/credential-import.d.ts

@@ -3,6 +3,7 @@ import type { AuthCredential } from "@sayknow-cli/ai";
 export type ExternalProvider = "anthropic" | "openai-codex";
 /** Where a discovered credential came from. */
 export type CredentialOrigin = "claude-code-file" | "claude-code-keychain" | "codex-file";
+export declare const AUTO_IMPORT_OAUTH_PROVIDER_ORIGINS: Record<ExternalProvider, ReadonlySet<CredentialOrigin>>;
 /** Human labels for providers, used in redacted summaries. */
 export declare const EXTERNAL_PROVIDER_LABELS: Record<ExternalProvider, string>;
 /** A credential that can be safely imported into skc's store. */
@@ -72,6 +73,8 @@ export declare function discoverExternalCredentials(options?: DiscoveryOptions):
 export declare function formatCredentialSummary(credential: ImportableCredential): string;
 /** Redacted summary lines for an entire discovery result. Never includes secrets. */
 export declare function formatDiscoverySummary(result: CredentialDiscoveryResult): string[];
+export declare function isAutoImportOAuthCredential(credential: ImportableCredential): boolean;
+export declare function filterAutoImportOAuthCredentials(credentials: readonly ImportableCredential[]): ImportableCredential[];
 /**
  * Persist discovered credentials via `upsert`. Each credential is imported
  * independently; a failure on one is recorded without aborting the rest.

package/dist/types/setup/host-plugin-setup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Host plugin setup for `skc setup claude` and `skc setup codex`.
+ *
+ * Renders install guidance and a fail-closed coordinator MCP config preview for
+ * the canonical generated plugin bundle under `plugins/`. This is intentionally
+ * render-only and fail-closed: the workdir allowlist is scoped to the project
+ * root and no mutation class is enabled until the user opts in.
+ */
+export type HostPluginKind = "claude" | "codex";
+export interface HostPluginSetupFlags {
+    json?: boolean;
+    check?: boolean;
+    root?: string[];
+    repo?: string;
+}
+export interface HostPluginSetupResult {
+    ok: true;
+    host: HostPluginKind;
+    mode: "render";
+    gated: boolean;
+    pluginPath: string;
+    manifestPath: string;
+    marketplacePath: string;
+    installGuidance: string[];
+    coordinatorConfigPreview: {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    };
+    mutationPolicy: string;
+    notes: string[];
+    check?: {
+        ok: boolean;
+        checked: string[];
+        missing: string[];
+    };
+}
+export declare function buildHostPluginSetup(host: HostPluginKind, flags?: HostPluginSetupFlags): HostPluginSetupResult;
+export declare function formatHostPluginSetup(result: HostPluginSetupResult): string;

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

@@ -69,6 +69,7 @@ export interface SkcTmuxProfileContext {
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    version?: string | null;
 }
 export declare function applySkcTmuxProfile(context: SkcTmuxProfileContext): SkcTmuxProfileResult;
 export declare function buildSkcTmuxWindowTitle(cwd: string, branch: string | null | undefined): string;

package/dist/types/skc-runtime/ralplan-runtime.d.ts

@@ -12,7 +12,7 @@
  *
  * 2. **Artifact write**: `skc ralplan --write --stage <type> --stage_n <N> --artifact
  *    <path-or-string> [--run-id <id>] [--session-id <id>] [--json]` persists Planner / Architect
- *    / Critic / revision / ADR / final markdown under `.skc/plans/ralplan/<run-id>/`, maintains
+ *    / Critic / revision / post-interview / ADR / final markdown under `.skc/plans/ralplan/<run-id>/`, maintains
  *    an `index.jsonl` audit log, copies `final` stages to `pending-approval.md`, and advances
  *    the HUD chip to reflect the latest persisted stage.
  */

package/dist/types/skc-runtime/state-writer.d.ts

@@ -66,10 +66,12 @@ export interface GuardedStateWriterOptions extends StateWriterOptions {
 export type GuardedWriteResult = {
     path: string;
     written: true;
+    revision: number;
 } | {
     path: string;
     written: false;
     reason: "stale-skip";
+    revision: number;
 };
 export interface StateWriterOptions {
     cwd?: string;

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

@@ -10,6 +10,7 @@ export declare const SKC_TMUX_BRANCH_SLUG_OPTION = "@skc-branch-slug";
 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 interface SkcTmuxProfileCommand {
     description: string;
     args: string[];
@@ -50,6 +51,7 @@ export declare function buildSkcTmuxRequiredProfileCommands(target: string, meta
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    version?: string | null;
 }): SkcTmuxProfileCommand[];
 export declare function buildSkcTmuxProfileCommands(target: string, env?: NodeJS.ProcessEnv, metadata?: {
     branch?: string | null;
@@ -57,5 +59,6 @@ export declare function buildSkcTmuxProfileCommands(target: string, env?: NodeJS
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    version?: string | null;
 }): SkcTmuxProfileCommand[];
 export declare function normalizeTmuxCreatedAt(raw: string): string;

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

@@ -10,6 +10,7 @@ export interface SkcTmuxSessionStatus {
     project?: string;
     sessionId?: string;
     sessionStateFile?: string;
+    version?: string;
     panePids: number[];
     profile?: string;
 }
@@ -20,6 +21,7 @@ export interface SkcTmuxSessionTagsForGc {
     branchSlug?: string;
     sessionId?: string;
     sessionStateFile?: string;
+    version?: string;
     createdAt?: string;
     attached?: boolean;
     panePids?: number[];

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

@@ -27,10 +27,25 @@ export declare function validateCompletionReceipt(input: {
 export declare function readUltragoalVerificationState(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
+    sessionId?: string | null;
 }): Promise<UltragoalGuardDiagnostic>;
 export declare function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic>;
 export declare function assertCanCompleteCurrentGoal(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
+    sessionId?: string | null;
 }): Promise<void>;
 export declare function isUltragoalBypassPrompt(prompt: string): boolean;
+export interface UltragoalPauseBlockDiagnostic {
+    blocked: boolean;
+    reason: string;
+}
+/**
+ * While an Ultragoal run is active, `goal({"op":"pause"})` is only allowed when the
+ * current durable Ultragoal state is readable and the latest durable ledger event
+ * classifies the current blocker as `human_blocked`. Resolvable blockers must be
+ * worked, not parked. Reads fail closed so unreadable durable state or ledger data
+ * blocks pause rather than silently allowing a give-up.
+ */
+export declare function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPauseBlockDiagnostic>;
+export declare function assertUltragoalPauseAllowed(cwd: string): Promise<void>;

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

@@ -193,6 +193,19 @@ export declare function recordUltragoalReviewBlockers(input: {
     evidence: string;
     skcGoalJson?: string;
 }): Promise<UltragoalPlan>;
+export type UltragoalBlockerClassification = "human_blocked" | "resolvable";
+/**
+ * Record an audited blocker triage classification in the durable ledger. A
+ * `human_blocked` classification is the only thing that authorizes
+ * `goal({"op":"pause"})` while an Ultragoal run is active; `resolvable` is an
+ * audit note and never unblocks pause.
+ */
+export declare function recordUltragoalBlockerClassification(input: {
+    cwd: string;
+    classification: UltragoalBlockerClassification;
+    evidence: string;
+    goalId?: string;
+}): Promise<UltragoalLedgerEvent>;
 type UltragoalReviewContractStrength = "strong" | "thin-derived";
 interface UltragoalReviewFinding extends JsonObject {
     severity: "blocker";
@@ -208,6 +221,7 @@ interface UltragoalReviewResult extends JsonObject {
     weakContractCapApplied: boolean;
     blockerGoalIds?: string[];
 }
+export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
 export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;
 export {};

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

@@ -0,0 +1,13 @@
+/**
+ * Process-wide registry mapping a session id to its active {@link AskAnswerSource}.
+ *
+ * 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.
+ */
+import type { AskAnswerSource } from "./index";
+/** Register `source` for `sessionId`. Returns a disposer that clears it. */
+export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;
+/** The answer source for `sessionId`, if one is registered. */
+export declare function getAskAnswerSource(sessionId: string): AskAnswerSource | undefined;

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

@@ -1,8 +1,10 @@
 import type { AgentToolResult } from "@sayknow-cli/agent-core";
 import { type Component } from "@sayknow-cli/tui";
+import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
+import type { RenderResult } from "../web/scrapers/types";
 import { type OutputMeta } from "./output-meta";
 export declare function isReadableUrlPath(value: string): boolean;
 export interface ParsedReadUrlTarget {
@@ -16,6 +18,27 @@ interface FetchImagePayload {
     data: string;
     mimeType: string;
 }
+type FetchRenderResult = RenderResult & {
+    image?: FetchImagePayload;
+};
+/**
+ * Opt-in insane-search fallback for blocked / degraded public URL reads.
+ *
+ * Returns a finalized `method: "insane"` result on success, or null (so the
+ * caller continues with its normal degraded behavior). Fail-closed: no note,
+ * guard DNS, dependency probe, or subprocess when raw mode or the opt-in
+ * setting is off. The public-URL guard runs BEFORE any probe/spawn.
+ */
+export declare function tryInsaneFallback(args: {
+    url: string;
+    finalUrl: string;
+    timeout: number;
+    raw: boolean;
+    settings: Settings;
+    signal: AbortSignal | undefined;
+    fetchedAt: string;
+    notes: string[];
+}): Promise<FetchRenderResult | null>;
 export interface ReadUrlToolDetails {
     kind: "url";
     url: string;

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

@@ -55,6 +55,7 @@ export * from "./search-tool-bm25";
 export * from "./skill";
 export * from "./ssh";
 export * from "./subagent";
+export * from "./telegram-send";
 export * from "./todo-write";
 export * from "./vim";
 export * from "./write";
@@ -68,6 +69,17 @@ export type ContextFileEntry = {
 };
 export type { DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
+/**
+ * Source of remote answers for interactive asks (e.g. a Telegram reply routed
+ * through the notifications SDK). Lets a pending ask resolve without RPC mode.
+ */
+export interface AskAnswerSource {
+    /**
+     * Race a remote answer against the local UI for one question. Resolves with the
+     * chosen option label or free-text answer, or `undefined` to defer to local UI.
+     */
+    awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
+}
 /** Session context for tool factories */
 export interface ToolSession {
     /** Current working directory */
@@ -167,6 +179,13 @@ export interface ToolSession {
     getGoalModeState?: () => GoalModeState | undefined;
     /** Unattended workflow-gate emitter (present only when unattended mode is negotiated). */
     getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
+    /**
+     * Optional remote answer source for interactive asks. When present, the ask
+     * tool races the local UI selection against a remote answer (e.g. a Telegram
+     * reply via the notifications SDK) so asks can be answered without RPC mode.
+     * No-op when undefined: the ask path behaves exactly as before.
+     */
+    getAskAnswerSource?: () => AskAnswerSource | undefined;
     /** Optional per-session restriction for goal tool operations. */
     goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
     /** Goal runtime for the active agent session. */

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

@@ -42,6 +42,9 @@ export interface SubagentSnapshot {
     outputRef?: string;
     truncated?: boolean;
     guidance?: string;
+    steerMessage?: string;
+    steerState?: "queued" | "resume_queued" | "resume_started";
+    steerPauseRequested?: boolean;
     /** Live streaming progress for the awaited subagent (await panel only; UI detail). */
     progress?: AgentProgress;
     /** True when a live in-session progress producer exists for this subagent. */

package/dist/types/tools/telegram-send.d.ts

@@ -0,0 +1,32 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import { z } from "zod/v4";
+import type { ToolSession } from "./index";
+declare const telegramSendSchema: z.ZodObject<{
+    path: z.ZodString;
+    caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TelegramSendParams = z.infer<typeof telegramSendSchema>;
+interface TelegramSendDetails {
+    path: string;
+    caption?: string;
+    ok: boolean;
+    error?: string;
+}
+export declare class TelegramSendTool implements AgentTool<typeof telegramSendSchema, TelegramSendDetails> {
+    private readonly session;
+    readonly name = "telegram_send";
+    readonly label = "TelegramSend";
+    readonly summary = "Send a workspace file to Telegram";
+    readonly loadMode = "discoverable";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        path: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): TelegramSendTool | null;
+    private resolveContainedFile;
+    execute(_toolCallId: string, params: TelegramSendParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TelegramSendDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TelegramSendDetails>>;
+}
+export {};