@gajae-code/coding-agent 0.6.5 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-06-22
+
+### Added
+
+- Notifications SDK with configure-once Telegram UX: each session exposes a loopback WebSocket endpoint with a discovery file and a generic `action_needed`/`reply` JSON protocol, so any client (Telegram, Discord, Slack, mobile) can see action-needed signals and answer pending asks without RPC or terminal scraping (#874).
+- Managed Telegram reference daemon with a threaded per-session surface: one-time identity header, streamed `context_update` (last message, task, goal, token/model usage, diff), live/finalized turn output, and agent image streaming (`image_attachment` + multipart `sendPhoto`).
+- Typing indicator and native double-check acknowledgements for Telegram inbound messages (#989).
+- Scalable `gjc daemon` control plane with safe reload, enforcing one `getUpdates` poller per bot token so new sessions attach to the existing daemon instead of causing Telegram 409 conflicts (#993).
+
+### Changed
+
+- Asks are exempt from redaction so remote prompts stay readable and answerable; idle summaries are stripped and streamed content frames (`turn_stream`, `context_update`, `image_attachment`) are suppressed when redaction is enabled (#998, #1001).
+- Telegram replies are routed by their thread/topic; removed the legacy `/answer <session-tag>` command in favour of thread-native replies.
+- Pretty HTML formatting and markdown-table rendering for Telegram daemon output (#986, #997).
+
+### Fixed
+
+- Strip embedded option indexes from Telegram button labels and stop double-numbering inline buttons (#994, #996).
+- Free-text answers resolve pending asks and ask choices remain unredacted (#998, #1001).
+- Recover in-flight sessions after a connection drop and connect new sessions during the `getUpdates` long-poll (#988, #990).
+- Daemon hardening: deliver ask buttons at invocation, fix the topic-reuse race, write daemon logs to file with resilient frame handling, and de-duplicate idle output (#985, #991, and related).
+
 ## [0.6.5] - 2026-06-21
 
 ### Changed
@@ -19,6 +41,7 @@
 - Rejected counterexample-only claims in research-plan regardless of `dropCondition` wording (#942).
 - Bounded computer-use screenshot inline images to avoid oversized payloads.
 - Tolerated missing session env in guard reads (#930).
+- Fixed a session-scoped active-state staleness bug where a freshly written mode-state revision was not reflected in the in-memory envelope, so the active-state/HUD writer skipped the newer update as stale — dropping the deep-interview ambiguity HUD chip after scoring and leaving the active-skills phase mirror behind a `handoff` transition.
 
 ### Documentation
 
@@ -52,6 +75,11 @@
 - Documented lifecycle notification hooks (#903).
 - Added a routed GJC session guide for Clawhip/Hermes/OpenClaw visible routed sessions and linked it from the Hermes docs and operator instructions.
 
+### Fixed
+
+- Fixed combo/cross-provider model presets flipping the main provider on resume. A profile's main model was applied through `setModelTemporary`, which records the session `model_change` with `role: "temporary"`; on resume the session restored `models.default` (the stale pre-profile base model), so an "Apply for this session" combo like `opus-codex` came back on the base default (e.g. `openai-codex/gpt-5.5`) instead of the profile's main model (`anthropic/claude-opus-4-8`). Profile activation now records its main model as the session default (without writing global settings), while transient retry/fallback/context-promotion/plan-mode switches keep `role: "temporary"` so the issue #849 protection is preserved.
+- Hardened the model-profile activation rollback so a failed activation no longer poisons the resume default. The rollback previously restored the pre-activation *live* model as the session default (`role: "default"`); if the user was on a transient retry/fallback/context-promotion/plan switch when activation failed, that transient model was promoted to the resume default and weakened the issue #849 protection. Activation now snapshots the pre-activation resume default separately from the live model and re-asserts it on rollback, while the runtime live model still rolls back as a transient switch (`role: "temporary"`).
+
 ## [0.6.3] - 2026-06-19
 
 ### Fixed
@@ -128,6 +156,7 @@
 
 ### Fixed
 
+- Rendered `/dump` tool-call parameters with readable structured bodies, XML-safe text, and decoded Unicode escape sequences so `ask`/`proxy_ask` deep-interview payloads no longer show dense `questions` JSON or literal Korean `\u...` escapes.
 - Prevented `gjc --tmux` partial-launch diagnostics from throwing when stderr is already closed during shutdown.
 - Fixed v0.5.1-style macOS/Linux standalone binaries crashing before the first model request with `Cannot find module '@gajae-code/natives' from '/$bunfs/root/gjc-*'` when pre-prompt context maintenance invokes the native tokenizer.
 - Mapped the retired `codex-standard` model profile name to `codex-medium` during profile activation, **as a fallback only** so a user-defined profile literally named `codex-standard` is never shadowed, letting stale `modelProfile.default: codex-standard` configs reach activation instead of blocking startup after the rebuilt profile catalog.

package/dist/types/async/job-manager.d.ts

@@ -68,7 +68,9 @@ export interface SubagentLiveHandle {
     /** Request a cooperative safe-boundary pause (never aborts the in-flight tool). */
     requestPause(): void;
     /** Inject a steering message into the live session. */
-    injectMessage(content: string, deliverAs: "steer" | "followUp" | "nextTurn"): Promise<void>;
+    injectMessage(content: string, deliverAs: "steer" | "followUp" | "nextTurn", opts?: {
+        fromAgentId?: string;
+    }): Promise<void>;
 }
 /**
  * Canonical, stable-id-keyed record for a subagent. Survives `AsyncJob`

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

@@ -0,0 +1,25 @@
+/**
+ * `gjc daemon` command handler.
+ *
+ * Generic over the static built-in daemon controller map: lists/inspects
+ * daemons and drives cooperative stop/reload. Telegram is the only kind today.
+ */
+import { Settings } from "../config/settings";
+import type { BuiltInDaemonController, DaemonKind } from "../daemon/control-types";
+export type DaemonCliAction = "list" | "status" | "stop" | "reload";
+export interface DaemonCommandArgs {
+    action: DaemonCliAction;
+    kinds: DaemonKind[];
+    all: boolean;
+    json: boolean;
+    force: boolean;
+    gracefulTimeoutMs?: number;
+    killTimeoutMs?: number;
+    spawnIfStopped?: boolean;
+}
+export interface DaemonCommandDeps {
+    settings?: Settings;
+    controllers?: BuiltInDaemonController[];
+}
+export declare function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined;
+export declare function runDaemonCommand(cmd: DaemonCommandArgs, deps?: DaemonCommandDeps): Promise<void>;

package/dist/types/cli/notify-cli.d.ts

@@ -0,0 +1,23 @@
+import { Settings } from "../config/settings";
+export type NotifyAction = "setup" | "status" | "daemon-internal";
+export interface NotifyCommandArgs {
+    action: NotifyAction;
+    smoke?: boolean;
+    rawArgs: string[];
+    token?: string;
+    chatId?: string;
+    redact?: boolean;
+}
+export interface NotifyCommandDeps {
+    fetchImpl?: typeof fetch;
+    apiBase?: string;
+    settings?: Settings;
+    setupToken?: string;
+    pollTimeoutMs?: number;
+    pollIntervalMs?: number;
+    setupChatId?: string;
+    setupRedact?: boolean;
+}
+export declare function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined;
+export declare function runNotifyCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;
+export declare function printNotifyHelp(): void;

package/dist/types/cli/setup-cli.d.ts

@@ -3,7 +3,9 @@
  *
  * Handles `gjc setup [component]` to install the normal defaults or optional feature dependencies.
  */
-export type SetupComponent = "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+import { AuthStorage, SqliteAuthCredentialStore } from "@gajae-code/ai";
+import { runExternalCredentialAutoImport } from "../setup/credential-auto-import";
+export type SetupComponent = "claude" | "codex" | "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {
@@ -34,6 +36,7 @@ export interface SetupCommandArgs {
         profileDir?: string;
         yes?: boolean;
         dryRun?: boolean;
+        keychain?: boolean;
     };
 }
 /**
@@ -48,6 +51,22 @@ export declare function parseSetupArgs(args: string[]): SetupCommandArgs | undef
  * Run the setup command.
  */
 export declare function runSetupCommand(cmd: SetupCommandArgs): Promise<void>;
+/**
+ * Discover existing Claude Code / Codex CLI credentials and import them into the
+ * gjc credential store after a redacted preview + confirmation. Falls back to
+ * manual-setup guidance when nothing importable is found.
+ */
+export interface CredentialsSetupDependencies {
+    openStore?: typeof SqliteAuthCredentialStore.open;
+    createAuthStorage?: (store: Awaited<ReturnType<typeof SqliteAuthCredentialStore.open>>) => AuthStorage;
+    discover?: Parameters<typeof runExternalCredentialAutoImport>[0]["discover"];
+}
+export declare function handleCredentialsSetup(flags: {
+    json?: boolean;
+    yes?: boolean;
+    dryRun?: boolean;
+    keychain?: boolean;
+}, deps?: CredentialsSetupDependencies): Promise<void>;
 /**
  * Print setup command help.
  */

package/dist/types/commands/daemon.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Manage GJC background daemons (status/list/stop/reload).
+ */
+import { Command } from "@gajae-code/utils/cli";
+import { type DaemonCliAction } from "../cli/daemon-cli";
+export default class Daemon extends Command {
+    static description: string;
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: DaemonCliAction[];
+        };
+        kind: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            multiple: true;
+        };
+    };
+    static flags: {
+        all: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        force: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "graceful-timeout-ms": import("@gajae-code/utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+        };
+        "kill-timeout-ms": import("@gajae-code/utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+        };
+        "spawn-if-stopped": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+    };
+    run(): Promise<void>;
+}

package/dist/types/commands/notify.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Configure Telegram notifications.
+ */
+import { Command } from "@gajae-code/utils/cli";
+import { type NotifyAction } from "../cli/notify-cli";
+export default class Notify extends Command {
+    static description: string;
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: NotifyAction[];
+        };
+        extra: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            multiple: true;
+        };
+    };
+    static flags: {
+        smoke: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        token: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "chat-id": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        redact: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "owner-id": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "agent-dir": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+    };
+    run(): Promise<void>;
+}

package/dist/types/config/model-profile-activation.d.ts

@@ -7,6 +7,8 @@ type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel
     setModelTemporary?: AgentSession["setModelTemporary"];
     setActiveModelProfile?: (name: string | undefined) => void;
     getActiveModelProfile?: () => string | undefined;
+    getSessionDefaultModelSelector?: () => string | undefined;
+    recordResumeDefaultModel?: (selector: string) => void;
 };
 export interface PrepareModelProfileActivationOptions {
     session: ModelProfileActivationSession;
@@ -23,10 +25,20 @@ export interface PreparedModelProfileActivation {
     previousModel: Model<Api> | undefined;
     previousThinkingLevel: ThinkingLevel | undefined;
     previousAgentModelOverrides: Record<string, string>;
+    previousModelRoles: Record<string, string>;
     defaultModel: Model<Api> | undefined;
     defaultThinkingLevel: ThinkingLevel | undefined;
+    modelRoles: Record<string, string>;
     agentModelOverrides: Record<string, string>;
     previousActiveModelProfile: string | undefined;
+    /**
+     * The session resume default ("provider/id") captured BEFORE activation —
+     * the model resume would restore prior to this profile. Snapshotted
+     * separately from `previousModel` (the live runtime model, which may be a
+     * transient switch) so a failed-activation rollback restores the correct
+     * resume default without promoting a transient model to it.
+     */
+    previousSessionDefaultModel: string | undefined;
 }
 export declare function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string;
 export declare function prepareModelProfileActivation(options: PrepareModelProfileActivationOptions): Promise<PreparedModelProfileActivation>;

package/dist/types/config/model-profiles.d.ts

@@ -20,7 +20,8 @@ export interface ModelProfileDefinition {
 }
 export interface ResolvedProfileBinding {
     defaultSelector?: string;
-    agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default">, string>>;
+    modelRoles: Partial<Record<"vision", string>>;
+    agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default" | "vision">, string>>;
 }
 export declare function deriveModelProfileMappedProviders(definition: Pick<ModelProfileDefinition, "modelMapping">): string[];
 export declare function aggregateModelProfileRequiredProviders(requiredProviders: readonly string[], definition: Pick<ModelProfileDefinition, "modelMapping">): string[];

package/dist/types/config/model-registry.d.ts

@@ -11,7 +11,7 @@ import { type Settings } from "./settings";
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
 export declare const kNoAuth = "N/A";
 export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
-export type ModelRole = "default";
+export type ModelRole = "default" | "vision";
 export interface ModelRoleInfo {
     tag?: string;
     name: string;
@@ -19,7 +19,7 @@ export interface ModelRoleInfo {
 }
 export declare const MODEL_ROLES: Record<ModelRole, ModelRoleInfo>;
 export declare const MODEL_ROLE_IDS: ModelRole[];
-export type GjcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
+export type GjcModelAssignmentTargetId = "default" | "vision" | "executor" | "architect" | "planner" | "critic";
 export interface GjcModelAssignmentTargetInfo extends ModelRoleInfo {
     id: GjcModelAssignmentTargetId;
     settingsPath: "modelRoles" | "task.agentModelOverrides";
@@ -268,7 +268,7 @@ export declare const ModelsConfigFile: ConfigFile<{
     profiles?: Record<string, {
         required_providers: string[];
         display_name?: string | undefined;
-        model_mapping: Partial<Record<"architect" | "critic" | "default" | "executor" | "planner", string>>;
+        model_mapping: Partial<Record<"architect" | "critic" | "default" | "executor" | "planner" | "vision", string>>;
     }> | undefined;
 }>;
 /** Provider override config (baseUrl, headers, apiKey, compat, transport) without custom models */

package/dist/types/config/models-config-schema.d.ts

@@ -68,6 +68,7 @@ export declare const ProfileRoleSchema: z.ZodEnum<{
     default: "default";
     executor: "executor";
     planner: "planner";
+    vision: "vision";
 }>;
 export declare const ProfileModelSelectorSchema: z.ZodString;
 export declare const ProfileModelMappingSchema: z.ZodRecord<z.ZodEnum<{
@@ -76,6 +77,7 @@ export declare const ProfileModelMappingSchema: z.ZodRecord<z.ZodEnum<{
     default: "default";
     executor: "executor";
     planner: "planner";
+    vision: "vision";
 }> & z.core.$partial, z.ZodString>;
 export declare const ProfileDefinitionSchema: z.ZodObject<{
     required_providers: z.ZodArray<z.ZodString>;
@@ -86,6 +88,7 @@ export declare const ProfileDefinitionSchema: z.ZodObject<{
         default: "default";
         executor: "executor";
         planner: "planner";
+        vision: "vision";
     }> & z.core.$partial, z.ZodString>;
 }, z.core.$strict>;
 export declare const ProfilesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -97,6 +100,7 @@ export declare const ProfilesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
         default: "default";
         executor: "executor";
         planner: "planner";
+        vision: "vision";
     }> & z.core.$partial, z.ZodString>;
 }, z.core.$strict>>;
 export declare const ModelOverrideSchema: z.ZodObject<{
@@ -687,6 +691,7 @@ export declare const ModelsConfigSchema: z.ZodObject<{
             default: "default";
             executor: "executor";
             planner: "planner";
+            vision: "vision";
         }> & z.core.$partial, z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;

package/dist/types/config/settings-schema.d.ts

@@ -118,6 +118,32 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly default: undefined;
     };
+    readonly "notifications.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "notifications.telegram.botToken": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "notifications.telegram.chatId": {
+        readonly type: "string";
+        readonly default: undefined;
+    };
+    readonly "notifications.redact": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "notifications.verbosity": {
+        readonly type: "string";
+        readonly default: "lean";
+        readonly validate: (value: string) => value is "lean" | "verbose";
+    };
+    readonly "notifications.daemon.idleTimeoutMs": {
+        readonly type: "number";
+        readonly default: 60000;
+        readonly validate: (value: number) => boolean;
+    };
     readonly autoResume: {
         readonly type: "boolean";
         readonly default: false;
@@ -3542,6 +3568,17 @@ export interface ShellMinimizerSettings {
     except: string[];
     maxCaptureBytes: number;
 }
+export interface NotificationsSettings {
+    enabled: boolean;
+    telegram: {
+        botToken: string | undefined;
+        chatId: string | undefined;
+    };
+    redact: boolean;
+    daemon: {
+        idleTimeoutMs: number;
+    };
+}
 /** Map group prefix -> typed settings interface */
 export interface GroupTypeMap {
     compaction: CompactionSettings;
@@ -3560,6 +3597,7 @@ export interface GroupTypeMap {
     modelTags: ModelTagsSettings;
     cycleOrder: string[];
     shellMinimizer: ShellMinimizerSettings;
+    notifications: NotificationsSettings;
 }
 export type GroupPrefix = keyof GroupTypeMap;
 export {};

package/dist/types/coordinator/contract.d.ts

@@ -1,4 +1,4 @@
 export declare const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
 export declare const COORDINATOR_MCP_SERVER_NAME = "gjc-coordinator-mcp";
-export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_watch_events", "gjc_coordinator_register_session", "gjc_coordinator_start_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status"];
+export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_watch_events", "gjc_coordinator_register_session", "gjc_coordinator_start_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status", "gjc_delegate_plan", "gjc_delegate_execute", "gjc_delegate_team"];
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/daemon/builtin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Static built-in daemon controller map.
+ *
+ * Intentionally a static map keyed by daemon kind rather than a mutable plugin
+ * registry: there is exactly one kind today (`telegram`). Promote to a richer
+ * registry only when a second daemon kind exists.
+ */
+import type { Settings } from "../config/settings";
+import { type TelegramDaemonControlDeps } from "../notifications/telegram-daemon-control";
+import type { BuiltInDaemonController, DaemonKind } from "./control-types";
+export declare const BUILT_IN_DAEMON_KINDS: readonly ["telegram"];
+export interface BuiltInDaemonControllerDeps {
+    telegram?: TelegramDaemonControlDeps;
+}
+export declare function createBuiltInDaemonControllers(settings: Settings, deps?: BuiltInDaemonControllerDeps): Record<DaemonKind, BuiltInDaemonController>;
+/**
+ * Resolve the controllers a command should act on. `--all` selects every
+ * built-in kind; otherwise the explicit `kinds` (defaulting to `telegram`).
+ */
+export declare function selectDaemonControllers(settings: Settings, kinds: DaemonKind[] | undefined, all: boolean, deps?: BuiltInDaemonControllerDeps): BuiltInDaemonController[];

package/dist/types/daemon/control-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Public types for the `gjc daemon` control plane.
+ *
+ * Deliberately compact: a small result/status surface plus a built-in
+ * controller contract. There is exactly one daemon kind today (`telegram`);
+ * a richer registry is intentionally deferred until a second kind exists.
+ */
+export type DaemonKind = "telegram";
+export type DaemonAction = "list" | "status" | "stop" | "reload";
+export type DaemonHealth = "not_configured" | "stopped" | "running" | "stale" | "stopping" | "error";
+export interface DaemonRuntimeInfo {
+    /** `source` when respawn goes through bun/node + the entry script; `compiled` for a single-file binary. */
+    mode: "source" | "compiled";
+    execPath: string;
+    /** True only in source/dev mode, where a respawn loads amended TypeScript directly. */
+    reloadPicksUpSourceEdits: boolean;
+    /** Present when the runtime mode constrains what reload can achieve (e.g. compiled binary). */
+    warning?: string;
+}
+export interface DaemonStatus {
+    kind: DaemonKind;
+    configured: boolean;
+    health: DaemonHealth;
+    pid?: number;
+    ownerId?: string;
+    startedAt?: number;
+    heartbeatAt?: number;
+    roots?: string[];
+    rootCount?: number;
+    runtime: DaemonRuntimeInfo;
+    detail?: string;
+}
+export interface DaemonOperationOptions {
+    /** How long to wait for cooperative release before escalating. */
+    gracefulTimeoutMs?: number;
+    /** How long to wait for the old pid to die after SIGKILL. */
+    killTimeoutMs?: number;
+    /** Allow hard-kill escalation / acting on a still-live owner. */
+    force?: boolean;
+    /** For reload: spawn a fresh owner even when none is currently running. */
+    spawnIfStopped?: boolean;
+}
+export interface DaemonOperationResult {
+    kind: DaemonKind;
+    action: Exclude<DaemonAction, "list">;
+    ok: boolean;
+    before?: DaemonStatus;
+    after?: DaemonStatus;
+    warnings: string[];
+    message: string;
+}
+export interface BuiltInDaemonController {
+    readonly kind: DaemonKind;
+    status(): Promise<DaemonStatus>;
+    stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+    reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+}

package/dist/types/daemon/runtime.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared source-vs-compiled runtime detection for daemon spawning.
+ *
+ * Centralizes the logic previously embedded in `ensureTelegramDaemonRunning`
+ * so session autostart, reload, and status reporting agree on how a daemon
+ * process is launched and whether a reload can pick up amended source.
+ */
+export interface GjcRuntimeSpawnInfo {
+    execPath: string;
+    mode: "source" | "compiled";
+    /** Prefix prepended before the gjc subcommand args; `[Bun.main]` in source mode, otherwise `[]`. */
+    argsPrefix: string[];
+    /** True only when respawn loads edited TypeScript directly (source/dev mode). */
+    reloadPicksUpSourceEdits: boolean;
+    /** Set in compiled mode to explain that a rebuild is required before reload picks up source edits. */
+    warning?: string;
+}
+/**
+ * Resolve how to spawn a detached gjc subcommand for the current runtime.
+ *
+ * Source/dev mode (bun/node) prepends the entry script (`Bun.main`) so the
+ * respawn loads edited source. A compiled single-file binary self-spawns its
+ * own subcommand directly and cannot pick up workspace source edits.
+ */
+export declare function resolveGjcRuntimeSpawnInfo(execPath?: string): GjcRuntimeSpawnInfo;

package/dist/types/extensibility/extensions/types.d.ts

@@ -20,6 +20,7 @@ import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { CustomEditor } from "../../modes/components/custom-editor";
+import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/unattended-session";
 import type { Theme } from "../../modes/theme/theme";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
@@ -206,6 +207,11 @@ export interface ExtensionContext {
     getSystemPrompt(): string[];
     /** @deprecated Use hasPendingMessages() instead */
     hasQueuedMessages(): boolean;
+    /**
+     * Unattended workflow-gate bridge. Present only when the session runs in
+     * unattended/RPC mode; `undefined` in interactive/TUI mode (notify-only).
+     */
+    workflowGate?: WorkflowGateEmitter;
 }
 /**
  * Extended context for command handlers.
@@ -834,6 +840,8 @@ export interface ExtensionContextActions {
     getContextUsage: () => ContextUsage | undefined;
     compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;
     getSystemPrompt: () => string[];
+    /** Unattended workflow-gate bridge (present only in unattended/RPC mode). */
+    getWorkflowGate?: () => WorkflowGateEmitter | undefined;
 }
 /** Actions for ExtensionCommandContext (ctx.* in command handlers). */
 export interface ExtensionCommandContextActions {

package/dist/types/gjc-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/gjc-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/gjc-runtime/ultragoal-runtime.d.ts

@@ -193,6 +193,19 @@ export declare function recordUltragoalReviewBlockers(input: {
     evidence: string;
     gjcGoalJson?: 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/modes/components/oauth-selector.d.ts

@@ -1,5 +1,6 @@
 import { Container } from "@gajae-code/tui";
 import type { AuthStorage } from "../../session/auth-storage";
+import type { ImportableCredential } from "../../setup/credential-import";
 /**
  * Component that renders an OAuth provider selector.
  */
@@ -8,6 +9,7 @@ export declare class OAuthSelectorComponent extends Container {
     constructor(mode: "login" | "logout", authStorage: AuthStorage, onSelect: (providerId: string) => void, onCancel: () => void, options?: {
         validateAuth?: (providerId: string) => Promise<boolean>;
         requestRender?: () => void;
+        externalCredentialCandidates?: ImportableCredential[];
     });
     stopValidation(): void;
     dispose(): void;