@sayknow-cli/coding-agent 0.3.7 → 0.3.8

package/dist/types/sdk.d.ts

@@ -1,5 +1,6 @@
 import { type AgentTelemetryConfig, type ThinkingLevel } from "@sayknow-cli/agent-core";
 import { type Model, type ProviderSessionState } from "@sayknow-cli/ai";
+import { createAppendOnlyContextManager, providerSupportsAppendOnlyAuto, resolveAppendOnlyMode } from "./append-only-mode";
 import { type Rule } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
 import { type ScopedModelSelection } from "./config/model-resolver";
@@ -241,5 +242,7 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export { createAppendOnlyContextManager, providerSupportsAppendOnlyAuto, resolveAppendOnlyMode };
 export declare function createPluginHooksExtension(hooks: ConstrainedPluginHook[]): ExtensionFactory;
+export declare function resolveIntentTracingEnabled(intentTracingSetting: boolean | undefined, hasUI: boolean): boolean;
 export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

package/dist/types/session/agent-session.d.ts

@@ -14,7 +14,7 @@
  */
 import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StablePrefixSnapshot, ThinkingLevel } from "@sayknow-cli/agent-core";
 import { type CompactionResult, type EmergencyCompactionSample } from "@sayknow-cli/agent-core/compaction";
-import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@sayknow-cli/ai";
+import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, UsageReport } from "@sayknow-cli/ai";
 export interface ForkContextSeedMetadata {
     sourceSessionId: string;
     parentMessageCount: number;
@@ -75,6 +75,7 @@ import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool
 import type { AskAnswerSource, ToolSession } from "../tools";
 import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
+import { type WorkspaceTree } from "../workspace-tree";
 import type { ClientBridge } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
 import { type CustomMessage } from "./messages";
@@ -159,7 +160,7 @@ export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
     settings: Settings;
-    /** Models to cycle through with Ctrl+P (from --models flag) */
+    /** Models to cycle through with Alt+N (from --models flag) */
     scopedModels?: ScopedModelSelection[];
     /** Initial session thinking selector. */
     thinkingLevel?: ThinkingLevel;
@@ -200,6 +201,8 @@ export interface AgentSessionConfig {
     rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
         systemPrompt: string[];
     }>;
+    /** Initial workspace tree snapshot used for the first volatile per-turn context message. */
+    workspaceTree?: WorkspaceTree;
     /** Rebuild the SSH tool from current capability discovery results. */
     reloadSshTool?: () => Promise<AgentTool | null>;
     requestedToolNames?: ReadonlySet<string>;
@@ -317,6 +320,13 @@ export interface SessionStats {
     premiumRequests: number;
     cost: number;
 }
+export type QueuedMessageEditMode = "steer" | "followUp";
+export interface QueuedMessageEditEntry {
+    id: string;
+    text: string;
+    mode: QueuedMessageEditMode;
+    label: string;
+}
 /** A custom message contributed at the before-agent-start point. */
 export type BeforeAgentStartInternalMessage = Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">;
 /**
@@ -329,6 +339,33 @@ export type BeforeAgentStartContributor = (event: {
     images?: ImageContent[];
     sessionId: string | undefined;
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
+export declare class WorkerIntegrationRequestScheduler {
+    #private;
+    readonly request: () => Promise<void>;
+    constructor(request: () => Promise<void>);
+    enqueue(): void;
+    flush(): Promise<void>;
+}
+export type StreamingEditParsedToolCall = {
+    toolCall: ToolCall;
+    path: string;
+    resolvedPath: string;
+    diff?: string;
+    op?: string;
+    rename?: string;
+};
+export type StreamingEditParsedCacheEntry = {
+    version: string;
+    parsed: StreamingEditParsedToolCall | undefined;
+};
+export declare function getStreamingEditToolCallForEvent(event: AgentEvent, cache: Map<string, StreamingEditParsedCacheEntry>, resolvePath: (filePath: string) => string | undefined): StreamingEditParsedToolCall | undefined;
+/** Test-only counters for AgentSession event fan-out hot-path assertions. */
+export declare const __agentSessionPerfCounters: {
+    listenerSnapshotRebuilds: number;
+    messageUpdateExtensionQueues: number;
+    reset(): void;
+};
+export declare function buildContextInjectionSignature(kind: string, parts: readonly string[]): string;
 export declare class AgentSession {
     #private;
     readonly agent: Agent;
@@ -337,6 +374,13 @@ export declare class AgentSession {
     readonly taskDepth: number;
     readonly yieldQueue: YieldQueue;
     readonly configWarnings: string[];
+    readonly streamingEditDebugCounters: {
+        guardRuns: number;
+        processedChars: number;
+        checkedRemovedLines: number;
+        fullChecks: number;
+        nonEditDeterminations: number;
+    };
     readonly rawSseDebugBuffer: RawSseDebugBuffer;
     constructor(config: AgentSessionConfig);
     /** Model registry for API key resolution and model discovery */
@@ -670,8 +714,11 @@ export declare class AgentSession {
         steering: readonly string[];
         followUp: readonly string[];
     };
+    getQueuedMessageEntries(): QueuedMessageEditEntry[];
+    removeQueuedMessageForEditing(id: string): string | undefined;
+    moveQueuedMessageForEditing(id: string, direction: "up" | "down"): boolean;
     /**
-     * Pop the last queued message (steering first, then follow-up).
+     * Pop the newest queued message across steering and follow-up queues.
      * Used by dequeue keybinding to restore messages to editor one at a time.
      * Returns the popped entry's `.text`; the tag (if any) dies with the
      * record — no orphan state can outlive the queue entry.
@@ -706,6 +753,11 @@ export declare class AgentSession {
      * @returns true if completed, false if cancelled by hook
      */
     newSession(options?: NewSessionOptions): Promise<boolean>;
+    /**
+     * Clear active conversational/model context while preserving the current
+     * session identity and durable history trail.
+     */
+    clearContext(): Promise<boolean>;
     /**
      * Set a display name for the current session.
      */
@@ -905,9 +957,12 @@ export declare class AgentSession {
      */
     setAutoRetryEnabled(enabled: boolean): void;
     /**
-     * Manually retry the last failed assistant turn.
-     * Removes the error message from agent state and re-attempts with a fresh retry budget.
-     * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
+     * Manually retry the last failed assistant turn, or resume an interrupted tail
+     * left by a non-graceful process exit after the user/custom/tool-result message
+     * was persisted but before the agent emitted a terminal assistant response.
+     * Removes failed/aborted/unresolved tool-use assistant tails before
+     * re-attempting with a fresh retry budget.
+     * @returns true if retry/resume was initiated, false if no retryable tail exists or agent is busy
      */
     retry(): Promise<boolean>;
     /**

package/dist/types/session/agent-storage.d.ts

@@ -93,6 +93,7 @@ export declare class AgentStorage {
      * Sets a cached value with expiry time (unix seconds).
      */
     setCache(key: string, value: string, expiresAtSec: number): void;
+    deleteCachePrefix(prefix: string): void;
     /**
      * Deletes expired cache entries. Call periodically for cleanup.
      */

package/dist/types/session/file-mention-pruning.d.ts

@@ -0,0 +1,8 @@
+import type { SessionEntry, SessionMessageEntry } from "./session-manager";
+export interface FileMentionPruneResult {
+    changed: SessionMessageEntry[];
+    bytesSaved: number;
+}
+/** Notice injected in place of a superseded file-mention body. */
+export declare function stalefileMentionNotice(path: string): string;
+export declare function pruneStaleFileMentions(entries: readonly SessionEntry[], resolveAbs: (path: string) => string): FileMentionPruneResult;

package/dist/types/session/messages.d.ts

@@ -129,6 +129,10 @@ export interface FileMentionMessage {
         /** Why the file contents were omitted from auto-read. */
         skippedReason?: "tooLarge";
         image?: ImageContent;
+        /** Set when this mention duplicated a recently shown path (compact note, no full body). */
+        duplicate?: boolean;
+        /** Set when a stale entry was pruned to a digest notice (never silently deleted). */
+        pruned?: boolean;
     }>;
     timestamp: number;
 }

package/dist/types/session/session-manager.d.ts

@@ -1,5 +1,6 @@
 import type { AgentMessage } from "@sayknow-cli/agent-core";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@sayknow-cli/ai";
+import type { TtsrInjectionRecord } from "../export/ttsr";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
@@ -141,6 +142,10 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
     type: "ttsr_injection";
     /** Names of rules that were injected */
     injectedRules: string[];
+    /** Rich rule injection records with repeat state. */
+    injectedRuleRecords?: TtsrInjectionRecord[];
+    /** TTSR manager message count when this injection was recorded. */
+    ttsrMessageCount?: number;
 }
 /** Persisted MCP discovery selection state for a session branch. */
 export interface MCPToolSelectionEntry extends SessionEntryBase {
@@ -212,6 +217,10 @@ export interface SessionContext {
     models: Record<string, string>;
     /** Names of TTSR rules that have been injected this session */
     injectedTtsrRules: string[];
+    /** Rich TTSR rule injection records for repeat resume. */
+    injectedTtsrRuleRecords?: TtsrInjectionRecord[];
+    /** TTSR manager message count for repeat resume. */
+    ttsrMessageCount?: number;
     /** MCP tool names selected through discovery for this session branch. */
     selectedMCPToolNames: string[];
     /** Whether this branch contains an explicit persisted MCP selection entry. */
@@ -477,6 +486,13 @@ export declare class SessionManager {
     appendCompaction<T = unknown>(summary: string, shortSummary: string | undefined, firstKeptEntryId: string, tokensBefore: number, details?: T, fromExtension?: boolean, preserveData?: Record<string, unknown>): string;
     /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
     appendCustomEntry(customType: string, data?: unknown): string;
+    /**
+     * Append a root marker that starts a fresh active branch without changing the
+     * session id or deleting earlier durable entries. Subsequent messages descend
+     * from this marker, so provider context is clear while history remains
+     * available for diagnostics/export.
+     */
+    appendContextClearEntry(data?: Record<string, unknown>): string;
     /**
      * Write mutated message entries back into the canonical entry store by id.
      *
@@ -511,7 +527,7 @@ export declare class SessionManager {
      * @param ruleNames Names of rules that were injected
      * @returns Entry id
      */
-    appendTtsrInjection(ruleNames: string[]): string;
+    appendTtsrInjection(ruleNames: string[], records?: TtsrInjectionRecord[], ttsrMessageCount?: number): string;
     /**
      * Get all unique TTSR rule names that have been injected in the current branch.
      * Scans from root to current leaf for ttsr_injection entries.

package/dist/types/skc-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/skc-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/skc-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/skc-runtime/session-state-sidecar.d.ts

@@ -3,6 +3,11 @@ export declare const SKC_COORDINATOR_SESSION_STATE_FILE_ENV = "SKC_COORDINATOR_S
 export declare const SKC_COORDINATOR_SESSION_ID_ENV = "SKC_COORDINATOR_SESSION_ID";
 export declare const SKC_COORDINATOR_SESSION_BRANCH_ENV = "SKC_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/skc-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/skc-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/skc-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 UltragoalSkcGoalMode = "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;
     skcGoalMode?: UltragoalSkcGoalMode;
     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/skill-state/active-state.d.ts

@@ -92,7 +92,24 @@ export declare function listActiveSkills(raw: unknown): SkillActiveEntry[];
 export declare function normalizeSkillActiveState(raw: unknown): SkillActiveState | null;
 export declare function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths;
 export declare function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]): SkillActiveEntry[];
-export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null>;
+export type VisibleSkillActiveStateCacheTier = "security" | "hud";
+export interface ReadVisibleSkillActiveStateOptions {
+    tier?: VisibleSkillActiveStateCacheTier;
+}
+interface ActiveStateStatSignature {
+    path: string;
+    mtimeMs: number;
+    size: number;
+}
+interface ActiveStateSignature {
+    sessionPath: ActiveStateStatSignature | null;
+    activeDir: ActiveStateStatSignature | null;
+    activeEntries: ActiveStateStatSignature[];
+    ralplanModeState: ActiveStateStatSignature | null;
+}
+export declare function computeActiveStateSignature(cwd: string, sessionId: string): Promise<ActiveStateSignature>;
+export declare function invalidateVisibleSkillActiveStateCache(cwd?: string, sessionId?: string): void;
+export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, opts?: ReadVisibleSkillActiveStateOptions): Promise<SkillActiveState | null>;
 export declare function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void>;
 export interface ApplyHandoffOptions {
     cwd: string;