@gajae-code/coding-agent 0.11.8 → 0.11.9

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [0.11.9] - 2026-07-24
+
+### Fixed
+
+- 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).
+
+- 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 drain spawned child stdout and stderr concurrently with process exit, preventing CI pipe teardown races from replacing 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).
 ## [0.11.8] - 2026-07-23
 ### Added
 
@@ -15,6 +30,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 +61,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 +286,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/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,7 @@ export type StrictMutationReadResult = {
 };
 export declare function readExistingStateForMutation(filePath: string): Promise<StrictMutationReadResult>;
 export declare function workflowEnvelopeContentSha256(value: unknown): string;
+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 +191,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/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;

package/dist/types/sdk/bus/chat-daemon-control.d.ts

@@ -13,7 +13,9 @@ export type ChatDaemonAction = "stop" | "reload";
  * authority declaration contract with bounded frame-delivery acknowledgement.
  * Generation 11 accepts typed retained exact-unlink cleanup authority — a
  * concrete detached quarantine plus a proven-absent canonical lock pathname —
- * when deleting an observed owner-lock lease.
+ * when deleting an observed owner-lock lease. Generation 12 refreshes retained
+ * native path and process authority semantics. Generation 13 rejects special
+ * files before retained native authority opens.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

package/dist/types/sdk/bus/telegram-daemon-contract.d.ts

@@ -36,5 +36,7 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * Generation 25 adds startup dead-root prune + leak-artifact self-heal
  * on TelegramNotificationDaemon.run (#2958). Generation 26 adds bounded reload
  * cooldown and lazy Telegram topic lifecycle safeguards (#2956, #2960, #2984).
+ * Generation 27 refreshes retained native path and process authority semantics.
+ * Generation 28 rejects special files before retained native authority opens.
  */
-export declare const DAEMON_GENERATION = 26;
+export declare const DAEMON_GENERATION = 28;

package/dist/types/session/internal/managed-session-scope.d.ts

@@ -1,6 +1,7 @@
 import * as native from "@gajae-code/natives";
 import type { ResumeSessionIdentity } from "../session-manager";
-import { type ManagedDirectoryRoot, type ManagedSessionSecurityPolicy } from "./managed-session-storage";
+import { type NativeDirectoryTreeSnapshot } from "../session-storage";
+import { type ManagedDirectoryRoot, type ManagedSessionSecurityPolicy, type ManagedStorageLock } from "./managed-session-storage";
 export declare const MANAGED_SESSION_LAYOUT_VERSION: 2;
 export declare const MANAGED_SESSION_IDENTITY_VERSION: 1;
 export declare const MANAGED_SESSION_BINDING_FILE = ".gjc-managed-session-scope.v2.json";
@@ -67,7 +68,7 @@ export type ManagedCandidateListing = {
     code: "scan_failed" | "unsafe_root" | "invalid_candidate";
     message: string;
 };
-export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
+export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "artifact_capacity_exceeded" | "durability_failed" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
 export type ManagedOpenCandidateResult = {
     kind: "opened";
     path: string;
@@ -114,10 +115,19 @@ interface ManagedScopeInput {
 export declare function resolveManagedScope(input: ManagedScopeInput): ManagedScopeResolution;
 /** Resolve a scope for a synchronous write without mutating an existing ACL mismatch. */
 export declare function resolveManagedScopeForWrite(input: ManagedScopeInput): ManagedScopeResolution;
+export declare function canonicalBindingOpenFlags(platform?: NodeJS.Platform): number;
+export declare function fsyncCanonicalBinding(bindingPath: string, expected: string): void;
 export declare function ensureManagedScope(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy): Promise<ManagedScopeResolution>;
 /** Synchronously create and validate the v2 binding before a default session writer exists. */
 export declare function prepareManagedSessionScopeForWriteSync(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy, authority?: ManagedCandidateWriteAuthority): ManagedScopeResolution;
 export declare function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing;
+export declare function matchesMigrationArtifactRoot(pathname: string, identity: {
+    dev: bigint;
+    ino: bigint;
+    size: bigint;
+    mtimeNs: bigint;
+}, expectedTree: NativeDirectoryTreeSnapshot, platform?: NodeJS.Platform): boolean;
+export declare function restorePreparedArtifactRoot(scope: ManagedScope, source: ManagedCandidate, lock?: ManagedStorageLock): void;
 /** Resume tombstoned cleanup under its original operation lease without restoring retired candidates. */
 export declare function reconcileManagedTombstones(scope: ManagedScope): Promise<void>;
 /** Create the v2 binding and private write protocol directories before managed writes. */

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -1,9 +1,10 @@
 import { type NativeDirectoryTreeSnapshot, type NativeOwnerOnlySecurityResult, type RecoveryFsRoot } from "@gajae-code/natives";
 import { type NativePublishOutcome } from "./native-publish-outcome";
 export declare const MANAGED_ARTIFACT_MAX_DEPTH = 32;
-export declare const MANAGED_ARTIFACT_MAX_FILES = 10000;
+export declare const MANAGED_ARTIFACT_MAX_FILES = 50000;
 export declare const MANAGED_ARTIFACT_MAX_FILE_BYTES: number;
 export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
+export declare const MANAGED_ARTIFACT_COPY_BATCH_SIZE = 256;
 export declare class ManagedPublishError extends Error {
     readonly classification: "destination_conflict" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "identity_mismatch" | "io_error" | "durability_failed";
     readonly diagnostic: string;
@@ -12,7 +13,7 @@ export declare class ManagedPublishError extends Error {
 /** Cleanup is safe only when the native move reports that it did not commit. */
 export declare function mayCleanManagedTreeStaging(error: unknown): boolean;
 export type ManagedSessionSecurityPolicy = "default" | "windows-existing-verify-first";
-export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "atomic_unavailable" | "durability_not_provable" | "migration_retired" | "managed_storage_unsupported";
+export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "artifact_capacity_exceeded" | "durability_failed" | "atomic_unavailable" | "durability_not_provable" | "migration_retired" | "managed_storage_unsupported";
 export interface ManagedStorageLock {
     path: string;
     attemptId: string;
@@ -104,8 +105,12 @@ export declare function replaceManagedFile(destination: string, bytes: Uint8Arra
 export declare function copyManagedFileNoReplace(source: string, destination: string, snapshot?: ManagedFileSnapshot, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
 /** Acquire a lease lock with bounded wait, heartbeats, conservative stale reclaim, and fencing. */
 export declare function acquireManagedLock(locksDirectory: string, name: string, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<ManagedStorageLock>;
+export interface ManagedArtifactTreeLimits {
+    maxFiles?: number;
+    maxTotalBytes?: number;
+}
 /** Bounds a no-follow artifact tree before it can be copied or deleted. */
-export declare function validateManagedArtifactTree(root: string): void;
+export declare function validateManagedArtifactTree(root: string, limits?: ManagedArtifactTreeLimits): void;
 /** Flush a copied managed artifact tree, including empty directories, before publishing its receipt. */
 export declare function fsyncManagedArtifactTree(root: string): NativeDirectoryTreeSnapshot;
 export declare function publishManagedTombstone(destination: string, record: Record<string, unknown>, assertOwned?: () => void): Promise<void>;