flavor-code 1.2.1

package/dist/skills/registry.d.ts

@@ -0,0 +1,47 @@
+import type { FileHandle } from "node:fs/promises";
+export type SkillSource = "global" | "project";
+export interface SkillMetadata {
+    readonly name: string;
+    readonly description: string;
+    readonly source: SkillSource;
+    readonly root: string;
+    readonly disableModelInvocation: boolean;
+}
+export interface SkillDiagnostic {
+    readonly path: string;
+    readonly message: string;
+}
+export type SkillSelector = (query: string, candidates: readonly SkillMetadata[]) => string | undefined | Promise<string | undefined>;
+export type SkillResourceAuthorizer = (path: string, skill: SkillMetadata) => boolean | Promise<boolean>;
+export type SkillFileOpener = (path: string, flags: number) => Promise<FileHandle>;
+export type SkillResourceKind = "asset" | "reference" | "script";
+export interface ResolvedSkillResource {
+    readonly displayPath: string;
+    readonly kind: SkillResourceKind;
+    readonly size: number;
+    readonly skill: Readonly<Pick<SkillMetadata, "name" | "source">>;
+}
+export interface SkillRegistryOptions {
+    globalRoots?: readonly string[];
+    projectRoots?: readonly string[];
+    selector?: SkillSelector;
+    authorizeResource?: SkillResourceAuthorizer;
+    maxMetadataBytes?: number;
+    maxBodyBytes?: number;
+    maxResourceBytes?: number;
+    openFile?: SkillFileOpener;
+    disabledNames?: readonly string[];
+}
+export declare class SkillRegistry {
+    #private;
+    constructor(options?: SkillRegistryOptions);
+    get diagnostics(): readonly SkillDiagnostic[];
+    setDisabledNames(names: readonly string[]): void;
+    refresh(): Promise<readonly SkillMetadata[]>;
+    discover(): Promise<readonly SkillMetadata[]>;
+    match(query: string): Promise<SkillMetadata | undefined>;
+    loadBody(skill: SkillMetadata): Promise<string>;
+    resolveResource(skill: SkillMetadata, reference: string): Promise<ResolvedSkillResource>;
+    readResource(capability: ResolvedSkillResource): Promise<Buffer>;
+    readTextResource(capability: ResolvedSkillResource): Promise<string>;
+}

package/dist/skills/tool.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import type { ToolDefinition } from "../tools/types.js";
+import type { SkillRegistry } from "./registry.js";
+declare const SkillResourceInput: z.ZodObject<{
+    skill: z.ZodString;
+    reference: z.ZodString;
+}, z.core.$strict>;
+export declare function createSkillResourceTool(registry: SkillRegistry): ToolDefinition<z.infer<typeof SkillResourceInput>>;
+export {};

package/dist/sleep/organizer.d.ts

@@ -0,0 +1,37 @@
+import { SessionStore } from "../session/store.js";
+export type SleepOrganizeResult = {
+    status: "no-sessions" | "exists" | "locked";
+    date: string;
+} | {
+    status: "written";
+    date: string;
+    path: string;
+    sessionCount: number;
+};
+export interface ProjectSleepOrganizerOptions {
+    workspace: string;
+    sessions?: SessionStore;
+    generate(prompt: string, signal: AbortSignal): Promise<string>;
+}
+export interface ProjectSleepSchedulerOptions {
+    enabled: boolean;
+    organize(date: string, signal: AbortSignal): Promise<unknown>;
+    catchUpDates?: (signal: AbortSignal) => Promise<readonly string[]>;
+    retryDelayMs?: number;
+    now?: () => Date;
+    onError?: (error: unknown) => void;
+}
+export declare function localDateKey(date: Date): string;
+export declare function previousLocalDateKey(date: Date): string;
+export declare class ProjectSleepOrganizer {
+    #private;
+    constructor(options: ProjectSleepOrganizerOptions);
+    organize(date: string, signal?: AbortSignal): Promise<SleepOrganizeResult>;
+    pendingDates(beforeDate: string): Promise<string[]>;
+}
+export declare class ProjectSleepScheduler {
+    #private;
+    constructor(options: ProjectSleepSchedulerOptions);
+    start(): void;
+    dispose(): Promise<void>;
+}

package/dist/tools/ask-user-question.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+declare const QuestionSchema: z.ZodObject<{
+    question: z.ZodString;
+    header: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const AskUserQuestionInput: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        header: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AskUserQuestionInput = z.infer<typeof AskUserQuestionInput>;
+export type Question = z.infer<typeof QuestionSchema>;
+export interface AskUserQuestionHandler {
+    (questions: readonly Question[], signal: AbortSignal): Promise<Record<number, string>>;
+}
+/**
+ * Extracts answers a hook-relayed UI (e.g. the Flavor Island app) returned for
+ * an AskUserQuestion PermissionRequest. The decision's updatedInput carries the
+ * re-shaped hook payload, whose `input.answers` is keyed by question text. The
+ * result maps question index to answer; anything short of a complete non-empty
+ * answer set returns undefined so the terminal prompt remains the fallback.
+ */
+export declare function hookAnswersFromUpdatedInput(updatedInput: unknown, questions: readonly Question[]): Record<number, string> | undefined;
+/**
+ * A simple bridge that holds pending questions and resolves when answers arrive.
+ * The UI layer polls `pending` to render the question prompts and calls `answer()`
+ * when the user responds.
+ */
+export declare class QuestionBridge {
+    #private;
+    constructor(onChange?: () => void);
+    get pending(): readonly Question[] | undefined;
+    ask(questions: readonly Question[], signal: AbortSignal): Promise<Record<number, string>>;
+    answer(answers: Record<number, string>): void;
+    cancel(reason?: string): void;
+    dispose(): void;
+}
+export declare function createAskUserQuestionTool(handler: AskUserQuestionHandler): ToolDefinition<AskUserQuestionInput>;
+export {};

package/dist/tools/file-diff.d.ts

@@ -0,0 +1,9 @@
+import type { FileChangePresentation } from "./types.js";
+export declare const MAX_DIFF_PREVIEW_LINES = 120;
+export interface DiffHunkInput {
+    oldStart: number;
+    newStart: number;
+    lines: readonly string[];
+}
+export declare function buildFileChangePresentation(path: string, before: string, after: string, operation: "create" | "update"): FileChangePresentation;
+export declare function buildPatchPresentation(path: string, created: boolean, hunks: readonly DiffHunkInput[]): FileChangePresentation;

package/dist/tools/files.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { type ToolDefinition } from "./types.js";
+export declare const MAX_READ_BYTES = 1048576;
+declare const ReadInput: z.ZodObject<{
+    path: z.ZodString;
+    maxBytes: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    startLine: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    endLine: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    force: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString & z.ZodType<"false" | "true", string, z.core.$ZodTypeInternals<"false" | "true", string>>]>>>;
+}, z.core.$strip>;
+declare const WriteInput: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+declare const EditInput: z.ZodObject<{
+    path: z.ZodString;
+    oldText: z.ZodString;
+    newText: z.ZodString;
+}, z.core.$strip>;
+declare const ApplyPatchInput: z.ZodObject<{
+    patch: z.ZodString;
+}, z.core.$strip>;
+export interface ReadFileHandle {
+    read(buffer: Buffer, offset: number, length: number, position: number | null): Promise<{
+        bytesRead: number;
+    }>;
+    close(): Promise<void>;
+}
+export interface ReadToolOptions {
+    openFile?: (path: string) => Promise<ReadFileHandle>;
+}
+export interface FileWriteProposal {
+    path: string;
+    before: string;
+    after: string;
+    kind: "create" | "update";
+}
+export interface FileMutationOptions {
+    beforeCommit?(proposal: FileWriteProposal, signal: AbortSignal): Promise<void>;
+}
+export declare function createReadTool(workspace: string, options?: ReadToolOptions): ToolDefinition<z.infer<typeof ReadInput>>;
+export declare function createWriteTool(workspace: string, options?: FileMutationOptions): ToolDefinition<z.infer<typeof WriteInput>>;
+export declare function createEditTool(workspace: string, options?: FileMutationOptions): ToolDefinition<z.infer<typeof EditInput>>;
+export declare function createApplyPatchTool(workspace: string, options?: FileMutationOptions): ToolDefinition<z.infer<typeof ApplyPatchInput>>;
+export declare const createRead: typeof createReadTool;
+export declare const createWrite: typeof createWriteTool;
+export declare const createEdit: typeof createEditTool;
+export declare const createApplyPatch: typeof createApplyPatchTool;
+export {};

package/dist/tools/lsp.d.ts

@@ -0,0 +1,77 @@
+import type { ToolDefinition } from "./types.js";
+interface LspLocation {
+    uri: string;
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}
+interface LspHover {
+    contents: {
+        kind: string;
+        language?: string;
+        value: string;
+    } | string;
+    range?: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}
+interface LspDiagnostic {
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    severity: number;
+    message: string;
+    source?: string;
+}
+interface LanguageServerConfig {
+    language: string;
+    extensions: string[];
+    command: string;
+    args: string[];
+    rootFiles: string[];
+}
+export interface LspManager {
+    findReferences(uri: string, line: number, character: number): Promise<LspLocation[]>;
+    hover(uri: string, line: number, character: number): Promise<LspHover | null>;
+    diagnostics(uri: string): Promise<LspDiagnostic[]>;
+    dispose(): void;
+}
+export declare class RealLspManager implements LspManager {
+    #private;
+    constructor(options: {
+        workspace: string;
+        serverConfigs?: LanguageServerConfig[];
+        onStatus?: ((message: string) => void) | undefined;
+    });
+    dispose(): void;
+    findReferences(uri: string, line: number, character: number): Promise<LspLocation[]>;
+    hover(uri: string, line: number, character: number): Promise<LspHover | null>;
+    diagnostics(uri: string): Promise<LspDiagnostic[]>;
+}
+export interface LspToolOptions {
+    manager?: LspManager;
+    onStatus?: (message: string) => void;
+}
+export declare function createLspTools(workspace: string, options?: LspToolOptions): ToolDefinition<unknown>[];
+export {};

package/dist/tools/managed.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+export declare const RegisterManagedToolInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    implementation: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        global: "global";
+        project: "project";
+    }>>;
+    agents: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        main: "main";
+        subagent: "subagent";
+    }>>>;
+}, z.core.$strict>;
+export declare const RemoveManagedToolInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    scope: z.ZodOptional<z.ZodEnum<{
+        global: "global";
+        project: "project";
+    }>>;
+}, z.core.$strict>;
+export type RegisterManagedToolInput = z.input<typeof RegisterManagedToolInputSchema>;
+export type ManagedToolScope = z.output<typeof RegisterManagedToolInputSchema>["scope"];
+export type RemoveManagedToolInput = z.input<typeof RemoveManagedToolInputSchema>;
+export interface ManagedToolSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly scope: ManagedToolScope;
+    readonly path: string;
+    readonly createdAt: string;
+    readonly agents?: readonly ("main" | "subagent")[];
+    readonly active: boolean;
+}
+export interface ManagedToolStoreOptions {
+    workspace: string;
+    home: string;
+    now?: () => string;
+}
+/** Durable store for agent-authored tools. Managed code is trusted in-process code, like plugins. */
+export declare class ManagedToolStore {
+    #private;
+    constructor(options: ManagedToolStoreOptions);
+    get diagnostics(): readonly string[];
+    directory(scope: ManagedToolScope): string;
+    load(): Promise<void>;
+    definitions(): readonly ToolDefinition<unknown>[];
+    list(): readonly ManagedToolSummary[];
+    register(rawInput: RegisterManagedToolInput): Promise<ManagedToolSummary>;
+    remove(rawInput: RemoveManagedToolInput): Promise<ManagedToolSummary>;
+    removalPaths(rawInput: RemoveManagedToolInput): string[];
+}
+export interface ManagedToolManagementOptions {
+    store: ManagedToolStore;
+    conflict(name: string): string | undefined;
+    onChanged(): void | Promise<void>;
+}
+export declare function createManagedToolManagementTools(options: ManagedToolManagementOptions): readonly ToolDefinition<unknown>[];

package/dist/tools/runtime.d.ts

@@ -0,0 +1,58 @@
+import type { HookBus } from "../hooks/bus.js";
+import { type PermissionEngine, type PermissionRequest, type ToolCategory } from "../permissions/engine.js";
+import type { PermissionClassifier } from "../permissions/classifier.js";
+import { type ToolCall, type ToolContext, type ToolDefinition, type ToolResult } from "./types.js";
+export type ApprovalDecision = "once" | "always" | "deny";
+export type ApprovalCallback = (request: PermissionRequest & {
+    reason?: string;
+}, signal: AbortSignal) => ApprovalDecision | Promise<ApprovalDecision>;
+export interface ToolRuntimeOptions {
+    tools: readonly ToolDefinition<unknown>[];
+    hooks: HookBus;
+    permissions: PermissionEngine;
+    approve?: ApprovalCallback;
+    /** Classifies unresolved main-agent calls in auto mode. Failures fall back to approval. */
+    classify?: PermissionClassifier;
+    /** Categories that should skip the approval callback. Destructive is never added. */
+    alwaysAllowed?: ToolCategory[];
+    /** Workspace used for durable overflow files. Defaults to process.cwd(). */
+    workspace?: string;
+    /** Inline tool-result content budgets. */
+    outputLimits?: Partial<ToolOutputLimits>;
+}
+export interface ToolOutputLimits {
+    perToolChars: number;
+    perTurnChars: number;
+}
+export interface ToolOutputOverflow {
+    truncated: true;
+    reason: "per_tool_limit" | "turn_limit" | "per_tool_and_turn_limit";
+    preview: string;
+    originalChars: number;
+    previewChars: number;
+    savedTo: string;
+}
+export declare const DEFAULT_TOOL_OUTPUT_LIMITS: Readonly<ToolOutputLimits>;
+export type ToolInputValidation = {
+    ok: true;
+    input: unknown;
+} | {
+    ok: false;
+    error: {
+        code: "unknown_tool" | "invalid_input";
+        message: string;
+    };
+};
+export declare class ToolRuntime {
+    #private;
+    constructor(options: ToolRuntimeOptions);
+    dispose(): void;
+    definition(name: string): ToolDefinition<unknown> | undefined;
+    replaceTools(tools: readonly ToolDefinition<unknown>[]): void;
+    /** Starts the aggregate result budget for one model response's tool calls. */
+    beginTurn(): void;
+    validate(call: ToolCall): ToolInputValidation;
+    label(call: ToolCall): string | undefined;
+    hint(call: ToolCall): string | undefined;
+    execute(call: ToolCall, context: ToolContext): Promise<ToolResult>;
+}

package/dist/tools/search.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+declare const GlobInput: z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+declare const GrepInput: z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    glob: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fileType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        c: "c";
+        cpp: "cpp";
+        cs: "cs";
+        css: "css";
+        dart: "dart";
+        go: "go";
+        html: "html";
+        java: "java";
+        javascript: "javascript";
+        js: "js";
+        json: "json";
+        kotlin: "kotlin";
+        lua: "lua";
+        markdown: "markdown";
+        md: "md";
+        php: "php";
+        py: "py";
+        python: "python";
+        ruby: "ruby";
+        rust: "rust";
+        sh: "sh";
+        sql: "sql";
+        swift: "swift";
+        text: "text";
+        toml: "toml";
+        ts: "ts";
+        typescript: "typescript";
+        xml: "xml";
+        yaml: "yaml";
+    }>>>;
+    context: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    limit: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export interface SearchToolOptions {
+    forceNode?: boolean;
+    rgPath?: string;
+    rgArgsPrefix?: string[];
+    defaultLimit?: number;
+    maxFileBytes?: number;
+    maxSearchBytes?: number;
+    maxEntriesPerDirectory?: number;
+    maxDiscoveredFiles?: number;
+    maxIgnoreFileBytes?: number;
+    maxTotalIgnoreBytes?: number;
+    maxIgnoreLayers?: number;
+    maxIgnoreRules?: number;
+    maxIgnoreTraversedDirectories?: number;
+    maxIgnoreTraversedEntries?: number;
+}
+export interface SearchResult<T> {
+    matches: T[];
+    truncated: boolean;
+}
+export interface GrepMatch {
+    path: string;
+    line: number;
+    column: number;
+    text: string;
+    before: string[];
+    after: string[];
+}
+export declare function createGlobTool(workspace: string, options?: SearchToolOptions): ToolDefinition<z.infer<typeof GlobInput>>;
+export declare function createGrepTool(workspace: string, options?: SearchToolOptions): ToolDefinition<z.infer<typeof GrepInput>>;
+export {};

package/dist/tools/shell.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+import type { ExecutionEnvironment } from "../execution/types.js";
+export declare const DEFAULT_MAX_OUTPUT_BYTES = 1048576;
+declare const ShellInput: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    timeoutMs: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export interface ShellToolOptions {
+    maxOutputBytes?: number;
+    executionEnvironment?: ExecutionEnvironment;
+}
+export interface TruncationMetadata {
+    truncated: boolean;
+    originalBytes: number;
+    limitBytes: number;
+}
+export interface ShellResult {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+    truncation: {
+        stdout: TruncationMetadata;
+        stderr: TruncationMetadata;
+    };
+    terminationReason: "timeout" | "cancelled" | null;
+}
+type ShellTool = Omit<ToolDefinition<z.infer<typeof ShellInput>>, "execute"> & {
+    execute(input: z.infer<typeof ShellInput>, signal: AbortSignal): Promise<ShellResult>;
+};
+export declare function createShellTool(workspace: string, options?: ShellToolOptions): ShellTool;
+export declare function executeShell(root: string, input: z.infer<typeof ShellInput>, cancellation: AbortSignal, maxBytes: number): Promise<ShellResult>;
+export {};

package/dist/tools/task-output.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+declare const CommandRunSchema: z.ZodObject<{
+    command: z.ZodString;
+    exitCode: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+    summary: z.ZodString;
+}, z.core.$strip>;
+declare const VerificationItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    passed: z.ZodBoolean;
+    details: z.ZodString;
+}, z.core.$strip>;
+declare const TaskOutputInput: z.ZodObject<{
+    summary: z.ZodString;
+    filesChanged: z.ZodArray<z.ZodString>;
+    commandsRun: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+        summary: z.ZodString;
+    }, z.core.$strip>>;
+    verification: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        passed: z.ZodBoolean;
+        details: z.ZodString;
+    }, z.core.$strip>>;
+    artifacts: z.ZodArray<z.ZodString>;
+    risks: z.ZodArray<z.ZodString>;
+    suggestedNextSteps: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const TaskOutputResultSchema: z.ZodObject<{
+    summary: z.ZodString;
+    filesChanged: z.ZodArray<z.ZodString>;
+    commandsRun: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+        summary: z.ZodString;
+    }, z.core.$strip>>;
+    verification: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        passed: z.ZodBoolean;
+        details: z.ZodString;
+    }, z.core.$strip>>;
+    artifacts: z.ZodArray<z.ZodString>;
+    risks: z.ZodArray<z.ZodString>;
+    suggestedNextSteps: z.ZodArray<z.ZodString>;
+    taskCompleted: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type TaskOutputInput = z.infer<typeof TaskOutputInput>;
+export type TaskOutputResult = z.infer<typeof TaskOutputResultSchema>;
+export type CommandRun = z.infer<typeof CommandRunSchema>;
+export type VerificationItem = z.infer<typeof VerificationItemSchema>;
+export declare function createTaskOutputTool(): ToolDefinition<TaskOutputInput>;
+export {};

package/dist/tools/todo-write.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+export declare const TodoStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    completed: "completed";
+    in_progress: "in_progress";
+    pending: "pending";
+}>;
+export declare const TodoItemSchema: z.ZodObject<{
+    content: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        in_progress: "in_progress";
+        pending: "pending";
+    }>;
+    activeForm: z.ZodString;
+}, z.core.$strip>;
+declare const TodoWriteInput: z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
+        }>;
+        activeForm: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TodoStatus = z.infer<typeof TodoStatusSchema>;
+export type TodoItem = z.infer<typeof TodoItemSchema>;
+export type TodoWriteInput = z.infer<typeof TodoWriteInput>;
+export declare function createTodoWriteTool(): ToolDefinition<TodoWriteInput>;
+export {};

package/dist/tools/types.d.ts

@@ -0,0 +1,56 @@
+import type { z } from "zod";
+import type { PermissionRequest } from "../permissions/engine.js";
+export type ToolPermissionMetadata = Omit<PermissionRequest, "agent" | "tool">;
+export interface FileDiffLine {
+    kind: "context" | "removed" | "added" | "omitted";
+    oldLine?: number;
+    newLine?: number;
+    text: string;
+}
+export interface FileChangePresentation {
+    kind: "file-change";
+    operation: "create" | "update" | "delete";
+    path: string;
+    added: number;
+    removed: number;
+    lines: FileDiffLine[];
+}
+export type ToolPresentation = FileChangePresentation;
+export declare function withToolPresentation<T extends object>(output: T, presentation: ToolPresentation): T;
+export declare function getToolPresentation(output: unknown): ToolPresentation | undefined;
+export interface ToolDefinition<T> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<T>;
+    /** Restrict a tool to selected agent roles. Omit to expose it to both roles. */
+    agents?: readonly ToolContext["agent"][];
+    /** Optional provider-facing JSON Schema when it must differ from runtime validation. */
+    modelInputSchema?: Record<string, unknown>;
+    /** Whether providers should enforce strict function arguments. Defaults to true. */
+    modelStrict?: boolean;
+    paths(input: T): string[];
+    /**
+     * Optional short human-readable parameter summary, rendered dimmed next to the tool name.
+     * Must return plain text (no ANSI escapes). Return undefined or an empty string to omit the hint.
+     */
+    summarize?(input: T): string | undefined;
+    permissions?(input: T): ToolPermissionMetadata;
+    execute(input: T, signal: AbortSignal): Promise<unknown>;
+}
+export interface ToolCall {
+    name: string;
+    input: unknown;
+}
+export interface ToolContext {
+    agent: "main" | "subagent";
+    signal?: AbortSignal;
+}
+export interface ToolResult {
+    ok: boolean;
+    output?: unknown;
+    presentation?: ToolPresentation;
+    error?: {
+        code: string;
+        message: string;
+    };
+}

package/dist/trace/recorder.d.ts

@@ -0,0 +1,14 @@
+import { type TraceKind } from "./schema.js";
+export interface TraceRecorderOptions {
+    path: string;
+    sessionId: string;
+    secrets?: readonly string[];
+    now?: () => Date;
+}
+export declare class TraceRecorder {
+    #private;
+    readonly path: string;
+    constructor(options: TraceRecorderOptions);
+    record(kind: TraceKind, payload: unknown): Promise<void>;
+    close(): Promise<void>;
+}