flavor-code 1.2.1

package/dist/plugins/types.d.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { type HookEventName, type HookHandler, type HookHandlerOptions } from "../hooks/types.js";
+import type { ModelAdapter } from "../models/types.js";
+import type { ToolDefinition } from "../tools/types.js";
+export declare const PluginManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    apiVersion: z.ZodLiteral<"1">;
+    main: z.ZodString;
+    permissions: z.ZodArray<z.ZodEnum<{
+        "filesystem:read": "filesystem:read";
+        "filesystem:write": "filesystem:write";
+    }>>;
+    contributes: z.ZodObject<{
+        commands: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        hooks: z.ZodArray<z.ZodObject<{
+            name: z.ZodEnum<{
+                AfterModelCall: "AfterModelCall";
+                AfterPlan: "AfterPlan";
+                BeforeModelCall: "BeforeModelCall";
+                BeforePlan: "BeforePlan";
+                Notification: "Notification";
+                PermissionRequest: "PermissionRequest";
+                PluginLoad: "PluginLoad";
+                PluginUnload: "PluginUnload";
+                PostCompact: "PostCompact";
+                PostToolUse: "PostToolUse";
+                PostToolUseFailure: "PostToolUseFailure";
+                PreCompact: "PreCompact";
+                PreToolUse: "PreToolUse";
+                SessionEnd: "SessionEnd";
+                SessionStart: "SessionStart";
+                Stop: "Stop";
+                SubagentStart: "SubagentStart";
+                SubagentStop: "SubagentStop";
+                UserPromptSubmit: "UserPromptSubmit";
+            }>;
+        }, z.core.$strict>>;
+        skillRoots: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+        modelAdapters: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PluginManifest = z.infer<typeof PluginManifestSchema>;
+export type PluginSource = "global" | "project" | "npm";
+export type PluginPermission = PluginManifest["permissions"][number];
+export interface PluginLogger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+export interface PluginFilesystemService {
+    readFile(path: string, encoding?: BufferEncoding): Promise<string | Uint8Array>;
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+}
+export interface PluginServices {
+    readonly filesystem: PluginFilesystemService;
+}
+export type PluginDisposer = () => void | Promise<void>;
+export interface PluginCommandContext {
+    readonly workspace: string;
+    readonly signal: AbortSignal;
+}
+export type PluginCommandHandler = (args: readonly string[], context: PluginCommandContext) => unknown | Promise<unknown>;
+/**
+ * A deliberately narrow registration surface. Plugins run in-process and are trusted in the
+ * MVP: this API mediates host-provided capabilities, but it is not a Node.js process sandbox.
+ */
+export interface PluginContext {
+    readonly signal: AbortSignal;
+    readonly config: unknown;
+    readonly logger: PluginLogger;
+    readonly services: PluginServices;
+    registerCommand(name: string, command: PluginCommandHandler): PluginDisposer;
+    registerTool(name: string, tool: ToolDefinition<unknown>): PluginDisposer;
+    registerHook(name: HookEventName, hook: HookHandler, options?: HookHandlerOptions): PluginDisposer;
+    registerSkillRoot(name: string, root: string): PluginDisposer;
+    registerModelAdapter(name: string, adapter: ModelAdapter): PluginDisposer;
+}
+export interface PluginSkillRootCapability {
+    readonly path: string;
+    readonly identity: {
+        readonly dev: bigint;
+        readonly ino: bigint;
+        readonly mtimeNs: bigint;
+        readonly ctimeNs: bigint;
+    };
+}
+export interface PluginDiagnostic {
+    readonly plugin: string;
+    readonly path?: string;
+    readonly message: string;
+}
+export interface LoadedPlugin {
+    readonly name: string;
+    readonly version: string;
+    readonly source: PluginSource;
+    readonly root: string;
+}
+export interface PluginRegistrationCallbacks {
+    command(name: string, command: PluginCommandHandler): PluginDisposer;
+    tool(name: string, tool: ToolDefinition<unknown>): PluginDisposer;
+    hook(name: HookEventName, hook: HookHandler, options?: HookHandlerOptions): PluginDisposer;
+    /** Consumers must revalidate identity before access, or delegate reading to SkillRegistry. */
+    skillRoot(name: string, root: PluginSkillRootCapability): PluginDisposer;
+    modelAdapter(name: string, adapter: ModelAdapter): PluginDisposer;
+}
+export interface FilesystemAuthorizationRequest {
+    readonly plugin: string;
+    readonly operation: "read" | "write";
+    readonly path: string;
+}
+export interface PluginHostOptions {
+    globalPluginDirs?: readonly string[];
+    projectPluginDirs?: readonly string[];
+    npmPackages?: readonly string[];
+    disabledPlugins?: readonly string[];
+    resolveNpmPackage?: (specifier: string) => string | undefined | Promise<string | undefined>;
+    registrations: PluginRegistrationCallbacks;
+    config?: unknown;
+    logger?: PluginLogger;
+    authorizeFilesystem?: (request: FilesystemAuthorizationRequest) => boolean | Promise<boolean>;
+    emitLifecycle?: (type: "PluginLoad" | "PluginUnload", plugin: LoadedPlugin) => void | Promise<void>;
+    activationTimeoutMs?: number;
+    unloadTimeoutMs?: number;
+}

package/dist/production.d.ts

@@ -0,0 +1,59 @@
+import type { AgentEvent } from "./agent/types.js";
+import { GoalOrchestrator } from "./goal/orchestrator.js";
+import { type McpClientFactory } from "./mcp/client.js";
+import type { PermissionRequest } from "./permissions/engine.js";
+import { type PromptEnvironment } from "./prompts/system.js";
+import type { ApprovalDecision } from "./tools/runtime.js";
+import { type FileWriteProposal } from "./tools/files.js";
+import { FlavorSession, type SessionOutput, type SessionServices } from "./ui/session.js";
+import { type TranscriptState } from "./ui/transcript.js";
+import { MemoryReviewBridge } from "./memory/review.js";
+export interface ProductionRuntimeOptions {
+    workspace?: string;
+    home?: string;
+    environment?: NodeJS.ProcessEnv;
+    output(event: SessionOutput): void;
+    onApprovalChange?(): void;
+    /** Non-interactive callers must deny requests instead of waiting for input. */
+    approvalPolicy?: "prompt" | "deny";
+    /** Allow a protocol host to resolve tool approvals without enabling other interactive UI bridges. */
+    rpcToolApprovals?: boolean;
+    /** Optional pre-commit gate used by protocol hosts to stream a proposed text write before it reaches disk. */
+    beforeFileCommit?(proposal: FileWriteProposal, signal: AbortSignal): Promise<void>;
+    /** Resume a named session, or the latest session when true. Never resumed implicitly. */
+    resumeSession?: string | true;
+    /** Test and embedding seam for creating configured MCP clients. */
+    mcpClientFactory?: McpClientFactory;
+}
+export interface ProductionRuntime {
+    session: FlavorSession;
+    services: SessionServices;
+    approvals: ApprovalBridge;
+    memoryReviews: MemoryReviewBridge;
+    diagnostics: readonly string[];
+    sessionId: string;
+    restoredTranscript: TranscriptState;
+    dispose(): Promise<void>;
+}
+export interface PromptEnvironmentInput {
+    now?: Date;
+    platform?: string;
+    osVersion?: string;
+    shell?: string;
+    isGitRepository?: boolean | "unknown";
+}
+export declare function createPromptEnvironment(input?: PromptEnvironmentInput): PromptEnvironment;
+export declare class ApprovalBridge {
+    #private;
+    constructor(onChange?: () => void);
+    get pending(): (PermissionRequest & {
+        id: string;
+        reason?: string;
+    }) | undefined;
+    request(request: PermissionRequest & {
+        reason?: string;
+    }, signal?: AbortSignal): Promise<ApprovalDecision>;
+    resolve(decision: ApprovalDecision): void;
+}
+export declare function createProductionRuntime(options: ProductionRuntimeOptions): Promise<ProductionRuntime>;
+export declare function runGoalSession(orchestrator: GoalOrchestrator, goal: string, signal: AbortSignal): AsyncIterable<AgentEvent>;

package/dist/prompts/system.d.ts

@@ -0,0 +1,28 @@
+import type { PermissionMode } from "../permissions/engine.js";
+export type PromptAgentRole = "main" | "subagent";
+export interface PromptEnvironment {
+    date: string;
+    platform: NodeJS.Platform | string;
+    osVersion: string;
+    shell: string;
+    isGitRepository: boolean | "unknown";
+}
+export interface SystemPromptOptions {
+    agent: PromptAgentRole;
+    languageInstruction?: string;
+    workspace: string;
+    toolNames: ReadonlySet<string>;
+    environment: PromptEnvironment;
+}
+export declare function buildSystemPrompt(options: SystemPromptOptions): string[];
+export declare function buildCurrentDateSection(date: string): string;
+/**
+ * Volatile runtime values that change with /model or /permission commands.
+ * Kept out of the stable system prefix so those switches do not invalidate
+ * the prompt-cache prefix.
+ */
+export declare function buildRuntimeEnvironmentSection(options: {
+    model: string;
+    permissionMode: PermissionMode;
+}): string;
+export declare function buildSubagentDirective(): string;

package/dist/rpc/schema.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const RpcCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"prompt">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"steer">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"follow_up">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"abort">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get_state">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get_queue">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"clear_queue">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"approval_decision">;
+    approvalId: z.ZodString;
+    decision: z.ZodEnum<{
+        always: "always";
+        deny: "deny";
+        once: "once";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"write_commit">;
+    writeId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"checkpoint">;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"get_tree">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"rewind">;
+    nodeId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"unrevert">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"fork">;
+    nodeId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"shutdown">;
+}, z.core.$strict>], "type">;
+export type RpcCommand = z.infer<typeof RpcCommandSchema>;

package/dist/rpc/server.d.ts

@@ -0,0 +1,54 @@
+import type { Readable, Writable } from "node:stream";
+import type { AgentQueueSnapshot } from "../agent/message-queue.js";
+import type { SessionOutput } from "../ui/session.js";
+import type { SessionApprovalRequest } from "../ui/session.js";
+import type { ApprovalDecision } from "../tools/runtime.js";
+export interface RpcSessionLike {
+    readonly active: boolean;
+    start(): Promise<void>;
+    submit(prompt: string): Promise<void>;
+    steer(prompt: string): void;
+    followUp(prompt: string): void;
+    interrupt(): "cancelled" | "exit";
+    queueSnapshot(): AgentQueueSnapshot;
+    clearQueue(): AgentQueueSnapshot;
+    whenIdle(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface RpcRuntimeLike {
+    readonly sessionId: string;
+    readonly session: RpcSessionLike;
+    readonly services?: {
+        checkpoint?(label?: string): Promise<unknown>;
+        tree?(): readonly unknown[];
+        rewind?(nodeId: string): Promise<void>;
+        unrevert?(): Promise<void>;
+        fork?(nodeId: string): Promise<void>;
+    };
+    readonly approvals?: {
+        readonly pending: SessionApprovalRequest | undefined;
+        resolve(decision: ApprovalDecision): void;
+    };
+    readonly rpcApprovals?: boolean;
+    readonly rpcWrites?: {
+        readonly pendingId: string | undefined;
+        commit(id: string): void;
+        dispose(): void;
+    };
+    dispose(): Promise<void>;
+}
+export interface FlavorRpcServerOptions {
+    input: Readable;
+    output: Writable;
+    workspace: string;
+    createRuntime(options: {
+        workspace: string;
+        output: (event: SessionOutput) => void;
+    }): Promise<RpcRuntimeLike>;
+    onRecord?(kind: "command" | "response" | "output", payload: unknown): void | Promise<void>;
+}
+export declare class FlavorRpcServer {
+    #private;
+    constructor(options: FlavorRpcServerOptions);
+    start(): Promise<void>;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,19 @@
+export { createProductionRuntime } from "../production.js";
+export { createProductionRuntime as createFlavorRuntime } from "../production.js";
+export type { ProductionRuntime, ProductionRuntimeOptions } from "../production.js";
+export { FlavorSession } from "../ui/session.js";
+export type { SessionOutput, SessionServices } from "../ui/session.js";
+export { AgentMessageQueue } from "../agent/message-queue.js";
+export type { AgentQueueSnapshot, AgentQueueKind, AgentQueueMode, AgentMessageQueueOptions, } from "../agent/message-queue.js";
+export { FlavorRpcServer } from "../rpc/server.js";
+export type { FlavorRpcServerOptions, RpcRuntimeLike, RpcSessionLike } from "../rpc/server.js";
+export { TraceRecorder } from "../trace/recorder.js";
+export { replayTrace, replayOutputEvents } from "../trace/replay.js";
+export type { TraceRecord, TraceKind } from "../trace/schema.js";
+export { SessionHistory } from "../session/tree.js";
+export type { SessionTreeNode, SessionHistoryOptions } from "../session/tree.js";
+export { WorkspaceCheckpointStore } from "../session/checkpoint.js";
+export type { WorkspaceCheckpoint, WorkspaceCheckpointStoreOptions, CheckpointFile } from "../session/checkpoint.js";
+export { DockerExecutionEnvironment, buildDockerInvocation } from "../execution/docker.js";
+export type { ExecutionEnvironment, ExecutionRequest, ExecutionResult } from "../execution/types.js";
+export type { AgentEvent } from "../agent/types.js";

package/dist/sdk/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  FlavorRpcServer,
+  TraceRecordSchema,
+  TraceRecorder
+} from "../chunk-M744K7MK.js";
+import {
+  AgentMessageQueue,
+  DockerExecutionEnvironment,
+  FlavorSession,
+  SessionHistory,
+  WorkspaceCheckpointStore,
+  buildDockerInvocation,
+  createProductionRuntime
+} from "../chunk-BU64GNXE.js";
+import "../chunk-MVIMQEQT.js";
+import "../chunk-VOCZVFP7.js";
+import "../chunk-JZ322RCJ.js";
+
+// src/trace/replay.ts
+import { readFile } from "fs/promises";
+async function replayTrace(path, sessionId) {
+  const raw = await readFile(path, "utf8");
+  const records = raw.split(/\r?\n/).filter(Boolean).map((line) => TraceRecordSchema.parse(JSON.parse(line)));
+  let previous = 0;
+  for (const record of records) {
+    if (record.sequence <= previous) throw new Error("Trace sequence is not strictly increasing");
+    previous = record.sequence;
+  }
+  return sessionId === void 0 ? records : records.filter((record) => record.sessionId === sessionId);
+}
+async function* replayOutputEvents(path, sessionId) {
+  const records = await replayTrace(path, sessionId);
+  for (const record of records) {
+    if (record.kind === "output") yield record.payload;
+  }
+}
+export {
+  AgentMessageQueue,
+  DockerExecutionEnvironment,
+  FlavorRpcServer,
+  FlavorSession,
+  SessionHistory,
+  TraceRecorder,
+  WorkspaceCheckpointStore,
+  buildDockerInvocation,
+  createProductionRuntime as createFlavorRuntime,
+  createProductionRuntime,
+  replayOutputEvents,
+  replayTrace
+};
+//# sourceMappingURL=index.js.map

package/dist/sdk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trace/replay.ts"],"sourcesContent":["import { readFile } from \"node:fs/promises\";\n\nimport { TraceRecordSchema, type TraceRecord } from \"./schema.js\";\n\nexport async function replayTrace(path: string, sessionId?: string): Promise<TraceRecord[]> {\n  const raw = await readFile(path, \"utf8\");\n  const records = raw.split(/\\r?\\n/).filter(Boolean).map((line) => TraceRecordSchema.parse(JSON.parse(line)));\n  let previous = 0;\n  for (const record of records) {\n    if (record.sequence <= previous) throw new Error(\"Trace sequence is not strictly increasing\");\n    previous = record.sequence;\n  }\n  return sessionId === undefined ? records : records.filter((record) => record.sessionId === sessionId);\n}\n\nexport async function* replayOutputEvents(path: string, sessionId?: string): AsyncIterable<unknown> {\n  const records = await replayTrace(path, sessionId);\n  for (const record of records) {\n    if (record.kind === \"output\") yield record.payload;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,gBAAgB;AAIzB,eAAsB,YAAY,MAAc,WAA4C;AAC1F,QAAM,MAAM,MAAM,SAAS,MAAM,MAAM;AACvC,QAAM,UAAU,IAAI,MAAM,OAAO,EAAE,OAAO,OAAO,EAAE,IAAI,CAAC,SAAS,kBAAkB,MAAM,KAAK,MAAM,IAAI,CAAC,CAAC;AAC1G,MAAI,WAAW;AACf,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,YAAY,SAAU,OAAM,IAAI,MAAM,2CAA2C;AAC5F,eAAW,OAAO;AAAA,EACpB;AACA,SAAO,cAAc,SAAY,UAAU,QAAQ,OAAO,CAAC,WAAW,OAAO,cAAc,SAAS;AACtG;AAEA,gBAAuB,mBAAmB,MAAc,WAA4C;AAClG,QAAM,UAAU,MAAM,YAAY,MAAM,SAAS;AACjD,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,SAAS,SAAU,OAAM,OAAO;AAAA,EAC7C;AACF;","names":[]}

package/dist/session/checkpoint.d.ts

@@ -0,0 +1,25 @@
+export interface CheckpointFile {
+    path: string;
+    digest: string;
+    size: number;
+    mode: number;
+}
+export interface WorkspaceCheckpoint {
+    version: 1;
+    id: string;
+    createdAt: string;
+    label?: string;
+    files: CheckpointFile[];
+}
+export interface WorkspaceCheckpointStoreOptions {
+    workspace: string;
+    maxFileBytes?: number;
+    maxTotalBytes?: number;
+}
+export declare class WorkspaceCheckpointStore {
+    #private;
+    constructor(options: WorkspaceCheckpointStoreOptions);
+    create(label?: string): Promise<WorkspaceCheckpoint>;
+    load(id: string): Promise<WorkspaceCheckpoint>;
+    restore(id: string): Promise<WorkspaceCheckpoint>;
+}

package/dist/session/store.d.ts

@@ -0,0 +1,154 @@
+import { z } from "zod";
+import { type TranscriptState } from "../ui/transcript.js";
+import type { ModelContent } from "../models/types.js";
+export declare const SESSION_VERSION: 3;
+export declare const DEFAULT_MAX_SESSION_BYTES: number;
+export declare const SessionDocumentSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    workspace: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>;
+    tasks: z.ZodObject<{
+        plan: z.ZodOptional<z.ZodObject<{
+            tasks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                subject: z.ZodString;
+                activeForm: z.ZodString;
+                status: z.ZodEnum<{
+                    blocked: "blocked";
+                    cancelled: "cancelled";
+                    completed: "completed";
+                    failed: "failed";
+                    in_progress: "in_progress";
+                    pending: "pending";
+                }>;
+                dependencies: z.ZodArray<z.ZodString>;
+                result: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        graph: z.ZodOptional<z.ZodObject<{
+            nodes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                dependencies: z.ZodArray<z.ZodString>;
+                expectedOutputs: z.ZodArray<z.ZodString>;
+                verification: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        states: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            blocked: "blocked";
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+        }>>;
+        results: z.ZodRecord<z.ZodString, z.ZodObject<{
+            taskId: z.ZodString;
+            status: z.ZodEnum<{
+                blocked: "blocked";
+                completed: "completed";
+                failed: "failed";
+            }>;
+            summary: z.ZodString;
+            filesChanged: z.ZodArray<z.ZodString>;
+            commandsRun: z.ZodArray<z.ZodObject<{
+                command: z.ZodString;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                summary: z.ZodString;
+            }, z.core.$strict>>;
+            verification: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                passed: z.ZodBoolean;
+                details: z.ZodString;
+            }, z.core.$strict>>;
+            artifacts: z.ZodArray<z.ZodString>;
+            risks: z.ZodArray<z.ZodString>;
+            suggestedNextSteps: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    models: z.ZodObject<{
+        main: z.ZodString;
+        subagent: z.ZodString;
+    }, z.core.$strict>;
+    permissionMode: z.ZodPreprocess<z.ZodDefault<z.ZodEnum<{
+        acceptEdits: "acceptEdits";
+        auto: "auto";
+        bubble: "bubble";
+        bypassPermissions: "bypassPermissions";
+        default: "default";
+        plan: "plan";
+    }>>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            abandoned: "abandoned";
+            active: "active";
+            completed: "completed";
+        }>;
+        taskId: z.ZodOptional<z.ZodString>;
+        messageStart: z.ZodOptional<z.ZodNumber>;
+        finalizedAt: z.ZodOptional<z.ZodString>;
+        transcriptHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    version: z.ZodLiteral<3>;
+    conversation: z.ZodObject<{
+        compact: z.ZodOptional<z.ZodObject<{
+            summary: z.ZodString;
+            compactedAt: z.ZodString;
+        }, z.core.$strict>>;
+        messages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            toolCallId: z.ZodOptional<z.ZodString>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                input: z.ZodUnknown;
+            }, z.core.$strict>>>;
+            role: z.ZodLiteral<"user">;
+            content: z.ZodType<ModelContent, unknown, z.core.$ZodTypeInternals<ModelContent, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            toolCallId: z.ZodOptional<z.ZodString>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                input: z.ZodUnknown;
+            }, z.core.$strict>>>;
+            role: z.ZodLiteral<"assistant">;
+            content: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            toolCallId: z.ZodOptional<z.ZodString>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                input: z.ZodUnknown;
+            }, z.core.$strict>>>;
+            role: z.ZodLiteral<"tool">;
+            content: z.ZodString;
+        }, z.core.$strict>], "role">>;
+    }, z.core.$strict>;
+    timeline: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        state: z.ZodCustom<TranscriptState, TranscriptState>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SessionDocument = z.infer<typeof SessionDocumentSchema>;
+export interface SessionEntry {
+    sessionId: string;
+    createdAt: string;
+    updatedAt: string;
+    mainModel: string;
+}
+export interface SessionStoreOptions {
+    workspace: string;
+    maxBytes?: number;
+    maxSessions?: number;
+}
+export declare class SessionStore {
+    #private;
+    constructor(options: SessionStoreOptions);
+    save(input: SessionDocument): Promise<void>;
+    load(sessionId?: string): Promise<SessionDocument>;
+    list(): Promise<SessionEntry[]>;
+    delete(sessionId: string): Promise<void>;
+}

package/dist/session/tree.d.ts

@@ -0,0 +1,31 @@
+import type { ContextSnapshot } from "../context/manager.js";
+export interface SessionTreeNode {
+    id: string;
+    parentId: string | null;
+    createdAt: string;
+    prompt: string;
+    checkpointId: string;
+    context: ContextSnapshot;
+}
+export interface SessionHistoryOptions {
+    workspace: string;
+    sessionId: string;
+    restoreContext?(snapshot: ContextSnapshot): void | Promise<void>;
+}
+export declare class SessionHistory {
+    #private;
+    private constructor();
+    static open(options: SessionHistoryOptions): Promise<SessionHistory>;
+    get leafId(): string | null;
+    tree(): readonly SessionTreeNode[];
+    append(input: {
+        prompt: string;
+        context: ContextSnapshot;
+        label?: string;
+    }): Promise<SessionTreeNode>;
+    checkpoint(label: string | undefined, context: ContextSnapshot): Promise<SessionTreeNode>;
+    moveTo(nodeId: string): Promise<void>;
+    fork(nodeId: string): Promise<ContextSnapshot>;
+    rewind(nodeId: string, currentContext: ContextSnapshot): Promise<void>;
+    unrevert(): Promise<void>;
+}

package/dist/skills/builtin-loop.d.ts

@@ -0,0 +1,12 @@
+import type { LoopVerificationEvidence } from "../loop/types.js";
+export declare const BUILTIN_LOOP_SKILL: {
+    readonly name: "loop";
+    readonly description: "Iteratively work toward a goal using host-owned verification evidence";
+};
+export interface LoopCyclePromptInput {
+    goal: string;
+    cycle: number;
+    memory?: string;
+    verification?: LoopVerificationEvidence;
+}
+export declare function buildLoopCyclePrompt(input: LoopCyclePromptInput): string;