@gajae-code/coding-agent 0.11.0 → 0.11.2

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

@@ -4,9 +4,11 @@ import type { ImageContent, Message, MessageAttribution, ServiceTier, TextConten
 import type { TtsrInjectionRecord } from "../export/ttsr";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
+import { type ManagedMigrationPolicy } from "./internal/managed-session-scope";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
+import { type SessionManagerReadAccess, sessionManagerReadCapability } from "./session-manager-internal";
 import type { SessionStorage, SessionStorageStat, VerifiedSessionDeleteResult, VerifiedSessionDeleteTarget } from "./session-storage";
-export declare const CURRENT_SESSION_VERSION = 3;
+export declare const CURRENT_SESSION_VERSION = 4;
 export interface SessionHeader {
     type: "session";
     version?: number;
@@ -80,6 +82,8 @@ export declare function associateSessionMessageObservationId(message: AgentMessa
 export declare function getSessionMessageObservationId(message: AgentMessage): string | undefined;
 export declare function associateSessionMessageViewportAnchorId(message: AgentMessage, anchorId: string): void;
 export declare function getSessionMessageViewportAnchorId(message: AgentMessage): string | undefined;
+/** Returns registered viewport anchors for durable user messages in session order. */
+export declare function getUserMessageViewportAnchorIds(messages: readonly AgentMessage[]): string[];
 export declare function transferSessionMessageIdentity(source: AgentMessage[], target: AgentMessage[]): void;
 export interface ThinkingLevelChangeEntry extends SessionEntryBase {
     type: "thinking_level_change";
@@ -211,7 +215,19 @@ export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
 }
 /** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
 export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry | ConfiguredModelChainEntry;
-/** Raw file entry (includes header) */
+/** Append-only replacement for mutable fields on the session header. */
+export interface HeaderPatchRecord {
+    type: "header_patch";
+    patch: Partial<Pick<SessionHeader, "title" | "titleSource" | "cwd">>;
+}
+/** Append-only replacement for replay metadata on one existing session entry. */
+export interface EntryPatchRecord {
+    type: "entry_patch";
+    entryId: string;
+    patch: Partial<Pick<SessionMessageEntry, "message">>;
+}
+export type SessionPatchRecord = HeaderPatchRecord | EntryPatchRecord;
+/** Resolved file entries; patch records are applied by parseSessionEntries(). */
 export type FileEntry = SessionHeader | SessionEntry;
 export type DefaultModelSelectionStage = {
     readonly entryRevision: number;
@@ -282,7 +298,16 @@ export interface ResumeTailTerminal {
 }
 export interface ResumeTailError {
     kind: "error";
-    reason: "missing" | "malformed" | "unstable" | "read-failed";
+    reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled";
+}
+export type SessionDirectoryMigrationPolicy = ManagedMigrationPolicy;
+export declare class SessionManagedStorageError extends Error {
+    readonly code = "managed_storage_unsupported";
+    constructor();
+}
+export declare class SessionMigrationPolicyError extends Error {
+    readonly code = "legacy_migration_disabled";
+    constructor();
 }
 export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
 export interface StrictSessionOpenSuccess {
@@ -321,6 +346,8 @@ export interface SessionInfo {
     created: Date;
     modified: Date;
     messageCount: number;
+    /** True when messageCount was counted from only the bounded list prefix. */
+    messageCountIsEstimate?: boolean;
     /** File size in bytes on disk; used for compact list rendering. */
     size: number;
     firstMessage: string;
@@ -367,7 +394,35 @@ export type SessionManagerCloseOutcome = {
     kind: "close_unknown";
     error: Error;
 };
-export type ReadonlySessionManager = Pick<SessionManager, "getCwd" | "getSessionDir" | "getSessionId" | "getSessionFile" | "getSessionName" | "getArtifactsDir" | "getArtifactManager" | "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "getLeafId" | "getLeafEntry" | "getEntry" | "getLabel" | "getBranch" | "getHeader" | "getEntries" | "getTree" | "getUsageStatistics" | "putBlob">;
+/** Read-only session state made available to extensions and custom tools. */
+/** Frozen read-only session facade made available to extensions and custom tools. */
+export interface ReadonlySessionManager {
+    getCwd(): string;
+    getSessionDir(): string;
+    getSessionId(): string;
+    getSessionFile(): string | undefined;
+    getSessionName(): string | undefined;
+    getArtifactsDir(): string | null;
+    getArtifactPath(id: string): Promise<string | null>;
+    getLeafId(): string | null;
+    getLeafEntry(): SessionEntry | undefined;
+    getEntry(id: string): SessionEntry | undefined;
+    getLabel(id: string): string | undefined;
+    getBranch(fromId?: string): SessionEntry[];
+    getHeader(): SessionHeader | null;
+    getEntries(): SessionEntry[];
+    getTree(): SessionTreeNode[];
+    getUsageStatistics(): UsageStatistics;
+}
+/** Creates an immutable facade that never exposes SessionManager mutation authority. */
+export declare function createReadonlySessionManager(manager: SessionManager): ReadonlySessionManager;
+/** Internal artifact-writing capability. Read-only facades expose it only through a private weak-map lookup. */
+export type SessionArtifactCapability = Readonly<Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "putBlob">>;
+/**
+ * Returns the artifact capability for a concrete persistence owner or one of its
+ * immutable read-only facades. Structural lookalikes remain unauthorized.
+ */
+export declare function sessionArtifactCapability(value: unknown): SessionArtifactCapability | undefined;
 /** Exported for testing */
 export declare function migrateSessionEntries(entries: FileEntry[]): void;
 /** Exported for compaction.test.ts */
@@ -408,6 +463,11 @@ declare class RecentSessionInfo {
 export declare function recoverOrphanedBackups(sessionDir: string, storage: SessionStorage): Promise<void>;
 /** Exported for testing */
 export declare function findMostRecentSession(sessionDir: string, storage?: SessionStorage): Promise<string | null>;
+interface SessionMoveDirectoryHandle {
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function syncSessionMoveDirectory(directory: string, platform?: NodeJS.Platform, openDirectory?: (directory: string) => Promise<SessionMoveDirectoryHandle>): Promise<void>;
 declare const RESIDENT_BLOB_SENTINEL_KEY = "__gjcResidentBlob";
 type ResidentBlobKind = "text" | "imageUrl" | "imageData";
 interface ResidentBlobSentinel {
@@ -481,7 +541,7 @@ export declare class SessionManager {
     setSessionFile(sessionFile: string): Promise<void>;
     /** Start a new session. Closes any existing writer first. */
     newSession(options?: NewSessionOptions): Promise<string | undefined>;
-    /** Delete a session file and its artifacts. Drains the persist writer first to avoid EPERM on Windows. ENOENT is treated as success. */
+    /** Tombstone and exact-delete managed transcripts, detaching the active transcript first. */
     dropSession(sessionPath: string): Promise<void>;
     /**
      * Fork the current session, creating a new session file with the same entries.
@@ -639,6 +699,8 @@ export declare class SessionManager {
      * the canonical store. This applies such mutations for real.
      */
     applyEntryMessageUpdates(entries: readonly SessionMessageEntry[]): void;
+    /** Write mutated custom-message entries back into the canonical entry store by id. */
+    applyCustomMessageEntryUpdates(entries: readonly CustomMessageEntry[]): void;
     /**
      * Rewrite the session file after in-place entry updates.
      * Use sparingly (e.g., pruning old tool outputs).
@@ -717,8 +779,11 @@ export declare class SessionManager {
      * Build the session context (what gets sent to the LLM).
      * Uses tree traversal from current leaf.
      */
+    /**
+     * Return a defensive context snapshot for public consumers.
+     */
     buildSessionContext(): SessionContext;
-    /** Strip stale OpenAI Responses assistant replay metadata from loaded in-memory entries. */
+    /** Strip stale OpenAI Responses assistant replay metadata from loaded in-memory entries without persisting it. */
     sanitizeLoadedOpenAIResponsesReplayMetadata(): boolean;
     /**
      * Get session header.
@@ -726,11 +791,12 @@ export declare class SessionManager {
     getHeader(): SessionHeader | null;
     getEntries(): SessionEntry[];
     /**
-     * Get the session as a tree structure. Returns a shallow defensive copy of all entries.
+     * Get the session as a tree structure. Returns defensive copies of all entries.
      * A well-formed session has exactly one root (first entry with parentId === null).
      * Orphaned entries (broken parent chain) are also returned as roots.
      */
     getTree(): SessionTreeNode[];
+    [sessionManagerReadCapability](): SessionManagerReadAccess;
     /**
      * Start a new branch from an earlier entry.
      * Moves the leaf pointer to the specified entry. The next appendXXX() call
@@ -768,21 +834,25 @@ export declare class SessionManager {
      * @param sessionDir Optional session directory. If omitted, uses default (~/.gjc/agent/sessions/<encoded-cwd>/).
      */
     static create(cwd: string, sessionDir?: string, storage?: SessionStorage): SessionManager;
+    /** Resolve a default-managed candidate through binding validation and copy-retain migration before mutation. */
+    static prepareManagedCandidateForWrite(filePath: string, migrationPolicy: SessionDirectoryMigrationPolicy): Promise<string>;
     /**
      * Fork a session into the current project directory.
      * Copies history from another session file while creating a new session file in the current sessionDir.
      */
-    static forkFrom(sourcePath: string, cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
+    static forkFrom(sourcePath: string, cwd: string, sessionDir?: string, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
     /**
      * Open a specific session file.
      * @param path Path to session file
      * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
      */
-    static open(filePath: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
+    static open(filePath: string, sessionDir?: string, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
     /**
      * List sessions for the resume picker without recovery or other maintenance writes.
      */
     static listForResumePickerReadOnly(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionInfo[]>;
+    /** Tombstone and exact-delete a default-managed candidate. */
+    static deleteManagedCandidate(sessionPath: string): Promise<void>;
     /** Capture exact source content for a strict fork without granting write ownership. */
     static captureTranscriptStrict(filePath: string, storage?: SessionStorage): StrictSessionCaptureResult;
     /**
@@ -790,7 +860,7 @@ export declare class SessionManager {
      * revalidate captured authority before destination initialization and transcript
      * persistence; destination history always comes from the captured bytes.
      */
-    static forkFromCaptured(snapshot: CapturedSessionTranscriptSnapshot, cwd: string, sessionDir?: string): Promise<StrictSessionForkResult>;
+    static forkFromCaptured(snapshot: CapturedSessionTranscriptSnapshot, cwd: string, sessionDir?: string, _migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<StrictSessionForkResult>;
     /** Inspect a selected session without acquiring write-capable ownership. */
     static inspectSessionTailReadOnly(filePath: string, storage?: SessionStorage): Promise<ResumeTailInspection>;
     /**
@@ -798,13 +868,13 @@ export declare class SessionManager {
      * the returned discriminant; an error result never creates, rewrites, or adopts
      * the selected path. Breadcrumb ownership begins only after `kind: "opened"`.
      */
-    static openExistingStrict(identity: ResumeSessionIdentity, sessionDir?: string, storage?: SessionStorage): Promise<StrictSessionOpenResult>;
+    static openExistingStrict(identity: ResumeSessionIdentity, sessionDir?: string, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<StrictSessionOpenResult>;
     /**
      * Continue the most recent session, or create new if none.
      * @param cwd Working directory
      * @param sessionDir Optional session directory. If omitted, uses default (~/.gjc/agent/sessions/<encoded-cwd>/).
      */
-    static continueRecent(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
+    static continueRecent(cwd: string, sessionDir?: string, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
     /** Create an in-memory session (no file persistence) */
     static inMemory(cwd?: string, storage?: SessionStorage): SessionManager;
     /**

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

@@ -109,10 +109,13 @@ export interface SessionStorage {
     deleteSessionVerified?(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult>;
     openWriter(path: string, options?: SessionStorageWriterOpenOptions): SessionStorageWriter;
 }
-/** Exact (dev, ino) identity fields used for ACP authorization binding. */
+/** Exact authorization evidence for a transcript or artifact path. */
 export interface SessionStorageFileIdentity {
     dev: bigint;
     ino: bigint;
+    size: number;
+    mtimeNs: bigint;
+    sha256: string;
 }
 /** Kind of verification failure surfaced by {@link deleteSessionVerified}. */
 export type VerifiedDeleteFailureKind = "containment" | "symlink" | "stat" | "identity" | "header" | "cwd" | "artifacts";
@@ -149,6 +152,18 @@ export interface VerifiedSessionDeleteTarget {
      * fails closed. Omit on first attempt or to accept recorded absence.
      */
     expectedArtifactsIdentity?: SessionStorageFileIdentity;
+    /** Stable native recursive-tree evidence captured before artifact detachment. */
+    expectedArtifactsTree?: NativeDirectoryTreeSnapshot;
+    /** Identity-bound quarantine path retained when recursive artifact cleanup failed. */
+    detachedArtifactsPath?: string;
+    /** Identity-bound quarantine path retained when transcript unlink deferred cleanup. */
+    detachedTranscriptPath?: string;
+    /** Caller-published, no-replace quarantine pathname for the next artifact detach. */
+    plannedArtifactsPath?: string;
+    /** Caller-published, no-replace quarantine pathname for the next transcript detach. */
+    plannedTranscriptPath?: string;
+    /** Set only after a durable caller receipt records successful artifact removal. */
+    artifactsRemoved?: true;
 }
 /**
  * Outcome of a verified hard delete. Artifact removal happens first; only after
@@ -157,6 +172,10 @@ export interface VerifiedSessionDeleteTarget {
  * `deleted` and never `{}`.
  */
 export type VerifiedSessionDeleteResult = {
+    kind: "artifacts_removed";
+    phase: "artifacts";
+    transcriptIdentity: SessionStorageFileIdentity;
+} | {
     kind: "deleted";
 } | {
     kind: "cleanup_pending";
@@ -164,6 +183,10 @@ export type VerifiedSessionDeleteResult = {
     error: Error;
     /** Artifact directory identity at failure time; undefined when absent. */
     artifactsIdentity: SessionStorageFileIdentity | undefined;
+    /** Identity-bound quarantine path retained when recursive cleanup failed. */
+    detachedArtifactsPath: string;
+    /** Native snapshot required for an identity-bound recursive retry. */
+    artifactsTree: NativeDirectoryTreeSnapshot;
     /** Transcript identity (unchanged) for retry binding. */
     transcriptIdentity: SessionStorageFileIdentity;
 } | {
@@ -172,6 +195,22 @@ export type VerifiedSessionDeleteResult = {
     error: Error;
     /** Transcript identity at failure time for retry binding. */
     transcriptIdentity: SessionStorageFileIdentity;
+    /** Optional identity-bound transcript quarantine path for restart cleanup. */
+    detachedTranscriptPath?: string;
+};
+type NativeDirectoryTreeEntry = {
+    relativePath: string;
+    kind: string;
+    dev: string;
+    ino: string;
+    size: string;
+    mtimeNs: string;
+    sha256?: string;
+};
+export type NativeDirectoryTreeSnapshot = {
+    rootDev: string;
+    rootIno: string;
+    entries: NativeDirectoryTreeEntry[];
 };
 export declare class FileSessionStorage implements SessionStorage {
     #private;
@@ -194,8 +233,8 @@ export declare class FileSessionStorage implements SessionStorage {
     unlinkSync(path: string): void;
     openWriter(path: string, options?: SessionStorageWriterOpenOptions): SessionStorageWriter;
     /**
-     * Delete a session file and its artifacts directory.
-     * Artifacts are stored in a sibling directory with the same name minus .jsonl extension.
+     * Delete a session and sibling artifacts in an operator-selected explicit directory.
+     * Default managed roots use deleteSessionVerified and never call this path.
      */
     deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
     /**
@@ -228,3 +267,4 @@ export declare class MemorySessionStorage implements SessionStorage {
     deleteSessionVerified(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult>;
     openWriter(path: string, options?: SessionStorageWriterOpenOptions): SessionStorageWriter;
 }
+export {};

package/dist/types/session/volatile-context-pruning.d.ts

@@ -0,0 +1,15 @@
+import type { CustomMessageEntry, SessionEntry } from "./session-manager";
+/**
+ * Volatile context is refreshed for every prompt. Only its newest copy is useful;
+ * replacing older copies at a maintenance boundary preserves the audit trail
+ * without repeatedly charging the model for stale workspace snapshots.
+ */
+export declare function pruneSupersededVolatileProjectContext(entries: readonly SessionEntry[]): {
+    changed: CustomMessageEntry[];
+    bytesSaved: number;
+};
+/** Retire superseded known singleton maintenance reminders without touching ordinary user context. */
+export declare function pruneSupersededMaintenanceReminders(entries: readonly SessionEntry[]): {
+    changed: CustomMessageEntry[];
+    bytesSaved: number;
+};

package/dist/types/skill-state/{deep-interview-mutation-guard.d.ts → workflow-mutation-guard.d.ts}

@@ -1,4 +1,5 @@
 import type { AgentTool } from "@gajae-code/agent-core";
+import { readVisibleSkillActiveState } from "./active-state";
 export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `gjc deep-interview --write --stage final` or hand off to an execution phase.";
 export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = ".gjc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.gjc/**`; use the sanctioned `gjc` CLI instead.";
 export declare const RALPLAN_MUTATION_BLOCK_MESSAGE = "Ralplan planning phase boundary: keep refining the consensus plan and persist plan artifacts through `gjc ralplan --write` (stage scratch files under a temp dir if needed). Product-code mutation tools and patch execution are blocked while ralplan is active; mutate only after the plan is approved and execution begins.";
@@ -7,7 +8,7 @@ type ToolWithEditMode = AgentTool & {
     mode?: unknown;
     customWireName?: unknown;
 };
-export interface DeepInterviewMutationGuardInput {
+export interface WorkflowMutationGuardInput {
     cwd: string;
     sessionId?: string;
     threadId?: string;
@@ -15,24 +16,39 @@ export interface DeepInterviewMutationGuardInput {
     args: unknown;
     forceOverride?: boolean;
     enforceWorkflowState?: boolean;
+    guardContext?: WorkflowGuardContext;
 }
-export interface DeepInterviewMutationDecision {
+export interface WorkflowMutationDecision {
     blocked: boolean;
     message?: string;
     targets: string[];
     reason?: string;
     command?: string;
 }
-export declare function assertDeepInterviewMutationRawPathsAllowed(input: {
+export interface WorkflowGuardContext {
+    sessionId: string | null;
+    activeState: Awaited<ReturnType<typeof readVisibleSkillActiveState>>;
+    modeStates: ReadonlyMap<string, ModeState | null>;
+}
+interface ModeState {
+    active?: boolean;
+    current_phase?: string;
+    session_id?: string;
+    thread_id?: string;
+    [key: string]: unknown;
+}
+export declare function readWorkflowGuardContext(cwd: string, options?: {
+    sessionId?: string;
+    threadId?: string;
+}): Promise<WorkflowGuardContext>;
+export declare function assertWorkflowMutationRawPathsAllowed(input: {
     cwd: string;
     sessionId?: string;
     threadId?: string;
     rawPaths: string[];
     forceOverride?: boolean;
+    guardContext?: WorkflowGuardContext;
 }): Promise<void>;
-export declare function getDeepInterviewMutationDecision(input: DeepInterviewMutationGuardInput): Promise<DeepInterviewMutationDecision>;
-export declare function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void>;
-export declare const getWorkflowMutationDecision: typeof getDeepInterviewMutationDecision;
-export declare const assertWorkflowMutationAllowed: typeof assertDeepInterviewMutationAllowed;
-export declare const assertWorkflowMutationRawPathsAllowed: typeof assertDeepInterviewMutationRawPathsAllowed;
+export declare function getWorkflowMutationDecision(input: WorkflowMutationGuardInput): Promise<WorkflowMutationDecision>;
+export declare function assertWorkflowMutationAllowed(input: WorkflowMutationGuardInput): Promise<void>;
 export {};

package/dist/types/skill-state/workflow-state-contract.d.ts

@@ -40,14 +40,12 @@ export interface AuditEntry {
     paths: string[];
 }
 export declare function workflowModeStateFileName(skill: CanonicalGjcWorkflowSkill): string;
-export declare function workflowStateStoragePath(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): string;
-export declare function workflowActiveStatePath(cwd: string, sessionId?: string): string;
 export declare function buildWorkflowStateReceipt(input: {
     cwd: string;
     skill: CanonicalGjcWorkflowSkill;
     owner: WorkflowStateMutationOwner;
     command: string;
-    sessionId?: string;
+    sessionId: string;
     nowIso?: string;
     mutationId?: string;
 }): WorkflowStateReceipt;

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -1,7 +1,10 @@
+import { type ComposerSubmissionOptions } from "../modes/types";
 import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
-export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime & {
+    composer?: ComposerSubmissionOptions;
+};
 export declare function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined;
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;

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

@@ -3,7 +3,7 @@
  */
 import type { AgentTool } from "@gajae-code/agent-core";
 import type { SkillsSettings } from "./config/settings";
-import { type Skill } from "./extensibility/skills";
+import type { Skill } from "./extensibility/skills";
 import { type WorkspaceTree } from "./workspace-tree";
 interface AlwaysApplyRule {
     name: string;
@@ -75,17 +75,8 @@ export interface BuildSystemPromptOptions {
     }>;
     /** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
     intentField?: string;
-    /** Whether MCP tool discovery is active for this prompt build. */
-    mcpDiscoveryMode?: boolean;
-    /** Discoverable MCP server summaries to advertise when discovery mode is active. */
-    mcpDiscoveryServerSummaries?: string[];
-    /** Whether built-in tool discovery ("all" mode) is active; enables the tool-discovery prompt block. */
+    /** Whether built-in tool discovery is active; enables the tool-discovery prompt block. */
     toolDiscoveryActive?: boolean;
-    /** Hidden discoverable tools to advertise (name + one-line summary) when tool discovery is active. */
-    discoverableTools?: Array<{
-        name: string;
-        summary: string;
-    }>;
     /** Encourage the agent to delegate via tasks unless changes are trivial. */
     eagerTasks?: boolean;
     /** Rules with alwaysApply=true — their full content is injected into the prompt. */

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

@@ -4,7 +4,7 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@gajae-code/agent-core";
-import type { ServiceTier } from "@gajae-code/ai";
+import type { Model, ServiceTier } from "@gajae-code/ai";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
@@ -19,6 +19,7 @@ import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+export declare function trimForkContextSeedForModel(seed: ForkContextSeed, model: Model | undefined): ForkContextSeed;
 /** Options for subagent execution */
 export interface ExecutorOptions {
     cwd: string;
@@ -93,6 +94,7 @@ export interface ExecutorOptions {
     autoloadSkills?: Skill[];
     forkContextSeed?: ForkContextSeed;
 }
+export declare function renderSubagentUserPrompt(assignment: string, independentMode: boolean): string;
 export interface YieldItem {
     data?: unknown;
     status?: "success" | "aborted";

package/dist/types/thinking.d.ts

@@ -19,4 +19,11 @@ export declare function toReasoningEffort(level: ThinkingLevel | undefined): Eff
  */
 export declare function resolveThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ResolvedThinkingLevel | undefined;
 export declare function clampExplicitThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ThinkingLevel | undefined;
+export interface SelectorThinkingSuffix {
+    selector: string;
+    thinkingLevel?: ThinkingLevel;
+    invalidSuffix?: string;
+}
+/** Split the final selector suffix once, preserving colons in model IDs. */
+export declare function splitSelectorThinkingSuffix(selector: string): SelectorThinkingSuffix;
 export declare function formatClampedModelSelector(selector: string, model: Model | undefined): string;

package/dist/types/tool-discovery/tool-index.d.ts

@@ -3,6 +3,7 @@ export type DiscoverableToolSource = "builtin" | "mcp" | "extension" | "custom";
 export interface DiscoverableTool {
     name: string;
     label: string;
+    description: string;
     /** Short BM25 corpus entry; falls back to description first 200 chars */
     summary: string;
     source: DiscoverableToolSource;
@@ -34,39 +35,6 @@ export interface DiscoverableToolSearchResult {
     tool: DiscoverableTool;
     score: number;
 }
-/** @deprecated Use DiscoverableTool with source === "mcp" */
-export type DiscoverableMCPTool = Pick<DiscoverableTool, "name" | "label" | "schemaKeys" | "serverName" | "mcpToolName"> & {
-    description: string;
-};
-/** @deprecated Use DiscoverableToolServerSummary */
-export type DiscoverableMCPToolServerSummary = DiscoverableToolServerSummary;
-/** @deprecated Use DiscoverableToolSummary */
-export type DiscoverableMCPToolSummary = DiscoverableToolSummary;
-/** Tool object stored on legacy MCP index documents. Carries both legacy `description` and the
- *  generic `summary`/`source` so the legacy index is structurally assignable to
- *  DiscoverableToolSearchIndex (search functions read termFrequencies, not the tool fields). */
-export type DiscoverableMCPSearchTool = DiscoverableTool & {
-    description: string;
-};
-/** @deprecated Use DiscoverableToolSearchDocument */
-export interface DiscoverableMCPSearchDocument {
-    tool: DiscoverableMCPSearchTool;
-    termFrequencies: Map<string, number>;
-    length: number;
-}
-/** @deprecated Use DiscoverableToolSearchIndex.
- *  Documents on this index expose `tool.description` (legacy MCP shape) while still being
- *  searchable via `searchDiscoverableTools`. */
-export interface DiscoverableMCPSearchIndex {
-    documents: DiscoverableMCPSearchDocument[];
-    averageLength: number;
-    documentFrequencies: Map<string, number>;
-}
-/** @deprecated Use DiscoverableToolSearchResult */
-export interface DiscoverableMCPSearchResult {
-    tool: DiscoverableMCPSearchTool;
-    score: number;
-}
 export declare function isMCPToolName(name: string): boolean;
 export declare function isMCPBridgeTool(tool: {
     name: string;
@@ -93,20 +61,3 @@ export declare function selectDiscoverableToolNamesByServer(tools: Iterable<Disc
 export declare function summarizeDiscoverableTools(tools: DiscoverableTool[]): DiscoverableToolSummary;
 export declare function buildDiscoverableToolSearchIndex(tools: Iterable<DiscoverableTool>): DiscoverableToolSearchIndex;
 export declare function searchDiscoverableTools(index: DiscoverableToolSearchIndex, query: string, limit: number): DiscoverableToolSearchResult[];
-/** @deprecated Use getDiscoverableTool */
-export declare function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null;
-/** @deprecated Use collectDiscoverableTools with source filter */
-export declare function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[];
-/** @deprecated Use selectDiscoverableToolNamesByServer */
-export declare function selectDiscoverableMCPToolNamesByServer(tools: Iterable<DiscoverableMCPTool>, serverNames: ReadonlySet<string>): string[];
-/** @deprecated Use summarizeDiscoverableTools */
-export declare function summarizeDiscoverableMCPTools(tools: DiscoverableMCPTool[]): DiscoverableMCPToolSummary;
-/** @deprecated Use buildDiscoverableToolSearchIndex.
- *  Builds an index whose documents preserve the legacy `description` field on each tool while
- *  also carrying the generic `summary` (set from `description`) so the index remains usable
- *  with `searchDiscoverableTools`. */
-export declare function buildDiscoverableMCPSearchIndex(tools: Iterable<DiscoverableMCPTool>): DiscoverableMCPSearchIndex;
-/** @deprecated Use searchDiscoverableTools */
-export declare function searchDiscoverableMCPTools(index: DiscoverableMCPSearchIndex | DiscoverableToolSearchIndex, query: string, limit: number): DiscoverableMCPSearchResult[];
-/** @deprecated Use formatDiscoverableToolServerSummary */
-export declare const formatDiscoverableMCPToolServerSummary: typeof formatDiscoverableToolServerSummary;

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

@@ -35,7 +35,38 @@ export declare const askSchema: z.ZodObject<{
             component: z.ZodString;
             dimension: z.ZodString;
             ambiguity: z.ZodNumber;
-        }, z.core.$strip>>;
+            intent_contract: z.ZodOptional<z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    category: z.ZodEnum<{
+                        artifact: "artifact";
+                        constraint: "constraint";
+                        integration: "integration";
+                        surface: "surface";
+                    }>;
+                    statement: z.ZodString;
+                }, z.core.$strict>>;
+                confirmation_options: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            intent_review: z.ZodOptional<z.ZodObject<{
+                observed_items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    category: z.ZodEnum<{
+                        artifact: "artifact";
+                        constraint: "constraint";
+                        integration: "integration";
+                        surface: "surface";
+                    }>;
+                    statement: z.ZodString;
+                }, z.core.$strict>>;
+                supporting_substitutions: z.ZodArray<z.ZodObject<{
+                    removed_id: z.ZodString;
+                    replacement_ids: z.ZodArray<z.ZodString>;
+                    rationale: z.ZodString;
+                }, z.core.$strict>>;
+                approval_options: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
         workflowGate: z.ZodOptional<z.ZodObject<{
             stage: z.ZodEnum<{
                 "deep-interview": "deep-interview";
@@ -124,7 +155,38 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
                 component: z.ZodString;
                 dimension: z.ZodString;
                 ambiguity: z.ZodNumber;
-            }, z.core.$strip>>;
+                intent_contract: z.ZodOptional<z.ZodObject<{
+                    items: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        category: z.ZodEnum<{
+                            artifact: "artifact";
+                            constraint: "constraint";
+                            integration: "integration";
+                            surface: "surface";
+                        }>;
+                        statement: z.ZodString;
+                    }, z.core.$strict>>;
+                    confirmation_options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                intent_review: z.ZodOptional<z.ZodObject<{
+                    observed_items: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        category: z.ZodEnum<{
+                            artifact: "artifact";
+                            constraint: "constraint";
+                            integration: "integration";
+                            surface: "surface";
+                        }>;
+                        statement: z.ZodString;
+                    }, z.core.$strict>>;
+                    supporting_substitutions: z.ZodArray<z.ZodObject<{
+                        removed_id: z.ZodString;
+                        replacement_ids: z.ZodArray<z.ZodString>;
+                        rationale: z.ZodString;
+                    }, z.core.$strict>>;
+                    approval_options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
             workflowGate: z.ZodOptional<z.ZodObject<{
                 stage: z.ZodEnum<{
                     "deep-interview": "deep-interview";

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

@@ -42,6 +42,8 @@ export interface BashToolDetails {
         type: "bash";
     };
 }
+/** Project only a bare executable name; commands and their output are never notification-safe. */
+export declare function summarizeBashToolActivity(kind: "args" | "result", value: unknown): string | undefined;
 export interface BashToolOptions {
 }
 /**
@@ -59,6 +61,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
     readonly parameters: BashToolSchema;
     readonly concurrency = "exclusive";
     readonly strict = true;
+    readonly safeSummary: typeof summarizeBashToolActivity;
     constructor(session: ToolSession);
     /**
      * Start a background bash job for the Monitor tool. Reuses the full Bash