@gajae-code/coding-agent 0.11.8 → 0.11.10

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## [Unreleased]
 
+## [0.11.10] - 2026-07-25
+### Changed
+
+- The built-in `claude-opus`, `opus-codex`, and `fable-opus-codex` presets now use `anthropic/claude-opus-5` instead of `anthropic/claude-opus-4-8`, with effort suffixes preserved; `packages/ai/src/models.json` was regenerated so `anthropic/claude-opus-5` resolves; non-opus roles (`anthropic/claude-sonnet-5` executor/planner overrides, codex and fable roles) are unchanged.
+
+## [0.11.9] - 2026-07-24
+
+### Fixed
+
+- Restricted role-agent `bash` now accepts literal mid-word tildes, so git revision syntax such as `git diff HEAD~1` no longer has to be quoted. Bash performs tilde expansion only at the start of a word, so word-initial forms (`~`, `~/path`, `~user`) remain blocked.
+- Restricted role-agent `bash` now rejects unquoted tildes at every bash expansion position inside assignment words, including the compound `name+=value` form, so `A=~`, `A+=~`, `foo=~root/bar`, `A=x:~`, `A+=x:~`, and repeated colon segments such as `a=x:~:y:~` fail closed. Tildes bash does not expand — mid-word git revisions (`HEAD~1`), non-assignment words (`--opt=~`, `1abc=~`, `a++=~`, `a+b=~`), and quoted forms — remain allowed (#3117).
+- Read-only role agents (`architect`, `planner`, `critic`) now receive the `irc` coordination tool and a read-only git prefix set (`status`, `log`, `show`, `diff`, `blame`, `rev-parse`, `ls-files`) in restricted bash; mutating git and arbitrary shell stay blocked. `irc` also stays in the initial active tool set for subagents whenever the parent runtime reports IRC availability, instead of costing a discovery round-trip (#3109).
+- The restricted-bash workflow guard now allows `/dev/null` redirects (so `cmd 2>/dev/null` is no longer treated as a repository write during planning phases) while keeping `/dev/stdout`, `/dev/stderr`, and `/dev/fd/<n>` blocked, failing closed on `exec` redirections, and recognizing `>|`, `>&path`, `<>`, path-qualified writers, and every `dd of=` operand. Hook-seeded deep-interview state is now gated on `isNativeDeepInterviewV1` and seeded as a native v1 envelope, so typed operations no longer fail with `DI_STATE_SCHEMA_INVALID` and run the interview manually (#3127).
+- The vendored `insane-search` engine no longer treats a `429` as terminal: rate-limited probe and grid candidates back off (linear escalation honoring `Retry-After`, hard-capped at 30s) and continue through grid diversity and browser fallback. The backoff base from `INSANE_RATE_LIMIT_BACKOFF_S` is validated and clamped, so non-numeric, `NaN`, infinite, negative, or huge values can no longer raise, hang, or defeat a per-attempt deadline, and sleeps stay short enough to honor cancellation (#3131).
+- ACP sessions now apply execution permission decisions to eval calls and to tools invoked from JavaScript or Python eval contexts, while non-ACP session behavior remains unchanged.
+- Interactive prompt cancellation now reaches API-key preflight through `ModelRegistry`, allowing aborted submissions to clear immediately even while a shared credential-usage request continues in the background.
+- Alibaba Token Plan canonical first-event timeouts now surface without session retry/fallback replay and are not internally retried by auto-compaction, preventing repeated provider usage (#3026).
+- Delegated-task and subagent status surfaces now distinguish provider recovery from normal running, identify first-event versus idle-stream stalls, show retry budget and provider-progress age, and aggregate concurrent degradation by provider (#3071).
+- Telegram notification daemon ownership hardening (#3048): Bot API outcomes now share one honest classifier so both the initiating `429` response and cooldown-suppressed calls settle retryably instead of being lost or falsely rejected, including selected acknowledgements; exclusive operator work is registered before its callback can throw; notification health degrades corrupt daemon-state JSON to a warning; root-registration ownership tokens propagate through injected and built-in ensure, rollback, reconciliation, teardown, and abandoned-startup cleanup seams, with token-bearing rows refusing tokenless cleanup while genuinely legacy rows retain root-match behavior; and initial daemon readiness is published only after the matching heartbeat sidecar rename is durable, so no waiter can attach during the proof window.
+- `/new`, `fork()`, handoff, `/resume`, and branch/tree-jump transitions now complete verified managed `local://` legacy-root migration for the successor session identity *before* that identity is published to the agent, the workflow-gate emitter, or extension hooks, so no observer can resolve `local://` against an ungated root across the gate's `await` boundary. Matches cold-start `createAgentSession()` (#2797) and extends `/resume` (#2925). Sending a prompt right after `/new` no longer fails with "local:// legacy migration must complete before path resolution".
+
+- Telegram notification topics now fence malformed successful `createForumTopic` responses per session endpoint, preventing repeated ambiguous topic creation while keeping explicit Bot API failures retryable.
+- Windows managed-session resume no longer reports `durability_failed` when Bun rejects `fsync` on the read-only descriptor used to revalidate an existing canonical binding; Windows now uses an owner-writable descriptor for that durability fence while retaining no-follow and pre/post identity/content checks.
+- SDK daemon CLI end-to-end tests now capture spawned child stdout and stderr through temporary files instead of pipes, removing the CI pipe teardown race that replaced the product exit contract with SIGPIPE status 141 (#3024).
+- Interactive launch bootstrap is now suppressed for parser-accepted `--print=`, `--help=`, and `--version=` equals forms, keeping non-interactive output free of the warming-workspace preamble on TTYs.
+- Managed legacy-session artifact migration now accepts up to 50,000 files, processes copy work in bounded batches, and reports capacity exhaustion separately from unsafe artifact topology (#2935).
+- Kimi Code first-event timeouts now surface after the provider's continuous first-event wait instead of replaying the full request from zero.
+
+- Rejected subagent schema payloads now retain their complete structured data in canonical output artifacts; inline results remain bounded while `agent://` output stays lossless (#2894).
+- Managed legacy-session artifact migration now validates Windows directory roots from the native tree snapshot, tolerates only lazy metadata on plain Windows directories, and replays both clean and cleanup-pending detaches while retaining fail-closed receipt validation. Canonical binding durability sync uses a writable no-follow handle on Windows NTFS stacks that reject `FlushFileBuffers` on read-only handles (#3015, #2913).
+- A single managed session tombstone that fails to reconcile (e.g. an artifact directory identity mismatch) no longer blocks resume or delete of every other session in the same managed scope; the failure is isolated to that tombstone and logged, unless it belongs to the session currently being opened, which still fails closed.
+
 ## [0.11.8] - 2026-07-23
 ### Added
 
@@ -15,6 +47,7 @@
 
 - Runtime MCP OAuth credentials are now bound to their authorized server origin and token endpoint, reject redirecting refresh responses, and fail closed when legacy or changed configuration lacks an exact match.
 - `/share` now keeps full-session HTML in owner-private unpredictable staging until the share handler or `gh gist create` process has fully stopped; cancelling a blocked gist upload terminates and awaits that process before reporting cancellation and removing the export.
+- MCP diagnostics now redact opaque endpoint paths, user information, query values, and fragments without changing outbound requests, and parse-failure logs omit response bodies that could echo request secrets.
 - Telegram notification daemon self-heals degraded on-disk state: permanently missing scan roots are pruned (so one deleted worktree no longer disables orphan-topic cleanup), and retained exact-unlink transition/placeholder artifacts are reaped on ownership acquire and each scan. `gjc daemon reload` can recover without manual filesystem surgery (#2956).
 - On macOS, resuming a managed session no longer fails with `identity_mismatch` when the first write-append open changes only file `ctime` (e.g. APFS write-provenance / `com.apple.provenance`). `appendSync` allows a single bounded re-capture + retry when `dev`/`ino`/`size`/`mtime`/SHA-256 remain unchanged, and still rejects real content races and repeated ctime transitions (#2944).
 - Interactive `/resume` / `AgentSession.switchSession()` now awaits verified managed `local://` legacy-root migration for the newly selected session before post-commit lifecycle proceeds, matching cold-start `createAgentSession()` readiness from #2797 so synchronous `local://` resolution no longer fails with "legacy migration must complete before path resolution" after a mid-session switch (#2925).
@@ -45,6 +78,7 @@
 - ACP session close now rotates idempotency keys for resumed attachment generations while retaining the same key across terminally uncertain close retries.
 - ConversationStore now tolerates only unsupported Windows parent-directory durability errors after preserving temporary-file fsync and atomic rename.
 - Ralplan no longer re-asks for execution approval when the user already explicitly named `ultragoal` or `team` in the current turn; that naming is the consent.
+- Interactive Windows startup now stays keyboard-ready with large session histories and native multiplexers by showing an interactive-only bootstrap before the first TUI start, deferring bounded recent-session discovery until afterward, and reducing psmux frame pressure while preserving the three-second animation and update checks.
 
 - Cron guidance now routes silent recurring polling and event-driven PR/CI watchers to `monitor`, because every cron firing starts a normal assistant turn and prompt wording cannot reliably suppress its response.
 - Ordinary `ask` calls now normalize a provider-emitted `deepInterview: null` placeholder instead of misclassifying it as malformed Round-0 intent recovery data and rejecting it before coercion.
@@ -269,11 +303,11 @@
 
 ## [0.10.1] - 2026-07-13
 
+- Deep-interview bundled guidance now uses the typed native setup, topology, answer-recovery, round-result, selective inspection, and sanity-check commands for normal workflow state changes. Generic `gjc state` remains limited to documented compatibility/recovery handoff paths; ambiguity, receipts, revisions, topology persistence, and diagnosis/repair remain runtime-owned.
 ### Added
 
 - Added an owner-proof idle session reaper and `gjc_coordinator_stop_session` for ephemeral (delegate-created) coordinator sessions. Termination goes exclusively through the canonical SDK broker `session.close` lifecycle (durable process identity verified before close) — never a raw `process.kill` or tmux control. The reaper re-validates ephemeral and no-active-turn state at close time under the same per-session mutation lock as delegate reuse, and purges coordinator metadata only after SDK closure is verified, retaining it when closure cannot be confirmed (#2080).
 
-- Added an owner-proof idle session reaper and `gjc_coordinator_stop_session` for ephemeral (delegate-created) coordinator sessions. Termination goes exclusively through the owner-proof `forceCloseGjcTmuxSession` path (pid, native session id, owner generation, server key, and start time all verified before SIGTERM) — never a raw `process.kill`. The reaper binds each close to the persisted runtime-state file, re-validates ephemeral and no-active-turn at kill time under the same per-session mutation lock as delegate reuse, and purges state only on verified termination (#2080).
 - SDK clients can now pass an explicit thinking level to `model.set`, atomically applying the effective model and thinking level to the active session and the machine-global default for future sessions, while project policy and resumed session history retain precedence.
 - Context-usage tokens/% now use provider-reported usage as the single source of truth on every surface. `AgentSession.getContextUsage()` returns a source-tagged snapshot (`source: "provider_anchor" | "heuristic" | "unknown"`), and the status-line `context_pct` segment, inline model percentage, and `/context` totals consume that snapshot instead of recomputing an independent heuristic sum — so footer, status line, `/context`, ACP, and RPC can no longer disagree about the same session state. Heuristic estimation now applies only when no provider anchor exists (session start, aborted/error-only turns), and that fallback now includes the fixed system-prompt/tool/skill context it previously omitted. The pre-prompt compaction estimate honors the latest-compaction boundary (never anchors on stale pre-compaction usage totals), unknown post-compaction usage stays unknown (status line renders `?`; ACP omits the `usage_update` instead of reporting `used: 0`), and `/context` labels its total by provenance with a reconciliation line when the estimated category composition diverges from the provider-reported total.
 - Post-durable default-model-selection failures now expose a stable SDK error with bounded `restored`, `partial`, or `unknown` rollback state; preflight and validation errors remain unchanged.

package/dist/types/cli.d.ts

@@ -6,6 +6,7 @@
 import "@gajae-code/utils/postmortem";
 import { Command, type CommandEntry } from "@gajae-code/utils/cli";
 export declare const commands: CommandEntry[];
+export declare function interactiveBootstrapText(argv: readonly string[], stdinIsTTY?: boolean, stdoutIsTTY?: boolean): string | undefined;
 export declare class RootHelpCommand extends Command {
     static description: string;
     static hidden: boolean;

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

@@ -1,7 +1,6 @@
-import type { GjcModelAssignmentTargetId } from "./model-registry";
 import { type ModelSelectorValue } from "./model-selector-value";
-import type { ModelsConfig } from "./models-config-schema";
-export type ModelProfileRole = GjcModelAssignmentTargetId;
+import type { GJC_MODEL_ASSIGNMENT_TARGET_IDS, ModelsConfig } from "./models-config-schema";
+export type ModelProfileRole = (typeof GJC_MODEL_ASSIGNMENT_TARGET_IDS)[number];
 export interface ModelProfileDefinition {
     name: string;
     requiredProviders: string[];

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

@@ -387,12 +387,14 @@ export declare class ModelRegistry {
      */
     getApiKey(model: Model<Api>, sessionId?: string, options?: {
         credentialSelector?: AuthCredentialSelector;
+        signal?: AbortSignal;
     }): Promise<string | undefined>;
     /**
      * Get API key for a provider (e.g., "openai").
      */
     getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string, options?: {
         credentialSelector?: AuthCredentialSelector;
+        signal?: AbortSignal;
     }): Promise<string | undefined>;
     /**
      * Check if a model is using OAuth credentials (subscription).

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

@@ -9,15 +9,13 @@ export interface AmbiguityClampResult {
     effective: number;
     clamped: boolean;
 }
-/** Compute the deterministic floor from the inner deep-interview `state` object. */
+/** Compute the deterministic floor from integer units of persisted evidence. */
 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.
+ * Legacy pure utility for migrations and explicit repair flows. The recorder does
+ * not dispute facts when an answer is retracted: scored evidence is immutable.
  * Returns new arrays/objects; never mutates the input.
  */
 export declare function disputeFactsFromRetractedRound(facts: readonly unknown[], retractedRound: number): {
@@ -37,3 +35,12 @@ export interface AppliedAmbiguityFloor {
  * (state CLI write/reconcile, recorder) applies this immediately before persisting.
  */
 export declare function applyAmbiguityFloorToEnvelope(value: unknown): AppliedAmbiguityFloor;
+export type DeepInterviewAmbiguityMilestone = "initial" | "progress" | "refined" | "ready";
+export declare function deriveAmbiguityMilestone(effectiveUnits: number, thresholdUnits: number): DeepInterviewAmbiguityMilestone;
+export declare function scoreToUnits(score: number): number;
+export declare function weightedAmbiguityUnits(scores: {
+    goal: number;
+    constraints: number;
+    criteria: number;
+    context?: number;
+}, type: "greenfield" | "brownfield"): number;

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

@@ -0,0 +1,8 @@
+import { type DeepInterviewDraftKind } from "./deep-interview-payload";
+export interface DeepInterviewDraftResult {
+    status: number;
+    stdout?: string;
+    stderr?: string;
+}
+export declare function runDeepInterviewDraftCommand(input: readonly string[], cwd: string): Promise<DeepInterviewDraftResult>;
+export declare function runDeepInterviewDraftInternalConsumeCommand(draftId: string, expectedDraftRevision: number, kind: DeepInterviewDraftKind, cwd: string): Promise<DeepInterviewDraftResult>;

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

@@ -0,0 +1,41 @@
+import type { DeepInterviewRoundResultV1 } from "./deep-interview-state";
+export declare const DEEP_INTERVIEW_DRAFT_KINDS: readonly ["initialize-context", "confirm-topology", "record-answer", "apply-round-result"];
+export type DeepInterviewDraftKind = (typeof DEEP_INTERVIEW_DRAFT_KINDS)[number];
+export type DeepInterviewDraftPayload = Record<string, unknown>;
+export type DraftScalarType = "string" | "id" | "text" | "score" | "number" | "safe-int" | "boolean" | "enum";
+export interface DraftLeafDescriptor {
+    kind: "leaf";
+    type: DraftScalarType;
+    nullable?: boolean;
+    maxBytes?: number;
+    values?: readonly string[];
+    optional?: boolean;
+    dynamicMapValue?: boolean;
+}
+export interface DraftObjectDescriptor {
+    kind: "object";
+    fields: Record<string, DraftDescriptor>;
+    optional?: boolean;
+    dynamicMapValue?: boolean;
+    dynamicValue?: DraftLeafDescriptor;
+}
+export interface DraftArrayDescriptor {
+    kind: "array";
+    item: DraftLeafDescriptor | DraftObjectDescriptor;
+    maxItems: number;
+    optional?: boolean;
+}
+export type DraftDescriptor = DraftLeafDescriptor | DraftObjectDescriptor | DraftArrayDescriptor;
+export declare function deepInterviewDraftSchema(kind: DeepInterviewDraftKind): DraftObjectDescriptor;
+/** Shared strict payload decoders used by compatibility JSON and CLI-owned drafts. */
+export declare function decodeInitializeContextPayload(payload: unknown): Record<string, unknown>;
+export declare function decodeConfirmTopologyPayload(payload: unknown): Record<string, unknown>;
+export declare function decodeRecordAnswerPayload(payload: unknown): {
+    question: string;
+    answer: {
+        selected_options: string[];
+        custom_input: string | null;
+    };
+};
+export declare function decodeApplyRoundResultPayload(payload: unknown, state: Record<string, unknown>): DeepInterviewRoundResultV1;
+export declare function validateDraftPayload(kind: DeepInterviewDraftKind, payload: unknown, state?: Record<string, unknown>): void;

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

@@ -1,4 +1,4 @@
-import { type DeepInterviewEstablishedFact, type DeepInterviewIntentItem, type DeepInterviewIntentSubstitution, type DeepInterviewRoundRecord, type DeepInterviewStateEnvelope, type DeepInterviewTriggerMetadata } from "./deep-interview-state";
+import { type DeepInterviewEstablishedFact, type DeepInterviewIntentItem, type DeepInterviewIntentSubstitution, type DeepInterviewRoundRecord, type DeepInterviewRoundResultV1, type DeepInterviewStateEnvelope, type DeepInterviewTriggerMetadata } from "./deep-interview-state";
 export * from "./deep-interview-ambiguity";
 export * from "./deep-interview-state";
 /**
@@ -40,6 +40,8 @@ export interface DeepInterviewScoringInput {
     scores: Record<string, number>;
     ambiguity: number;
     triggers?: DeepInterviewTriggerMetadata[];
+    /** Complete native round result for typed callers. */
+    roundResult?: DeepInterviewRoundResultV1;
 }
 export type AppendOrMergeAction = "created" | "noop" | "replaced";
 export interface AppendOrMergeResult {
@@ -67,11 +69,9 @@ export interface TransitionValidationResult {
 }
 export declare function buildAnswerShell(input: DeepInterviewAnswerInput, now?: string): DeepInterviewRoundRecord;
 /**
- * Append-or-merge by `round_key`. Exactly one record per key:
- * - no existing record -> append (`created`);
- * - identical question_hash + answer_hash -> deterministic no-op (`noop`);
- * - same key, different hashes -> deterministic replacement of the prior shell
- *   (`replaced`); the prior answer for that key is superseded and lifecycle resets.
+ * Append-or-merge by `round_key`. An answer is a no-op only when its complete
+ * canonical shell identity matches; a scored record is immutable evidence and
+ * cannot be replaced by a late answer.
  */
 export declare function appendOrMergeRound(rounds: readonly DeepInterviewRoundRecord[], shell: DeepInterviewRoundRecord): AppendOrMergeResult;
 /**
@@ -94,28 +94,43 @@ export declare function ensureDeepInterviewStateShape(value: unknown): DeepInter
 export declare function projectCompactState(value: unknown, options?: {
     lastN?: number;
 }): DeepInterviewCompactState;
+interface RecorderMutationOptions {
+    sessionId?: string;
+    expectedRevision?: number;
+}
+export interface DeepInterviewPostCommitWarning {
+    code: "DI_POST_COMMIT_AUDIT_FAILED" | "DI_POST_COMMIT_ACTIVITY_FAILED" | "DI_POST_COMMIT_HUD_FAILED";
+    message: string;
+}
+export declare function runDeepInterviewPostCommitEffects(options: {
+    cwd: string;
+    statePath: string;
+    sessionId: string;
+    envelope: Record<string, unknown>;
+    revision: number;
+    writer: string;
+    auditWarnings?: readonly {
+        code: "DI_POST_COMMIT_AUDIT_FAILED";
+        message: string;
+    }[];
+}): Promise<DeepInterviewPostCommitWarning[]>;
 /** 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).
  *
- * 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.
+ * Replacing an already-scored answer is rejected with
+ * `DI_ANSWER_LIFECYCLE_CONFLICT`; scored evidence is immutable.
  */
-export declare function appendOrMergeDeepInterviewRound(cwd: string, statePath: string, input: DeepInterviewAnswerInput, options?: {
-    sessionId?: string;
-}): Promise<{
+export declare function appendOrMergeDeepInterviewRound(cwd: string, statePath: string, input: DeepInterviewAnswerInput, options?: RecorderMutationOptions): Promise<{
     action: AppendOrMergeAction;
     record: DeepInterviewRoundRecord;
-    disputedFactIds?: string[];
+    warnings: DeepInterviewPostCommitWarning[];
 }>;
 /** Merge scoring output into the same round record, transitioning to `scored`. */
-export declare function enrichDeepInterviewRoundScoring(cwd: string, statePath: string, input: DeepInterviewScoringInput, options?: {
-    sessionId?: string;
-}): Promise<{
+export declare function enrichDeepInterviewRoundScoring(cwd: string, statePath: string, input: DeepInterviewScoringInput, options?: RecorderMutationOptions): Promise<{
     record: DeepInterviewRoundRecord;
+    warnings: DeepInterviewPostCommitWarning[];
 }>;
 /** Compact projection so callers read a slice instead of the full transcript. */
 export declare function readDeepInterviewStateCompact(statePath: string, options?: {

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

@@ -0,0 +1,17 @@
+import { type DeepInterviewRoundResultV1 } from "./deep-interview-state";
+export interface DeepInterviewRepairResult {
+    status: number;
+    stdout?: string;
+    stderr?: string;
+}
+export declare const DEEP_INTERVIEW_REPAIR_VERBS: readonly ["initialize-context", "confirm-topology", "record-answer", "apply-round-result", "inspect", "sanity-check"];
+export type DeepInterviewRepairVerb = (typeof DEEP_INTERVIEW_REPAIR_VERBS)[number];
+export declare function isDeepInterviewRepairVerb(value: string): value is DeepInterviewRepairVerb;
+export declare function decodeDeepInterviewAnswerJson(value: unknown): {
+    selected_options: string[];
+    custom_input: string | null;
+};
+export declare function decodeDeepInterviewRoundResultJson(value: unknown, state: Record<string, unknown>): DeepInterviewRoundResultV1;
+export declare function decodeDeepInterviewSetupJson(value: unknown): Record<string, unknown>;
+export declare function decodeDeepInterviewTopologyJson(value: unknown): Record<string, unknown>;
+export declare function runDeepInterviewRepairCommand(args: readonly string[], cwd: string): Promise<DeepInterviewRepairResult>;

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

@@ -1,3 +1,4 @@
+import { computeAmbiguityFloor, type DeepInterviewAmbiguityMilestone } from "./deep-interview-ambiguity";
 /**
  * Pure, dependency-free foundation for deep-interview state shape.
  *
@@ -35,10 +36,6 @@ export interface DeepInterviewTriggerMetadata {
     status: DeepInterviewTriggerStatus;
     component: string;
     dimension: string;
-    priorDimensionScore?: number;
-    newDimensionScore?: number;
-    priorAmbiguity?: number;
-    newAmbiguity?: number;
     evidence?: string;
     contradictedFactId?: string;
     /** Required when status is `disputed` or `unresolved` to exempt the invariant. */
@@ -68,9 +65,11 @@ export interface DeepInterviewRoundRecord {
     /** Deterministic floor in effect when this round was scored, when it clamped. */
     ambiguity_floor?: number;
     triggers?: DeepInterviewTriggerMetadata[];
+    round_result_digest?: string;
 }
 export interface DeepInterviewStateEnvelope {
     threshold?: number;
+    threshold_units?: number;
     threshold_source?: string;
     state?: Record<string, unknown>;
     [key: string]: unknown;
@@ -197,3 +196,135 @@ export declare function assertDeepInterviewIntentReview(value: unknown, locked:
     round: unknown;
     answer_hash: unknown;
 }[]): asserts value is DeepInterviewIntentReview;
+export type DeepInterviewDimension = "goal" | "constraints" | "criteria" | "context";
+export type DeepInterviewResolution = "auto_research_accepted" | "auto_answer" | "direct" | "refined" | "cited_confirmation";
+export interface DeepInterviewFactOperation {
+    op: "add" | "dispute" | "supersede";
+    id: string;
+    statement?: string;
+    component?: string;
+    dimension?: DeepInterviewDimension;
+    evidence?: string;
+    target_id?: string;
+}
+export interface DeepInterviewOntologyEntity {
+    id: string;
+    name: string;
+    type: string;
+    fields: string[];
+}
+export interface DeepInterviewOntologyRelationship {
+    id: string;
+    from_entity_id: string;
+    to_entity_id: string;
+    type: string;
+}
+export interface DeepInterviewOntologyReasoning {
+    statement: string;
+    evidence?: string;
+}
+export interface DeepInterviewOntologyInput {
+    entities: DeepInterviewOntologyEntity[];
+    relationships: DeepInterviewOntologyRelationship[];
+    reasoning: DeepInterviewOntologyReasoning[];
+}
+export interface DeepInterviewComponentUpdate {
+    component_id: string;
+    scores: Record<DeepInterviewDimension, number>;
+}
+/**
+ * Optional legacy assertions accepted only when they agree with the native
+ * target. The persisted target is always derived from component scores.
+ */
+export interface DeepInterviewTargetingInput {
+    target_component_id?: string;
+    target_dimension?: DeepInterviewDimension;
+    weakest_component_id?: string;
+    weakest_dimension?: DeepInterviewDimension;
+    last_targeted_component_id?: string | null;
+}
+export interface DeepInterviewRoundBookkeeping {
+    resolution: DeepInterviewResolution;
+    round_ids?: string[];
+    counter_deltas?: Record<string, number>;
+}
+/**
+ * Closed evidence submitted for one scoring transaction. All convergence values
+ * (ambiguity, floor, milestone, ontology counts, rotation, and streak) are
+ * native-derived and intentionally cannot be supplied here.
+ */
+export interface DeepInterviewRoundResultV1 {
+    global_scores: Record<DeepInterviewDimension, number>;
+    component_updates?: DeepInterviewComponentUpdate[];
+    targeting?: DeepInterviewTargetingInput;
+    triggers?: DeepInterviewTriggerMetadata[];
+    fact_ops?: DeepInterviewFactOperation[];
+    ontology?: DeepInterviewOntologyInput | DeepInterviewOntologyEntity[];
+    bookkeeping?: DeepInterviewRoundBookkeeping;
+    /** Compatibility adapter for recorder callers; never persisted as the v1 wire shape. */
+    component_scores?: Record<string, Record<DeepInterviewDimension, number>>;
+    auto_answered?: boolean;
+}
+/**
+ * Version 1 native projection returned by `apply-round-result` as
+ * `native_projection`. This is the complete renderable convergence surface;
+ * callers must not derive or supplement it from candidate scorer input.
+ */
+export interface DeepInterviewRoundResultProjection {
+    score_units: Partial<Record<DeepInterviewDimension, number>>;
+    weighted_ambiguity: number;
+    weighted_ambiguity_units: number;
+    floor: number;
+    floor_units: number;
+    floor_cause: ReturnType<typeof computeAmbiguityFloor>;
+    effective_ambiguity: number;
+    effective_ambiguity_units: number;
+    prior_effective_ambiguity: number | null;
+    direction: "increased" | "decreased" | "unchanged" | "initial";
+    ambiguity_milestone: DeepInterviewAmbiguityMilestone;
+    topology: unknown;
+    topology_counts: {
+        active: number;
+        deferred: number;
+        total: number;
+    };
+    ontology: unknown;
+    ontology_counts: {
+        stable: number;
+        changed: number;
+        new: number;
+        basis: string;
+    };
+    targeting: {
+        target_component_id: string | null;
+        target_dimension: DeepInterviewDimension | null;
+        last_targeted_component_id: string | null;
+    };
+    transition: {
+        round_key: string;
+        lifecycle: "scored";
+        auto_answer_streak: number;
+    };
+}
+export type DeepInterviewApplyRoundResult = {
+    kind: "noop";
+    envelope: DeepInterviewStateEnvelope;
+    projection?: DeepInterviewRoundResultProjection;
+} | {
+    kind: "write";
+    envelope: DeepInterviewStateEnvelope;
+    projection: DeepInterviewRoundResultProjection;
+};
+/** Strict UTF-8 JSON serialization used by v1 replay digests. */
+export declare function canonicalDeepInterviewJson(value: unknown): string;
+export declare function deepInterviewRoundResultDigest(input: {
+    round: number;
+    question_id: string;
+    round_id?: string | null;
+    result: unknown;
+}): string;
+/** Complete persisted answer identity; omitted optional values normalize to null. */
+export declare function deepInterviewAnswerIdentityEqual(a: Pick<DeepInterviewRoundRecord, "round" | "round_key" | "round_id" | "question_id" | "component" | "dimension" | "question_text" | "question_hash" | "selected_options" | "custom_input">, b: Pick<DeepInterviewRoundRecord, "round" | "round_key" | "round_id" | "question_id" | "component" | "dimension" | "question_text" | "question_hash" | "selected_options" | "custom_input">): boolean;
+/** Apply one closed v1 scoring round. The input contains evidence only; all convergence state is derived here. */
+export declare function applyDeepInterviewRoundResultV1(envelopeValue: unknown, roundKey: string, result: DeepInterviewRoundResultV1, now: string): DeepInterviewApplyRoundResult;
+export declare function validateDeepInterviewV1Envelope(value: Record<string, unknown>): void;

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

@@ -46,6 +46,47 @@ export interface WorkflowEnvelopeIntegrityMismatch {
     expected: string;
     actual: string;
 }
+export type WorkflowReceiptVerification = "legacy" | "native-valid" | "receipt-malformed" | "receipt-missing" | "checksum-mismatch";
+export interface GuardedWorkflowEnvelopeTransformOptions extends StateWriterOptions {
+    expectedRevision: number;
+    /** Additional native schema validation applied to both current and candidate envelopes. */
+    validate?: (value: Record<string, unknown>, legacy: boolean) => void;
+    transform: (current: Record<string, unknown>, context: {
+        revision: number;
+        legacy: boolean;
+    }) => {
+        kind: "noop";
+    } | {
+        kind: "write";
+        value: Record<string, unknown>;
+    } | Promise<{
+        kind: "noop";
+    } | {
+        kind: "write";
+        value: Record<string, unknown>;
+    }>;
+}
+export interface GuardedWorkflowEnvelopeWarning {
+    code: "DI_POST_COMMIT_AUDIT_FAILED";
+    message: string;
+}
+export type GuardedWorkflowEnvelopeTransformResult = {
+    path: string;
+    written: false;
+    reason: "noop";
+    revision: number;
+    warnings: [];
+} | {
+    path: string;
+    written: true;
+    revision: number;
+    stamped: Record<string, unknown>;
+    warnings: GuardedWorkflowEnvelopeWarning[];
+};
+export declare class GuardedWorkflowEnvelopeError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
 export interface WorkflowTransactionJournal {
     version: 1;
     mutation_id: string;
@@ -80,6 +121,7 @@ export interface StateWriterOptions {
     receipt?: StateWriterReceiptContext;
     audit?: StateWriterAuditContext;
     sourceRevision?: number;
+    orderingRevision?: number;
     /**
      * Cross-process lock tuning for read-modify-write paths that route through
      * `withWorkflowStateLock` / `updateJsonAtomic`. Omit for the hardened
@@ -141,6 +183,8 @@ export type StrictMutationReadResult = {
 };
 export declare function readExistingStateForMutation(filePath: string): Promise<StrictMutationReadResult>;
 export declare function workflowEnvelopeContentSha256(value: unknown): string;
+export declare function isNativeDeepInterviewV1(value: Record<string, unknown>): boolean;
+export declare function verifyWorkflowEnvelopeReceiptValue(value: unknown, filePath: string): WorkflowReceiptVerification;
 export declare function stampWorkflowEnvelopeChecksum<T>(value: T, filePath: string, computedAt?: string): T;
 export declare function detectWorkflowEnvelopeIntegrityMismatch(filePath: string): Promise<WorkflowEnvelopeIntegrityMismatch | undefined>;
 type ActiveStateCacheInvalidator = (cwd?: string, sessionId?: string) => void;
@@ -148,6 +192,7 @@ export declare function setActiveStateCacheInvalidator(invalidator: ActiveStateC
 export declare function persistedStateRevision(value: unknown): number;
 export declare function writeGuardedJsonAtomic(targetPath: string, value: unknown, options: GuardedStateWriterOptions): Promise<GuardedWriteResult>;
 export declare function writeGuardedWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options: GuardedStateWriterOptions): Promise<GuardedWriteResult>;
+export declare function transformGuardedWorkflowEnvelopeAtomic(targetPath: string, options: GuardedWorkflowEnvelopeTransformOptions): Promise<GuardedWorkflowEnvelopeTransformResult>;
 export declare function writeJsonAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeTextAtomic(targetPath: string, text: string, options?: StateWriterOptions): Promise<string>;

package/dist/types/gjc-runtime/workflow-manifest.d.ts

@@ -1,7 +1,6 @@
 /**
  * TypeScript is the authoritative source of truth for GJC workflow manifests.
- * Any JSON manifest projection is derived from this module and must never be
- * hand-edited.
+ * Keep the checked-in JSON projection synchronized manually with this module.
  */
 import { type CanonicalGjcWorkflowSkill } from "../skill-state/canonical-skills";
 export interface WorkflowState {
@@ -18,7 +17,9 @@ export interface WorkflowVerb {
     name: string;
     planned?: boolean;
     /** Invocation surface that exposes this verb in the real CLI parser. */
-    surface?: "state-action" | "command-positional" | "command-flag";
+    surface?: "state-action" | "command-positional" | "command-flag" | "draft-action";
+    /** Legacy surface retained for callers that have not migrated to normal typed commands. */
+    compatibilityOnly?: boolean;
 }
 export interface TypedArgSpec {
     name: string;
@@ -26,6 +27,7 @@ export interface TypedArgSpec {
     enumValues?: string[];
     required?: boolean;
     appliesToVerbs?: string[];
+    compatibilityOnly?: boolean;
     planned?: boolean;
 }
 export interface RetentionPolicy {

package/dist/types/modes/components/welcome.d.ts

@@ -45,3 +45,5 @@ export declare class WelcomeComponent implements Component {
     setLspServers(servers: LspServerInfo[]): void;
     render(termWidth: number): string[];
 }
+/** Resolve the intro cadence without making tests mutate global process state. */
+export declare function resolveWelcomeIntroTickMs(platform?: NodeJS.Platform, tmux?: string | undefined): number;

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

@@ -5,7 +5,7 @@ import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/t
 import { getNotificationConfig, maskToken } from "../../sdk/bus/config";
 import { proposedTelegramIdentity, reconcileCommittedTelegramConfiguration, removeTelegramConfiguration, saveTelegramInactive } from "../../sdk/bus/notification-orchestration";
 import { buildNotificationStatusReport, checkNotificationHealth, recoverNotifications, sanitizeDiagnostic, sendNotificationTest } from "../../sdk/bus/notification-service";
-import { ensureTelegramDaemonRunningDetailed, resolveTelegramSetupPreflight, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
+import { ensureTelegramDaemonRunningDetailed, readNotificationRootRegistration, resolveTelegramSetupPreflight, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
 import { runTelegramSetup } from "../../sdk/bus/telegram-setup";
 import { type CredentialAutoImportStateStore } from "../../setup/credential-auto-import";
 import { type CommandPaletteAction } from "../components/command-palette";
@@ -28,6 +28,13 @@ export interface NotificationsEditorAdapterContext {
     sessionManager: Pick<InteractiveModeContext["sessionManager"], "getCwd" | "getSessionId">;
     notifyConfigChanged?: () => Promise<void> | void;
 }
+type TelegramDaemonStopResult = {
+    ok: boolean;
+    message: string;
+    before?: {
+        health?: string;
+    };
+};
 export interface NotificationsEditorOperationDependencies {
     getNotificationConfig: typeof getNotificationConfig;
     maskToken: typeof maskToken;
@@ -43,7 +50,13 @@ export interface NotificationsEditorOperationDependencies {
     reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
     saveTelegramInactive: typeof saveTelegramInactive;
     removeTelegramConfiguration: typeof removeTelegramConfiguration;
+    readNotificationRootRegistration: typeof readNotificationRootRegistration;
     unregisterNotificationRoot: typeof unregisterNotificationRoot;
+    stopTelegramDaemonIfRootRegistryFenceMatches(input: {
+        settings: Settings;
+        registryFingerprint: string;
+        stop: () => Promise<TelegramDaemonStopResult>;
+    }): Promise<boolean>;
     reloadTelegramDaemon(settings: Settings): Promise<{
         ok: boolean;
         message: string;
@@ -52,13 +65,7 @@ export interface NotificationsEditorOperationDependencies {
         ok: boolean;
         message: string;
     }>;
-    stopTelegramDaemon(settings: Settings): Promise<{
-        ok: boolean;
-        message: string;
-        before?: {
-            health?: string;
-        };
-    }>;
+    stopTelegramDaemon(settings: Settings): Promise<TelegramDaemonStopResult>;
 }
 /**
  * Concrete service adapter for the direct Notifications settings tab. Secrets remain in this closure's
@@ -128,3 +135,4 @@ export declare class SelectorController {
     showJobsOverlay(observer: JobsObserver): void;
     showTasksPane(aggregator: TasksAggregator): void;
 }
+export {};

package/dist/types/runtime-mcp/redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function redactMCPEndpoint(value: string | undefined): string | undefined;
+export declare function redactMCPDiagnosticValue(value: unknown): unknown;