@gajae-code/coding-agent 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -2,6 +2,54 @@
 
 ## [Unreleased]
 
+## [0.8.2] - 2026-07-06
+### Added
+
+- Queued message selector entries can now be reordered with `Ctrl+Up` / `Ctrl+Down`, with `Ctrl+Shift+Up` / `Ctrl+Shift+Down` still accepted when the terminal forwards them, while keeping the current draft intact.
+
+- Added `gjc completion inshellisense`, which generates or installs a Fig/withfig-compatible `gjc` completion spec for Microsoft inshellisense without adding inshellisense as a runtime dependency.
+
+### Fixed
+- `gjc team` packaged binaries now avoid persisting Bun virtual `/$bunfs/...` entrypoints as worker commands, so tmux worker panes launch through a real executable or the `gjc` fallback instead of immediately disappearing (#1661).
+- `computer` now honors `include_screenshot` and `computer.autoScreenshot` by returning bounded post-action screenshots, and batch steps now respect nested per-step `timeout` values.
+- Custom-provider `gpt-5.5` entries without an explicit `contextWindow` now default to the 272K Codex prompt budget unless the provider uses first-party `openai-responses`, so Codex passthrough proxies (e.g. CLIProxyAPI) compact in time instead of dying with `context_length_exceeded` at ~272K while the registry advertises 1M.
+- `telegram_send` now rejects files over Telegram's document upload limit before reading them into memory or handing them to the notification sink.
+- `telegram_send` now rejects file attachments while Telegram notification redaction is enabled, preventing explicit file sends from bypassing the redaction boundary.
+- Telegram notification daemons now persist consumed update ids so threaded replies are not reinjected after a daemon restart replays old `getUpdates` entries.
+- Telegram notify setup now hides the interactive BotFather token prompt input, preventing the raw bot token from being echoed into terminal scrollback while pairing notifications.
+- Telegram unattended workflow-gate listeners are now disposed when a notification session stops, preventing stale stopped servers from retaining future gate emissions after shutdown or notification restart.
+- Telegram notification setup and daemon delivery now reject non-private Telegram chat ids before saving configuration, creating forum topics, or sending session content, preserving the private-chat-only routing boundary.
+- Telegram daemon autostart now refuses to attach a new session to a live daemon whose persisted bot-token fingerprint or chat id differs from the current settings, and it avoids registering the session root until ownership is trusted so rotated Telegram credentials cannot keep leaking through the old daemon.
+- Skill autocomplete now supports direct skill-name prefixes after prompt text (for example, `please /ra` → `/skill:ralplan`) while keeping bare `/` menus free of skill entries.
+- `gjc --tmux` on native Windows/psmux now keeps the status line and composer pinned to the bottom after viewport redraws by honoring the GJC tmux launch marker as a multiplexer signal even when `$TMUX` is absent.
+- Provider safety refusals (e.g. Anthropic `stop_reason: "refusal"` → `Refusal (<category>): …`, and `sensitive` → `Content flagged by safety filters`) are now classified as terminal retry errors and surface immediately. They previously fell through to the unbounded `"unknown"` retry class, and because a refusal is deterministic for the submitted context, the session looped refusal → retry → refusal forever — resubmitting the full context every `retry.maxDelayMs` and re-billing it as a prompt-cache write whenever the backoff outlived the cache TTL (#1655).
+- Coordinator event watches now wake on runtime sidecar state changes and emit a bounded `turn.acknowledged` event, so a tmux-resident session that accepts a prompt and then vanishes is durably classified as recoverable `tmux_session_missing_after_prompt_acknowledgement` instead of leaving only a watch registration with no terminal verdict (#1496).
+- Raw tmux-resident sessions now persist public-safe runtime state under their `.gjc/_session-*/runtime/runtime-state.json` even when no coordinator sidecar env is present, so post-ack owner exits leave recoverable `process_exit_before_terminal_state` evidence instead of looking like successful cleanup with no durable output (#1496).
+
+- `gjc config list`, `gjc config get`, and `gjc config set` now redact secret-like string settings by default, with `--show-secrets` as an explicit unsafe opt-in.
+
+- `/new` session-start notifications now render directly under the welcome panel instead of leaving an extra blank row above the confirmation line.
+- Goal completion now preserves the terminal `goal({op: "complete"})` state even when a `goal_updated` extension hook throws, preventing hook-side write errors from trapping a verified ultragoal run in the continuation loop.
+- Ultragoal completion no longer requires the computer-use red-team suite for non-computer changes that only touch the shared `tools/index.ts` registration file.
+- Task subagent output-ID allocation (`AgentOutputManager`) is now concurrency-safe. `#ensureInitialized` previously set a boolean flag *before* the awaited `readdir`, so when two `task` calls are dispatched in the same turn (they run concurrently as shared-concurrency tools on one session-scoped manager) the second allocation short-circuited initialization and started from index `0` while the first scan was still in flight — colliding with existing `N-*.md` outputs and duplicating ids across batches, which overwrote prior subagent outputs on resume. The scan is now memoized as a promise so concurrent `allocate`/`allocateBatch`/`peekNextIndex` calls await the same `readdir` before `#nextId` is derived.
+- Task fork-context seeds (`inheritContext`) now keep a *contiguous* run of the most recent messages. The selection loop in `buildForkContextSeed` walks newest→oldest but used `continue` when a message overflowed the token budget, so it skipped the oversized recent message and scavenged smaller *older* ones — yielding a non-contiguous seed that misrepresents the conversation and breaks the recency contract of the `receipt`/`last-turn`/`bounded` modes. It now `break`s at the first over-budget message, so a subagent receives the actual recent context (or none) instead of a jumbled mix of recent and stale messages.
+- The `/settings` → Model → **Default Model Profile** submenu now lists the model profiles from the registry instead of rendering an empty `No matching commands` list. The setting declared `options: "runtime"`, but the selector layer only injected runtime choices for themes, thinking level, and the status-line preset — never for model profiles — so the submenu was always empty. Selecting a profile there now also applies it live (the same `activateModelProfile` path as the `/model` preset flow) and persists it as the startup default, instead of only persisting for the next startup.
+- `gjc stats` now resolves to the usage-statistics command instead of being treated as a chat prompt. `src/commands/stats.ts` (backed by the `@gajae-code/stats` dependency via `src/cli/stats-cli.ts`) existed and was fully functional, but the entry was never added to the `commands` registry in `cli.ts`, so `isSubcommand()` returned false for `stats` and the invocation fell through to the default `launch` command — leaving the usage dashboard/summary unreachable and absent from `gjc --help`. Registered the command and listed it in the help surface.
+
+## [0.8.1] - 2026-07-04
+
+### Added
+
+- Skills can now be invoked inline within a prompt (for example, mid-message `/skill:*` references) instead of only as a standalone prompt, with matching autocomplete, input-controller queueing, and ACP dispatch support.
+
+### Fixed
+
+- The Telegram notification daemon now tombstones a session endpoint generation after `session_closed`, preventing the scan loop from reconnecting to the still-live old endpoint and recreating an empty topic immediately after deleting the original topic.
+- `/contribute-pr` in the interactive TUI now prepares the redacted manifest and worker prompt without spawning a second GJC process on the same terminal, avoiding competing TUI renderers that make the chat viewport jump around. Run the generated worker prompt from a separate terminal instead.
+- The `skill` tool is now a default-registered essential tool instead of a discoverable one, so skill chaining is always available without first activating it through tool discovery.
+- The coordinator MCP server now classifies vanished-but-acknowledged tmux turns correctly, avoiding spurious delivery failures when a delegated turn's pane disappears after its prompt was already acknowledged.
+- Tool-call argument strings are now sanitized of invalid Unicode surrogate sequences across providers (Anthropic, Bedrock, Google, OpenAI chat/completions/responses, and Codex), including custom Responses tool input, preventing malformed tool calls from breaking requests.
+
 ## [0.8.0] - 2026-07-04
 
 ### Added

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

@@ -0,0 +1,41 @@
+import type { CommandCtor, CommandEntry } from "@gajae-code/utils/cli";
+export type FigName = string | string[];
+export interface FigArg {
+    name: string;
+    description?: string;
+    isOptional?: boolean;
+    isVariadic?: boolean;
+    suggestions?: string[];
+}
+export interface FigOption {
+    name: FigName;
+    description?: string;
+    args?: FigArg;
+    isRepeatable?: boolean;
+}
+export interface FigSubcommand {
+    name: FigName;
+    description?: string;
+    options?: FigOption[];
+    args?: FigArg | FigArg[];
+}
+export interface FigSpec extends FigSubcommand {
+    name: string;
+    subcommands?: FigSubcommand[];
+}
+export type InshellisenseIndexStatus = "created" | "updated" | "already-compatible" | "overwritten";
+export interface InstallGjcInshellisenseSpecOptions {
+    dir?: string;
+    force?: boolean;
+}
+export interface InstallGjcInshellisenseSpecResult {
+    directory: string;
+    specPath: string;
+    indexPath: string;
+    indexStatus: InshellisenseIndexStatus;
+}
+export declare function defaultInshellisenseSpecDir(homeDir?: string): string;
+export declare function buildGjcFigSpec(entries: CommandEntry[], rootCommandOverride?: CommandCtor): Promise<FigSpec>;
+export declare function renderFigSpecModule(spec: FigSpec): string;
+export declare function renderInshellisenseIndexModule(): string;
+export declare function installGjcInshellisenseSpec(spec: FigSpec, options?: InstallGjcInshellisenseSpecOptions): Promise<InstallGjcInshellisenseSpecResult>;

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

@@ -11,6 +11,7 @@ export interface ConfigCommandArgs {
     value?: string;
     flags: {
         json?: boolean;
+        showSecrets?: boolean;
     };
 }
 /**

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

@@ -22,4 +22,11 @@ export interface NotifyCommandDeps {
 }
 export declare function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined;
 export declare function runNotifyCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;
+type TokenPromptInput = NodeJS.ReadStream & {
+    isRaw?: boolean;
+    setRawMode?: (mode: boolean) => unknown;
+};
+type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
+export declare function promptForToken(input?: TokenPromptInput, output?: TokenPromptOutput): Promise<string>;
 export declare function printNotifyHelp(): void;
+export {};

package/dist/types/cli.d.ts

@@ -3,7 +3,130 @@
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
-import { type CommandEntry } from "@gajae-code/utils/cli";
+import { Command, type CommandEntry } from "@gajae-code/utils/cli";
 export declare const commands: CommandEntry[];
+export declare class RootHelpCommand extends Command {
+    static description: string;
+    static hidden: boolean;
+    static args: {
+        messages: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            multiple: true;
+        };
+    };
+    static flags: {
+        model: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        smol: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        slow: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        plan: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        mpreset: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        default: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        provider: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "api-key": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "system-prompt": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "append-system-prompt": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "allow-home": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        mode: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
+        print: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+        };
+        continue: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+        };
+        resume: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+        };
+        "session-dir": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "no-session": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        models: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "no-tools": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "no-lsp": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "no-pty": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        tmux: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        tools: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        thinking: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
+        hook: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        extension: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+            multiple: true;
+        };
+        "no-extensions": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "no-skills": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        skills: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "no-rules": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        export: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "list-models": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "no-title": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+    };
+    static examples: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}
 /** Run the CLI with the given argv (no `process.argv` prefix). */
 export declare function runCli(argv: string[]): Promise<void>;

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

@@ -0,0 +1,29 @@
+/**
+ * Generate shell completion specs for external completion engines.
+ */
+import { Command } from "@gajae-code/utils/cli";
+export default class Completion extends Command {
+    static description: string;
+    static args: {
+        target: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: readonly ["inshellisense", "fig"];
+        };
+    };
+    static flags: {
+        install: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        dir: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        force: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+    };
+    run(): Promise<void>;
+}

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

@@ -25,6 +25,9 @@ export default class Config extends Command {
         json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        "show-secrets": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
     };
     run(): Promise<void>;
 }

package/dist/types/commands/deep-interview.d.ts

@@ -12,6 +12,9 @@ export default class DeepInterview extends Command {
         deep: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        trace: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
         threshold: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

package/dist/types/config/file-lock.d.ts

@@ -13,16 +13,17 @@ export interface FileLockOwnerToken {
     pid: number;
     timestamp: number;
 }
-/** Outcome of a guarded GC removal attempt (`removeFileLockDirForGc`). */
+/** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
 export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
 /**
  * @internal
- * Fail-closed removal of a dead lock dir for GC. Re-reads the on-disk owner
- * token as close to the unlink as possible and only deletes the dir when it
- * STILL holds the exact `{pid, timestamp}` identity the caller observed dead.
+ * Fail-closed removal of a lock dir whose owner is expected to be dead or
+ * finished. Re-reads the on-disk owner token as close to the unlink as possible
+ * and only deletes the dir when it STILL holds the exact `{pid, timestamp}`
+ * identity the caller observed.
  *
- * Closes the prune-time TOCTOU window (#606): between GC's dead re-read/probe
- * and the unlink, a live process can reclaim a stale lock at the same path
+ * Closes stale-cleanup TOCTOU windows (#606): between a dead/stale re-read and
+ * the unlink, a live process can reclaim a stale lock at the same path
  * (`acquireLock` rms the stale dir, then re-`mkdir`s and rewrites `info` with a
  * fresh pid+timestamp). Deleting by path alone would reap that LIVE lock. Any
  * mismatch (`owner_changed`) or absent/unreadable info (`missing` — e.g. a

package/dist/types/config/keybindings.d.ts

@@ -244,8 +244,8 @@ export declare const KEYBINDINGS: {
         readonly description: "Queue message for next turn";
     };
     readonly "app.message.dequeue": {
-        readonly defaultKeys: "alt+up";
-        readonly description: "Dequeue message";
+        readonly defaultKeys: ["alt+up", "alt+down"];
+        readonly description: "Select queued message to edit";
     };
     readonly "app.clipboard.pasteImage": {
         readonly defaultKeys: "alt+v" | "ctrl+v";

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

@@ -46,7 +46,13 @@ export interface MaterializeModelProfileAssignmentOptions {
     role: GjcModelAssignmentTargetId;
     selector: string;
 }
+export interface MaterializeModelProfileAssignmentsOptions {
+    session: Pick<ModelProfileActivationSession, "model" | "thinkingLevel" | "setActiveModelProfile" | "getActiveModelProfile">;
+    settings: Pick<Settings, "clearOverride" | "get" | "override" | "set">;
+    assignments: ReadonlyMap<GjcModelAssignmentTargetId, string> | Partial<Record<GjcModelAssignmentTargetId, string>>;
+}
 export declare function materializeActiveModelProfileAssignment(options: MaterializeModelProfileAssignmentOptions): boolean;
+export declare function materializeActiveModelProfileAssignments(options: MaterializeModelProfileAssignmentsOptions): boolean;
 export declare function formatModelProfileCredentialError(profileLabel: string, providers: readonly string[]): string;
 export declare function prepareModelProfileActivation(options: PrepareModelProfileActivationOptions): Promise<PreparedModelProfileActivation>;
 export declare function applyPreparedModelProfileActivation(prepared: PreparedModelProfileActivation, options?: {

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

@@ -108,6 +108,14 @@ export declare class Settings {
      * Set a model role (helper for modelRoles record).
      */
     setModelRole(role: ModelRole | string, modelId: string): void;
+    /**
+     * Set an agent model override while keeping any live runtime override aligned.
+     *
+     * Runtime model profiles override `task.agentModelOverrides` for the current
+     * session. A user-selected role assignment must win immediately in that same
+     * session, but only the explicit agent change should be persisted.
+     */
+    setAgentModelOverride(agentName: string, modelId: string): void;
     /**
      * Get a model role (helper for modelRoles record).
      */

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

@@ -61,7 +61,8 @@ export declare class ExtensionRunner {
     private readonly cwd;
     private readonly sessionManager;
     private readonly modelRegistry;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry);
+    private readonly sessionMetadata?;
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, sessionMetadata?: ExtensionContext["sessionMetadata"]);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.

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

@@ -186,6 +186,12 @@ export interface CompactOptions {
     onComplete?: (result: CompactionResult) => void;
     onError?: (error: Error) => void;
 }
+export interface ExtensionSessionMetadata {
+    kind: "main" | "sub";
+    taskDepth: number;
+    parentTaskPrefix?: string;
+    currentAgentType?: string;
+}
 /**
  * Context passed to extension event handlers.
  */
@@ -202,6 +208,8 @@ export interface ExtensionContext {
     cwd: string;
     /** Session manager (read-only) */
     sessionManager: ReadonlySessionManager;
+    /** Session classification supplied by the SDK for extension policy decisions. */
+    sessionMetadata?: ExtensionSessionMetadata;
     /** Model registry for API key resolution */
     modelRegistry: ModelRegistry;
     /** Current model (may be undefined) */

package/dist/types/gjc-runtime/deep-interview-ambiguity.d.ts

@@ -0,0 +1,39 @@
+import { type DeepInterviewStateEnvelope } from "./deep-interview-state";
+export interface AmbiguityFloorBreakdown {
+    floor: number;
+    disputed_fact_count: number;
+    unscored_active_component_count: number;
+    auto_answer_ratio: number;
+}
+export interface AmbiguityClampResult {
+    effective: number;
+    clamped: boolean;
+}
+/** Compute the deterministic floor from the inner deep-interview `state` object. */
+export declare function computeAmbiguityFloor(inner: unknown): AmbiguityFloorBreakdown;
+/** Clamp an LLM-reported ambiguity to the deterministic floor: `max(reported, floor)`. */
+export declare function clampReportedAmbiguity(reported: number, floor: number): AmbiguityClampResult;
+/**
+ * Mark every established fact recorded in `retractedRound` as disputed. This is the
+ * mechanical contradiction signal for answer retraction: when the user replaces an
+ * already-scored answer (A -> B pivot), the facts that answer established can no
+ * longer be trusted, so they raise the floor until re-confirmed or superseded.
+ * Returns new arrays/objects; never mutates the input.
+ */
+export declare function disputeFactsFromRetractedRound(facts: readonly unknown[], retractedRound: number): {
+    facts: Record<string, unknown>[];
+    disputedIds: string[];
+};
+export interface AppliedAmbiguityFloor {
+    envelope: DeepInterviewStateEnvelope;
+    breakdown: AmbiguityFloorBreakdown;
+    clamped: boolean;
+}
+/**
+ * Enforce the floor invariant on a full deep-interview envelope: recompute the floor
+ * from persisted evidence, clamp `state.current_ambiguity`, and clamp the latest
+ * scored round (preserving the original value as `reported_ambiguity` for audit).
+ * Historical rounds are never rewritten. Idempotent and non-mutating; every writer
+ * (state CLI write/reconcile, recorder) applies this immediately before persisting.
+ */
+export declare function applyAmbiguityFloorToEnvelope(value: unknown): AppliedAmbiguityFloor;

package/dist/types/gjc-runtime/deep-interview-recorder.d.ts

@@ -1,4 +1,5 @@
 import { type DeepInterviewEstablishedFact, type DeepInterviewRoundRecord, type DeepInterviewStateEnvelope, type DeepInterviewTriggerMetadata } from "./deep-interview-state";
+export * from "./deep-interview-ambiguity";
 export * from "./deep-interview-state";
 /**
  * Runtime-owned deep-interview round recorder (conflict-aware scoring support).
@@ -86,12 +87,20 @@ export declare function projectCompactState(value: unknown, options?: {
 }): DeepInterviewCompactState;
 /** Refresh the best-effort HUD cache from persisted deep-interview state. */
 export declare function syncDeepInterviewRecorderHud(cwd: string, statePath: string, sessionId: string | undefined): Promise<void>;
-/** Record an `answered` shell for one round (append-or-merge by durable key). */
+/**
+ * Record an `answered` shell for one round (append-or-merge by durable key).
+ *
+ * Retraction dynamics: replacing an already-`scored` answer is a mechanical
+ * contradiction signal (the user pivoted). The facts that round established are
+ * marked disputed, which raises the deterministic ambiguity floor immediately —
+ * without waiting for the LLM scorer to self-report a trigger.
+ */
 export declare function appendOrMergeDeepInterviewRound(cwd: string, statePath: string, input: DeepInterviewAnswerInput, options?: {
     sessionId?: string;
 }): Promise<{
     action: AppendOrMergeAction;
     record: DeepInterviewRoundRecord;
+    disputedFactIds?: string[];
 }>;
 /** Merge scoring output into the same round record, transitioning to `scored`. */
 export declare function enrichDeepInterviewRoundScoring(cwd: string, statePath: string, input: DeepInterviewScoringInput, options?: {

package/dist/types/gjc-runtime/deep-interview-runtime.d.ts

@@ -4,7 +4,7 @@ export * from "./deep-interview-recorder";
  *
  * The CLI itself does not run the Socratic interview; that lives inside the `/skill:deep-interview`
  * skill executed by the agent. This handler validates the documented argument-hint surface
- * (`[--quick|--standard|--deep] <idea>`), seeds `.gjc/state/deep-interview-state.json`, and
+ * (`[--trace] [--quick|--standard|--deep] <idea>`), seeds `.gjc/state/deep-interview-state.json`, and
  * updates the shared HUD rail via `syncSkillActiveState` so the active interview is visible to
  * the TUI.
  */

package/dist/types/gjc-runtime/deep-interview-state.d.ts

@@ -21,6 +21,13 @@ export interface DeepInterviewEstablishedFact {
     dimension?: string;
     evidence?: string;
     disputed: boolean;
+    /**
+     * Resolution pointer for a disputed fact: the id of the fact that replaced it
+     * after the user confirmed a pivot. A disputed fact without `superseded_by`
+     * keeps the deterministic ambiguity floor elevated; setting it releases the
+     * pressure while preserving the contradicted fact for audit.
+     */
+    superseded_by?: string;
 }
 export interface DeepInterviewTriggerMetadata {
     kind: DeepInterviewTriggerKind;
@@ -54,7 +61,12 @@ export interface DeepInterviewRoundRecord {
     answered_at: string;
     scored_at?: string;
     scores?: Record<string, number>;
+    /** Effective ambiguity after the deterministic floor clamp (`max(reported, floor)`). */
     ambiguity?: number;
+    /** Original LLM-reported ambiguity, preserved for audit when the floor clamped it. */
+    reported_ambiguity?: number;
+    /** Deterministic floor in effect when this round was scored, when it clamped. */
+    ambiguity_floor?: number;
     triggers?: DeepInterviewTriggerMetadata[];
 }
 export interface DeepInterviewStateEnvelope {

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

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

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

@@ -218,6 +218,7 @@ interface UltragoalChangeSet extends JsonObject {
     mergeBase?: string;
     paths: UltragoalChangeSetPath[];
     rawDiffStat?: string;
+    rawDiff?: string;
     trusted: true;
 }
 export declare function normalizeSurfaceToken(value: string): string;

package/dist/types/main.d.ts

@@ -18,6 +18,9 @@ export interface InteractiveModeNotify {
     message: string;
 }
 export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+type CreateSessionForMain = (options: CreateAgentSessionOptions, context?: {
+    skipPostCreateModelRefresh?: boolean;
+}) => Promise<CreateAgentSessionResult>;
 type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 export interface AcpSessionFactoryOptions {
     baseOptions: CreateAgentSessionOptions;
@@ -27,7 +30,7 @@ export interface AcpSessionFactoryOptions {
     modelRegistry: ModelRegistry;
     parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
     rawArgs: string[];
-    createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
+    createSession: CreateSessionForMain;
 }
 export declare function applyStartupModelProfiles(args: {
     session: AgentSession;

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

@@ -10,6 +10,7 @@ export type ModelSelectorSelection = {
     kind: "assignment";
     model: Model;
     role: GjcModelAssignmentTargetId | null;
+    roles?: readonly GjcModelAssignmentTargetId[];
     thinkingLevel?: ThinkingLevel;
     selector?: string;
 } | {
@@ -56,6 +57,9 @@ export declare class ModelSelectorComponent extends Container {
     refreshPresetProfiles(profileName?: string): void;
     getSearchInput(): Input;
     __testSelectProfile(profileName: string, setDefault: boolean): Promise<void>;
+    __testSelectAssignment(selection: Omit<Extract<ModelSelectorSelection, {
+        kind: "assignment";
+    }>, "kind">): Promise<void>;
     __testSelectPresetAction(profileName: string, action: "rename" | "delete"): Promise<void>;
     __testSelectedPresetRowIdentity(): string | undefined;
 }

package/dist/types/modes/components/queued-message-selector.d.ts

@@ -0,0 +1,12 @@
+import { Container, SelectList } from "@gajae-code/tui";
+import type { QueuedMessageEditEntry } from "../../session/agent-session";
+type QueuedMessageMoveDirection = "up" | "down";
+export type { QueuedMessageMoveDirection };
+export declare class QueuedMessageSelectorComponent extends Container {
+    #private;
+    constructor(entries: QueuedMessageEditEntry[], onSelect: (entry: QueuedMessageEditEntry) => void, onDelete: (entry: QueuedMessageEditEntry, selectedIndex: number) => void, onMove: (entry: QueuedMessageEditEntry, selectedIndex: number, direction: QueuedMessageMoveDirection) => void, onCancel: () => void, options?: {
+        selectedIndex?: number;
+    });
+    handleInput(keyData: string): void;
+    getSelectList(): SelectList;
+}

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

@@ -16,6 +16,8 @@ export interface SettingsRuntimeContext {
     thinkingLevel: ThinkingLevel | undefined;
     /** Available themes */
     availableThemes: string[];
+    /** Available model profile names (from the model registry) */
+    availableModelProfiles: string[];
     /** Working directory for plugins tab */
     cwd: string;
 }

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

@@ -14,9 +14,7 @@ export declare class InputController {
     handleFollowUp(): Promise<void>;
     /** Send editor text explicitly as a queued next-turn message. */
     handleQueueSubmit(): Promise<void>;
-    restoreLatestQueuedMessageToEditor(options?: {
-        currentText?: string;
-    }): number;
+    restoreLatestQueuedMessageToEditor(): number;
     restoreQueuedMessagesToEditor(options?: {
         abort?: boolean;
         currentText?: string;