stitchkit 0.120.0 → 0.122.0

package/CHANGELOG.md

@@ -15,6 +15,89 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [0.122.0] - 2026-11-10
+
+### ⚠️ Breaking changes
+
+**Who must act:** scripts and agents that read stdout after a managed CLI command exits with `CLI_PRESENTATION_FAILED` when the command is a `GET` endpoint or a tool declaring `annotations.readOnlyHint: true`. Commands with an effect and native `defineCliCommand` presenters change nothing. See the [migration](docs/guide/upgrading.md#read-view-refusal).
+
+- `stitchkit/cli` — **a read withholds its result when the requested view is refused.**
+  A misspelled `--table`, `--count-by`, `--sum` or `--sort` field on a command that only reads
+  prints nothing to stdout: the diagnostic names the field and the fields that are there, and the
+  answer is one corrected call away. A command only reads when its tool declares
+  `annotations.readOnlyHint: true`, or declares no `readOnlyHint` and its method is `GET`. A command
+  with an effect still prints its complete result, because repeating it would repeat the effect.
+  `details.resultOnStdout` states which case occurred.
+  Before: `app user_list --table id,nosuchcolumn` → exit `8`, every record on stdout.
+  After: exit `8`, stdout empty; `app user_list --table id,name` returns the table.
+  [migration](docs/guide/upgrading.md#read-view-refusal). → ADR 0286
+  **Affects:** `stitchkit/cli` behaviour
+
+### Added
+
+- `stitchkit/server` — `generateOpenApiDocument({ security })` describes how a caller presents its
+  credential: named HTTP bearer, basic or API key (header, query, cookie) schemes become
+  `components.securitySchemes`, and each protected operation gets a standard `security`
+  requirement, keyed by the scopes the contracts already declare. Generation refuses a protected
+  scope with no scheme, naming the operation, instead of advertising it as open. Without
+  `security` the document is unchanged. Two new type exports, `OpenApiSecurity` and
+  `OpenApiSecurityScheme`, raise the `stitchkit/server` surface ceiling from 220 to 222 so a host
+  can type its scheme table. [guide](docs/guide/server.md#security-schemes--security)
+- `stitchkit/agent-runtime` — a long tool tells the agent's screen what it is doing. What a
+  handler reports through `ctx.reportProgress` under the agent runtime becomes a transient
+  `tool-progress` event of the run (`AgentToolProgressEventSchema`) with the call's `callId`; it
+  was a no-op there, so the run showed `started` and nothing else until the result. The model
+  still reads only the tool's result. Messages are cut to `AGENT_TOOL_PROGRESS_MESSAGE_MAX`,
+  reports of one call closer than 250 ms are dropped, and nothing is published after the call
+  settles. In `stitchkit/agent-runtime/browser`, `reduceAgentControlEvent` keeps each running
+  call's last report in `transientByRun[runId].tools` (`AgentRunTransient`,
+  `AgentToolActivity`) and drops it on the call's terminal status. A reducer or `switch` written
+  by hand over `AgentRuntimeEvent` sees one more `type`. The surface ceilings move from 373 to 374
+  (`stitchkit/agent-runtime`) and from 92 to 96 (`stitchkit/agent-runtime/browser`) for these
+  names. [guide](docs/guide/agent-runtime.md)
+
+## [0.121.0] - 2026-11-09
+
+### ⚠️ Breaking changes
+
+**Who must act:** hosts that build a complete `AgentCodingToolLimits` value, read exact `list_directory`, `glob` or `search_files` outputs, rely on a symlink `run_command` cwd or on `glob` returning no paths for a missing `path`, or send search regexes with named backreferences or counted repetition above 1,000. A host mounting the coding tools with partial limits and ordinary queries changes nothing. See the [migration](docs/guide/upgrading.md#bounded-coding-search).
+
+- `stitchkit/agent-runtime/coding-tools` — **search reports its coverage and bounds traversal before reading.**
+  `search_files` prunes incompatible glob branches before authorization/open, streams matches,
+  honors cancellation and bounds directory opens, entries, total content bytes, elapsed time and
+  the entire serialized result. `coverage` distinguishes a complete empty result from denied,
+  unreadable, cancelled or limited work. Directory errors carry a relative path, operation and code.
+  Regex searches keep JavaScript syntax, modifiers and Annex B forms. A line whose backtracking
+  work, with repetition capped at the line's length, stays within 2^24 steps runs natively; any
+  other line runs on a cached linear automaton that observes the deadline inside the line (ten to
+  forty times slower than native matching, with no catastrophic case). Named backreferences,
+  counted repetition above 1,000 and, for patterns that need the automaton, more than 16,384 automaton states,
+  65,536 construction steps or 4,194,304 overlapping character-set memberships now refuse beside numbered backreferences and
+  lookaround; an invalid pattern's refusal carries the engine's reason.
+  Before: `{ query: '(?<w>a)\\k<w>', regex: true }` → after: `{ query: '(a)a', regex: true }`.
+  A `glob` path or `run_command` cwd that is missing, a file or a symlink refuses with
+  `NOT_FOUND`/`BAD_REQUEST` and a hint, as `list_directory` does; a missing `glob` path used to
+  return no paths.
+  Hosts constructing a full
+  `AgentCodingToolLimits` value add the five search ceilings; partial `limits` use finite defaults.
+  [ADR 0285](docs/decisions/0285-search-bounds-the-work-before-reading.md),
+  [migration](docs/guide/upgrading.md#bounded-coding-search).
+  List and glob use the same budgets and coverage, including bounded canonical spelling checks;
+  list raw enumeration respects maxListEntries and glob patterns have a 4,096-unit ceiling.
+  Every filesystem tool pins root before either policy; an ordinary command enters its pinned
+  cwd through the descriptor's `/proc` link on Linux and through an isolated fchdir guard on
+  macOS. Symlink cwd descendants refuse; custom sandbox launchers own cwd capture.
+  **Affects:** `stitchkit/agent-runtime/coding-tools` createAgentCodingTools, AgentCodingToolLimitsSchema, AgentCodingToolLimits, behaviour
+
+### Fixed
+
+- `stitchkit/process` — **`timeoutMs` counts from the moment the command started.** A guarded
+  command (`ownerLoss: 'terminate'`) starts its guard first; that start, tens of milliseconds, used
+  the command's own budget, so a short budget timed out a command that never got to run. The
+  guard's start is now bounded by `timeoutMs` or 5 seconds, whichever is longer.
+  **Affects:** `stitchkit/process` behaviour
+- API reference export tables are checked against each actual entrypoint in both directions.
+
 ## [0.120.0] - 2026-11-05
 
 ### ⚠️ Breaking changes

package/dist/agent-runtime/browser-control-contract.d.ts

@@ -656,6 +656,18 @@ export declare const agentControlRealtimeContract: import("../realtime/index.js"
                 }>;
                 input: z.ZodOptional<z.ZodJSONSchema>;
                 output: z.ZodOptional<z.ZodJSONSchema>;
+            }, z.core.$strip>, z.ZodObject<{
+                conversationId: z.ZodString;
+                runId: z.ZodString;
+                emittedAt: z.ZodISODateTime;
+                type: z.ZodLiteral<"tool-progress">;
+                runtimeEpoch: z.ZodString;
+                sequence: z.ZodInt;
+                callId: z.ZodString;
+                toolName: z.ZodString;
+                message: z.ZodOptional<z.ZodString>;
+                progress: z.ZodOptional<z.ZodNumber>;
+                total: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>, z.ZodObject<{
                 conversationId: z.ZodString;
                 runId: z.ZodString;

package/dist/agent-runtime/browser-control-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-control-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/browser-control-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAWpC,CAAC;AACH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;QAEjB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAItB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGP,CAAC"}
+{"version":3,"file":"browser-control-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/browser-control-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAWpC,CAAC;AACH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;QAEjB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAItB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGP,CAAC"}

package/dist/agent-runtime/coding-discovery.d.ts

@@ -0,0 +1,25 @@
+import type { ContainedFileHandle } from '../internal/contained-handle.js';
+import type { AgentCodingToolConfig, AgentCodingToolLimits } from './coding-tool-contract.js';
+import { ContainedScanBudget } from './contained-scan-budget.js';
+export declare function discoveryRun(config: AgentCodingToolConfig, limits: AgentCodingToolLimits, path: string, include: string, symlinks: 'skip' | 'list'): {
+    budget: ContainedScanBudget;
+    coverage: {
+        complete: boolean;
+        reasons: ("cancelled" | "denied" | "max-bytes" | "max-depth" | "max-directories" | "max-entries" | "max-file-bytes" | "max-files" | "max-line-bytes" | "max-output-bytes" | "max-results" | "timeout" | "unreadable")[];
+        scope: {
+            path: string;
+            include: string;
+            excludedDirectories: "configured" | "default";
+            symlinks: "list" | "skip";
+        };
+        visitedDirectories: number;
+        visitedEntries: number;
+        readBytes: number;
+        elapsedMs: number;
+    };
+    run(caller: AbortSignal | undefined, work: (root: ContainedFileHandle) => Promise<void>): Promise<void>;
+    refresh(): void;
+};
+/** Admission precedes retention; names cannot multiply the serialized output limit. */
+export declare function discoveryCollector(output: unknown, budget: ContainedScanBudget, maximum: number): (item: unknown) => void;
+//# sourceMappingURL=coding-discovery.d.ts.map

package/dist/agent-runtime/coding-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-discovery.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-discovery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE3F,OAAO,EAAE,mBAAmB,EAAe,MAAM,yBAAyB,CAAC;AAG3E,wBAAgB,YAAY,CAC1B,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,MAAM;;;;;;;;;;;;;;;;gBA2Bb,WAAW,GAAG,SAAS,QACzB,CAAC,IAAI,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC;;EAyCvD;AAED,uFAAuF;AACvF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,UAQD,OAAO,UAMtB"}

package/dist/agent-runtime/coding-search-automaton.d.ts

@@ -0,0 +1,37 @@
+import { type RegexAssertion, type RegexNode, type UnitAtom } from './coding-search-regex-syntax.js';
+/** Unrolled counted repetition and alternation stay below this many automaton states. */
+export declare const MAX_REGEX_STATES = 16384;
+type State = {
+    kind: 'unit';
+    atom: UnitAtom;
+    next: number;
+} | {
+    kind: 'split';
+    next: number[];
+} | {
+    kind: 'assert';
+    at: RegexAssertion;
+    next: number;
+} | {
+    kind: 'accept';
+};
+export declare function buildAutomaton(tree: RegexNode, check: () => void): {
+    states: State[];
+    start: number;
+};
+/**
+ * A compiled search expression. Matching walks the line once; each step is a cached
+ * transition of the lazily built deterministic automaton, keyed by the unit's class. A cache
+ * miss costs the state's own units plus the start atoms matching that class, so a line costs at
+ * most states × UTF-16 units, the cache stays within its state and transition ceilings, and
+ * every step can observe the caller's deadline.
+ */
+export interface SearchRegex {
+    test(text: string): boolean;
+}
+export declare function lazyMatcher({ states, start }: {
+    states: State[];
+    start: number;
+}, check: () => void): SearchRegex;
+export {};
+//# sourceMappingURL=coding-search-automaton.d.ts.map

package/dist/agent-runtime/coding-search-automaton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-automaton.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-automaton.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,QAAQ,EAEd,MAAM,8BAA8B,CAAC;AAGtC,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAOvC,KAAK,KAAK,GACN;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvB,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,IAAI,GAChB;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CA6CpC;AAuBD;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B;AAwBD,wBAAgB,WAAW,CACzB,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EACrD,KAAK,EAAE,MAAM,IAAI,GAChB,WAAW,CAiLb"}

package/dist/agent-runtime/coding-search-case-fold.d.ts

@@ -0,0 +1,4 @@
+/** Units equal to `code` under the `i` flag without `u`; the inverse table is built once. */
+export declare function caseVariants(code: number): number[];
+export declare function casedUnits(): readonly number[];
+//# sourceMappingURL=coding-search-case-fold.d.ts.map

package/dist/agent-runtime/coding-search-case-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-case-fold.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-case-fold.ts"],"names":[],"mappings":"AAiCA,6FAA6F;AAC7F,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAGnD;AAKD,wBAAgB,UAAU,IAAI,SAAS,MAAM,EAAE,CAG9C"}

package/dist/agent-runtime/coding-search-class-ranges.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Exact unit ranges of a bracket class without the `u` flag, including escapes inside it, so
+ * the automaton partitions the alphabet instead of asking the engine per unit. Every result is
+ * checked against the engine at each range boundary and midpoint; any doubt leaves the class to
+ * the engine.
+ */
+export type UnitRanges = [number, number][];
+/** The exact ranges of a bracket class, or undefined when only the engine can answer. */
+export declare function classRanges(source: string, ignoreCase?: boolean): UnitRanges | undefined;
+//# sourceMappingURL=coding-search-class-ranges.d.ts.map

package/dist/agent-runtime/coding-search-class-ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-class-ranges.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-class-ranges.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;AA4I5C,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,UAAU,GAAG,SAAS,CAiBtF"}

package/dist/agent-runtime/coding-search-contract.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export declare const SearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        content: "content";
+        path: "path";
+    }>>;
+    regex: z.ZodDefault<z.ZodBoolean>;
+    context: z.ZodDefault<z.ZodInt>;
+    include: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SearchInput = z.infer<typeof SearchInputSchema>;
+export declare const SearchMatchSchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodOptional<z.ZodInt>;
+    text: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    after: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SearchMatch = z.infer<typeof SearchMatchSchema>;
+export declare const SearchOutputSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodOptional<z.ZodInt>;
+        text: z.ZodOptional<z.ZodString>;
+        before: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        after: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    truncated: z.ZodBoolean;
+    scannedFiles: z.ZodInt;
+    skippedDirectories: z.ZodInt;
+    skippedSymlinks: z.ZodInt;
+    denied: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            directory: "directory";
+            file: "file";
+            other: "other";
+            symlink: "symlink";
+        }>;
+    }, z.core.$strict>>>;
+    deniedTruncated: z.ZodOptional<z.ZodBoolean>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        operation: z.ZodString;
+        code: z.ZodString;
+    }, z.core.$strict>>>;
+    errorsTruncated: z.ZodOptional<z.ZodBoolean>;
+    hint: z.ZodOptional<z.ZodString>;
+    coverage: z.ZodObject<{
+        complete: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodEnum<{
+            cancelled: "cancelled";
+            denied: "denied";
+            "max-bytes": "max-bytes";
+            "max-depth": "max-depth";
+            "max-directories": "max-directories";
+            "max-entries": "max-entries";
+            "max-file-bytes": "max-file-bytes";
+            "max-files": "max-files";
+            "max-line-bytes": "max-line-bytes";
+            "max-output-bytes": "max-output-bytes";
+            "max-results": "max-results";
+            timeout: "timeout";
+            unreadable: "unreadable";
+        }>>;
+        scope: z.ZodObject<{
+            path: z.ZodString;
+            include: z.ZodString;
+            excludedDirectories: z.ZodEnum<{
+                configured: "configured";
+                default: "default";
+            }>;
+            symlinks: z.ZodEnum<{
+                list: "list";
+                skip: "skip";
+            }>;
+        }, z.core.$strict>;
+        visitedDirectories: z.ZodInt;
+        visitedEntries: z.ZodInt;
+        readBytes: z.ZodInt;
+        elapsedMs: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SearchOutput = z.infer<typeof SearchOutputSchema>;
+//# sourceMappingURL=coding-search-contract.d.ts.map

package/dist/agent-runtime/coding-search-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB;;;;;;;;;kBAoBnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,iBAAiB;;;;;;kBAQnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBpB,CAAC;AACZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/agent-runtime/coding-search-limits.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const AgentCodingSearchLimitsSchema: z.ZodObject<{
+    maxSearchResults: z.ZodInt;
+    maxSearchFiles: z.ZodInt;
+    maxSearchDepth: z.ZodInt;
+    maxSearchDirectories: z.ZodInt;
+    maxSearchEntries: z.ZodInt;
+    maxSearchBytes: z.ZodInt;
+    maxSearchOutputBytes: z.ZodInt;
+    searchTimeoutMs: z.ZodInt;
+}, z.core.$strict>;
+export type AgentCodingSearchLimits = z.infer<typeof AgentCodingSearchLimitsSchema>;
+//# sourceMappingURL=coding-search-limits.d.ts.map

package/dist/agent-runtime/coding-search-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-limits.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-limits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,6BAA6B;;;;;;;;;kBAW/B,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/agent-runtime/coding-search-matcher.d.ts

@@ -0,0 +1,33 @@
+import { type SearchRegex } from './coding-search-automaton.js';
+import { type RegexNode } from './coding-search-regex-syntax.js';
+/**
+ * Backtracking steps one native match of one line may spend. The engine itself stops after
+ * 100,000,000 counted operations per call and then answers no match, and one step of this model
+ * costs it about two; 2^24 keeps a threefold margin below that limit, so a native line never ends
+ * in a silent false. Native matching cannot be interrupted, so this also bounds the deadline's
+ * overshoot to one such line.
+ */
+export declare const MAX_NATIVE_LINE_WORK: number;
+/**
+ * The backtracking work per start position of a line of at most `units` units: each start
+ * walks each path through the alternatives once, so paths × the longest path bounds it. On such
+ * a line no repetition iterates more than `units` times beyond the iterations it requires (and
+ * a body that cannot match empty cannot even reach those), so `x{m,M}`, `x*` and `x+` are their
+ * unrolled forms with the bounds capped there: p^m × (1 + p + … + p^(M−m)) paths and M × the
+ * body's length.
+ */
+export declare function backtrackingWork(node: RegexNode, units: number): {
+    paths: number;
+    length: number;
+};
+/** The linear automaton alone, for any accepted pattern. */
+export declare function compileLinearSearchRegex(pattern: string, check: () => void): SearchRegex;
+/**
+ * JavaScript `RegExp` syntax without flags with bounded cost per line. A line whose bounded
+ * backtracking work — per start position × its length, repetition capped at its length — stays
+ * within `MAX_NATIVE_LINE_WORK` runs on the native engine itself; the deadline is observed
+ * between lines. Any other line runs on the linear automaton, because a deadline cannot
+ * interrupt one native match. The work is measured per power-of-two line length, once.
+ */
+export declare function compileSearchRegex(pattern: string, check: () => void): SearchRegex;
+//# sourceMappingURL=coding-search-matcher.d.ts.map

package/dist/agent-runtime/coding-search-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-matcher.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-matcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,EAEL,KAAK,SAAS,EAEf,MAAM,8BAA8B,CAAC;AAGtC;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,QAAU,CAAC;AAkC5C;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,GACZ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAmDnC;AAyCD,4DAA4D;AAC5D,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,WAAW,CAOxF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,WAAW,CAqClF"}

package/dist/agent-runtime/coding-search-output.d.ts

@@ -0,0 +1,5 @@
+import type { SearchOutput } from './coding-search-contract.js';
+import { type ContainedScanBudget } from './contained-scan-budget.js';
+/** Matches are admitted while streaming; diagnostics get the remaining serialized byte budget. */
+export declare function boundSearchDiagnostics(output: Pick<SearchOutput, 'denied' | 'errors' | 'deniedTruncated' | 'errorsTruncated'>, budget: ContainedScanBudget, maxBytes: number): void;
+//# sourceMappingURL=coding-search-output.d.ts.map

package/dist/agent-runtime/coding-search-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-output.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,KAAK,mBAAmB,EAAe,MAAM,yBAAyB,CAAC;AAEhF,kGAAkG;AAClG,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,QAAQ,GAAG,iBAAiB,GAAG,iBAAiB,CAAC,EACvF,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,MAAM,GACf,IAAI,CA4CN"}

package/dist/agent-runtime/coding-search-regex-syntax.d.ts

@@ -0,0 +1,39 @@
+export type RegexAssertion = 'start' | 'end' | 'line-start' | 'line-end' | 'word' | 'not-word';
+/**
+ * One single-unit atom. `ranges` is the exact inclusive set when the atom is a literal or a
+ * bracket class of plain characters and ranges; every other atom answers through `matches`, a
+ * native one-character expression. Equal atoms are one object, so `key` identifies it.
+ */
+export interface UnitAtom {
+    key: string;
+    ranges?: readonly (readonly [number, number])[];
+    matches(unit: number): boolean;
+}
+export type RegexNode = {
+    kind: 'empty';
+} | {
+    kind: 'unit';
+    atom: UnitAtom;
+} | {
+    kind: 'assert';
+    at: RegexAssertion;
+} | {
+    kind: 'sequence';
+    items: RegexNode[];
+} | {
+    kind: 'alternation';
+    options: RegexNode[];
+} | {
+    kind: 'repeat';
+    body: RegexNode;
+    min: number;
+    max: number;
+};
+/** Thrown with the construct a host-facing refusal names. */
+export declare class UnsupportedRegexSyntax extends Error {
+}
+/** Counted repetition is unrolled; a larger bound is refused before it can allocate. */
+export declare const MAX_REGEX_REPEAT = 1000;
+/** Parses a pattern the native engine has already accepted without flags. */
+export declare function parseSearchRegex(pattern: string, check: () => void): RegexNode;
+//# sourceMappingURL=coding-search-regex-syntax.d.ts.map

package/dist/agent-runtime/coding-search-regex-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-regex-syntax.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-regex-syntax.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,GAAG,YAAY,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU,CAAC;AAE/F;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IAChD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC;AAED,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,cAAc,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,6DAA6D;AAC7D,qBAAa,sBAAuB,SAAQ,KAAK;CAAG;AAEpD,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AA4BtC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,SAAS,CAqL9E"}

package/dist/agent-runtime/coding-search-unit-classes.d.ts

@@ -0,0 +1,31 @@
+import { type UnitAtom } from './coding-search-regex-syntax.js';
+/** What a position's assertions can observe about a neighbouring unit. */
+export declare const Ahead: {
+    End: number;
+    Word: number;
+    LineTerminator: number;
+    Other: number;
+};
+export type Ahead = (typeof Ahead)[keyof typeof Ahead];
+export declare const classify: (unit: number) => Ahead;
+/** Atom memberships the range partition may hold, summed over its segments. */
+export declare const MAX_RANGE_MEMBERSHIPS: number;
+/**
+ * Atoms the engine must answer per unit: only classes whose ranges the engine check sent back,
+ * since literals, escapes, classes and dot all carry ranges. Their work is this × 65,536 units.
+ */
+export declare const MAX_NATIVE_ATOMS = 64;
+/**
+ * UTF-16 units the automaton cannot tell apart share one class: the same range segment, the
+ * same answers from every native atom and the same kind for word and line assertions.
+ * Transitions are keyed by class, so a text over a large alphabet caches as few transitions as
+ * the pattern distinguishes. Classes are at most the 65,536 units, each with a fixed-size bit
+ * set over the native atoms, so the table needs no eviction.
+ */
+export declare function unitClasses(atoms: UnitAtom[], check: () => void): {
+    classOf: (unit: number) => number;
+    kindOf: (unitClass: number) => Ahead;
+    atomsOf: (unitClass: number) => readonly UnitAtom[];
+    matches: (atom: UnitAtom, unitClass: number) => boolean;
+};
+//# sourceMappingURL=coding-search-unit-classes.d.ts.map

package/dist/agent-runtime/coding-search-unit-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coding-search-unit-classes.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-search-unit-classes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA0B,MAAM,8BAA8B,CAAC;AAErF,0EAA0E;AAC1E,eAAO,MAAM,KAAK;;;;;CAGjB,CAAC;AACF,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AASvD,eAAO,MAAM,QAAQ,SAAU,MAAM,KAAG,KACiD,CAAC;AAE1F,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,QAAU,CAAC;AAC7C;;;GAGG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAwEnC;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,IAAI;oBAoBvC,MAAM,KAAG,MAAM;wBAwBhB,MAAM,KAAG,KAAK;yBACb,MAAM,KAAG,SAAS,QAAQ,EAAE;oBASjC,QAAQ,aAAa,MAAM,KAAG,OAAO;EASxD"}

package/dist/agent-runtime/coding-shell-process.d.ts

@@ -5,6 +5,7 @@ export declare function runCodingShell(input: {
     executable: string;
     args: readonly string[];
     cwd: string;
+    cwdDescriptor?: number;
     environment: Readonly<Record<string, string>>;
     signal?: AbortSignal;
     timeoutMs: number;

package/dist/agent-runtime/coding-shell-process.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-shell-process.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-shell-process.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,qBAAqB,EAAqB,MAAM,wBAAwB,CAAC;AAEvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAuCrD,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAC/C,aAAa,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/E,KAAK,CAAC,EAAE,MAAM,UAAU,CAAC,WAAW,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CACrE;;;;;;;;;;;;;;;GA2JA"}
+{"version":3,"file":"coding-shell-process.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-shell-process.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,qBAAqB,EAAqB,MAAM,wBAAwB,CAAC;AAEvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAuCrD,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;IAC/C,aAAa,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/E,KAAK,CAAC,EAAE,MAAM,UAAU,CAAC,WAAW,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CACrE;;;;;;;;;;;;;;;GA4JA"}

package/dist/agent-runtime/coding-tool-contract.d.ts

@@ -2,6 +2,14 @@ import { z } from 'zod';
 import type { ToolTransport } from '../contract/define.js';
 import type { AgentProcessSandbox, AgentSandboxRestriction } from './sandbox.js';
 export declare const AgentCodingToolLimitsSchema: z.ZodObject<{
+    maxSearchResults: z.ZodInt;
+    maxSearchFiles: z.ZodInt;
+    maxSearchDepth: z.ZodInt;
+    maxSearchDirectories: z.ZodInt;
+    maxSearchEntries: z.ZodInt;
+    maxSearchBytes: z.ZodInt;
+    maxSearchOutputBytes: z.ZodInt;
+    searchTimeoutMs: z.ZodInt;
     maxPathBytes: z.ZodInt;
     maxReadBytes: z.ZodInt;
     maxWriteBytes: z.ZodInt;
@@ -10,9 +18,6 @@ export declare const AgentCodingToolLimitsSchema: z.ZodObject<{
     maxShellOutputBytes: z.ZodInt;
     maxArtifactBytes: z.ZodInt;
     maxListEntries: z.ZodInt;
-    maxSearchResults: z.ZodInt;
-    maxSearchFiles: z.ZodInt;
-    maxSearchDepth: z.ZodInt;
     shellTimeoutMs: z.ZodInt;
     shellTerminationGraceMs: z.ZodInt;
 }, z.core.$strict>;

package/dist/agent-runtime/coding-tool-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-contract.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"coding-tool-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-contract.ts"],"names":[],"mappings":"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"}

package/dist/agent-runtime/coding-tool-files.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-files.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-files.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAK3B,MAAM,wBAAwB,CAAC;AAmDhC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CAyKtC"}
+{"version":3,"file":"coding-tool-files.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-files.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAK3B,MAAM,wBAAwB,CAAC;AAoDhC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CAyKtC"}

package/dist/agent-runtime/coding-tool-listing.d.ts

@@ -1,15 +1,5 @@
 import type { AgentCodingToolConfig, AgentCodingToolDefinition, AgentCodingToolLimits } from './coding-tool-contract.js';
-/** The same set `search_files` skips, so one workspace has one idea of noise. */
+/** The same set search_files skips. List shows these directories explicitly. */
 export declare const DEFAULT_EXCLUDED_DIRECTORIES: string[];
-/**
- * Compile one workspace glob into a regular expression.
- *
- * A deliberate subset — `**`, `*`, `?`, and nothing else — written here rather
- * than taken as a dependency: the whole surface has one runtime dependency, and
- * a matcher this size does not earn a second. Everything outside the subset is
- * escaped, so a pattern containing regex punctuation matches it literally
- * instead of meaning something the caller did not write.
- */
-export declare function compileWorkspaceGlob(pattern: string): RegExp;
 export declare function createListingCodingTools(config: AgentCodingToolConfig, limits: AgentCodingToolLimits): readonly AgentCodingToolDefinition[];
 //# sourceMappingURL=coding-tool-listing.d.ts.map

package/dist/agent-runtime/coding-tool-listing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-listing.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-listing.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAehC,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,UAQxC,CAAC;AA6CF;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA2B5D;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CA6HtC"}
+{"version":3,"file":"coding-tool-listing.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-listing.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAahC,gFAAgF;AAChF,eAAO,MAAM,4BAA4B,UAQxC,CAAC;AA0CF,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CAgMtC"}

package/dist/agent-runtime/coding-tool-paths.d.ts

@@ -1,4 +1,6 @@
+import type { ContainedFileHandle } from '../internal/contained-handle.js';
 import { type AgentCodingToolAuthorization, type AgentCodingToolConfig } from './coding-tool-contract.js';
+import type { ContainedScanBudget } from './contained-scan-budget.js';
 export declare function boundedCodingRelativePath(root: string, requested: string, maxPathBytes: number): string;
 export declare function existingCodingPath(root: string, requested: string, maxPathBytes: number): Promise<{
     absolute: string;
@@ -42,8 +44,10 @@ export declare function authorizeCodingPath(config: AgentCodingToolConfig, path:
  * and a policy that keeps an audit no longer sees the leaf once an ancestor has
  * refused.
  */
-export declare function authorizeCodingPathChain(config: AgentCodingToolConfig, relative: string): Promise<void>;
+export declare function authorizeCodingPathChain(config: AgentCodingToolConfig, relative: string, root: ContainedFileHandle, budget?: ContainedScanBudget): Promise<void>;
 /** Serialize framework-owned compare-and-replace transactions for one canonical target. */
-export declare function withCodingPathLock<T>(target: string, work: () => Promise<T>): Promise<T>;
+export declare function withCodingPathLock<T>(root: ContainedFileHandle, relative: string, work: () => Promise<T>): Promise<T>;
 export declare function textOccurrences(source: string, search: string): number;
+/** Select the workspace capability before any asynchronous host policy runs. */
+export declare function withCodingRoot<T>(configured: string, work: (root: ContainedFileHandle, canonicalPath: string) => Promise<T>): Promise<T>;
 //# sourceMappingURL=coding-tool-paths.d.ts.map

package/dist/agent-runtime/coding-tool-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-paths.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-paths.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,4BAA4B,EAEjC,KAAK,qBAAqB,EAE3B,MAAM,wBAAwB,CAAC;AAwChC,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,MAAM,CA6CR;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM;;;GAKrB;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM;;;GAarB;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM;;;GAQrB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAIlB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAoBf;AAID,2FAA2F;AAC3F,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CAeZ;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUtE"}
+{"version":3,"file":"coding-tool-paths.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-paths.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,EACL,KAAK,4BAA4B,EAEjC,KAAK,qBAAqB,EAE3B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAuCnE,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,MAAM,CA6CR;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM;;;GAKrB;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM;;;GAarB;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM;;;GAQrB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAIlB;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,mBAAmB,EACzB,MAAM,CAAC,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAgCf;AAID,2FAA2F;AAC3F,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,IAAI,EAAE,mBAAmB,EACzB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUtE;AAED,gFAAgF;AAChF,wBAAsB,cAAc,CAAC,CAAC,EACpC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,CAAC,IAAI,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GACrE,OAAO,CAAC,CAAC,CAAC,CAQZ"}

package/dist/agent-runtime/coding-tool-refusals.d.ts

@@ -61,6 +61,12 @@ export declare function codingPathRefusal(code: CodingRefusalCode, message: stri
  * model can do about it, and keeps being scrubbed. Default-deny by omission.
  */
 export declare function refuseMissingCodingPath(error: unknown, relative: string): never;
+/**
+ * A directory argument (`list_directory` and `glob` paths, `run_command` cwd) that cannot be
+ * opened as a directory. Directory capabilities never follow a symlink, so a symlink alias is
+ * refused the same way as a file, and the model is told to name the real directory.
+ */
+export declare function refuseUnopenableCodingDirectory(error: unknown, relative: string): never;
 /**
  * The write failures a caller can act on: something else occupies the path. A
  * lost race and a stale check end here too, so each has one answer however it

package/dist/agent-runtime/coding-tool-refusals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-refusals.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-refusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,aAAa,0IAQ4B,CAAC;AAEhD,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAClF,KAAK,CAUP;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,KAAK,CAKP;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAmC/E;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,KAAK,CAkCP;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CASpE"}
+{"version":3,"file":"coding-tool-refusals.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-refusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,aAAa,0IAQ4B,CAAC;AAEhD,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAClF,KAAK,CAUP;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,KAAK,CAKP;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAmC/E;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAkBvF;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,KAAK,CAkCP;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CASpE"}

package/dist/agent-runtime/coding-tool-search-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-search-patch.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-search-patch.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAyWhC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CAsBtC"}
+{"version":3,"file":"coding-tool-search-patch.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-search-patch.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AA8KhC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CAWtC"}