@gajae-code/coding-agent 0.8.1 → 0.9.0

package/dist/types/export/ttsr.d.ts

@@ -11,9 +11,16 @@ export interface TtsrMatchContext {
     /** Stable key to isolate buffering (for example a tool call ID). */
     streamKey?: string;
 }
+/** Tracks when a rule was last injected (for repeat gating). */
+export interface TtsrInjectionRecord {
+    name: string;
+    lastInjectedAt: number;
+    repeatMode?: "once" | "after-gap";
+    repeatGap?: number;
+}
 export declare class TtsrManager {
     #private;
-    constructor(settings?: TtsrSettings);
+    constructor(settings?: Partial<TtsrSettings>);
     /** Add a TTSR rule to be monitored. */
     addRule(rule: Rule): boolean;
     /**
@@ -29,8 +36,10 @@ export declare class TtsrManager {
     markInjectedByNames(ruleNames: string[]): void;
     /** Get names of all injected rules (for persistence). */
     getInjectedRuleNames(): string[];
-    /** Restore injected state from a list of rule names. */
-    restoreInjected(ruleNames: string[]): void;
+    /** Get full injected rule records (for persistence). */
+    getInjectedRecords(): TtsrInjectionRecord[];
+    /** Restore injected state from legacy rule names or persisted records. */
+    restoreInjected(records: string[] | TtsrInjectionRecord[]): void;
     /** Reset stream buffers (called on new turn). */
     resetBuffer(): void;
     /** Check if any TTSR rules are registered. */
@@ -39,6 +48,8 @@ export declare class TtsrManager {
     incrementMessageCount(): void;
     /** Get current message count. */
     getMessageCount(): number;
+    /** Restore message counter after session resume. */
+    restoreMessageCount(messageCount: number): void;
     /** Get settings. */
     getSettings(): Required<TtsrSettings>;
 }

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 {
@@ -80,8 +92,11 @@ export declare function deriveRoundKey(interviewId: string | undefined, input: {
  * legacy flattened fields hoisted in losslessly, transcript duplicates removed
  * from the top level, and `rounds`/`established_facts` guaranteed to be arrays.
  *
- * Idempotent: a canonical envelope is returned unchanged in shape. Never deletes
- * unknown envelope or nested fields, and never mutates the input.
+ * Idempotent: a canonical envelope is returned unchanged in shape. Preserves all
+ * unknown envelope and nested fields except the envelope-reserved keys that leak
+ * into `state` (see `ENVELOPE_RESERVED_STATE_KEYS`), which are stripped so a
+ * malformed envelope-in-state write cannot permanently nest state. Never mutates
+ * the input.
  */
 export declare function normalizeDeepInterviewEnvelope(value: unknown): DeepInterviewStateEnvelope;
 /**

package/dist/types/gjc-runtime/session-state-sidecar.d.ts

@@ -3,6 +3,11 @@ export declare const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_S
 export declare const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
 export declare const GJC_COORDINATOR_SESSION_BRANCH_ENV = "GJC_COORDINATOR_SESSION_BRANCH";
 export type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
+/** Test-only counters for runtime sidecar hot-path assertions. */
+export declare const __sessionStateSidecarPerfCounters: {
+    persistFromEventCalls: number;
+    reset(): void;
+};
 interface RuntimeStateEvent {
     type: string;
     messages?: unknown[];
@@ -26,6 +31,8 @@ export declare function readTerminalRuntimeStateMarker(input: {
     cwd?: string | null;
     sessionFile?: string | null;
 }): Promise<TerminalRuntimeStateStatus>;
+export declare function stateForEvent(event: RuntimeStateEvent): RuntimeState | null;
+export declare function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean;
 export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeStateEvent, context: RuntimeStateContext): Promise<void>;
 export declare function persistCoordinatorRuntimeStateFromPostmortem(reason: postmortem.Reason, context: RuntimeStateContext): void;
 export declare function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext): () => void;

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

@@ -142,6 +142,8 @@ export declare function readExistingStateForMutation(filePath: string): Promise<
 export declare function workflowEnvelopeContentSha256(value: unknown): string;
 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;
+export declare function setActiveStateCacheInvalidator(invalidator: ActiveStateCacheInvalidator): void;
 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>;
@@ -239,3 +241,4 @@ export declare function beginWorkflowTransactionJournal(input: {
 }): Promise<string>;
 export declare function updateWorkflowTransactionJournal(cwd: string, sessionId: string, mutationId: string, patch: Partial<WorkflowTransactionJournal>): Promise<string>;
 export declare function completeWorkflowTransactionJournal(cwd: string, sessionId: string, mutationId: string): Promise<void>;
+export {};

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

@@ -146,6 +146,7 @@ export interface GjcTeamWorkerLifecycle {
 }
 export type GjcTeamNotificationDeliveryState = "pending" | "sent" | "queued" | "deferred" | "failed" | "delivered" | "acknowledged";
 export type GjcTeamPaneAttemptResult = "sent" | "queued" | "deferred" | "failed";
+export type GjcTeamMailboxDeliveryTransportKind = "notifications_sdk" | "pane";
 export interface GjcTeamNotification {
     id: string;
     kind: "mailbox_message" | "worker_lifecycle" | "invalid_attempt";
@@ -164,6 +165,29 @@ export interface GjcTeamNotification {
     updated_at: string;
     replay_count: number;
 }
+export interface GjcTeamMailboxDeliveryInput {
+    team_name: string;
+    state_dir: string;
+    config: GjcTeamConfig;
+    notification: GjcTeamNotification;
+    message: GjcTeamMailboxMessage;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type GjcTeamMailboxDeliveryResult = {
+    transport: "notifications_sdk";
+    state: GjcTeamNotificationDeliveryState;
+    reason?: string;
+} | {
+    transport: "pane";
+    state: GjcTeamPaneAttemptResult;
+    reason?: string;
+};
+export interface GjcTeamMailboxDeliveryTransport {
+    deliverMailboxMessage(input: GjcTeamMailboxDeliveryInput): Promise<GjcTeamMailboxDeliveryResult | null>;
+}
+export declare function setGjcTeamMailboxDeliveryTransport(transport: GjcTeamMailboxDeliveryTransport | undefined): () => void;
+export declare function setGjcTeamMailboxDeliveryTransportForTest(transport: GjcTeamMailboxDeliveryTransport | undefined): () => void;
 export interface GjcTeamNotificationSummary {
     total: number;
     replay_eligible: number;
@@ -197,6 +221,7 @@ export interface GjcTeamStartOptions {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     dryRun?: boolean;
+    mailboxDeliveryTransport?: GjcTeamMailboxDeliveryTransport;
 }
 export interface GjcTeamApiClaimResult {
     ok: boolean;
@@ -280,7 +305,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 = {
@@ -305,6 +331,7 @@ export declare function classifyGjcTeamCheckpointFiles(files: string[]): {
     protected: string[];
 };
 export declare function classifyWorkerCheckpointStatus(cwd: string): GjcWorkerCheckpointClassification;
+export declare function classifyWorkerCheckpointStatusAsync(cwd: string): Promise<GjcWorkerCheckpointClassification>;
 export declare function startGjcTeam(options: GjcTeamStartOptions): Promise<GjcTeamSnapshot>;
 export declare function readGjcTeamSnapshot(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv, options?: GjcTeamSnapshotOptions): Promise<GjcTeamSnapshot>;
 export declare function monitorGjcTeamSnapshot(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot>;

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

@@ -0,0 +1,42 @@
+import type { UltragoalCompletionVerification, UltragoalGoal, UltragoalGoalStatus, UltragoalLedgerEvent, UltragoalPlan, UltragoalReceiptKind } from "./ultragoal-runtime";
+export type UltragoalReceiptFreshnessDiagnostic = {
+    state: "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
+    message: string;
+    goalId?: string;
+};
+export declare function requiredUltragoalGoals(plan: UltragoalPlan): UltragoalGoal[];
+export declare function receiptRelevantGoals(plan: UltragoalPlan, goal: UltragoalGoal, receiptKind: UltragoalReceiptKind): UltragoalGoal[];
+export declare function computeUltragoalPlanGeneration(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receiptKind: UltragoalReceiptKind;
+    beforeStatus: UltragoalGoalStatus;
+    excludeEventId?: string;
+    targetGoalUpdatedAt?: string;
+}): {
+    planGeneration: string;
+    basis: UltragoalCompletionVerification["basis"];
+};
+export declare function findLedgerReceiptEvent(ledger: readonly UltragoalLedgerEvent[], receipt: UltragoalCompletionVerification): UltragoalLedgerEvent | null;
+export declare function validateReceiptFreshBase(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receipt: UltragoalCompletionVerification;
+    receiptKind: UltragoalReceiptKind;
+}): UltragoalReceiptFreshnessDiagnostic | null;
+export declare function findFreshBatchCloseReceipt(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    deferredGoal: UltragoalGoal;
+    deferredReceipt: UltragoalCompletionVerification;
+}): UltragoalCompletionVerification | null;
+export declare function validateDeferredMemberReceiptFresh(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receipt: UltragoalCompletionVerification;
+    receiptKind: UltragoalReceiptKind;
+    requireClose: boolean;
+}): UltragoalReceiptFreshnessDiagnostic;

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

@@ -1,6 +1,77 @@
 import type { WorkflowHudSummary } from "../skill-state/active-state";
+export { computeUltragoalPlanGeneration, receiptRelevantGoals } from "./ultragoal-receipt-freshness";
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus = "pending" | "active" | "complete" | "failed" | "blocked" | "review_blocked" | "superseded";
+export type UltragoalPipelineMetadataSource = "original_plan_graph" | "legacy_brief_only" | "steering";
+export type UltragoalPipelineOverlapState = "none" | "open" | "joined_clean" | "blocked_disjoint_continue" | "quarantine_required" | "rebaseline_complete";
+export interface UltragoalPipelineTargets extends JsonObject {
+    files: string[];
+    surfaces: string[];
+}
+export interface UltragoalPipelineMetadata extends JsonObject {
+    schemaVersion: 1;
+    goalId: string;
+    source: UltragoalPipelineMetadataSource;
+    eligible: boolean;
+    dependsOn: string[];
+    independentOf: string[];
+    targets: UltragoalPipelineTargets;
+    metadataHash: string;
+    overlap: UltragoalPipelineOverlapState;
+    overlapId?: string;
+    priorGoalId?: string;
+    nextGoalId?: string;
+    blockerFootprints?: UltragoalPipelineTargets[];
+    invalidationReason?: string;
+    invalidatedAt?: string;
+}
+export interface UltragoalGoalMetadataInput {
+    schemaVersion: 1;
+    goalId: string;
+    source: UltragoalPipelineMetadataSource;
+    dependsOn?: string[];
+    independentOf?: string[];
+    targets?: Partial<UltragoalPipelineTargets>;
+}
+export interface UltragoalValidationBatchMetadata extends JsonObject {
+    schemaVersion: 1;
+    batchId: string;
+    memberIds: string[];
+    finalGoalId: string;
+    mode: "aggregate-only";
+    metadataHash: string;
+}
+export interface UltragoalValidationBatchInput {
+    schemaVersion: 1;
+    batchId: string;
+    memberIds: string[];
+    finalGoalId: string;
+}
+export interface UltragoalPipelineOverlapHandles extends JsonObject {
+    review: JsonObject;
+    qa: JsonObject;
+    implementation: JsonObject;
+}
+export interface UltragoalPipelineOverlapReceipt extends JsonObject {
+    ok: true;
+    event: string;
+    overlap_id: string;
+    prior_goal_id: string;
+    next_goal_id?: string;
+    goal_id?: string;
+    status?: UltragoalPipelineOverlapState;
+    next_goal_status?: UltragoalGoalStatus;
+    goals_path: string;
+    ledger_path: string;
+}
+export type UltragoalPipelineLedgerEventName = "pipeline_overlap_started" | "pipeline_overlap_joined" | "pipeline_overlap_blocked" | "pipeline_overlap_quarantined" | "pipeline_overlap_rebaselined";
+export interface UltragoalPipelineLedgerEvent extends UltragoalLedgerEvent {
+    event: UltragoalPipelineLedgerEventName;
+    schemaVersion: 1;
+    overlapId: string;
+    priorGoalId: string;
+    nextGoalId: string;
+}
 export interface UltragoalGoal {
     id: string;
     title: string;
@@ -13,6 +84,8 @@ export interface UltragoalGoal {
     evidence?: string;
     steering?: Record<string, unknown>;
     completionVerification?: UltragoalCompletionVerification;
+    pipelineMetadata?: UltragoalPipelineMetadata;
+    validationBatch?: UltragoalValidationBatchMetadata;
 }
 export interface UltragoalPlan {
     version: 1;
@@ -45,6 +118,26 @@ export interface UltragoalCompletionVerification {
         requiredGoalSetHashBeforeCheckpoint: string;
     };
     checkpointLedgerEventId: string;
+    validationBatch?: {
+        schemaVersion: 1;
+        role: "deferred-member";
+        batchId: string;
+        memberIds: string[];
+        finalGoalId: string;
+        metadataHash: string;
+        changeSetHash: string;
+    } | {
+        schemaVersion: 1;
+        role: "batch-close";
+        batchId: string;
+        memberIds: string[];
+        finalGoalId: string;
+        memberMetadataHashes: Record<string, string>;
+        memberReceiptIds: Record<string, string>;
+        memberCheckpointLedgerEventIds: Record<string, string>;
+        memberChangeSetHashes: Record<string, string>;
+        unionHash: string;
+    };
 }
 export interface UltragoalLedgerEvent extends JsonObject {
     eventId?: string;
@@ -106,6 +199,7 @@ export interface UltragoalStatusSummary {
     nudgeRemaining?: number;
     nudgeGoalId?: string;
     nudgeTargetKind?: UltragoalNudgeTargetKind;
+    pipelineOverlap?: JsonObject;
 }
 export interface UltragoalCommandResult {
     reviewBlockerGoalIds?: string[];
@@ -161,18 +255,6 @@ export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
     reason: string;
     currentGoalObjective?: string;
 }): Promise<UltragoalNudgeOutcome>;
-export declare function computeUltragoalPlanGeneration(input: {
-    plan: UltragoalPlan;
-    ledger: readonly UltragoalLedgerEvent[];
-    goal: UltragoalGoal;
-    receiptKind: UltragoalReceiptKind;
-    beforeStatus: UltragoalGoalStatus;
-    excludeEventId?: string;
-    targetGoalUpdatedAt?: string;
-}): {
-    planGeneration: string;
-    basis: UltragoalCompletionVerification["basis"];
-};
 export declare function readUltragoalPlan(cwd: string, sessionId?: string | null): Promise<UltragoalPlan | null>;
 export declare function getUltragoalStatus(cwd: string, sessionId?: string | null): Promise<UltragoalStatusSummary>;
 export declare function buildUltragoalHudSummary(summary: UltragoalStatusSummary, latestLedger?: UltragoalLedgerEvent): WorkflowHudSummary;
@@ -181,6 +263,10 @@ export declare function createUltragoalPlan(input: {
     brief: string;
     gjcGoalMode?: UltragoalGjcGoalMode;
     sessionId?: string | null;
+    goalMetadata?: UltragoalGoalMetadataInput[];
+    goalMetadataJson?: string;
+    validationBatches?: UltragoalValidationBatchInput[];
+    validationBatchJson?: string;
 }): Promise<UltragoalPlan>;
 export interface UltragoalRunCompletionState {
     requiredGoals: UltragoalGoal[];
@@ -190,6 +276,27 @@ export interface UltragoalRunCompletionState {
     hasBlockers: boolean;
     needsFinalAggregateReceipt: boolean;
 }
+export declare function startUltragoalPipelineOverlap(input: {
+    cwd: string;
+    priorGoalId: string;
+    nextGoalId: string;
+    reviewHandles: JsonObject | JsonObject[];
+    qaHandles: JsonObject | JsonObject[];
+    implementationHandle: JsonObject;
+}): Promise<UltragoalPipelineOverlapReceipt>;
+export declare function joinUltragoalPipelineOverlap(input: {
+    cwd: string;
+    overlapId: string;
+    reviewResult: JsonObject;
+    qaResult: JsonObject;
+}): Promise<UltragoalPipelineOverlapReceipt>;
+export declare function rebaselineUltragoalPipelineOverlap(input: {
+    cwd: string;
+    overlapId: string;
+    goalId: string;
+    evidence: string;
+    targetState: JsonObject;
+}): Promise<UltragoalPipelineOverlapReceipt>;
 export declare function getUltragoalRunCompletionState(plan: UltragoalPlan, options?: {
     retryFailed?: boolean;
 }): UltragoalRunCompletionState;
@@ -218,6 +325,7 @@ interface UltragoalChangeSet extends JsonObject {
     mergeBase?: string;
     paths: UltragoalChangeSetPath[];
     rawDiffStat?: string;
+    rawDiff?: string;
     trusted: true;
 }
 export declare function normalizeSurfaceToken(value: string): string;
@@ -300,4 +408,3 @@ interface UltragoalReviewResult extends JsonObject {
 export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
 export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;
-export {};

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

@@ -35,6 +35,7 @@ export declare class GoalRuntime {
     #private;
     constructor(host: GoalRuntimeHost);
     get snapshot(): GoalRuntimeSnapshot;
+    shouldTrackTurnBaseline(): boolean;
     onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void;
     onToolCompleted(toolName: string): Promise<void>;
     onGoalToolCompleted(): Promise<void>;

package/dist/types/hooks/native-skill-hook.d.ts

@@ -11,6 +11,18 @@ interface GjcNativeHookDispatchOptions {
     effectiveSkillConfig?: EffectiveSkillConfigInput;
     configPaths?: string[];
 }
+export declare function clearGjcNativeSkillHookCachesForTesting(): void;
+export declare function getGjcNativeSkillHookCacheStatsForTesting(): {
+    effectiveSkillConfigResolutions: number;
+};
+export declare function resolveGjcNativeSkillConfigForTesting(input: {
+    cwd: string;
+    configPaths?: string[];
+    sessionId?: string;
+    threadId?: string;
+    stateDir?: string;
+}): Promise<EffectiveSkillConfigInput>;
 export declare function dispatchGjcNativeSkillHook(payload: HookPayload, options?: GjcNativeHookDispatchOptions): Promise<GjcNativeHookDispatchResult>;
+export declare function runGjcNativeSkillHookInProcess(payload: HookPayload): Promise<string>;
 export declare function runGjcNativeSkillHookCli(): Promise<void>;
 export {};

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/assistant-message.d.ts

@@ -1,5 +1,8 @@
 import type { AssistantMessage, ImageContent, Usage } from "@gajae-code/ai";
 import { Container } from "@gajae-code/tui";
+interface AssistantMessageUpdateOptions {
+    streaming?: boolean;
+}
 /**
  * Component that renders a complete assistant message
  */
@@ -12,5 +15,6 @@ export declare class AssistantMessageComponent extends Container {
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     setUsageInfo(usage: Usage): void;
-    updateContent(message: AssistantMessage): void;
+    updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void;
 }
+export {};

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/components/status-line.d.ts

@@ -90,5 +90,14 @@ export declare class StatusLineComponent implements Component {
      * everything fits on one row.
      */
     getPreviewContent(width: number): string;
+    getCacheStatsForTest(): {
+        rowHits: number;
+        rowMisses: number;
+    };
+    invalidateBranchForTest(): void;
+    setCachedPrForTest(pr: {
+        number: number;
+        url: string;
+    } | null): void;
     render(width: number): string[];
 }