@sayknow-cli/coding-agent 0.4.2 → 0.4.3

package/dist/types/session/fallback-chain-controller.d.ts

@@ -0,0 +1,60 @@
+import type { FallbackTriggerClass } from "@sayknow-cli/ai/utils/fallback-transport";
+/** Immutable configured fallback intent. Transient attempt state never belongs here. */
+export interface ConfiguredFallbackChain {
+    role: string;
+    entries: readonly string[];
+    origin: string;
+    identity?: string;
+    explicitHead: boolean;
+}
+export interface FallbackFailure {
+    selector: string;
+    triggerClass: FallbackTriggerClass;
+    reason: string;
+}
+export type FallbackFailureResult = "retry" | "advance" | "exhausted";
+/**
+ * In-memory policy state for one fallback-chain scope. A controller is deliberately
+ * not serializable: configured chain intent is durable, current position is not.
+ */
+export declare class FallbackChainController {
+    #private;
+    readonly chain: ConfiguredFallbackChain;
+    readonly maxAttempts: number;
+    activeIndex: number;
+    attemptsUsed: number;
+    tried: FallbackFailure[];
+    skips: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    exhaustedForTurn: boolean;
+    constructor(chain: ConfiguredFallbackChain, maxAttempts: number);
+    get totalAttemptsUsed(): number;
+    currentSelector(): string | undefined;
+    onResolutionSkip(reason: string): boolean;
+    /** Charge an upstream request at its concrete transport boundary. */
+    onAttemptStarted(): void;
+    /** Remove the current started request from fallback-policy accounting without erasing prior failures. */
+    discardStartedAttempt(): void;
+    /** Start a logically new request with a fresh fallback-chain budget. */
+    resetAttemptBudget(): void;
+    /** Seed a controller from auth-aware resolution without charging requests. */
+    seedResolution(activeIndex: number, skips: Array<{
+        selector: string;
+        reason: string;
+    }>): void;
+    onAttemptFailure(triggerClass: FallbackTriggerClass, reason: string): FallbackFailureResult;
+    advance(): boolean;
+    /**
+     * Restore the entry that just advanced when credential rotation permits a retry.
+     * The chain-wide budget and failure history remain charged.
+     */
+    restorePreviousEntryForRetry(): boolean;
+    isExhausted(): boolean;
+    resetForNewTurn(): void;
+    resetSticky(): void;
+}
+export declare function cappedExponentialWithFullJitter(baseDelayMs: number, maxDelayMs: number, attemptK: number, random?: () => number): number;
+/** Retry-After is intentionally uncapped. */
+export declare function effectiveFallbackDelay(baseDelayMs: number, maxDelayMs: number, attemptK: number, retryAfterMs: number | undefined, random?: () => number): number;

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/history-storage.d.ts

@@ -0,0 +1,16 @@
+export interface HistoryEntry {
+    id: number;
+    prompt: string;
+    created_at: number;
+    cwd?: string;
+}
+export declare class HistoryStorage {
+    #private;
+    private constructor();
+    static open(dbPath?: string): HistoryStorage;
+    /** @internal Reset the singleton — test-only. */
+    static resetInstance(): void;
+    add(prompt: string, cwd?: string): Promise<void>;
+    getRecent(limit: number, cwd?: string): HistoryEntry[];
+    search(query: string, limit: number, cwd?: string): HistoryEntry[];
+}

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

@@ -0,0 +1,109 @@
+import * as native from "@sayknow-cli/natives";
+import type { ResumeSessionIdentity } from "../session-manager";
+export declare const MANAGED_SESSION_LAYOUT_VERSION: 2;
+export declare const MANAGED_SESSION_IDENTITY_VERSION: 1;
+export declare const MANAGED_SESSION_BINDING_FILE = ".skc-managed-session-scope.v2.json";
+export interface ManagedScope {
+    apiVersion: 1;
+    layoutVersion: 2;
+    identityVersion: 1;
+    agentDir: string;
+    sessionsRoot: string;
+    canonicalCwd: string;
+    legacyLexicalCwd: string;
+    directoryName: string;
+    directoryPath: string;
+    platform: "posix" | "win32";
+}
+export declare function managedDirectoryAuthorityForScope(scope: ManagedScope): native.RecoveryFsRoot | undefined;
+export declare function managedDirectoryIdentityForScope(scope: ManagedScope): {
+    dev: bigint;
+    ino: bigint;
+};
+export declare function managedRootForScope(scope: ManagedScope): import("./managed-session-storage").ManagedDirectoryRoot;
+export type ManagedMigrationPolicy = "copy-retain" | "disabled";
+export type ManagedScopeErrorCode = "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+export type ManagedScopeResolution = {
+    kind: "resolved";
+    scope: ManagedScope;
+} | {
+    kind: "error";
+    code: ManagedScopeErrorCode;
+    message: string;
+};
+export interface ManagedCandidate {
+    sessionId: string;
+    path: string;
+    cwd: string;
+    provenance: "v2" | "legacy";
+    identity: ResumeSessionIdentity;
+    migrationState: "native_v2" | "legacy_unmigrated" | "migrated_v2";
+}
+export type ManagedCandidateListing = {
+    kind: "complete";
+    scope: ManagedScope;
+    owned: readonly ManagedCandidate[];
+    foreignCount: number;
+    invalid: readonly {
+        code: string;
+    }[];
+} | {
+    kind: "error";
+    code: "scan_failed" | "unsafe_root" | "invalid_candidate";
+    message: string;
+};
+export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
+export type ManagedOpenCandidateResult = {
+    kind: "opened";
+    path: string;
+    candidate: ManagedCandidate;
+    migrated: boolean;
+} | {
+    kind: "error";
+    code: ManagedOpenFailure;
+    message: string;
+};
+export type ManagedDeleteCandidateResult = {
+    kind: "deleted";
+    tombstonePath: string;
+} | {
+    kind: "already_deleted";
+    tombstonePath: string;
+} | {
+    kind: "error";
+    code: ManagedOpenFailure;
+    message: string;
+};
+declare function scopeDigest(platform: "posix" | "win32", canonicalPath: string): string;
+export declare const computeManagedScopeDigest: typeof scopeDigest;
+/**
+ * Resolve benign symlinks in the deepest existing ancestor of a trusted storage
+ * root (e.g. macOS `/var -> /private/var`, or a symlinked `$HOME`) while keeping
+ * any not-yet-created tail verbatim. The native owner-only primitive and the
+ * session-storage reparse guard traverse with `O_NOFOLLOW` and reject every
+ * symlink component, so the trusted root must be canonical before it reaches
+ * them; canonicalizing only the existing prefix never follows an
+ * attacker-plantable component below the root.
+ */
+export declare function canonicalizeTrustedPath(target: string): string;
+export declare function resolveManagedScope(input: {
+    cwd: string;
+    agentDir: string;
+    sessionsRoot: string;
+}): ManagedScopeResolution;
+export declare function ensureManagedScope(scope: ManagedScope): Promise<ManagedScopeResolution>;
+/** Synchronously create and validate the v2 binding before a default session writer exists. */
+export declare function prepareManagedSessionScopeForWriteSync(scope: ManagedScope): ManagedScopeResolution;
+export declare function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing;
+/** Resume tombstoned cleanup under its original operation lease without restoring retired candidates. */
+export declare function reconcileManagedTombstones(scope: ManagedScope): Promise<void>;
+/** Create the v2 binding and private write protocol directories before managed writes. */
+export declare function prepareManagedSessionScopeForWrite(scope: ManagedScope): Promise<ManagedScopeResolution>;
+/**
+ * Open a validated candidate for mutation. Legacy transcripts are copied exactly once
+ * into v2 and retained at their original location; no transcript data is merged.
+ */
+export declare function openManagedCandidateForWrite(scope: ManagedScope, candidate: ManagedCandidate, migrationPolicy?: ManagedMigrationPolicy): Promise<ManagedOpenCandidateResult>;
+/** Tombstone a verified managed candidate before exact-identity deletion. */
+export declare function deleteManagedSessionCandidate(scope: ManagedScope, candidate: ManagedCandidate): Promise<ManagedDeleteCandidateResult>;
+export {};

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

@@ -0,0 +1,95 @@
+import { type NativeDirectoryTreeSnapshot, type NativeOwnerOnlySecurityResult, type RecoveryFsRoot } from "@sayknow-cli/natives";
+export declare const MANAGED_ARTIFACT_MAX_DEPTH = 32;
+export declare const MANAGED_ARTIFACT_MAX_FILES = 10000;
+export declare const MANAGED_ARTIFACT_MAX_FILE_BYTES: number;
+export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
+export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "migration_retired" | "managed_storage_unsupported";
+export interface ManagedStorageLock {
+    path: string;
+    attemptId: string;
+    assertOwned(): void;
+    release(): Promise<void>;
+}
+export interface ManagedFileSnapshot {
+    bytes: Buffer;
+    identity: {
+        dev: bigint;
+        ino: bigint;
+        size: number;
+        mtimeNs: bigint;
+        ctimeNs: bigint;
+        sha256: string;
+    };
+}
+export declare function validateNativeSecurityResult(value: unknown, operation: "apply" | "verify", kind: "directory" | "file"): NativeOwnerOnlySecurityResult;
+/** Captured configured-root authority for managed paths only. */
+export interface ManagedDirectoryRoot {
+    readonly canonicalPath: string;
+    readonly dev: bigint;
+    readonly ino: bigint;
+}
+export declare function managedDirectoryRoot(configuredRoot: string): ManagedDirectoryRoot;
+export declare function retainManagedDirectoryAuthority(root: ManagedDirectoryRoot, directory: string, expected?: {
+    dev: bigint;
+    ino: bigint;
+}): RecoveryFsRoot | undefined;
+export declare function assertManagedDirectoryRoot(root: ManagedDirectoryRoot): void;
+/** Internal retained-root capability for one managed descendant subtree. */
+export declare class ManagedSessionDescendantStore {
+    #private;
+    constructor(root: ManagedDirectoryRoot, baseDir: string, retained?: {
+        authority: RecoveryFsRoot;
+        authorityBaseDir: string;
+    });
+    get dir(): string;
+    get rootAuthority(): ManagedDirectoryRoot;
+    get subtreeRootAuthority(): ManagedDirectoryRoot;
+    deriveSubtree(relativePath: string): ManagedSessionDescendantStore;
+    retainAuthority(): RecoveryFsRoot | undefined;
+    assertBound(): void;
+    verifyRootSecurity(): void;
+    ensureDirectory(relativePath?: string): ManagedDirectoryRoot;
+    publishNoReplace(relativePath: string, bytes: Uint8Array): Promise<void>;
+    publishNoReplaceSync(relativePath: string, bytes: Uint8Array): void;
+    replace(relativePath: string, bytes: Uint8Array): Promise<void>;
+    replaceSync(relativePath: string, bytes: Uint8Array): void;
+    appendSync(relativePath: string, bytes: Uint8Array): void;
+    /** Read an exact managed file without exposing its pathname as authority. */
+    readExpected(relativePath: string): ManagedFileSnapshot | null;
+    /** Remove an exact captured file without reopening its pathname as authority. */
+    removeExpected(relativePath: string, expected: ManagedFileSnapshot): void;
+    /** Read and remove one managed descendant through retained authority. */
+    consume(relativePath: string): Promise<Uint8Array | null>;
+    /** Remove one managed descendant through retained authority when it exists. */
+    remove(relativePath: string): Promise<void>;
+    /** Capture a complete descendant tree through this retained root. */
+    captureTree(relativePath: string): NativeDirectoryTreeSnapshot;
+    /** Copy an exact captured tree into an absent managed destination. */
+    importTree(sourceRelativePath: string, destinationRelativePath: string, snapshot: NativeDirectoryTreeSnapshot): Promise<void>;
+    moveTreeNoReplace(sourceRelativePath: string, destinationRelativePath: string, expected: NativeDirectoryTreeSnapshot): void;
+    removeTreeExpected(relativePath: string, expected: NativeDirectoryTreeSnapshot): void;
+    fsyncTree(): NativeDirectoryTreeSnapshot;
+}
+export declare function shouldFsyncManagedDirectory(platform?: NodeJS.Platform): boolean;
+/** Create a managed directory and fail closed unless its owner-only mode/ACL verifies. */
+export declare function ensureManagedDirectory(pathname: string, root?: ManagedDirectoryRoot): void;
+/** Captures a bounded prefix from one no-follow descriptor and rechecks the pathname before use. */
+export declare function captureManagedFilePrefixNoFollow(pathname: string, maxBytes: number): ManagedFileSnapshot;
+/** Captures header/hash/copy input from one no-follow descriptor and rechecks the pathname before use. */
+export declare function captureManagedFileNoFollow(pathname: string): ManagedFileSnapshot;
+/** Atomically publishes bytes without replacing an existing destination. */
+export declare function publishManagedFileNoReplace(destination: string, bytes: Uint8Array, assertOwned?: () => void, root?: ManagedDirectoryRoot): Promise<void>;
+export declare function publishManagedFileNoReplaceSync(destination: string, bytes: Uint8Array, root?: ManagedDirectoryRoot): void;
+/** Replace one managed regular file while retaining the secured staging fd through publication. */
+export declare function replaceManagedFileSync(destination: string, bytes: Uint8Array, root: ManagedDirectoryRoot): void;
+export declare function replaceManagedFile(destination: string, bytes: Uint8Array, root: ManagedDirectoryRoot): Promise<void>;
+/** Copy the exact bytes captured from one no-follow source descriptor. */
+export declare function copyManagedFileNoReplace(source: string, destination: string, snapshot?: ManagedFileSnapshot, root?: ManagedDirectoryRoot): Promise<void>;
+/** Acquire a lease lock with bounded wait, heartbeats, conservative stale reclaim, and fencing. */
+export declare function acquireManagedLock(locksDirectory: string, name: string, root?: ManagedDirectoryRoot): Promise<ManagedStorageLock>;
+/** Bounds a no-follow artifact tree before it can be copied or deleted. */
+export declare function validateManagedArtifactTree(root: string): void;
+/** Flush a copied managed artifact tree, including empty directories, before publishing its receipt. */
+export declare function fsyncManagedArtifactTree(root: string): NativeDirectoryTreeSnapshot;
+export declare function publishManagedTombstone(destination: string, record: Record<string, unknown>, assertOwned?: () => void): Promise<void>;
+export declare function unlinkManagedFileVerified(pathname: string, expected: ManagedFileSnapshot["identity"]): Promise<void>;

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

@@ -0,0 +1,185 @@
+/**
+ * Custom message types and transformers for the coding agent.
+ *
+ * Extends the base AgentMessage type with coding-agent specific message types,
+ * and provides a transformer to convert them to LLM-compatible messages.
+ */
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+import { type BranchSummaryMessage, type CompactionSummaryMessage } from "@sayknow-cli/agent-core/compaction/messages";
+import type { AssistantMessage, ImageContent, Message, MessageAttribution, TextContent } from "@sayknow-cli/ai";
+export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, } from "@sayknow-cli/agent-core/compaction/messages";
+import type { LoadedSubskillActivation } from "../extensibility/skc-plugins";
+import type { OutputMeta } from "../tools/output-meta";
+/**
+ * Encode untrusted values embedded in prompt markup. Control and bidi characters become visible
+ * escape sequences so they cannot alter markup structure or display. Isolated UTF-16 surrogates
+ * are also escaped; valid Unicode pairs remain intact.
+ */
+export declare function escapePromptMetadata(value: string, options?: {
+    preserveNewlines?: boolean;
+}): string;
+export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+export interface SkillPromptDetails {
+    name: string;
+    path: string;
+    args?: string;
+    lineCount: number;
+    subskillActivation?: LoadedSubskillActivation;
+    subskillActivationSet?: LoadedSubskillActivation[];
+    /** Internal: tag used by AgentSession to remove the pending-display chip
+     *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
+     *  this message. Not surfaced to renderers; the `__` prefix signals
+     *  "private". Optional — non-streaming skill prompts never set it. Stripped
+     *  from persisted `details` by `SessionManager.appendCustomMessageEntry`
+     *  via the `INTERNAL_DETAILS_FIELDS` allowlist below. */
+    __pendingDisplayTag?: string;
+}
+/** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
+ *  was an *expected internal transition* (plan-mode → execution compaction)
+ *  and must NOT surface as a red "Operation aborted" line. Distinct from
+ *  `undefined` (default) so user-cancel aborts with no errorMessage still
+ *  render normally. Persists through SessionManager so history replay
+ *  branches identically.
+ *
+ *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
+ *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
+ *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
+ *  (fallback error emission) read it via `isSilentAbort`. */
+export declare const SILENT_ABORT_MARKER = "__skc.silent_abort__";
+/** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
+ *  than string-comparing inline so refactors to the marker constant (e.g.,
+ *  namespacing changes) propagate through every consumer in lockstep. */
+export declare function isSilentAbort(errorMessage: string | undefined): boolean;
+/** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
+ *  `details` blob. Safe over `unknown`; returns undefined when the field is
+ *  absent or non-string. */
+export declare function readPendingDisplayTag(details: unknown): string | undefined;
+/** Explicit allowlist of `details` field names that are AgentSession-internal
+ *  transient bookkeeping and MUST be removed before SessionManager persists
+ *  the CustomMessageEntry to disk. Scoped intentionally narrow: only fields
+ *  declared here are stripped. Adding a new entry is a deliberate, reviewed
+ *  change — unrelated future payload fields are never silently dropped. */
+export declare const INTERNAL_DETAILS_FIELDS: readonly ["__pendingDisplayTag"];
+/** Return a `details` copy with every key in `INTERNAL_DETAILS_FIELDS`
+ *  removed. Returns the input unchanged when there is nothing to strip
+ *  (null/non-object, or no listed fields present) so callers don't pay a
+ *  clone cost on the common path. */
+export declare function stripInternalDetailsFields<T>(details: T | undefined): T | undefined;
+export declare const PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES = 4096;
+export declare const PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES = 4096;
+/**
+ * Build the deterministic inline receipt for a tool result saved before the
+ * next provider context is constructed. Byte boundaries never split UTF-8
+ * code points, so head/tail recovery remains readable for emoji and CJK text.
+ */
+export declare function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string): string;
+/**
+ * Message type for bash executions via the ! command.
+ */
+export interface BashExecutionMessage {
+    role: "bashExecution";
+    command: string;
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    meta?: OutputMeta;
+    timestamp: number;
+    /** If true, this message is excluded from LLM context (!! prefix) */
+    excludeFromContext?: boolean;
+}
+/**
+ * Message type for user-initiated Python executions via the $ command.
+ * Shares the same kernel session as eval's Python backend.
+ */
+export interface PythonExecutionMessage {
+    role: "pythonExecution";
+    code: string;
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    meta?: OutputMeta;
+    timestamp: number;
+    /** If true, this message is excluded from LLM context ($$ prefix) */
+    excludeFromContext?: boolean;
+}
+/**
+ * Message type for extension-injected messages via sendMessage().
+ */
+export interface CustomMessage<T = unknown> {
+    role: "custom";
+    customType: string;
+    content: string | (TextContent | ImageContent)[];
+    display: boolean;
+    details?: T;
+    /** Who initiated this message for billing/attribution semantics. */
+    attribution?: MessageAttribution;
+    timestamp: number;
+}
+/**
+ * Legacy hook message type (pre-extensions). Kept for session migration.
+ */
+export interface HookMessage<T = unknown> {
+    role: "hookMessage";
+    customType: string;
+    content: string | (TextContent | ImageContent)[];
+    display: boolean;
+    details?: T;
+    /** Who initiated this message for billing/attribution semantics. */
+    attribution?: MessageAttribution;
+    timestamp: number;
+}
+/**
+ * Message type for auto-read file mentions via @filepath syntax.
+ */
+export interface FileMentionMessage {
+    role: "fileMention";
+    files: Array<{
+        path: string;
+        content: string;
+        lineCount?: number;
+        /** File size in bytes, if known. */
+        byteSize?: number;
+        /** 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;
+}
+declare module "@sayknow-cli/agent-core" {
+    interface CustomAgentMessages {
+        bashExecution: BashExecutionMessage;
+        pythonExecution: PythonExecutionMessage;
+        custom: CustomMessage;
+        hookMessage: HookMessage;
+        branchSummary: BranchSummaryMessage;
+        compactionSummary: CompactionSummaryMessage;
+        fileMention: FileMentionMessage;
+    }
+}
+/**
+ * Convert a BashExecutionMessage to user message text for LLM context.
+ */
+export declare function bashExecutionToText(msg: BashExecutionMessage): string;
+/**
+ * Convert a PythonExecutionMessage to user message text for LLM context.
+ */
+export declare function pythonExecutionToText(msg: PythonExecutionMessage): string;
+export declare function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: AssistantMessage): AssistantMessage;
+/** Convert CustomMessageEntry to AgentMessage format */
+export declare function createCustomMessage(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details: unknown | undefined, timestamp: string, attribution?: MessageAttribution): CustomMessage;
+/**
+ * Transform AgentMessages (including custom types) to LLM-compatible Messages.
+ *
+ * This is used by:
+ * - Agent's transormToLlm option (for prompt calls and queued messages)
+ * - Compaction's generateSummary (for summarization)
+ * - Custom extensions and tools
+ */
+export declare function convertToLlm(messages: AgentMessage[]): Message[];

package/dist/types/session/provider-safety-stop.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Recognizes legacy provider safety-stop labels persisted before `errorKind`.
+ * Keep this anchored and conservative so incidental transient-error prose stays retryable.
+ */
+export declare function isLegacyProviderSafetyStopMessage(errorMessage: string): boolean;

package/dist/types/session/session-dump-format.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Plain-text / markdown session formatting (same shape as /dump clipboard export).
+ */
+import type { AgentMessage, ThinkingLevel } from "@sayknow-cli/agent-core";
+import type { Model } from "@sayknow-cli/ai";
+/** Minimal tool shape for dump output (matches AgentTool fields used by formatSessionDumpText). */
+export interface SessionDumpToolInfo {
+    name: string;
+    description: string;
+    parameters: unknown;
+}
+export interface FormatSessionDumpTextOptions {
+    messages: readonly AgentMessage[];
+    systemPrompt?: readonly string[] | null;
+    model?: Model | null;
+    thinkingLevel?: ThinkingLevel | string | null;
+    tools?: readonly SessionDumpToolInfo[];
+}
+/**
+ * Format messages and session metadata as markdown/plain text (same as AgentSession.formatSessionAsText / /dump).
+ */
+export declare function formatSessionDumpText(options: FormatSessionDumpTextOptions): string;

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

@@ -0,0 +1,14 @@
+import type { SessionContext, SessionEntry, SessionManager, SessionTreeNode } from "./session-manager";
+/**
+ * Opaque capability for zero-copy session snapshots. This module is deliberately
+ * excluded from package exports; only trusted in-package readers may use it.
+ */
+export declare const sessionManagerReadCapability: unique symbol;
+export interface SessionManagerReadAccess {
+    getEntries(): readonly SessionEntry[];
+    getSessionContext(): Readonly<SessionContext>;
+    getTree(): SessionTreeNode[];
+}
+export declare function getEntriesForInternalRead(manager: SessionManager): readonly SessionEntry[];
+export declare function getSessionContextForInternalRead(manager: SessionManager): Readonly<SessionContext>;
+export declare function getTreeForInternalRead(manager: SessionManager): SessionTreeNode[];