@sayknow-cli/coding-agent 0.3.7 → 0.3.9

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/tmux-common.d.ts

@@ -2,6 +2,7 @@ import type { ResolvedTmuxBinary } from "./psmux-detect";
 export declare const SKC_DEFAULT_TMUX_SESSION = "sayknow_cli";
 export declare const SKC_TMUX_SESSION_PREFIX = "sayknow_cli_";
 export declare const SKC_TMUX_COMMAND_ENV = "SKC_TMUX_COMMAND";
+export declare const SKC_TMUX_ACTIVE_SESSION_ENV = "SKC_TMUX_ACTIVE_SESSION";
 export declare const SKC_TMUX_PROFILE_ENV = "SKC_TMUX_PROFILE";
 export declare const SKC_TMUX_MOUSE_ENV = "SKC_MOUSE";
 export declare const SKC_TMUX_PROFILE_OPTION = "@skc-profile";

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;

package/dist/types/system-prompt.d.ts

@@ -17,9 +17,12 @@ export interface LoadContextFilesOptions {
     cwd?: string;
 }
 /**
- * Load all project context files using the capability API.
+ * Load all context files using the capability API.
  * Returns {path, content, depth} entries for all discovered context files.
- * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
+ * Native user-global files (`~/.skc/agent/AGENTS.md`) come first, then project
+ * files sorted by depth (descending) so files closer to cwd appear last/more
+ * prominent. User-home files from foreign providers (`~/.claude/CLAUDE.md`,
+ * `~/.codex/AGENTS.md`, …) stay excluded — only skc's own user config applies.
  */
 export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
     path: string;
@@ -91,12 +94,25 @@ export interface BuildSystemPromptOptions {
     secretsEnabled?: boolean;
     /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
     workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+    /**
+     * Render a trimmed role-agent base prompt for subagent sessions: omits the
+     * workflow-surface/routing/self-awareness (`<skc-runtime>`) and `<soul>` blocks
+     * that only apply to the top-level interactive/print agent. Tool safety, repo
+     * safety, and the completion contract are retained. Default: false.
+     */
+    subagent?: boolean;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {
     /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
     systemPrompt: string[];
 }
+export interface BuildVolatileProjectContextOptions {
+    cwd?: string;
+    date?: string;
+    workspaceTree?: WorkspaceTree;
+}
+export declare function buildVolatileProjectContext(options?: BuildVolatileProjectContextOptions): string;
 /** Build the system prompt with tools, guidelines, and context */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
 export {};

package/dist/types/task/executor.d.ts

@@ -51,6 +51,8 @@ export interface ExecutorOptions {
     artifactsDir?: string;
     /** Path to parent conversation context file */
     contextFile?: string;
+    /** Whether the parent runtime actually exposes IRC coordination. */
+    ircAvailable?: boolean;
     eventBus?: EventBus;
     contextFiles?: ContextFileEntry[];
     skills?: Skill[];
@@ -112,6 +114,7 @@ interface FinalizeSubprocessOutputResult {
 }
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
+export declare const SUBAGENT_WARNING_PLACEHOLDER_YIELD = "SYSTEM WARNING: Subagent yield data contains a placeholder instead of the actual result.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
 export declare function createSubagentSettings(baseSettings: Settings, inheritedServiceTier?: ServiceTier): Settings;
 /**

package/dist/types/task/fork-context-budget.d.ts

@@ -0,0 +1,7 @@
+export declare const FORK_CONTEXT_TOKEN_BUDGET_BY_MODE: {
+    readonly none: 0;
+    readonly receipt: 2000;
+    readonly "last-turn": 4000;
+    readonly bounded: 8000;
+    readonly full: 15000;
+};

package/dist/types/task/token-log.d.ts

@@ -0,0 +1,30 @@
+import type { ChatUsageSnapshot, CostEstimate } from "@sayknow-cli/agent-core";
+import type { TaskTokenLog, TaskTokenMetrics } from "./types";
+export interface TaskTokenLogChatBuckets {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cachedInputTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly costUsd?: number;
+}
+export interface TaskTokenLogSessionManager {
+    getSessionId(): string;
+}
+export interface TaskTokenLogContext {
+    readonly subagentId: string;
+    readonly agent?: string;
+    readonly turn: number;
+    readonly at: string;
+    readonly model?: string;
+}
+export declare function taskTokenLogFromChat(chat: TaskTokenLogChatBuckets, ctx: TaskTokenLogContext): TaskTokenLog;
+export declare function taskTokenLogFromUsage(usage: ChatUsageSnapshot, ctx: TaskTokenLogContext & {
+    readonly cost?: CostEstimate;
+}): TaskTokenLog;
+export declare function resolveTaskTokenLogDir(cwd: string, sessionManager: TaskTokenLogSessionManager | undefined, envSessionId?: string | undefined): Promise<string | undefined>;
+export declare function persistTaskTokenLog(entry: TaskTokenLog, opts: {
+    dir: string;
+}): Promise<void>;
+export declare function readTaskTokenLogs(dir: string): Promise<TaskTokenLog[]>;
+export declare function computeTaskTokenMetrics(logs: readonly TaskTokenLog[]): TaskTokenMetrics;
+export declare function computeCacheHitRate(input: number, cacheRead: number): number;

package/dist/types/task/token-log.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tools/bisect.d.ts

@@ -0,0 +1,81 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+declare const bisectSchema: z.ZodObject<{
+    good: z.ZodString;
+    bad: z.ZodDefault<z.ZodString>;
+    run: z.ZodString;
+    invert: z.ZodDefault<z.ZodBoolean>;
+    maxSteps: z.ZodDefault<z.ZodNumber>;
+    stepTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type BisectParams = z.infer<typeof bisectSchema>;
+export type BisectVerdict = "good" | "bad" | "skip";
+export interface BisectStep {
+    rev: string;
+    verdict: BisectVerdict;
+}
+export interface BisectMarkResult {
+    exitCode: number;
+    output: string;
+}
+export interface BisectControllerDeps {
+    maxSteps: number;
+    /** SHA of the revision git currently has checked out. */
+    currentRev: () => Promise<string>;
+    /** Evaluate the predicate at the checked-out revision. */
+    evaluate: (rev: string) => Promise<BisectVerdict>;
+    /** Apply the verdict via `git bisect good|bad|skip` and return the raw result. */
+    mark: (verdict: BisectVerdict) => Promise<BisectMarkResult>;
+}
+export interface BisectOutcome {
+    culprit: string | null;
+    steps: BisectStep[];
+    concluded: boolean;
+    reason?: string;
+}
+export interface BisectToolDetails {
+    meta?: OutputMeta;
+    culprit: string | null;
+    invert: boolean;
+    concluded: boolean;
+    steps: BisectStep[];
+    author?: string;
+    date?: string;
+    subject?: string;
+    reason?: string;
+}
+/** Parse the culprit SHA from `git bisect good|bad` output, or null when not yet converged. */
+export declare function parseFirstBadCommit(output: string): string | null;
+/**
+ * Map a predicate exit code to a bisect verdict. `invert` swaps the good/bad
+ * mapping (to hunt for a fixing commit) but never reinterprets a skip.
+ */
+export declare function classifyExit(exitCode: number, invert: boolean): BisectVerdict;
+/**
+ * Drive the bisect loop. Pure orchestration — every git/predicate effect is
+ * injected — so it can be exercised deterministically without a real repo.
+ */
+export declare function runBisectController(deps: BisectControllerDeps, signal?: AbortSignal): Promise<BisectOutcome>;
+export declare class BisectTool implements AgentTool<typeof bisectSchema, BisectToolDetails> {
+    private readonly session;
+    readonly name = "bisect";
+    readonly label = "Bisect";
+    readonly summary = "Find the commit that introduced a regression by driving git bisect with a shell predicate";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        good: z.ZodString;
+        bad: z.ZodDefault<z.ZodString>;
+        run: z.ZodString;
+        invert: z.ZodDefault<z.ZodBoolean>;
+        maxSteps: z.ZodDefault<z.ZodNumber>;
+        stepTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly intent: (args: Partial<BisectParams>) => string;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: BisectParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<BisectToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<BisectToolDetails>>;
+}
+export {};