@smthrs/std 0.0.0-stage → 1.0.0-rc.3

package/dist/esm/Manifest.d.ts

@@ -0,0 +1,918 @@
+/**
+ * Built-in flow declarations and their separately supplied handlers.
+ *
+ * @since 1.0.0
+ */
+import * as Bash from "./Bash.ts";
+import * as WebSearch from "./WebSearch.ts";
+/**
+ * Frozen name-to-declaration registry for every standard flow.
+ *
+ * @category registries
+ * @since 1.0.0
+ */
+export declare const flows: Readonly<{
+    read: {
+        readonly name: "read";
+        readonly description: "Read a text file by 1-based offset and limit. content is RAW file text with no line-number prefixes, so any line of it is an edit anchor as it stands; the numbers are startLine/endLine.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly offset: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly content: import("effect/Schema").String;
+            readonly startLine: import("effect/Schema").Number;
+            readonly endLine: import("effect/Schema").Number;
+            readonly totalLines: import("effect/Schema").Number;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    write: {
+        readonly name: "write";
+        readonly description: "Write UTF-8 text to a path, replacing any existing file; parent directories are created. Prefer edit for targeted changes.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly content: import("effect/Schema").String;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly bytesWritten: import("effect/Schema").Number;
+            readonly created: import("effect/Schema").Boolean;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    edit: {
+        readonly name: "edit";
+        readonly description: "Edit a file by exact text (oldString, unique unless replaceAll) or by an earlier hit's line range (startLine/endLine, optional expect). A miss returns the file's real text; a hit returns the hunk.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly oldString: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly startLine: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly endLine: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly expect: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly newString: import("effect/Schema").String;
+            readonly replaceAll: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly replacements: import("effect/Schema").Number;
+            readonly startLine: import("effect/Schema").Number;
+            readonly endLine: import("effect/Schema").Number;
+            readonly hunk: import("effect/Schema").String;
+            readonly errors: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly line: import("effect/Schema").Number;
+                readonly character: import("effect/Schema").Number;
+                readonly message: import("effect/Schema").String;
+            }>>>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    ls: {
+        readonly name: "ls";
+        readonly description: "List a directory with directories first, trailing /, and locale-independent UTF-16 code-unit ordering; use 1-based offset and limit to page large listings.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly offset: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly entries: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly name: import("effect/Schema").String;
+                readonly kind: import("effect/Schema").Literals<readonly ["file", "directory"]>;
+            }>>;
+            readonly total: import("effect/Schema").Number;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    glob: {
+        readonly name: "glob";
+        readonly description: "Find files through the Smithers Ripgrep Subset v1 contract.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly pattern: import("effect/Schema").NonEmptyString;
+            readonly root: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly hidden: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly noIgnore: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly paths: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly total: import("effect/Schema").Int;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    grep: {
+        readonly name: "grep";
+        readonly description: "Search file contents through the Smithers Ripgrep Subset v1 contract. limit counts matches, each carrying its own context and enclosing definition; fixedStrings searches a literal, and one is retried.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly pattern: import("effect/Schema").String;
+            readonly root: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly fixedStrings: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly ignoreCase: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly smartCase: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly globs: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly beforeContext: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly afterContext: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly context: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly maxCount: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly filesWithMatches: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly hidden: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly symbols: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly noIgnore: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly matches: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly file: import("effect/Schema").String;
+                readonly line: import("effect/Schema").Int;
+                readonly text: import("effect/Schema").String;
+                readonly before: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly line: import("effect/Schema").Int;
+                    readonly text: import("effect/Schema").String;
+                }>>;
+                readonly after: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly line: import("effect/Schema").Int;
+                    readonly text: import("effect/Schema").String;
+                }>>;
+                readonly symbol: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                    readonly kind: import("effect/Schema").String;
+                    readonly name: import("effect/Schema").String;
+                    readonly startLine: import("effect/Schema").Int;
+                    readonly endLine: import("effect/Schema").Int;
+                }>>;
+            }>>;
+            readonly files: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly filesSearched: import("effect/Schema").Int;
+            readonly skippedBinary: import("effect/Schema").Int;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly retriedAsLiteral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    bash: {
+        readonly name: "bash";
+        readonly description: "Run a shell command, or an interpreter over a script passed as data instead of quoted into a line. container routes it through the host's container transport. mode:hermetic pre-checks path tokens.";
+        readonly input: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly mode: import("effect/Schema").Literal<"hermetic">;
+            readonly command: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly script: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly interpreter: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly args: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly stdin: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly container: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly reads: import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>;
+            readonly writes: import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>;
+            readonly cwd: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly env: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+            readonly timeoutMs: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>, import("effect/Schema").Struct<{
+            readonly mode: import("effect/Schema").withDecodingDefaultKey<import("effect/Schema").optionalKey<import("effect/Schema").Literal<"unhermetic">>, never>;
+            readonly command: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly script: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly interpreter: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly args: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly stdin: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly container: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly cwd: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly env: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+            readonly timeoutMs: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>]>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly exitCode: import("effect/Schema").Number;
+            readonly stdout: import("effect/Schema").String;
+            readonly stderr: import("effect/Schema").String;
+            readonly stdoutTruncated: import("effect/Schema").Boolean;
+            readonly stderrTruncated: import("effect/Schema").Boolean;
+            readonly stdoutDroppedBytes: import("effect/Schema").Number;
+            readonly stderrDroppedBytes: import("effect/Schema").Number;
+            readonly invalidProbe: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly reason: import("effect/Schema").Literals<readonly ["unknown-command", "unknown-test", "unknown-path", "unknown-module", "unknown-environment"]>;
+                readonly evidence: import("effect/Schema").String;
+                readonly message: import("effect/Schema").String;
+            }>>;
+            readonly mutated: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    test: {
+        readonly name: "test";
+        readonly description: "Run this repository's declared test runner and get {passed, failed[ids]}, not raw output. against:'base' also runs it on the pristine base commit, so a pre-existing failure is named, not investigated.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly selection: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly against: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["workspace", "base"]>>;
+            readonly timeoutMs: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly base: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly ref: import("effect/Schema").String;
+                readonly commit: import("effect/Schema").String;
+                readonly command: import("effect/Schema").String;
+                readonly exitCode: import("effect/Schema").Number;
+                readonly passed: import("effect/Schema").Number;
+                readonly failed: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly parsed: import("effect/Schema").Boolean;
+                readonly tail: import("effect/Schema").String;
+                readonly tailTruncated: import("effect/Schema").Boolean;
+                readonly tailDroppedBytes: import("effect/Schema").Number;
+                readonly invalidProbe: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                    readonly reason: import("effect/Schema").Literals<readonly ["unknown-command", "unknown-test", "unknown-path", "unknown-module", "unknown-environment"]>;
+                    readonly evidence: import("effect/Schema").String;
+                    readonly message: import("effect/Schema").String;
+                }>>;
+            }>>;
+            readonly introduced: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly preexisting: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly fixed: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly command: import("effect/Schema").String;
+            readonly exitCode: import("effect/Schema").Number;
+            readonly passed: import("effect/Schema").Number;
+            readonly failed: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly parsed: import("effect/Schema").Boolean;
+            readonly tail: import("effect/Schema").String;
+            readonly tailTruncated: import("effect/Schema").Boolean;
+            readonly tailDroppedBytes: import("effect/Schema").Number;
+            readonly invalidProbe: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly reason: import("effect/Schema").Literals<readonly ["unknown-command", "unknown-test", "unknown-path", "unknown-module", "unknown-environment"]>;
+                readonly evidence: import("effect/Schema").String;
+                readonly message: import("effect/Schema").String;
+            }>>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    shell_command: {
+        readonly name: "shell_command";
+        readonly description: string;
+        readonly input: import("effect/Schema").Struct<{
+            readonly command: import("effect/Schema").String;
+            readonly workdir: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly timeout_ms: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly output: import("effect/Schema").String;
+            readonly exitCode: import("effect/Schema").Number;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    apply_patch: {
+        readonly name: "apply_patch";
+        readonly description: "The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly input: import("effect/Schema").String;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly output: import("effect/Schema").String;
+            readonly added: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly modified: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly deleted: import("effect/Schema").$Array<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    update_plan: {
+        readonly name: "update_plan";
+        readonly description: string;
+        readonly input: import("effect/Schema").Struct<{
+            readonly explanation: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly plan: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly step: import("effect/Schema").String;
+                readonly status: import("effect/Schema").Literals<readonly ["pending", "in_progress", "completed"]>;
+            }>>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly output: import("effect/Schema").String;
+        }>;
+        readonly capabilities: readonly string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    fetch: {
+        readonly name: "fetch";
+        readonly description: "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly url: import("effect/Schema").String;
+            readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+            readonly timeout: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly status: import("effect/Schema").Number;
+            readonly body: import("effect/Schema").String;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    "http-post": {
+        readonly name: "http-post";
+        readonly description: "Post a text body to an absolute URL and return the response; this is irreversible because the remote side may already have acted.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly url: import("effect/Schema").String;
+            readonly body: import("effect/Schema").String;
+            readonly contentType: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+            readonly timeout: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly status: import("effect/Schema").Number;
+            readonly body: import("effect/Schema").String;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    explore: {
+        readonly name: "explore";
+        readonly description: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly prompt: import("effect/Schema").String;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly findings: import("effect/Schema").String;
+        }>;
+        readonly model: string | undefined;
+        readonly flows: readonly [{
+            readonly name: "read";
+            readonly description: "Read a text file by 1-based offset and limit. content is RAW file text with no line-number prefixes, so any line of it is an edit anchor as it stands; the numbers are startLine/endLine.";
+            readonly input: import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").String;
+                readonly offset: import("effect/Schema").optional<import("effect/Schema").Int>;
+                readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+            }>;
+            readonly output: import("effect/Schema").Struct<{
+                readonly content: import("effect/Schema").String;
+                readonly startLine: import("effect/Schema").Number;
+                readonly endLine: import("effect/Schema").Number;
+                readonly totalLines: import("effect/Schema").Number;
+                readonly truncated: import("effect/Schema").Boolean;
+                readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>;
+            readonly capabilities: string[];
+            readonly effects: import("@smthrs/plan/Effects").Declaration;
+        }, {
+            readonly name: "ls";
+            readonly description: "List a directory with directories first, trailing /, and locale-independent UTF-16 code-unit ordering; use 1-based offset and limit to page large listings.";
+            readonly input: import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").String;
+                readonly offset: import("effect/Schema").optional<import("effect/Schema").Int>;
+                readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+            }>;
+            readonly output: import("effect/Schema").Struct<{
+                readonly entries: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly name: import("effect/Schema").String;
+                    readonly kind: import("effect/Schema").Literals<readonly ["file", "directory"]>;
+                }>>;
+                readonly total: import("effect/Schema").Number;
+                readonly truncated: import("effect/Schema").Boolean;
+                readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>;
+            readonly capabilities: string[];
+            readonly effects: import("@smthrs/plan/Effects").Declaration;
+        }, {
+            readonly name: "glob";
+            readonly description: "Find files through the Smithers Ripgrep Subset v1 contract.";
+            readonly input: import("effect/Schema").Struct<{
+                readonly pattern: import("effect/Schema").NonEmptyString;
+                readonly root: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly hidden: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly noIgnore: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+            }>;
+            readonly output: import("effect/Schema").Struct<{
+                readonly paths: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly total: import("effect/Schema").Int;
+                readonly truncated: import("effect/Schema").Boolean;
+                readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>;
+            readonly capabilities: string[];
+            readonly effects: import("@smthrs/plan/Effects").Declaration;
+        }, {
+            readonly name: "grep";
+            readonly description: "Search file contents through the Smithers Ripgrep Subset v1 contract. limit counts matches, each carrying its own context and enclosing definition; fixedStrings searches a literal, and one is retried.";
+            readonly input: import("effect/Schema").Struct<{
+                readonly pattern: import("effect/Schema").String;
+                readonly root: import("effect/Schema").optional<import("effect/Schema").String>;
+                readonly fixedStrings: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly ignoreCase: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly smartCase: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly globs: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+                readonly beforeContext: import("effect/Schema").optional<import("effect/Schema").Int>;
+                readonly afterContext: import("effect/Schema").optional<import("effect/Schema").Int>;
+                readonly context: import("effect/Schema").optional<import("effect/Schema").Int>;
+                readonly maxCount: import("effect/Schema").optional<import("effect/Schema").Int>;
+                readonly filesWithMatches: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly hidden: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly symbols: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly noIgnore: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+            }>;
+            readonly output: import("effect/Schema").Struct<{
+                readonly matches: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly file: import("effect/Schema").String;
+                    readonly line: import("effect/Schema").Int;
+                    readonly text: import("effect/Schema").String;
+                    readonly before: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                        readonly line: import("effect/Schema").Int;
+                        readonly text: import("effect/Schema").String;
+                    }>>;
+                    readonly after: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                        readonly line: import("effect/Schema").Int;
+                        readonly text: import("effect/Schema").String;
+                    }>>;
+                    readonly symbol: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                        readonly kind: import("effect/Schema").String;
+                        readonly name: import("effect/Schema").String;
+                        readonly startLine: import("effect/Schema").Int;
+                        readonly endLine: import("effect/Schema").Int;
+                    }>>;
+                }>>;
+                readonly files: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly filesSearched: import("effect/Schema").Int;
+                readonly skippedBinary: import("effect/Schema").Int;
+                readonly truncated: import("effect/Schema").Boolean;
+                readonly retriedAsLiteral: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+                readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>;
+            readonly capabilities: string[];
+            readonly effects: import("@smthrs/plan/Effects").Declaration;
+        }];
+        readonly prompt: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+        readonly capabilities: readonly string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    webfetch: {
+        readonly name: "webfetch";
+        readonly description: "Fetch an HTTP URL and render its content as text, Markdown, or HTML.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly url: import("effect/Schema").String;
+            readonly format: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["text", "markdown", "html"]>>;
+            readonly timeout: import("effect/Schema").optional<import("effect/Schema").Number>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly url: import("effect/Schema").String;
+            readonly status: import("effect/Schema").Int;
+            readonly contentType: import("effect/Schema").String;
+            readonly content: import("effect/Schema").String;
+            readonly truncated: import("effect/Schema").Boolean;
+            readonly notice: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    websearch: {
+        readonly name: "websearch";
+        readonly description: "Search the web through a configured provider and return normalized results.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly query: import("effect/Schema").NonEmptyString;
+            readonly numResults: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly freshness: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["day", "week", "month", "year"]>>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly results: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly title: import("effect/Schema").String;
+                readonly url: import("effect/Schema").String;
+                readonly snippet: import("effect/Schema").String;
+                readonly publishedAt: import("effect/Schema").optional<import("effect/Schema").String>;
+            }>>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+    lsp: {
+        readonly name: "lsp";
+        readonly description: "Inspect code intelligence through the configured language server.";
+        readonly input: import("effect/Schema").Struct<{
+            readonly operation: import("effect/Schema").Literals<readonly ["hover", "definition", "references", "implementation", "documentSymbols", "workspaceSymbols", "prepareCallHierarchy", "callHierarchyIncoming", "callHierarchyOutgoing", "diagnostics"]>;
+            readonly path: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly line: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly character: import("effect/Schema").optional<import("effect/Schema").Int>;
+            readonly query: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>;
+        readonly output: import("effect/Schema").Struct<{
+            readonly result: import("effect/Schema").Unknown;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    };
+}>;
+/**
+ * Frozen name-to-handler registry for executable standard flows.
+ *
+ * Explore is dynamic and therefore has no handler entry.
+ *
+ * @category registries
+ * @since 1.0.0
+ */
+export declare const handlers: Readonly<{
+    read: (input: {
+        readonly path: string;
+        readonly limit?: number | undefined;
+        readonly offset?: number | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly content: string;
+        readonly endLine: number;
+        readonly startLine: number;
+        readonly truncated: boolean;
+        readonly totalLines: number;
+        readonly notice?: string | undefined;
+    }, import("./StdError.ts").StdError, import("effect/FileSystem").FileSystem>;
+    write: (input: {
+        readonly path: string;
+        readonly content: string;
+    }) => import("effect/Effect").Effect<{
+        readonly path: string;
+        readonly bytesWritten: number;
+        readonly created: boolean;
+    }, import("./StdError.ts").StdError, import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
+    edit: (input: {
+        readonly path: string;
+        readonly newString: string;
+        readonly replaceAll?: boolean | undefined;
+        readonly endLine?: number | undefined;
+        readonly oldString?: string | undefined;
+        readonly startLine?: number | undefined;
+        readonly expect?: string | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly hunk: string;
+        readonly path: string;
+        readonly endLine: number;
+        readonly startLine: number;
+        readonly replacements: number;
+        readonly errors?: readonly {
+            readonly line: number;
+            readonly character: number;
+            readonly message: string;
+        }[] | undefined;
+    }, import("./StdError.ts").StdError, import("effect/FileSystem").FileSystem>;
+    ls: (input: {
+        readonly path: string;
+        readonly limit?: number | undefined;
+        readonly offset?: number | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly entries: readonly {
+            readonly name: string;
+            readonly kind: "directory" | "file";
+        }[];
+        readonly truncated: boolean;
+        readonly total: number;
+        readonly notice?: string | undefined;
+    }, import("./StdError.ts").StdError, import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
+    glob: (input: {
+        readonly pattern: string;
+        readonly root?: string | undefined;
+        readonly limit?: number | undefined;
+        readonly hidden?: boolean | undefined;
+        readonly noIgnore?: boolean | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly paths: readonly string[];
+        readonly truncated: boolean;
+        readonly total: number;
+        readonly notice?: string | undefined;
+    }, import("./StdError.ts").StdError, import("./Search.ts").Search>;
+    grep: (input: {
+        readonly pattern: string;
+        readonly root?: string | undefined;
+        readonly limit?: number | undefined;
+        readonly context?: number | undefined;
+        readonly hidden?: boolean | undefined;
+        readonly noIgnore?: boolean | undefined;
+        readonly fixedStrings?: boolean | undefined;
+        readonly ignoreCase?: boolean | undefined;
+        readonly smartCase?: boolean | undefined;
+        readonly globs?: readonly string[] | undefined;
+        readonly beforeContext?: number | undefined;
+        readonly afterContext?: number | undefined;
+        readonly maxCount?: number | undefined;
+        readonly filesWithMatches?: boolean | undefined;
+        readonly symbols?: boolean | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly truncated: boolean;
+        readonly matches: readonly {
+            readonly line: number;
+            readonly text: string;
+            readonly file: string;
+            readonly after: readonly {
+                readonly line: number;
+                readonly text: string;
+            }[];
+            readonly before: readonly {
+                readonly line: number;
+                readonly text: string;
+            }[];
+            readonly symbol?: {
+                readonly kind: string;
+                readonly name: string;
+                readonly startLine: number;
+                readonly endLine: number;
+            } | undefined;
+        }[];
+        readonly files: readonly string[];
+        readonly filesSearched: number;
+        readonly skippedBinary: number;
+        readonly notice?: string | undefined;
+        readonly retriedAsLiteral?: boolean | undefined;
+    }, import("./StdError.ts").StdError, import("./Search.ts").Search>;
+    bash: (input: {
+        readonly mode: "hermetic";
+        readonly writes: readonly string[];
+        readonly reads: readonly string[];
+        readonly cwd?: string | undefined;
+        readonly env?: {
+            readonly [x: string]: string;
+        } | undefined;
+        readonly stdin?: string | undefined;
+        readonly command?: string | undefined;
+        readonly args?: readonly string[] | undefined;
+        readonly timeoutMs?: number | undefined;
+        readonly script?: string | undefined;
+        readonly interpreter?: string | undefined;
+        readonly container?: string | undefined;
+    } | {
+        readonly mode?: "unhermetic";
+        readonly cwd?: string | undefined;
+        readonly env?: {
+            readonly [x: string]: string;
+        } | undefined;
+        readonly stdin?: string | undefined;
+        readonly command?: string | undefined;
+        readonly args?: readonly string[] | undefined;
+        readonly timeoutMs?: number | undefined;
+        readonly script?: string | undefined;
+        readonly interpreter?: string | undefined;
+        readonly container?: string | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly stderr: string;
+        readonly exitCode: number;
+        readonly stdout: string;
+        readonly stdoutTruncated: boolean;
+        readonly stderrTruncated: boolean;
+        readonly stdoutDroppedBytes: number;
+        readonly stderrDroppedBytes: number;
+        readonly invalidProbe?: {
+            readonly reason: "unknown-command" | "unknown-test" | "unknown-path" | "unknown-module" | "unknown-environment";
+            readonly evidence: string;
+            readonly message: string;
+        } | undefined;
+        readonly mutated?: boolean | undefined;
+    }, import("./StdError.ts").StdError, import("@smthrs/kernel/ChildProcessSpawner").ChildProcessSpawner | import("effect/Path").Path>;
+    test: (input: {
+        readonly timeoutMs?: number | undefined;
+        readonly selection?: readonly string[] | undefined;
+        readonly against?: "base" | "workspace" | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly tail: string;
+        readonly exitCode: number;
+        readonly command: string;
+        readonly failed: readonly string[];
+        readonly passed: number;
+        readonly parsed: boolean;
+        readonly tailTruncated: boolean;
+        readonly tailDroppedBytes: number;
+        readonly fixed?: readonly string[] | undefined;
+        readonly invalidProbe?: {
+            readonly reason: "unknown-command" | "unknown-test" | "unknown-path" | "unknown-module" | "unknown-environment";
+            readonly evidence: string;
+            readonly message: string;
+        } | undefined;
+        readonly base?: {
+            readonly tail: string;
+            readonly exitCode: number;
+            readonly command: string;
+            readonly failed: readonly string[];
+            readonly ref: string;
+            readonly commit: string;
+            readonly passed: number;
+            readonly parsed: boolean;
+            readonly tailTruncated: boolean;
+            readonly tailDroppedBytes: number;
+            readonly invalidProbe?: {
+                readonly reason: "unknown-command" | "unknown-test" | "unknown-path" | "unknown-module" | "unknown-environment";
+                readonly evidence: string;
+                readonly message: string;
+            } | undefined;
+        } | undefined;
+        readonly introduced?: readonly string[] | undefined;
+        readonly preexisting?: readonly string[] | undefined;
+    }, import("./StdError.ts").StdError, import("@smthrs/kernel/ChildProcessSpawner").ChildProcessSpawner | import("@smthrs/model/Evaluator").Evaluator | import("./TestRunner.ts").TestRunner>;
+    shell_command: (input: {
+        readonly command: string;
+        readonly workdir?: string | undefined;
+        readonly timeout_ms?: number | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly output: string;
+        readonly exitCode: number;
+    }, import("./StdError.ts").StdError, import("@smthrs/kernel/ChildProcessSpawner").ChildProcessSpawner>;
+    apply_patch: (input: {
+        readonly input: string;
+    }) => import("effect/Effect").Effect<{
+        readonly output: string;
+        readonly added: readonly string[];
+        readonly modified: readonly string[];
+        readonly deleted: readonly string[];
+    }, import("./StdError.ts").StdError, import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
+    update_plan: (input: {
+        readonly plan: readonly {
+            readonly step: string;
+            readonly status: "pending" | "completed" | "in_progress";
+        }[];
+        readonly explanation?: string | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly output: string;
+    }, import("./StdError.ts").StdError, never>;
+    fetch: (input: {
+        readonly url: string;
+        readonly timeout?: number | undefined;
+        readonly headers?: {
+            readonly [x: string]: string;
+        } | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly status: number;
+        readonly body: string;
+        readonly truncated: boolean;
+        readonly notice?: string | undefined;
+    }, import("./StdError.ts").StdError, import("@smthrs/kernel/GrantStore").GrantStore | import("@smthrs/kernel/HttpClient").HttpClient>;
+    "http-post": (input: {
+        readonly body: string;
+        readonly url: string;
+        readonly timeout?: number | undefined;
+        readonly contentType?: string | undefined;
+        readonly headers?: {
+            readonly [x: string]: string;
+        } | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly status: number;
+        readonly body: string;
+        readonly truncated: boolean;
+        readonly notice?: string | undefined;
+    }, import("./StdError.ts").StdError, import("@smthrs/kernel/GrantStore").GrantStore | import("@smthrs/kernel/HttpClient").HttpClient>;
+    webfetch: (input: {
+        readonly url: string;
+        readonly timeout?: number | undefined;
+        readonly format?: "text" | "markdown" | "html" | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly status: number;
+        readonly content: string;
+        readonly contentType: string;
+        readonly url: string;
+        readonly truncated: boolean;
+        readonly notice?: string | undefined;
+    }, import("./StdError.ts").StdError, import("@smthrs/kernel/GrantStore").GrantStore | import("@smthrs/kernel/HttpClient").HttpClient>;
+    websearch: (input: {
+        readonly query: string;
+        readonly numResults?: number | undefined;
+        readonly freshness?: "day" | "week" | "month" | "year" | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly results: readonly {
+            readonly title: string;
+            readonly url: string;
+            readonly snippet: string;
+            readonly publishedAt?: string | undefined;
+        }[];
+    }, import("./StdError.ts").StdError, WebSearch.WebSearch>;
+    lsp: (input: {
+        readonly operation: "hover" | "definition" | "references" | "implementation" | "documentSymbols" | "workspaceSymbols" | "prepareCallHierarchy" | "callHierarchyIncoming" | "callHierarchyOutgoing" | "diagnostics";
+        readonly path?: string | undefined;
+        readonly line?: number | undefined;
+        readonly character?: number | undefined;
+        readonly query?: string | undefined;
+    }) => import("effect/Effect").Effect<{
+        readonly result: unknown;
+    }, import("./StdError.ts").StdError, import("effect/FileSystem").FileSystem | import("./LanguageServer.ts").LanguageServer>;
+}>;
+/**
+ * Frozen name-to-narrowing registry: the entry point for `effectsFor`.
+ *
+ * Every flow declares a registry-time worst case in `flow.effects`, and every
+ * module also narrows that declaration for one decoded input. Without this map
+ * a host holding a flow name and a decoded input has no generic way to reach
+ * the narrowing, so it would have to serialize conflicts against the worst case
+ * for every call. Explore is included even though it has no handler entry: it
+ * is a declaration a seat can be offered, and its envelope narrows the same way.
+ *
+ * @category registries
+ * @since 1.0.0
+ */
+export declare const effectsFor: Readonly<{
+    read: (input: {
+        readonly path: string;
+        readonly limit?: number | undefined;
+        readonly offset?: number | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    write: (input: {
+        readonly path: string;
+        readonly content: string;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    edit: (input: {
+        readonly path: string;
+        readonly newString: string;
+        readonly replaceAll?: boolean | undefined;
+        readonly endLine?: number | undefined;
+        readonly oldString?: string | undefined;
+        readonly startLine?: number | undefined;
+        readonly expect?: string | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    ls: (input: {
+        readonly path: string;
+        readonly limit?: number | undefined;
+        readonly offset?: number | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    glob: (input: {
+        readonly root?: string | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    grep: (input: {
+        readonly root?: string | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    bash: (input: Bash.Input) => import("@smthrs/plan/Effects").Declaration;
+    test: (_input: {
+        readonly timeoutMs?: number | undefined;
+        readonly selection?: readonly string[] | undefined;
+        readonly against?: "base" | "workspace" | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    shell_command: (_input: {
+        readonly command: string;
+        readonly workdir?: string | undefined;
+        readonly timeout_ms?: number | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    apply_patch: (_input: {
+        readonly input: string;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    update_plan: (_input: {
+        readonly plan: readonly {
+            readonly step: string;
+            readonly status: "pending" | "completed" | "in_progress";
+        }[];
+        readonly explanation?: string | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    fetch: (_input: {
+        readonly url: string;
+        readonly timeout?: number | undefined;
+        readonly headers?: {
+            readonly [x: string]: string;
+        } | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    "http-post": (_input: {
+        readonly body: string;
+        readonly url: string;
+        readonly timeout?: number | undefined;
+        readonly contentType?: string | undefined;
+        readonly headers?: {
+            readonly [x: string]: string;
+        } | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    explore: (_input: {
+        readonly prompt: string;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    webfetch: (_input: {
+        readonly url: string;
+        readonly timeout?: number | undefined;
+        readonly format?: "text" | "markdown" | "html" | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    websearch: (_input: {
+        readonly query: string;
+        readonly numResults?: number | undefined;
+        readonly freshness?: "day" | "week" | "month" | "year" | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+    lsp: (_input: {
+        readonly operation: "hover" | "definition" | "references" | "implementation" | "documentSymbols" | "workspaceSymbols" | "prepareCallHierarchy" | "callHierarchyIncoming" | "callHierarchyOutgoing" | "diagnostics";
+        readonly path?: string | undefined;
+        readonly line?: number | undefined;
+        readonly character?: number | undefined;
+        readonly query?: string | undefined;
+    }) => import("@smthrs/plan/Effects").Declaration;
+}>;
+/**
+ * Frozen standard flow names in registry order.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export declare const names: readonly ["read", "write", "edit", "ls", "glob", "grep", "bash", "test", "shell_command", "apply_patch", "update_plan", "fetch", "http-post", "explore", "webfetch", "websearch", "lsp"];
+/**
+ * Frozen names visible to a seat restricted to read-only flows.
+ *
+ * Seat policies consume this list instead of duplicating name checks.
+ *
+ * `websearch` is deliberately absent: its provider contract requires
+ * `net:post` authority, which is mutating under the kernel capability
+ * taxonomy, so it cannot ride in a read-only seat.
+ *
+ * @category visibility
+ * @since 1.0.0
+ */
+export declare const readOnly: readonly ["read", "ls", "glob", "grep", "fetch", "explore", "webfetch", "lsp"];
+//# sourceMappingURL=Manifest.d.ts.map