@zaly/agent 0.0.12 → 0.1.1

package/dist/index.d.mts

@@ -1,11 +1,10 @@
-import { p as SessionOptions, t as Session } from "./session-Ds5nJz5A.mjs";
+import { p as SessionOptions, t as Session } from "./session-Cq52cam5.mjs";
 import { Emitter, Envelope, MaybeGetter } from "@zaly/shared";
 import { BaseCollection } from "@zaly/shared/collection";
 import { AnyKey } from "@zaly/shared/registry";
-import { AiError, AnyPart, AnyType, AssistantMessage, CollectOptions, Content, FinishReason, Message, MetaOf, MetaPart, Model, ParamsOf, ReasoningEffort, Role, StreamEvent, StreamOptions, TokenCount as TokenCount$1, Tool, ToolCallPart, ToolContext, ToolResult, ToolResultPart, Usage } from "@zaly/ai";
+import { AnyPart, AnyType, AssistantMessage, Attachment, CollectOptions, Content, FinishReason, Message, MetaOf, MetaPart, Model, ParamsOf, ReasoningEffort, Role, StreamEvent, StreamOptions, TokenCount as TokenCount$1, Tool, ToolCallPart, ToolContext, ToolResult, ToolResultPart, Usage } from "@zaly/ai";
 import { Logger } from "@zaly/shared/logger";
 import { ArgsOpts, ArgsResult } from "@zaly/shared/args";
-//#region src/events.d.ts
 /** Status of an agent session — at most one transition per moment.
  *  `paused` covers both explicit pause and post-error states; the
  *  `lastError` field on the session disambiguates. */
@@ -76,8 +75,6 @@ type AgentEvents = {
     messages: Message[];
   };
 };
-//#endregion
-//#region src/masker.d.ts
 /** Top-level masking config. */
 type MaskerOptions = {
   enabled?: boolean;
@@ -134,8 +131,6 @@ declare class Masker {
    *  pressure crosses the hysteresis threshold. */
   mask(messages: readonly Message[], opts?: MaskOpts): Promise<Message[]>;
 }
-//#endregion
-//#region src/permissions/types.d.ts
 /**
  * Core permission primitives.
  *
@@ -221,8 +216,6 @@ interface PermissionContext<T extends string> {
 interface PermissionHandler<T extends string> {
   validate(input: string, ctx: PermissionContext<T>): CheckResult;
 }
-//#endregion
-//#region src/permissions/presets.d.ts
 /**
  * Permission presets — verdict-keyed pattern lists in the same shape
  * `parseRules` accepts. The TUI exposes these as `--preset strict`,
@@ -243,8 +236,6 @@ interface PermissionPreset {
   description: string;
   rules: Partial<Record<Verdict, string[]>>;
 }
-//#endregion
-//#region src/permissions/manager.d.ts
 type PermissionOptions = {
   /** Session cwd — anchor for resolving relative paths and the default
    *  spawn cwd for bash subprocesses. Pinned at construction; the agent
@@ -288,8 +279,6 @@ declare class PermissionManager {
   allowsAll(scope: string): boolean;
   validate(scope: string, input: string): CheckResult;
 }
-//#endregion
-//#region src/skills.d.ts
 export type SkillMeta = {
   name: string;
   mtime: number;
@@ -368,8 +357,6 @@ export declare class Skills {
     messages: [import("@zaly/ai").Message<"system">, import("@zaly/ai").Message<"assistant">, import("@zaly/ai").Message<"tool">];
   } | undefined>;
 }
-//#endregion
-//#region src/swarm.d.ts
 /** A registered agent in the swarm — a node in the agent tree. The
  *  `name` IS the id: agents address each other by name, so there's no
  *  point in maintaining a separate uuid the model would have to
@@ -483,8 +470,6 @@ declare class Swarm {
   /** Stop every registered agent in the swarm. */
   stopAll(): void;
 }
-//#endregion
-//#region src/ctx.d.ts
 type AgentContextOptions = Omit<AgentOptions, "session"> & {
   session: Session;
 };
@@ -540,8 +525,6 @@ declare class AgentContext extends Emitter<AgentContextEvents> {
 }
 declare function createAgentContext(opts: AgentOptions): Promise<AgentContext>;
 export declare function createAgent(opts: AgentOptions): Promise<Agent>;
-//#endregion
-//#region src/tasks.d.ts
 /** Status of a task. `pending` = queued behind a dependency, not yet
  *  started. `running` = work in progress (a Streamable is being polled).
  *  `done` = result captured, no longer mutating. */
@@ -708,8 +691,6 @@ declare class Tasks extends Emitter<TasksEvents> {
 declare function taskInfoPart(info: readonly TaskInfo[]): MetaPart;
 /** Build an `inject`-ready system message for a finished task. */
 declare function taskCompletionMessage(task: DoneTaskInfo): Message<"system">;
-//#endregion
-//#region src/utils/usage.d.ts
 /** Sum two Usages. Optional fields are only present in the result
  *  when at least one input had them set, so callers can tell "no
  *  reasoning happened this turn" apart from "0 reasoning tokens." */
@@ -729,8 +710,6 @@ declare class TokenUsage implements Usage {
   get total(): Usage;
   get contextSize(): number;
 }
-//#endregion
-//#region src/agent.d.ts
 /**
  * Long-lived agent — drives the multi-turn loop, owns the run-time
  * status / queues, and delegates conversation state to a `Session`.
@@ -891,8 +870,6 @@ declare class Agent extends Emitter<AgentEvents> {
    *  runner on completion) should invoke this explicitly. */
   dispose(): Promise<void>;
 }
-//#endregion
-//#region src/compaction/utils.d.ts
 export type ToolStat = {
   count: number;
   score: number;
@@ -955,8 +932,6 @@ export declare function messageTail(messages: readonly Message[], opts: {
 }): Message[];
 export declare function formatBashUsage(commands: BashUsage[]): string;
 export declare function formatFileUsage(files: FileUsage[]): string;
-//#endregion
-//#region src/compaction/compactions.d.ts
 type CompactionOptions = {
   enabled: boolean;
   threshold?: number;
@@ -970,14 +945,10 @@ type CompactionOptions = {
   reasoning?: ReasoningEffort;
   trigger?: "manual" | "auto";
 };
-//#endregion
-//#region src/notify.d.ts
 type NotifyOptions = {
   idle?: number;
   periodic?: number;
 };
-//#endregion
-//#region src/permissions/handlers/registry.d.ts
 type HandlerLoader = () => PermissionHandler<string>;
 declare const builtin$2: {
   readonly bash: () => PermissionHandler<"bash">;
@@ -1026,8 +997,6 @@ export declare const handlerRegistry: import("@zaly/shared/registry").Registry<H
   readonly tool: () => PermissionHandler<"tool">;
   readonly write: () => PermissionHandler<"read" | "write">;
 }>;
-//#endregion
-//#region src/stop.d.ts
 /** Caps + heuristics that can end a run early. Wired into the
  *  `AgentSession` loop via a single `detect()` call after each step. */
 interface StopOptions {
@@ -1096,8 +1065,6 @@ declare class StopPolicy {
    *  loop is the more pressing thing to surface. */
   detect(): AgentStopKind | undefined;
 }
-//#endregion
-//#region src/types.d.ts
 type SendMode = "inject" | "append";
 declare module "@zaly/ai" {
   interface ToolContext {
@@ -1305,33 +1272,6 @@ interface AgentOptions extends CollectOptions {
   bash?: string[];
   loadModel?: (id: string) => Promise<Model>;
 }
-//#endregion
-//#region src/utils/file.d.ts
-type FileMeta = {
-  path: string;
-  mtime: number;
-  kind: "read" | "write" | "edit";
-  /** True when the result reflects the whole-file content — set by
-   *  un-sliced `read` and by `write` (which always replaces the
-   *  full file). Used by the masker to know whether this result
-   *  subsumes earlier reads of the same path. `edit` never sets it
-   *  because the result is patch-relative. */
-  full?: boolean;
-  unchanged?: boolean;
-};
-type FileTool = Tool<{
-  path: string;
-}, unknown, FileMeta>;
-declare function assertFresh(path: string, ctx: ToolContext): void;
-declare function isUnchanged(path: string, ctx: ToolContext): boolean;
-declare function checkFresh(path: string, ctx: ToolContext, opts?: {
-  full?: boolean;
-}): AiError | true;
-/** Build the canonical freshness error. `data.reason` distinguishes
- *  never-read from changed-since-read for callers and renderers. */
-declare function freshnessError(path: string, reason: "NOT_READ" | "STALE"): AiError;
-//#endregion
-//#region src/prompt/registry.d.ts
 export interface PromptCtx {
   model: Model;
   cwd: string;
@@ -1364,8 +1304,6 @@ declare class PromptCollection extends BaseCollection<AnyPrompt[], Prompt[], Pro
   }): Promise<Prompt<string>[]>;
 }
 export declare function promptCollection(): Promise<PromptCollection>;
-//#endregion
-//#region src/tools/registry.d.ts
 /** Per-load context handed to every tool factory. Lets factories
  *  customise the tool — typically schema descriptions — based on the
  *  agent's model and working directory. Tools that don't care about
@@ -1416,17 +1354,43 @@ declare class ToolCollection extends BaseCollection<AnyTool[], AnyTool[], Tool>
   load(tools?: AnyTool[]): Promise<Tool[]>;
 }
 export declare function toolCollection(): Promise<ToolCollection>;
-//#endregion
-//#region src/tools/bash.d.ts
 type BashTool = typeof bashTool;
 declare const bashTool: import("@zaly/ai").Tool<{
   command: string;
   description?: string | undefined;
-  max_lines?: number | undefined;
+  limit?: number | undefined;
   timeout?: number | undefined;
 }, unknown, object>;
-//#endregion
-//#region src/tools/edit.d.ts
+type ReadTool = typeof readTool;
+type FileTool = Tool<{
+  path: string;
+}, unknown, FileMeta>;
+type FileMeta = {
+  path: string;
+  mtime: number;
+  kind: "read" | "write" | "edit";
+  /** True when the result reflects the whole-file content — set by
+   *  un-sliced `read` and by `write` (which always replaces the
+   *  full file). Used by the masker to know whether this result
+   *  subsumes earlier reads of the same path. `edit` never sets it
+   *  because the result is patch-relative. */
+  full?: boolean;
+  unchanged?: boolean;
+};
+type ReadToolMeta = FileMeta & {
+  offset: number;
+  limit: number;
+};
+/** Build the `read` tool with model-aware schema description. The
+ *  attachment-shape blurb is included only when the loaded model
+ *  actually accepts the relevant modality — text-only models see a
+ *  description that promises only text output, so they don't reach
+ *  for the tool expecting images they can't process. */
+declare const readTool: Tool<{
+  path: string;
+  offset?: number | undefined;
+  limit?: number | undefined;
+}, unknown, ReadToolMeta>;
 type EditTool = typeof editTool;
 type EditToolMeta = FileMeta & {
   /** File content before any edit was applied. */
@@ -1459,8 +1423,44 @@ declare const editTool: import("@zaly/ai").Tool<{
     newText: string;
   }[];
 }, unknown, EditToolMeta>;
-//#endregion
-//#region src/tools/find.d.ts
+type FetchTool = typeof fetchTool;
+type FetchToolMeta = {
+  kind: "fetch";
+  url: string;
+  type: "text" | Attachment["type"];
+  format?: string;
+  title?: string;
+  status: number;
+  statusText: string;
+  ok: boolean;
+  contentType?: string;
+  durationMs: number;
+  warning?: string;
+  truncated?: {
+    fullOutputPath: string;
+    totalBytes: number;
+    totalLines: number;
+  };
+};
+/**
+ * Fetch APIs or static pages. HTML becomes readable Markdown; raw mode
+ * preserves the response text. Conversion never runs page scripts.
+ * Truncated text is saved in full alongside the session, like bash output.
+ *
+ * Permissions: routes through the `fetch` scope when the agent wires up
+ * tool-side permission checks. Until then, callers should restrict via
+ * a wrapping permission layer (rule-based or explicit allowlist).
+ */
+declare const fetchTool: import("@zaly/ai").Tool<{
+  url: string;
+  method?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | undefined;
+  headers?: Record<string, string> | undefined;
+  query?: Record<string, string> | undefined;
+  body?: string | undefined;
+  format?: "auto" | "markdown" | "raw" | undefined;
+  limit?: number | undefined;
+  jsonpath?: string | undefined;
+}, unknown, FetchToolMeta>;
 type FindTool = typeof findTool;
 type FindToolMeta = {
   cwd: string;
@@ -1475,8 +1475,6 @@ declare const findTool: import("@zaly/ai").Tool<{
   ignore?: boolean | undefined;
   limit?: number | undefined;
 }, unknown, FindToolMeta>;
-//#endregion
-//#region src/tools/grep.d.ts
 type GrepTool = typeof grepTool;
 type GrepToolMeta = {
   cwd: string;
@@ -1492,25 +1490,6 @@ declare const grepTool: import("@zaly/ai").Tool<{
   context?: number | undefined;
   limit?: number | undefined;
 }, unknown, GrepToolMeta>;
-//#endregion
-//#region src/tools/read.d.ts
-type ReadTool = typeof readTool;
-type ReadToolMeta = FileMeta & {
-  offset: number;
-  limit: number;
-};
-/** Build the `read` tool with model-aware schema description. The
- *  attachment-shape blurb is included only when the loaded model
- *  actually accepts the relevant modality — text-only models see a
- *  description that promises only text output, so they don't reach
- *  for the tool expecting images they can't process. */
-declare const readTool: import("@zaly/ai").Tool<{
-  path: string;
-  offset?: number | undefined;
-  limit?: number | undefined;
-}, unknown, ReadToolMeta>;
-//#endregion
-//#region src/tools/write.d.ts
 type WriteTool = typeof writeTool;
 type WriteToolMeta = FileMeta & {
   /** File content before the write. Undefined for new files. The
@@ -1537,8 +1516,6 @@ declare const writeTool: import("@zaly/ai").Tool<{
   path: string;
   content: string;
 }, unknown, WriteToolMeta>;
-//#endregion
-//#region src/utils/uuid.d.ts
 /**
  * RFC 9562 UUIDv7 — timestamp-prefixed (48-bit ms since epoch),
  * monotonic within a millisecond via a 32-bit sequence counter,
@@ -1553,8 +1530,6 @@ declare const writeTool: import("@zaly/ai").Tool<{
 export declare function uuidv7(): string;
 export declare function isUuidv7(s: string): boolean;
 export declare function isUuidv7Like(s: string): boolean;
-//#endregion
-//#region src/commands.d.ts
 export type Command = {
   name: string;
   body: string;
@@ -1583,8 +1558,6 @@ export declare class Commands {
   get(name: string): Command | undefined;
   format(input: string | ArgsResult, cmd: Command): Promise<string>;
 }
-//#endregion
-//#region src/context/tokens.d.ts
 export type TokenCount = {
   type: AnyType | Message["role"] | "prompt" | "tool-schema" | "system-prompt";
   kind?: string;
@@ -1604,6 +1577,5 @@ export declare function tokenStats(msgs: readonly Message[], opts?: {
   expand?: (c: TokenCount) => boolean;
 }): TokenStats;
 export declare function formatTokenStats(s: TokenStats, indent?: number): string;
-//#endregion
-export type { Agent, AgentContext, AgentContextEvents, AgentEvents, AgentInit, AgentOptions, AgentStatus, AgentStop, AgentStopKind, AnyScope, BashTool, BuiltinScope, CheckResult, ContextPressure, DoneTaskInfo, EditTool, EditToolMeta, FileMeta, FileTool, FindTool, FindToolMeta, GrepTool, GrepToolMeta, PermissionContext, PermissionHandler, PermissionManager, PermissionOptions, PermissionPreset, PermissionPresetName, PermissionRequest, PermissionScope, PermissionScopes, PromptCollection, ReadTool, ReadToolMeta, Rule, SendMode, StepKind, StepResult, StopOptions, StopPolicy, Suggestion, TaskInfo, TaskMeta, TaskStatus, Tasks, TasksEvents, TokenUsage, ToolCollection, TurnResult, Verdict, WriteTool, WriteToolMeta, addUsage, assertFresh, checkFresh, createAgentContext, freshnessError, isUnchanged, taskCompletionMessage, taskInfoPart };
+export type { Agent, AgentContext, AgentContextEvents, AgentEvents, AgentInit, AgentOptions, AgentStatus, AgentStop, AgentStopKind, AnyScope, BashTool, BuiltinScope, CheckResult, ContextPressure, DoneTaskInfo, EditTool, EditToolMeta, FetchTool, FetchToolMeta, FileMeta, FileTool, FindTool, FindToolMeta, GrepTool, GrepToolMeta, PermissionContext, PermissionHandler, PermissionManager, PermissionOptions, PermissionPreset, PermissionPresetName, PermissionRequest, PermissionScope, PermissionScopes, PromptCollection, ReadTool, ReadToolMeta, Rule, SendMode, StepKind, StepResult, StopOptions, StopPolicy, Suggestion, TaskInfo, TaskMeta, TaskStatus, Tasks, TasksEvents, TokenUsage, ToolCollection, TurnResult, Verdict, WriteTool, WriteToolMeta, addUsage, createAgentContext, taskCompletionMessage, taskInfoPart };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["TokenCount","TokenCount","builtin","TokenCount","TokenCount","builtin"],"sources":["../src/events.ts","../src/masker.ts","../src/permissions/types.ts","../src/permissions/presets.ts","../src/permissions/manager.ts","../src/skills.ts","../src/swarm.ts","../src/ctx.ts","../src/tasks.ts","../src/utils/usage.ts","../src/agent.ts","../src/compaction/utils.ts","../src/compaction/compactions.ts","../src/notify.ts","../src/permissions/handlers/registry.ts","../src/stop.ts","../src/types.ts","../src/utils/file.ts","../src/prompt/registry.ts","../src/tools/registry.ts","../src/tools/bash.ts","../src/tools/edit.ts","../src/tools/find.ts","../src/tools/grep.ts","../src/tools/read.ts","../src/tools/write.ts","../src/utils/uuid.ts","../src/commands.ts","../src/context/tokens.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":["TokenCount","TokenCount","builtin","TokenCount","TokenCount","builtin"],"sources":["../src/events.ts","../src/masker.ts","../src/permissions/types.ts","../src/permissions/presets.ts","../src/permissions/manager.ts","../src/skills.ts","../src/swarm.ts","../src/ctx.ts","../src/tasks.ts","../src/utils/usage.ts","../src/agent.ts","../src/compaction/utils.ts","../src/compaction/compactions.ts","../src/notify.ts","../src/permissions/handlers/registry.ts","../src/stop.ts","../src/types.ts","../src/prompt/registry.ts","../src/tools/registry.ts","../src/tools/bash.ts","../src/tools/read.ts","../src/tools/edit.ts","../src/tools/fetch.ts","../src/tools/find.ts","../src/tools/grep.ts","../src/tools/write.ts","../src/utils/uuid.ts","../src/commands.ts","../src/context/tokens.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as extractConversation, c as formatFileUsage, d as Commands, f as toolCollection, g as createAgent, h as promptRegistry, i as extractBashUsage, l as messageTail, m as promptCollection, n as formatTokenStats, o as extractFileUsage, p as toolRegistry, r as tokenStats, s as formatBashUsage, t as estimatePart, u as Skills } from "./src-C852Q6gy.mjs";
-import { t as handlerRegistry } from "./registry-L9GDccS0.mjs";
-import { n as isUuidv7Like, r as uuidv7, t as isUuidv7 } from "./uuid-CAdJg4l8.mjs";
+import { a as extractConversation, c as formatFileUsage, d as Commands, f as toolCollection, g as createAgent, h as promptRegistry, i as extractBashUsage, l as messageTail, m as promptCollection, n as formatTokenStats, o as extractFileUsage, p as toolRegistry, r as tokenStats, s as formatBashUsage, t as estimatePart, u as Skills } from "./src-C04Qk9KE.mjs";
+import { t as handlerRegistry } from "./registry-CntkeXlo.mjs";
+import { n as isUuidv7Like, r as uuidv7, t as isUuidv7 } from "./uuid-rfbQ9ad2.mjs";
 export { Commands, Skills, createAgent, estimatePart, extractBashUsage, extractConversation, extractFileUsage, formatBashUsage, formatFileUsage, formatTokenStats, handlerRegistry, isUuidv7, isUuidv7Like, messageTail, promptCollection, promptRegistry, tokenStats, toolCollection, toolRegistry, uuidv7 };

package/dist/{jsonl-CvgEOakL.mjs → jsonl-BGt7eqPK.mjs}

@@ -1,6 +1,6 @@
 import { normPath, safeStringify, withLock } from "@zaly/shared";
 import { appendFile, open } from "node:fs/promises";
-//#region src/session/jsonl.ts
+// src/session/jsonl.ts
 const CHUNK_SIZE = 4194304;
 /**
 * JSONL-backed `SessionStore` — append-only file, one record per line.
@@ -128,7 +128,6 @@ var JsonlReader = class {
 		}
 	}
 };
-//#endregion
 export { JsonlStore as n, JsonlReader as t };
 
-//# sourceMappingURL=jsonl-CvgEOakL.mjs.map
+//# sourceMappingURL=jsonl-BGt7eqPK.mjs.map

package/dist/{jsonl-CvgEOakL.mjs.map → jsonl-BGt7eqPK.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"jsonl-CvgEOakL.mjs","names":[],"sources":["../src/session/jsonl.ts"],"sourcesContent":["import type { FileHandle } from \"node:fs/promises\"\nimport type { SessionStore } from \"./store.ts\"\nimport type { SessionNode } from \"./types.ts\"\n\nimport { normPath, safeStringify, withLock } from \"@zaly/shared\"\nimport { appendFile, open } from \"node:fs/promises\"\n\nconst CHUNK_SIZE = 4 * 1024 * 1024\n\n/**\n * JSONL-backed `SessionStore` — append-only file, one record per line.\n *\n * Current implementation reads the entire file on `load()` and keeps the\n * full DAG in memory. Future optimizations (lazy reads with offset\n * index, LRU cache for huge sessions) can land behind this same\n * interface without changing `Session`.\n *\n * Crash tolerance: a truncated last line (interrupted mid-write) is\n * silently dropped; any other JSON parse error mid-file throws so real\n * corruption surfaces loudly.\n */\nexport class JsonlStore implements SessionStore {\n  readonly path: string\n  #nodes = new Map<string, SessionNode>()\n  #root?: SessionNode\n  #jsonl: JsonlReader<SessionNode>\n\n  constructor(path: string) {\n    this.path = path\n    this.#jsonl = new JsonlReader(path)\n  }\n\n  /** Load + open: hydrate the DAG from `path` (when the file exists),\n   *  then open the writer in append mode. New nodes land on disk as\n   *  they're committed. */\n  static async load(path: string): Promise<JsonlStore> {\n    path = normPath(path)\n    const ret = new JsonlStore(path)\n    await ret.#fetch({ limit: 1 })\n    return ret\n  }\n\n  async #fetch(opts?: { id?: string; limit?: number }): Promise<SessionNode | undefined> {\n    let count = 0\n    let value: SessionNode | undefined\n    // oxlint-disable-next-line no-await-in-loop\n    while ((value = await this.#jsonl.next()) !== undefined) {\n      this.#nodes.set(value.uuid, value)\n      this.#root ??= value\n      if (opts?.limit && count++ >= opts.limit) break // safe — doesn't call .return()\n      if (opts?.id && value.uuid === opts.id) return value\n    }\n  }\n\n  get root(): SessionNode | undefined {\n    return this.#root\n  }\n\n  async get(id: string): Promise<SessionNode | undefined> {\n    return this.#nodes.get(id) ?? (await this.#fetch({ id }))\n  }\n\n  async write(node: SessionNode): Promise<void> {\n    const line = `${safeStringify(node)}\\n`\n    await withLock(this.path, async () => {\n      await appendFile(this.path, line, \"utf8\")\n    })\n    this.#nodes.set(node.uuid, node)\n    this.#root = node\n  }\n\n  async close(): Promise<void> {\n    await this.#jsonl.close()\n  }\n\n  async *all(): AsyncIterable<SessionNode> {\n    await this.#fetch()\n    yield* this.#nodes.values()\n  }\n}\n\nexport class JsonlReader<T> {\n  #fd?: FileHandle\n  #path: string\n  #it?: AsyncIterableIterator<T>\n  #count = 0\n\n  constructor(readonly path: string) {\n    this.#path = path\n    this.#it = this.generator()\n  }\n\n  #toJson(line: string): T | undefined {\n    if (line.trim() === \"\") return\n    try {\n      const ret = JSON.parse(line) as T\n      this.#count++\n      return ret\n    } catch (error) {\n      // Tolerate a truncated last line (crash mid-write); anything\n      // else is real corruption.\n      if (this.#count === 0) return\n      throw new Error(\n        `JsonlStore.load: malformed JSON at line ${this.#count + 1} of \"${this.#path}\": ${(error as Error).message}`,\n        { cause: error }\n      )\n    }\n  }\n\n  private async *generator(): AsyncIterableIterator<T> {\n    try {\n      this.#fd = await open(this.#path, \"r\")\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return\n      throw error\n    }\n    let { size: position } = await this.#fd.stat()\n    let leftover = \"\"\n    try {\n      while (position > 0) {\n        const length = Math.min(position, CHUNK_SIZE)\n        position -= length\n        // oxlint-disable-next-line no-await-in-loop\n        const { buffer } = await this.#fd.read(Buffer.alloc(length), 0, length, position)\n        const lines = (buffer.toString(\"utf8\") + leftover).split(/\\r?\\n/)\n        leftover = lines.shift() ?? \"\"\n        for (let i = lines.length - 1; i >= 0; i--) {\n          const v = this.#toJson(lines[i])\n          if (v) yield v\n        }\n      }\n      if (leftover.length) {\n        const v = this.#toJson(leftover)\n        if (v) yield v\n      }\n    } finally {\n      await this.#fd.close()\n      this.#it = undefined\n    }\n  }\n\n  async next(): Promise<T | undefined> {\n    if (!this.#it) return\n    const { value, done } = await this.#it.next()\n    return done ? undefined : value\n  }\n\n  async close() {\n    if (this.#it) {\n      await this.#it.return?.() // runs the generator's finally\n      this.#it = undefined\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"jsonl-BGt7eqPK.mjs","names":[],"sources":["../src/session/jsonl.ts"],"sourcesContent":["import type { FileHandle } from \"node:fs/promises\"\nimport type { SessionStore } from \"./store.ts\"\nimport type { SessionNode } from \"./types.ts\"\n\nimport { normPath, safeStringify, withLock } from \"@zaly/shared\"\nimport { appendFile, open } from \"node:fs/promises\"\n\nconst CHUNK_SIZE = 4 * 1024 * 1024\n\n/**\n * JSONL-backed `SessionStore` — append-only file, one record per line.\n *\n * Current implementation reads the entire file on `load()` and keeps the\n * full DAG in memory. Future optimizations (lazy reads with offset\n * index, LRU cache for huge sessions) can land behind this same\n * interface without changing `Session`.\n *\n * Crash tolerance: a truncated last line (interrupted mid-write) is\n * silently dropped; any other JSON parse error mid-file throws so real\n * corruption surfaces loudly.\n */\nexport class JsonlStore implements SessionStore {\n  readonly path: string\n  #nodes = new Map<string, SessionNode>()\n  #root?: SessionNode\n  #jsonl: JsonlReader<SessionNode>\n\n  constructor(path: string) {\n    this.path = path\n    this.#jsonl = new JsonlReader(path)\n  }\n\n  /** Load + open: hydrate the DAG from `path` (when the file exists),\n   *  then open the writer in append mode. New nodes land on disk as\n   *  they're committed. */\n  static async load(path: string): Promise<JsonlStore> {\n    path = normPath(path)\n    const ret = new JsonlStore(path)\n    await ret.#fetch({ limit: 1 })\n    return ret\n  }\n\n  async #fetch(opts?: { id?: string; limit?: number }): Promise<SessionNode | undefined> {\n    let count = 0\n    let value: SessionNode | undefined\n    // oxlint-disable-next-line no-await-in-loop\n    while ((value = await this.#jsonl.next()) !== undefined) {\n      this.#nodes.set(value.uuid, value)\n      this.#root ??= value\n      if (opts?.limit && count++ >= opts.limit) break // safe — doesn't call .return()\n      if (opts?.id && value.uuid === opts.id) return value\n    }\n  }\n\n  get root(): SessionNode | undefined {\n    return this.#root\n  }\n\n  async get(id: string): Promise<SessionNode | undefined> {\n    return this.#nodes.get(id) ?? (await this.#fetch({ id }))\n  }\n\n  async write(node: SessionNode): Promise<void> {\n    const line = `${safeStringify(node)}\\n`\n    await withLock(this.path, async () => {\n      await appendFile(this.path, line, \"utf8\")\n    })\n    this.#nodes.set(node.uuid, node)\n    this.#root = node\n  }\n\n  async close(): Promise<void> {\n    await this.#jsonl.close()\n  }\n\n  async *all(): AsyncIterable<SessionNode> {\n    await this.#fetch()\n    yield* this.#nodes.values()\n  }\n}\n\nexport class JsonlReader<T> {\n  #fd?: FileHandle\n  #path: string\n  #it?: AsyncIterableIterator<T>\n  #count = 0\n\n  constructor(readonly path: string) {\n    this.#path = path\n    this.#it = this.generator()\n  }\n\n  #toJson(line: string): T | undefined {\n    if (line.trim() === \"\") return\n    try {\n      const ret = JSON.parse(line) as T\n      this.#count++\n      return ret\n    } catch (error) {\n      // Tolerate a truncated last line (crash mid-write); anything\n      // else is real corruption.\n      if (this.#count === 0) return\n      throw new Error(\n        `JsonlStore.load: malformed JSON at line ${this.#count + 1} of \"${this.#path}\": ${(error as Error).message}`,\n        { cause: error }\n      )\n    }\n  }\n\n  private async *generator(): AsyncIterableIterator<T> {\n    try {\n      this.#fd = await open(this.#path, \"r\")\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return\n      throw error\n    }\n    let { size: position } = await this.#fd.stat()\n    let leftover = \"\"\n    try {\n      while (position > 0) {\n        const length = Math.min(position, CHUNK_SIZE)\n        position -= length\n        // oxlint-disable-next-line no-await-in-loop\n        const { buffer } = await this.#fd.read(Buffer.alloc(length), 0, length, position)\n        const lines = (buffer.toString(\"utf8\") + leftover).split(/\\r?\\n/)\n        leftover = lines.shift() ?? \"\"\n        for (let i = lines.length - 1; i >= 0; i--) {\n          const v = this.#toJson(lines[i])\n          if (v) yield v\n        }\n      }\n      if (leftover.length) {\n        const v = this.#toJson(leftover)\n        if (v) yield v\n      }\n    } finally {\n      await this.#fd.close()\n      this.#it = undefined\n    }\n  }\n\n  async next(): Promise<T | undefined> {\n    if (!this.#it) return\n    const { value, done } = await this.#it.next()\n    return done ? undefined : value\n  }\n\n  async close() {\n    if (this.#it) {\n      await this.#it.return?.() // runs the generator's finally\n      this.#it = undefined\n    }\n  }\n}\n"],"mappings":";;;AAOA,MAAM,aAAa;;;;;;;;;;;;;AAcnB,IAAa,aAAb,MAAa,WAAmC;CAC9C;CACA,yBAAS,IAAI,IAAyB;CACtC;CACA;CAEA,YAAY,MAAc;EACxB,KAAK,OAAO;EACZ,KAAK,SAAS,IAAI,YAAY,IAAI;CACpC;;;;CAKA,aAAa,KAAK,MAAmC;EACnD,OAAO,SAAS,IAAI;EACpB,MAAM,MAAM,IAAI,WAAW,IAAI;EAC/B,MAAM,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;EAC7B,OAAO;CACT;CAEA,MAAM,OAAO,MAA0E;EACrF,IAAI,QAAQ;EACZ,IAAI;EAEJ,QAAQ,QAAQ,MAAM,KAAK,OAAO,KAAK,OAAO,KAAA,GAAW;GACvD,KAAK,OAAO,IAAI,MAAM,MAAM,KAAK;GACjC,KAAK,UAAU;GACf,IAAI,MAAM,SAAS,WAAW,KAAK,OAAO;GAC1C,IAAI,MAAM,MAAM,MAAM,SAAS,KAAK,IAAI,OAAO;EACjD;CACF;CAEA,IAAI,OAAgC;EAClC,OAAO,KAAK;CACd;CAEA,MAAM,IAAI,IAA8C;EACtD,OAAO,KAAK,OAAO,IAAI,EAAE,KAAM,MAAM,KAAK,OAAO,EAAE,GAAG,CAAC;CACzD;CAEA,MAAM,MAAM,MAAkC;EAC5C,MAAM,OAAO,GAAG,cAAc,IAAI,EAAE;EACpC,MAAM,SAAS,KAAK,MAAM,YAAY;GACpC,MAAM,WAAW,KAAK,MAAM,MAAM,MAAM;EAC1C,CAAC;EACD,KAAK,OAAO,IAAI,KAAK,MAAM,IAAI;EAC/B,KAAK,QAAQ;CACf;CAEA,MAAM,QAAuB;EAC3B,MAAM,KAAK,OAAO,MAAM;CAC1B;CAEA,OAAO,MAAkC;EACvC,MAAM,KAAK,OAAO;EAClB,OAAO,KAAK,OAAO,OAAO;CAC5B;AACF;AAEA,IAAa,cAAb,MAA4B;CAML;CALrB;CACA;CACA;CACA,SAAS;CAET,YAAY,MAAuB;EAAd,KAAA,OAAA;EACnB,KAAK,QAAQ;EACb,KAAK,MAAM,KAAK,UAAU;CAC5B;CAEA,QAAQ,MAA6B;EACnC,IAAI,KAAK,KAAK,MAAM,IAAI;EACxB,IAAI;GACF,MAAM,MAAM,KAAK,MAAM,IAAI;GAC3B,KAAK;GACL,OAAO;EACT,SAAS,OAAO;GAGd,IAAI,KAAK,WAAW,GAAG;GACvB,MAAM,IAAI,MACR,2CAA2C,KAAK,SAAS,EAAE,OAAO,KAAK,MAAM,KAAM,MAAgB,WACnG,EAAE,OAAO,MAAM,CACjB;EACF;CACF;CAEA,OAAe,YAAsC;EACnD,IAAI;GACF,KAAK,MAAM,MAAM,KAAK,KAAK,OAAO,GAAG;EACvC,SAAS,OAAO;GACd,IAAK,MAAgC,SAAS,UAAU;GACxD,MAAM;EACR;EACA,IAAI,EAAE,MAAM,aAAa,MAAM,KAAK,IAAI,KAAK;EAC7C,IAAI,WAAW;EACf,IAAI;GACF,OAAO,WAAW,GAAG;IACnB,MAAM,SAAS,KAAK,IAAI,UAAU,UAAU;IAC5C,YAAY;IAEZ,MAAM,EAAE,WAAW,MAAM,KAAK,IAAI,KAAK,OAAO,MAAM,MAAM,GAAG,GAAG,QAAQ,QAAQ;IAChF,MAAM,SAAS,OAAO,SAAS,MAAM,IAAI,SAAA,CAAU,MAAM,OAAO;IAChE,WAAW,MAAM,MAAM,KAAK;IAC5B,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;KAC1C,MAAM,IAAI,KAAK,QAAQ,MAAM,EAAE;KAC/B,IAAI,GAAG,MAAM;IACf;GACF;GACA,IAAI,SAAS,QAAQ;IACnB,MAAM,IAAI,KAAK,QAAQ,QAAQ;IAC/B,IAAI,GAAG,MAAM;GACf;EACF,UAAU;GACR,MAAM,KAAK,IAAI,MAAM;GACrB,KAAK,MAAM,KAAA;EACb;CACF;CAEA,MAAM,OAA+B;EACnC,IAAI,CAAC,KAAK,KAAK;EACf,MAAM,EAAE,OAAO,SAAS,MAAM,KAAK,IAAI,KAAK;EAC5C,OAAO,OAAO,KAAA,IAAY;CAC5B;CAEA,MAAM,QAAQ;EACZ,IAAI,KAAK,KAAK;GACZ,MAAM,KAAK,IAAI,SAAS;GACxB,KAAK,MAAM,KAAA;EACb;CACF;AACF"}

package/dist/{manager-BqlbCGYV.mjs → manager-1zEE5WiA.mjs}

@@ -1,6 +1,6 @@
-import { t as handlerRegistry } from "./registry-L9GDccS0.mjs";
+import { t as handlerRegistry } from "./registry-CntkeXlo.mjs";
 import { normPath } from "@zaly/shared";
-//#region src/permissions/presets.ts
+// src/permissions/presets.ts
 /** Native tools that only inspect session state or workspace files. */
 const READONLY_TOOLS = [
 	"tool(read)",
@@ -166,8 +166,7 @@ const permissionPresets = {
 		] }
 	}
 };
-//#endregion
-//#region src/permissions/manager.ts
+// src/permissions/manager.ts
 /**
 * Owns per-session permission state and dispatches `validate(scope, input)`
 * to the registered handler for `scope`. Handlers receive rules
@@ -275,7 +274,6 @@ function parseRules(rules) {
 	}
 	return ret;
 }
-//#endregion
 export { PermissionManager };
 
-//# sourceMappingURL=manager-BqlbCGYV.mjs.map
+//# sourceMappingURL=manager-1zEE5WiA.mjs.map

package/dist/{manager-BqlbCGYV.mjs.map → manager-1zEE5WiA.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"manager-BqlbCGYV.mjs","names":[],"sources":["../src/permissions/presets.ts","../src/permissions/manager.ts"],"sourcesContent":["import type { Verdict } from \"./types.ts\"\n\n/**\n * Permission presets — verdict-keyed pattern lists in the same shape\n * `parseRules` accepts. The TUI exposes these as `--preset strict`,\n * `--preset readonly`, etc.; the manager resolves the chosen preset to\n * the structured `Rule<string>[]` at construction.\n *\n * Pattern grammar:\n *   \"bash(ls:*)\"     → bash command pattern\n *   \"read(/src/**)\"  → workspace-relative gitignore pattern\n *   \"read(*)\"        → matches every read in any workspace\n *   \"bash\"           → bare scope, equivalent to `bash(*)` (match any cmd)\n *\n * Scope names are exact matches against the tool name they gate\n * (snake_case). Underscored scopes work too (`task_stop`, `task_poll`).\n */\nexport type PermissionPresetName = \"strict\" | \"readonly\" | \"permissive\" | \"yolo\"\n\nexport interface PermissionPreset {\n  description: string\n  rules: Partial<Record<Verdict, string[]>>\n}\n\n// ── Pattern groups ─────────────────────────────────────────────────────────\n\n/** Native tools that only inspect session state or workspace files. */\nconst READONLY_TOOLS = [\n  \"tool(read)\",\n  \"tool(grep)\",\n  \"tool(find)\",\n  \"tool(task_list)\",\n  \"tool(task_poll)\",\n]\n\n/** Read-only utilities the model can run without surprises: file\n *  inspection, search, metadata. None of these modify state on their own.\n *  (`sed`/`awk` writes still gated by Write rules via the bash handler's\n *  composition with the file handler.) */\nconst READONLY_BASH = [\n  \"bash(ls:*)\",\n  \"bash(cat:*)\",\n  \"bash(head:*)\",\n  \"bash(tail:*)\",\n  \"bash(wc:*)\",\n  \"bash(find:*)\",\n  \"bash(grep:*)\",\n  \"bash(rg:*)\",\n  \"bash(fd:*)\",\n  \"bash(sort:*)\",\n  \"bash(uniq:*)\",\n  \"bash(cut:*)\",\n  \"bash(diff:*)\",\n  \"bash(stat:*)\",\n  \"bash(file:*)\",\n  \"bash(realpath:*)\",\n  \"bash(readlink:*)\",\n  \"bash(basename:*)\",\n  \"bash(dirname:*)\",\n  \"bash(echo:*)\",\n  \"bash(printf:*)\",\n  \"bash(sed:*)\",\n  \"bash(awk:*)\",\n  \"bash(xxd:*)\",\n  \"bash(hexdump:*)\",\n  \"bash(od:*)\",\n  \"bash(tree:*)\",\n  \"bash(pwd)\",\n  \"bash(true)\",\n  \"bash(false)\",\n  \"bash(which:*)\",\n  \"bash(type:*)\",\n  \"bash(command:*)\",\n  \"bash(test:*)\",\n  \"bash(cd:*)\",\n]\n\n/** Read-only git + GitHub CLI subcommands. */\nconst READONLY_GIT = [\n  \"bash(git status:*)\",\n  \"bash(git log:*)\",\n  \"bash(git diff:*)\",\n  \"bash(git show:*)\",\n  \"bash(git show-ref:*)\",\n  \"bash(git branch:*)\",\n  \"bash(git remote:*)\",\n  \"bash(git rev-parse:*)\",\n  \"bash(git config --get:*)\",\n  \"bash(gh issue list:*)\",\n  \"bash(gh issue view:*)\",\n  \"bash(gh pr list:*)\",\n  \"bash(gh pr view:*)\",\n  \"bash(gh repo view:*)\",\n]\n\n/** Common dev-workflow commands — build, test, typecheck. Excludes\n *  package management (`npm install`, `bun add`) which can drag arbitrary\n *  code in over the network. */\nconst DEV_BASIC = [\n  \"bash(bun test:*)\",\n  \"bash(bun test:node:*)\",\n  \"bash(bun test:bun:*)\",\n  \"bash(bun check:*)\",\n  \"bash(bun run:*)\",\n  \"bash(bun build:*)\",\n  \"bash(bunx tsc:*)\",\n  \"bash(bun tsc:*)\",\n  \"bash(bun x tsc:*)\",\n  \"bash(bunx vitest:*)\",\n  \"bash(bun x vitest:*)\",\n  \"bash(bunx oxlint:*)\",\n  \"bash(bun x oxlint:*)\",\n  \"bash(oxlint:*)\",\n]\n\n/** Hard denies — never auto-allowed, regardless of preset. */\nconst HARD_DENIES = [\"bash(sudo:*)\"]\n\n/** Broader rules unlocked by the permissive preset. Trades some safety\n *  for speed — appropriate for frontier models with strong instruction\n *  following. Includes ad-hoc bun/node evals and git mutations. */\nconst PERMISSIVE_EXTRAS = [\n  \"bash(bun -e:*)\",\n  \"bash(bun:*)\",\n  \"bash(node:*)\",\n  \"bash(node -e:*)\",\n  \"bash(make:*)\",\n  \"bash(mkdir:*)\",\n  \"bash(cp:*)\",\n  \"bash(mv:*)\",\n  \"bash(touch:*)\",\n  \"bash(ln:*)\",\n  \"bash(chmod:*)\",\n  \"bash(git add:*)\",\n  \"bash(git commit:*)\",\n  \"bash(git checkout:*)\",\n  \"bash(git restore:*)\",\n  \"bash(git stash:*)\",\n  \"bash(git fetch:*)\",\n  \"bash(git pull:*)\",\n  \"bash(curl:*)\",\n  \"bash(jq:*)\",\n  \"bash(perl -e:*)\",\n  \"bash(timeout:*)\",\n  \"bash(for:*)\",\n  \"bash(while:*)\",\n]\n\n// ── Presets ────────────────────────────────────────────────────────────────\n\n// oxlint-disable sort-keys\nexport const permissionPresets = {\n  strict: {\n    description: \"Ask for everything. No commands or file ops auto-allowed.\",\n    rules: {\n      deny: HARD_DENIES,\n      // Override the tool/file handlers' default allows.\n      ask: [\"tool(*)\", \"read(*)\", \"write(*)\"],\n    },\n  },\n  readonly: {\n    description:\n      \"Auto-allow read-only utilities, git read-only ops, and common build/test commands. \" +\n      \"Reads inside the workspace are allowed (sensitive paths denied); writes always ask.\",\n    rules: {\n      deny: HARD_DENIES,\n      allow: [...READONLY_TOOLS, ...READONLY_BASH, ...READONLY_GIT, ...DEV_BASIC],\n      ask: [\"tool(*)\", \"write(*)\"],\n    },\n  },\n  permissive: {\n    description:\n      \"Readonly preset plus broader dev commands (file moves, ad-hoc bun/node evals, \" +\n      \"git mutations, network fetches) and writes inside the workspace.\",\n    rules: {\n      deny: HARD_DENIES,\n      allow: [\n        \"tool(*)\",\n        ...READONLY_BASH,\n        ...READONLY_GIT,\n        ...DEV_BASIC,\n        ...PERMISSIVE_EXTRAS,\n        // Allow writes inside any workspace (sensitive paths still denied\n        // by the file handler before rule resolution).\n        \"write(*)\",\n      ],\n    },\n  },\n  yolo: {\n    description: \"Allow everything. No prompts. Use only when you trust the model and the task.\",\n    rules: {\n      allow: [\"bash\", \"read(*)\", \"write(*)\", \"tool(*)\"],\n    },\n  },\n} as const satisfies Record<PermissionPresetName, PermissionPreset>\n","import type { PermissionPresetName } from \"./presets.ts\"\nimport type { CheckResult, Rule, Verdict } from \"./types.ts\"\n\nimport { normPath } from \"@zaly/shared\"\nimport { handlerRegistry } from \"./handlers/registry.ts\"\nimport { permissionPresets } from \"./presets.ts\"\n\nexport type PermissionOptions = {\n  /** Session cwd — anchor for resolving relative paths and the default\n   *  spawn cwd for bash subprocesses. Pinned at construction; the agent\n   *  never mutates `process.cwd()`, and there's no `cd` tool. Defaults\n   *  to `process.cwd()`. */\n  cwd?: string\n  /** Named preset — supplies a baseline rule set. Explicit `rules` win\n   *  over preset rules on conflict (first-match-wins resolution; user\n   *  rules are listed before preset rules at construction). */\n  preset?: PermissionPresetName\n  rules?: Rule[] | Partial<Record<Verdict, string[] | undefined>>\n  /** Initial workspace list. `cwd` is auto-added so the user doesn't\n   *  have to repeat it. Pass paths absolute (or relative — they'll be\n   *  resolved against `cwd`). */\n  workspaces?: readonly string[]\n}\n\n/**\n * Owns per-session permission state and dispatches `validate(scope, input)`\n * to the registered handler for `scope`. Handlers receive rules\n * pre-filtered to their scope plus the shared workspace list.\n *\n * Mutators (`addWorkspace`, `addRule`, …) are how the prompt UI promotes\n * an `ask` verdict — once the user picks \"allow `Bash(git push:*)` for\n * this session\", the TUI calls `manager.addRule(...)` and subsequent\n * `validate()` calls pick it up via the filter.\n */\nexport class PermissionManager {\n  readonly cwd: string\n  #rules: Rule[] = []\n  #workspaces: string[]\n\n  constructor(opts?: PermissionOptions) {\n    this.cwd = normPath(opts?.cwd)\n    if (opts?.rules) {\n      const more = Array.isArray(opts.rules) ? opts.rules : parseRules(opts.rules)\n      this.#rules.push(...more)\n    }\n    if (opts?.preset) this.#rules.push(...parseRules(permissionPresets[opts.preset].rules))\n    this.#workspaces = (opts?.workspaces ?? []).map((p) => normPath(this.cwd, p))\n    // Auto-include cwd so users don't have to repeat it. Listed first so\n    // longest-prefix lookup in handlers stays predictable.\n    if (!this.#workspaces.includes(this.cwd)) this.#workspaces.unshift(this.cwd)\n  }\n\n  // ── Workspaces ──────────────────────────────────────────────────────\n\n  get workspaces(): readonly string[] {\n    return this.#workspaces\n  }\n\n  addWorkspace(path: string): void {\n    const abs = normPath(this.cwd, path)\n    if (!this.#workspaces.includes(abs)) this.#workspaces.push(abs)\n  }\n\n  removeWorkspace(path: string): void {\n    const abs = normPath(this.cwd, path)\n    const i = this.#workspaces.indexOf(abs)\n    if (i !== -1) this.#workspaces.splice(i, 1)\n  }\n\n  // ── Rules ───────────────────────────────────────────────────────────\n\n  get rules(): readonly Rule[] {\n    return this.#rules\n  }\n\n  /** Rules whose scope has no registered handler — surfaces config\n   *  errors (typos, unknown scopes, malformed pattern strings). The TUI\n   *  can render these as a startup warning. */\n  get invalidRules(): readonly Rule[] {\n    return this.#rules.filter((r) => !handlerRegistry.has(r.scope))\n  }\n\n  addRule(rule: Rule): void {\n    this.#rules.unshift(rule)\n  }\n\n  // ── Dispatch ────────────────────────────────────────────────────────\n\n  /** True only when a blanket allow has no earlier restrictive exceptions. */\n  allowsAll(scope: string): boolean {\n    for (const rule of this.#rules) {\n      if (rule.scope !== scope) continue\n      if (rule.policy !== \"allow\") return false\n      if (rule.pattern === \"*\") return true\n    }\n    return false\n  }\n\n  validate(scope: string, input: string): CheckResult {\n    if (!handlerRegistry.has(scope)) {\n      throw new Error(`no permission handler registered for scope \"${scope}\"`)\n    }\n    const handler = handlerRegistry.load(scope)\n    const rules = this.#rules.filter((r) => r.scope === scope)\n    return handler.validate(input, {\n      allowsAll: this.allowsAll.bind(this),\n      cwd: this.cwd,\n      rules,\n      scope,\n      validate: this.validate.bind(this),\n      workspaces: this.#workspaces,\n    })\n  }\n}\n\n/** Parse Claude-Code-style permission config (a verdict-keyed map of\n *  pattern strings) into structured `Rule<string>[]`.\n *\n *  Pattern shapes accepted:\n *    \"Bash(ls:*)\"   → { scope: \"bash\", pattern: \"ls:*\" }\n *    \"WebSearch\"    → { scope: \"websearch\", pattern: \"*\" }   // bare name = scope-wide\n *\n *  Scopes are normalized to lower-case so config can use either\n *  TitleCase (\"Bash\") or lowercase (\"bash\") interchangeably.\n *\n *  Malformed entries are pushed verbatim so `manager.invalidRules`\n *  surfaces them — typos in the scope (\"Bahs(...)\") are caught the same\n *  way (no handler registered → flagged invalid). */\nexport function parseRules(rules: Partial<Record<Verdict, string[] | undefined>>): Rule[] {\n  const ret: Rule[] = []\n  for (const policy of Object.keys(rules) as Verdict[]) {\n    const patterns = rules[policy]\n    if (!Array.isArray(patterns)) continue\n    for (const raw of patterns) {\n      const m = raw.match(/^(\\w+)(?:\\((.+)\\))?$/)\n      if (m) {\n        const [, scope, pat = \"*\"] = m\n        ret.push({ pattern: pat, policy, scope: scope.toLowerCase() })\n      } else {\n        // Truly malformed — preserve verbatim so invalidRules surfaces it.\n        ret.push({ pattern: raw, policy, scope: \"invalid\" })\n      }\n    }\n  }\n  return ret\n}\n"],"mappings":";;;;AA2BA,MAAM,iBAAiB;CACrB;CACA;CACA;CACA;CACA;AACF;;;;;AAMA,MAAM,gBAAgB;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAM,eAAe;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;AAKA,MAAM,YAAY;CAChB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAM,cAAc,CAAC,cAAc;;;;AAKnC,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAKA,MAAa,oBAAoB;CAC/B,QAAQ;EACN,aAAa;EACb,OAAO;GACL,MAAM;GAEN,KAAK;IAAC;IAAW;IAAW;GAAU;EACxC;CACF;CACA,UAAU;EACR,aACE;EAEF,OAAO;GACL,MAAM;GACN,OAAO;IAAC,GAAG;IAAgB,GAAG;IAAe,GAAG;IAAc,GAAG;GAAS;GAC1E,KAAK,CAAC,WAAW,UAAU;EAC7B;CACF;CACA,YAAY;EACV,aACE;EAEF,OAAO;GACL,MAAM;GACN,OAAO;IACL;IACA,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IAGH;GACF;EACF;CACF;CACA,MAAM;EACJ,aAAa;EACb,OAAO,EACL,OAAO;GAAC;GAAQ;GAAW;GAAY;EAAS,EAClD;CACF;AACF;;;;;;;;;;;;;AChKA,IAAa,oBAAb,MAA+B;CAC7B;CACA,SAAiB,CAAC;CAClB;CAEA,YAAY,MAA0B;EACpC,KAAK,MAAM,SAAS,MAAM,GAAG;EAC7B,IAAI,MAAM,OAAO;GACf,MAAM,OAAO,MAAM,QAAQ,KAAK,KAAK,IAAI,KAAK,QAAQ,WAAW,KAAK,KAAK;GAC3E,KAAK,OAAO,KAAK,GAAG,IAAI;EAC1B;EACA,IAAI,MAAM,QAAQ,KAAK,OAAO,KAAK,GAAG,WAAW,kBAAkB,KAAK,OAAO,CAAC,KAAK,CAAC;EACtF,KAAK,eAAe,MAAM,cAAc,CAAC,EAAA,CAAG,KAAK,MAAM,SAAS,KAAK,KAAK,CAAC,CAAC;EAG5E,IAAI,CAAC,KAAK,YAAY,SAAS,KAAK,GAAG,GAAG,KAAK,YAAY,QAAQ,KAAK,GAAG;CAC7E;CAIA,IAAI,aAAgC;EAClC,OAAO,KAAK;CACd;CAEA,aAAa,MAAoB;EAC/B,MAAM,MAAM,SAAS,KAAK,KAAK,IAAI;EACnC,IAAI,CAAC,KAAK,YAAY,SAAS,GAAG,GAAG,KAAK,YAAY,KAAK,GAAG;CAChE;CAEA,gBAAgB,MAAoB;EAClC,MAAM,MAAM,SAAS,KAAK,KAAK,IAAI;EACnC,MAAM,IAAI,KAAK,YAAY,QAAQ,GAAG;EACtC,IAAI,MAAM,IAAI,KAAK,YAAY,OAAO,GAAG,CAAC;CAC5C;CAIA,IAAI,QAAyB;EAC3B,OAAO,KAAK;CACd;;;;CAKA,IAAI,eAAgC;EAClC,OAAO,KAAK,OAAO,QAAQ,MAAM,CAAC,gBAAgB,IAAI,EAAE,KAAK,CAAC;CAChE;CAEA,QAAQ,MAAkB;EACxB,KAAK,OAAO,QAAQ,IAAI;CAC1B;;CAKA,UAAU,OAAwB;EAChC,KAAK,MAAM,QAAQ,KAAK,QAAQ;GAC9B,IAAI,KAAK,UAAU,OAAO;GAC1B,IAAI,KAAK,WAAW,SAAS,OAAO;GACpC,IAAI,KAAK,YAAY,KAAK,OAAO;EACnC;EACA,OAAO;CACT;CAEA,SAAS,OAAe,OAA4B;EAClD,IAAI,CAAC,gBAAgB,IAAI,KAAK,GAC5B,MAAM,IAAI,MAAM,+CAA+C,MAAM,EAAE;EAEzE,MAAM,UAAU,gBAAgB,KAAK,KAAK;EAC1C,MAAM,QAAQ,KAAK,OAAO,QAAQ,MAAM,EAAE,UAAU,KAAK;EACzD,OAAO,QAAQ,SAAS,OAAO;GAC7B,WAAW,KAAK,UAAU,KAAK,IAAI;GACnC,KAAK,KAAK;GACV;GACA;GACA,UAAU,KAAK,SAAS,KAAK,IAAI;GACjC,YAAY,KAAK;EACnB,CAAC;CACH;AACF;;;;;;;;;;;;;;AAeA,SAAgB,WAAW,OAA+D;CACxF,MAAM,MAAc,CAAC;CACrB,KAAK,MAAM,UAAU,OAAO,KAAK,KAAK,GAAgB;EACpD,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG;EAC9B,KAAK,MAAM,OAAO,UAAU;GAC1B,MAAM,IAAI,IAAI,MAAM,sBAAsB;GAC1C,IAAI,GAAG;IACL,MAAM,GAAG,OAAO,MAAM,OAAO;IAC7B,IAAI,KAAK;KAAE,SAAS;KAAK;KAAQ,OAAO,MAAM,YAAY;IAAE,CAAC;GAC/D,OAEE,IAAI,KAAK;IAAE,SAAS;IAAK;IAAQ,OAAO;GAAU,CAAC;EAEvD;CACF;CACA,OAAO;AACT"}
+{"version":3,"file":"manager-1zEE5WiA.mjs","names":[],"sources":["../src/permissions/presets.ts","../src/permissions/manager.ts"],"sourcesContent":["import type { Verdict } from \"./types.ts\"\n\n/**\n * Permission presets — verdict-keyed pattern lists in the same shape\n * `parseRules` accepts. The TUI exposes these as `--preset strict`,\n * `--preset readonly`, etc.; the manager resolves the chosen preset to\n * the structured `Rule<string>[]` at construction.\n *\n * Pattern grammar:\n *   \"bash(ls:*)\"     → bash command pattern\n *   \"read(/src/**)\"  → workspace-relative gitignore pattern\n *   \"read(*)\"        → matches every read in any workspace\n *   \"bash\"           → bare scope, equivalent to `bash(*)` (match any cmd)\n *\n * Scope names are exact matches against the tool name they gate\n * (snake_case). Underscored scopes work too (`task_stop`, `task_poll`).\n */\nexport type PermissionPresetName = \"strict\" | \"readonly\" | \"permissive\" | \"yolo\"\n\nexport interface PermissionPreset {\n  description: string\n  rules: Partial<Record<Verdict, string[]>>\n}\n\n// ── Pattern groups ─────────────────────────────────────────────────────────\n\n/** Native tools that only inspect session state or workspace files. */\nconst READONLY_TOOLS = [\n  \"tool(read)\",\n  \"tool(grep)\",\n  \"tool(find)\",\n  \"tool(task_list)\",\n  \"tool(task_poll)\",\n]\n\n/** Read-only utilities the model can run without surprises: file\n *  inspection, search, metadata. None of these modify state on their own.\n *  (`sed`/`awk` writes still gated by Write rules via the bash handler's\n *  composition with the file handler.) */\nconst READONLY_BASH = [\n  \"bash(ls:*)\",\n  \"bash(cat:*)\",\n  \"bash(head:*)\",\n  \"bash(tail:*)\",\n  \"bash(wc:*)\",\n  \"bash(find:*)\",\n  \"bash(grep:*)\",\n  \"bash(rg:*)\",\n  \"bash(fd:*)\",\n  \"bash(sort:*)\",\n  \"bash(uniq:*)\",\n  \"bash(cut:*)\",\n  \"bash(diff:*)\",\n  \"bash(stat:*)\",\n  \"bash(file:*)\",\n  \"bash(realpath:*)\",\n  \"bash(readlink:*)\",\n  \"bash(basename:*)\",\n  \"bash(dirname:*)\",\n  \"bash(echo:*)\",\n  \"bash(printf:*)\",\n  \"bash(sed:*)\",\n  \"bash(awk:*)\",\n  \"bash(xxd:*)\",\n  \"bash(hexdump:*)\",\n  \"bash(od:*)\",\n  \"bash(tree:*)\",\n  \"bash(pwd)\",\n  \"bash(true)\",\n  \"bash(false)\",\n  \"bash(which:*)\",\n  \"bash(type:*)\",\n  \"bash(command:*)\",\n  \"bash(test:*)\",\n  \"bash(cd:*)\",\n]\n\n/** Read-only git + GitHub CLI subcommands. */\nconst READONLY_GIT = [\n  \"bash(git status:*)\",\n  \"bash(git log:*)\",\n  \"bash(git diff:*)\",\n  \"bash(git show:*)\",\n  \"bash(git show-ref:*)\",\n  \"bash(git branch:*)\",\n  \"bash(git remote:*)\",\n  \"bash(git rev-parse:*)\",\n  \"bash(git config --get:*)\",\n  \"bash(gh issue list:*)\",\n  \"bash(gh issue view:*)\",\n  \"bash(gh pr list:*)\",\n  \"bash(gh pr view:*)\",\n  \"bash(gh repo view:*)\",\n]\n\n/** Common dev-workflow commands — build, test, typecheck. Excludes\n *  package management (`npm install`, `bun add`) which can drag arbitrary\n *  code in over the network. */\nconst DEV_BASIC = [\n  \"bash(bun test:*)\",\n  \"bash(bun test:node:*)\",\n  \"bash(bun test:bun:*)\",\n  \"bash(bun check:*)\",\n  \"bash(bun run:*)\",\n  \"bash(bun build:*)\",\n  \"bash(bunx tsc:*)\",\n  \"bash(bun tsc:*)\",\n  \"bash(bun x tsc:*)\",\n  \"bash(bunx vitest:*)\",\n  \"bash(bun x vitest:*)\",\n  \"bash(bunx oxlint:*)\",\n  \"bash(bun x oxlint:*)\",\n  \"bash(oxlint:*)\",\n]\n\n/** Hard denies — never auto-allowed, regardless of preset. */\nconst HARD_DENIES = [\"bash(sudo:*)\"]\n\n/** Broader rules unlocked by the permissive preset. Trades some safety\n *  for speed — appropriate for frontier models with strong instruction\n *  following. Includes ad-hoc bun/node evals and git mutations. */\nconst PERMISSIVE_EXTRAS = [\n  \"bash(bun -e:*)\",\n  \"bash(bun:*)\",\n  \"bash(node:*)\",\n  \"bash(node -e:*)\",\n  \"bash(make:*)\",\n  \"bash(mkdir:*)\",\n  \"bash(cp:*)\",\n  \"bash(mv:*)\",\n  \"bash(touch:*)\",\n  \"bash(ln:*)\",\n  \"bash(chmod:*)\",\n  \"bash(git add:*)\",\n  \"bash(git commit:*)\",\n  \"bash(git checkout:*)\",\n  \"bash(git restore:*)\",\n  \"bash(git stash:*)\",\n  \"bash(git fetch:*)\",\n  \"bash(git pull:*)\",\n  \"bash(curl:*)\",\n  \"bash(jq:*)\",\n  \"bash(perl -e:*)\",\n  \"bash(timeout:*)\",\n  \"bash(for:*)\",\n  \"bash(while:*)\",\n]\n\n// ── Presets ────────────────────────────────────────────────────────────────\n\n// oxlint-disable sort-keys\nexport const permissionPresets = {\n  strict: {\n    description: \"Ask for everything. No commands or file ops auto-allowed.\",\n    rules: {\n      deny: HARD_DENIES,\n      // Override the tool/file handlers' default allows.\n      ask: [\"tool(*)\", \"read(*)\", \"write(*)\"],\n    },\n  },\n  readonly: {\n    description:\n      \"Auto-allow read-only utilities, git read-only ops, and common build/test commands. \" +\n      \"Reads inside the workspace are allowed (sensitive paths denied); writes always ask.\",\n    rules: {\n      deny: HARD_DENIES,\n      allow: [...READONLY_TOOLS, ...READONLY_BASH, ...READONLY_GIT, ...DEV_BASIC],\n      ask: [\"tool(*)\", \"write(*)\"],\n    },\n  },\n  permissive: {\n    description:\n      \"Readonly preset plus broader dev commands (file moves, ad-hoc bun/node evals, \" +\n      \"git mutations, network fetches) and writes inside the workspace.\",\n    rules: {\n      deny: HARD_DENIES,\n      allow: [\n        \"tool(*)\",\n        ...READONLY_BASH,\n        ...READONLY_GIT,\n        ...DEV_BASIC,\n        ...PERMISSIVE_EXTRAS,\n        // Allow writes inside any workspace (sensitive paths still denied\n        // by the file handler before rule resolution).\n        \"write(*)\",\n      ],\n    },\n  },\n  yolo: {\n    description: \"Allow everything. No prompts. Use only when you trust the model and the task.\",\n    rules: {\n      allow: [\"bash\", \"read(*)\", \"write(*)\", \"tool(*)\"],\n    },\n  },\n} as const satisfies Record<PermissionPresetName, PermissionPreset>\n","import type { PermissionPresetName } from \"./presets.ts\"\nimport type { CheckResult, Rule, Verdict } from \"./types.ts\"\n\nimport { normPath } from \"@zaly/shared\"\nimport { handlerRegistry } from \"./handlers/registry.ts\"\nimport { permissionPresets } from \"./presets.ts\"\n\nexport type PermissionOptions = {\n  /** Session cwd — anchor for resolving relative paths and the default\n   *  spawn cwd for bash subprocesses. Pinned at construction; the agent\n   *  never mutates `process.cwd()`, and there's no `cd` tool. Defaults\n   *  to `process.cwd()`. */\n  cwd?: string\n  /** Named preset — supplies a baseline rule set. Explicit `rules` win\n   *  over preset rules on conflict (first-match-wins resolution; user\n   *  rules are listed before preset rules at construction). */\n  preset?: PermissionPresetName\n  rules?: Rule[] | Partial<Record<Verdict, string[] | undefined>>\n  /** Initial workspace list. `cwd` is auto-added so the user doesn't\n   *  have to repeat it. Pass paths absolute (or relative — they'll be\n   *  resolved against `cwd`). */\n  workspaces?: readonly string[]\n}\n\n/**\n * Owns per-session permission state and dispatches `validate(scope, input)`\n * to the registered handler for `scope`. Handlers receive rules\n * pre-filtered to their scope plus the shared workspace list.\n *\n * Mutators (`addWorkspace`, `addRule`, …) are how the prompt UI promotes\n * an `ask` verdict — once the user picks \"allow `Bash(git push:*)` for\n * this session\", the TUI calls `manager.addRule(...)` and subsequent\n * `validate()` calls pick it up via the filter.\n */\nexport class PermissionManager {\n  readonly cwd: string\n  #rules: Rule[] = []\n  #workspaces: string[]\n\n  constructor(opts?: PermissionOptions) {\n    this.cwd = normPath(opts?.cwd)\n    if (opts?.rules) {\n      const more = Array.isArray(opts.rules) ? opts.rules : parseRules(opts.rules)\n      this.#rules.push(...more)\n    }\n    if (opts?.preset) this.#rules.push(...parseRules(permissionPresets[opts.preset].rules))\n    this.#workspaces = (opts?.workspaces ?? []).map((p) => normPath(this.cwd, p))\n    // Auto-include cwd so users don't have to repeat it. Listed first so\n    // longest-prefix lookup in handlers stays predictable.\n    if (!this.#workspaces.includes(this.cwd)) this.#workspaces.unshift(this.cwd)\n  }\n\n  // ── Workspaces ──────────────────────────────────────────────────────\n\n  get workspaces(): readonly string[] {\n    return this.#workspaces\n  }\n\n  addWorkspace(path: string): void {\n    const abs = normPath(this.cwd, path)\n    if (!this.#workspaces.includes(abs)) this.#workspaces.push(abs)\n  }\n\n  removeWorkspace(path: string): void {\n    const abs = normPath(this.cwd, path)\n    const i = this.#workspaces.indexOf(abs)\n    if (i !== -1) this.#workspaces.splice(i, 1)\n  }\n\n  // ── Rules ───────────────────────────────────────────────────────────\n\n  get rules(): readonly Rule[] {\n    return this.#rules\n  }\n\n  /** Rules whose scope has no registered handler — surfaces config\n   *  errors (typos, unknown scopes, malformed pattern strings). The TUI\n   *  can render these as a startup warning. */\n  get invalidRules(): readonly Rule[] {\n    return this.#rules.filter((r) => !handlerRegistry.has(r.scope))\n  }\n\n  addRule(rule: Rule): void {\n    this.#rules.unshift(rule)\n  }\n\n  // ── Dispatch ────────────────────────────────────────────────────────\n\n  /** True only when a blanket allow has no earlier restrictive exceptions. */\n  allowsAll(scope: string): boolean {\n    for (const rule of this.#rules) {\n      if (rule.scope !== scope) continue\n      if (rule.policy !== \"allow\") return false\n      if (rule.pattern === \"*\") return true\n    }\n    return false\n  }\n\n  validate(scope: string, input: string): CheckResult {\n    if (!handlerRegistry.has(scope)) {\n      throw new Error(`no permission handler registered for scope \"${scope}\"`)\n    }\n    const handler = handlerRegistry.load(scope)\n    const rules = this.#rules.filter((r) => r.scope === scope)\n    return handler.validate(input, {\n      allowsAll: this.allowsAll.bind(this),\n      cwd: this.cwd,\n      rules,\n      scope,\n      validate: this.validate.bind(this),\n      workspaces: this.#workspaces,\n    })\n  }\n}\n\n/** Parse Claude-Code-style permission config (a verdict-keyed map of\n *  pattern strings) into structured `Rule<string>[]`.\n *\n *  Pattern shapes accepted:\n *    \"Bash(ls:*)\"   → { scope: \"bash\", pattern: \"ls:*\" }\n *    \"WebSearch\"    → { scope: \"websearch\", pattern: \"*\" }   // bare name = scope-wide\n *\n *  Scopes are normalized to lower-case so config can use either\n *  TitleCase (\"Bash\") or lowercase (\"bash\") interchangeably.\n *\n *  Malformed entries are pushed verbatim so `manager.invalidRules`\n *  surfaces them — typos in the scope (\"Bahs(...)\") are caught the same\n *  way (no handler registered → flagged invalid). */\nexport function parseRules(rules: Partial<Record<Verdict, string[] | undefined>>): Rule[] {\n  const ret: Rule[] = []\n  for (const policy of Object.keys(rules) as Verdict[]) {\n    const patterns = rules[policy]\n    if (!Array.isArray(patterns)) continue\n    for (const raw of patterns) {\n      const m = raw.match(/^(\\w+)(?:\\((.+)\\))?$/)\n      if (m) {\n        const [, scope, pat = \"*\"] = m\n        ret.push({ pattern: pat, policy, scope: scope.toLowerCase() })\n      } else {\n        // Truly malformed — preserve verbatim so invalidRules surfaces it.\n        ret.push({ pattern: raw, policy, scope: \"invalid\" })\n      }\n    }\n  }\n  return ret\n}\n"],"mappings":";;;;AA2BA,MAAM,iBAAiB;CACrB;CACA;CACA;CACA;CACA;AACF;;;;;AAMA,MAAM,gBAAgB;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAM,eAAe;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;AAKA,MAAM,YAAY;CAChB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAM,cAAc,CAAC,cAAc;;;;AAKnC,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAKA,MAAa,oBAAoB;CAC/B,QAAQ;EACN,aAAa;EACb,OAAO;GACL,MAAM;GAEN,KAAK;IAAC;IAAW;IAAW;GAAU;EACxC;CACF;CACA,UAAU;EACR,aACE;EAEF,OAAO;GACL,MAAM;GACN,OAAO;IAAC,GAAG;IAAgB,GAAG;IAAe,GAAG;IAAc,GAAG;GAAS;GAC1E,KAAK,CAAC,WAAW,UAAU;EAC7B;CACF;CACA,YAAY;EACV,aACE;EAEF,OAAO;GACL,MAAM;GACN,OAAO;IACL;IACA,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IAGH;GACF;EACF;CACF;CACA,MAAM;EACJ,aAAa;EACb,OAAO,EACL,OAAO;GAAC;GAAQ;GAAW;GAAY;EAAS,EAClD;CACF;AACF;;;;;;;;;;;;AChKA,IAAa,oBAAb,MAA+B;CAC7B;CACA,SAAiB,CAAC;CAClB;CAEA,YAAY,MAA0B;EACpC,KAAK,MAAM,SAAS,MAAM,GAAG;EAC7B,IAAI,MAAM,OAAO;GACf,MAAM,OAAO,MAAM,QAAQ,KAAK,KAAK,IAAI,KAAK,QAAQ,WAAW,KAAK,KAAK;GAC3E,KAAK,OAAO,KAAK,GAAG,IAAI;EAC1B;EACA,IAAI,MAAM,QAAQ,KAAK,OAAO,KAAK,GAAG,WAAW,kBAAkB,KAAK,OAAO,CAAC,KAAK,CAAC;EACtF,KAAK,eAAe,MAAM,cAAc,CAAC,EAAA,CAAG,KAAK,MAAM,SAAS,KAAK,KAAK,CAAC,CAAC;EAG5E,IAAI,CAAC,KAAK,YAAY,SAAS,KAAK,GAAG,GAAG,KAAK,YAAY,QAAQ,KAAK,GAAG;CAC7E;CAIA,IAAI,aAAgC;EAClC,OAAO,KAAK;CACd;CAEA,aAAa,MAAoB;EAC/B,MAAM,MAAM,SAAS,KAAK,KAAK,IAAI;EACnC,IAAI,CAAC,KAAK,YAAY,SAAS,GAAG,GAAG,KAAK,YAAY,KAAK,GAAG;CAChE;CAEA,gBAAgB,MAAoB;EAClC,MAAM,MAAM,SAAS,KAAK,KAAK,IAAI;EACnC,MAAM,IAAI,KAAK,YAAY,QAAQ,GAAG;EACtC,IAAI,MAAM,IAAI,KAAK,YAAY,OAAO,GAAG,CAAC;CAC5C;CAIA,IAAI,QAAyB;EAC3B,OAAO,KAAK;CACd;;;;CAKA,IAAI,eAAgC;EAClC,OAAO,KAAK,OAAO,QAAQ,MAAM,CAAC,gBAAgB,IAAI,EAAE,KAAK,CAAC;CAChE;CAEA,QAAQ,MAAkB;EACxB,KAAK,OAAO,QAAQ,IAAI;CAC1B;;CAKA,UAAU,OAAwB;EAChC,KAAK,MAAM,QAAQ,KAAK,QAAQ;GAC9B,IAAI,KAAK,UAAU,OAAO;GAC1B,IAAI,KAAK,WAAW,SAAS,OAAO;GACpC,IAAI,KAAK,YAAY,KAAK,OAAO;EACnC;EACA,OAAO;CACT;CAEA,SAAS,OAAe,OAA4B;EAClD,IAAI,CAAC,gBAAgB,IAAI,KAAK,GAC5B,MAAM,IAAI,MAAM,+CAA+C,MAAM,EAAE;EAEzE,MAAM,UAAU,gBAAgB,KAAK,KAAK;EAC1C,MAAM,QAAQ,KAAK,OAAO,QAAQ,MAAM,EAAE,UAAU,KAAK;EACzD,OAAO,QAAQ,SAAS,OAAO;GAC7B,WAAW,KAAK,UAAU,KAAK,IAAI;GACnC,KAAK,KAAK;GACV;GACA;GACA,UAAU,KAAK,SAAS,KAAK,IAAI;GACjC,YAAY,KAAK;EACnB,CAAC;CACH;AACF;;;;;;;;;;;;;;AAeA,SAAgB,WAAW,OAA+D;CACxF,MAAM,MAAc,CAAC;CACrB,KAAK,MAAM,UAAU,OAAO,KAAK,KAAK,GAAgB;EACpD,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG;EAC9B,KAAK,MAAM,OAAO,UAAU;GAC1B,MAAM,IAAI,IAAI,MAAM,sBAAsB;GAC1C,IAAI,GAAG;IACL,MAAM,GAAG,OAAO,MAAM,OAAO;IAC7B,IAAI,KAAK;KAAE,SAAS;KAAK;KAAQ,OAAO,MAAM,YAAY;IAAE,CAAC;GAC/D,OAEE,IAAI,KAAK;IAAE,SAAS;IAAK;IAAQ,OAAO;GAAU,CAAC;EAEvD;CACF;CACA,OAAO;AACT"}

package/dist/{markdown-Bv4J8cg3.mjs → markdown-8ICz5aFw.mjs}

@@ -1,7 +1,7 @@
 import { findUp, normPath, safeReadFile, safeStat } from "@zaly/shared";
 import { join } from "pathe";
 import { zalyPaths } from "@zaly/shared/paths";
-//#region src/prompt/markdown.ts
+// src/prompt/markdown.ts
 async function markdownPrompt(ctx, opts) {
 	const resources = [];
 	const project = zalyPaths.project(ctx.cwd);
@@ -47,7 +47,6 @@ async function memoryMdPrompt(ctx) {
 		project: [".agents/MEMORY.md"]
 	});
 }
-//#endregion
 export { agentsMdPrompt, memoryMdPrompt };
 
-//# sourceMappingURL=markdown-Bv4J8cg3.mjs.map
+//# sourceMappingURL=markdown-8ICz5aFw.mjs.map

package/dist/{markdown-Bv4J8cg3.mjs.map → markdown-8ICz5aFw.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"markdown-Bv4J8cg3.mjs","names":[],"sources":["../src/prompt/markdown.ts"],"sourcesContent":["import type { PromptCtx } from \"./registry.ts\"\n\nimport { findUp, normPath, safeReadFile, safeStat } from \"@zaly/shared\"\nimport { zalyPaths } from \"@zaly/shared/paths\"\nimport { join } from \"pathe\"\n\nexport type MarkdownPromptOptions = {\n  name: string\n  project?: string[]\n  dotUser?: string[] // dotZaly or dotAgents\n}\n\nexport function createMarkdownPrompt(opts: MarkdownPromptOptions) {\n  return (ctx: PromptCtx) => markdownPrompt(ctx, opts)\n}\n\nexport async function markdownPrompt(ctx: PromptCtx, opts: MarkdownPromptOptions): Promise<string> {\n  const resources: string[] = []\n  const project = zalyPaths.project(ctx.cwd)\n\n  if (opts.dotUser) {\n    const checks = opts.dotUser.flatMap((name) => [\n      join(zalyPaths.config, name),\n      `~/.agents/${name}`,\n    ])\n    for (const check of checks) {\n      const file = normPath(check)\n      if (safeStat(file)?.isFile()) {\n        resources.push(file)\n        break\n      }\n    }\n  }\n\n  if (opts.project) {\n    const file = findUp(ctx.cwd, opts.project, { stop: project.stop, type: \"file\" })\n    if (file) resources.push(file)\n  }\n\n  if (resources.length === 0) return \"\"\n\n  const contents = await Promise.all(resources.map((r) => safeReadFile(r)))\n  const ret: string[] = []\n  for (let i = 0; i < resources.length; i++) {\n    const content = contents[i]\n    if (!content) continue\n    const r = resources[i]\n    ret.push(`## ${opts.name} (${r})\\n\\n${content.trim()}`)\n  }\n  return ret.join(\"\\n\\n\")\n}\n\nexport async function agentsMdPrompt(ctx: PromptCtx) {\n  return markdownPrompt(ctx, {\n    dotUser: [\"AGENTS.md\"],\n    name: \"AGENTS.md\",\n    project: [\"AGENTS.md\", \"CLAUDE.md\"],\n  })\n}\n\nexport async function memoryMdPrompt(ctx: PromptCtx) {\n  return markdownPrompt(ctx, {\n    dotUser: [\"MEMORY.md\"],\n    name: \"MEMORY.md\",\n    project: [\".agents/MEMORY.md\"],\n  })\n}\n"],"mappings":";;;;AAgBA,eAAsB,eAAe,KAAgB,MAA8C;CACjG,MAAM,YAAsB,CAAC;CAC7B,MAAM,UAAU,UAAU,QAAQ,IAAI,GAAG;CAEzC,IAAI,KAAK,SAAS;EAChB,MAAM,SAAS,KAAK,QAAQ,SAAS,SAAS,CAC5C,KAAK,UAAU,QAAQ,IAAI,GAC3B,aAAa,MACf,CAAC;EACD,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,OAAO,SAAS,KAAK;GAC3B,IAAI,SAAS,IAAI,CAAC,EAAE,OAAO,GAAG;IAC5B,UAAU,KAAK,IAAI;IACnB;GACF;EACF;CACF;CAEA,IAAI,KAAK,SAAS;EAChB,MAAM,OAAO,OAAO,IAAI,KAAK,KAAK,SAAS;GAAE,MAAM,QAAQ;GAAM,MAAM;EAAO,CAAC;EAC/E,IAAI,MAAM,UAAU,KAAK,IAAI;CAC/B;CAEA,IAAI,UAAU,WAAW,GAAG,OAAO;CAEnC,MAAM,WAAW,MAAM,QAAQ,IAAI,UAAU,KAAK,MAAM,aAAa,CAAC,CAAC,CAAC;CACxE,MAAM,MAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,UAAU,SAAS;EACzB,IAAI,CAAC,SAAS;EACd,MAAM,IAAI,UAAU;EACpB,IAAI,KAAK,MAAM,KAAK,KAAK,IAAI,EAAE,OAAO,QAAQ,KAAK,GAAG;CACxD;CACA,OAAO,IAAI,KAAK,MAAM;AACxB;AAEA,eAAsB,eAAe,KAAgB;CACnD,OAAO,eAAe,KAAK;EACzB,SAAS,CAAC,WAAW;EACrB,MAAM;EACN,SAAS,CAAC,aAAa,WAAW;CACpC,CAAC;AACH;AAEA,eAAsB,eAAe,KAAgB;CACnD,OAAO,eAAe,KAAK;EACzB,SAAS,CAAC,WAAW;EACrB,MAAM;EACN,SAAS,CAAC,mBAAmB;CAC/B,CAAC;AACH"}
+{"version":3,"file":"markdown-8ICz5aFw.mjs","names":[],"sources":["../src/prompt/markdown.ts"],"sourcesContent":["import type { PromptCtx } from \"./registry.ts\"\n\nimport { findUp, normPath, safeReadFile, safeStat } from \"@zaly/shared\"\nimport { zalyPaths } from \"@zaly/shared/paths\"\nimport { join } from \"pathe\"\n\nexport type MarkdownPromptOptions = {\n  name: string\n  project?: string[]\n  dotUser?: string[] // dotZaly or dotAgents\n}\n\nexport function createMarkdownPrompt(opts: MarkdownPromptOptions) {\n  return (ctx: PromptCtx) => markdownPrompt(ctx, opts)\n}\n\nexport async function markdownPrompt(ctx: PromptCtx, opts: MarkdownPromptOptions): Promise<string> {\n  const resources: string[] = []\n  const project = zalyPaths.project(ctx.cwd)\n\n  if (opts.dotUser) {\n    const checks = opts.dotUser.flatMap((name) => [\n      join(zalyPaths.config, name),\n      `~/.agents/${name}`,\n    ])\n    for (const check of checks) {\n      const file = normPath(check)\n      if (safeStat(file)?.isFile()) {\n        resources.push(file)\n        break\n      }\n    }\n  }\n\n  if (opts.project) {\n    const file = findUp(ctx.cwd, opts.project, { stop: project.stop, type: \"file\" })\n    if (file) resources.push(file)\n  }\n\n  if (resources.length === 0) return \"\"\n\n  const contents = await Promise.all(resources.map((r) => safeReadFile(r)))\n  const ret: string[] = []\n  for (let i = 0; i < resources.length; i++) {\n    const content = contents[i]\n    if (!content) continue\n    const r = resources[i]\n    ret.push(`## ${opts.name} (${r})\\n\\n${content.trim()}`)\n  }\n  return ret.join(\"\\n\\n\")\n}\n\nexport async function agentsMdPrompt(ctx: PromptCtx) {\n  return markdownPrompt(ctx, {\n    dotUser: [\"AGENTS.md\"],\n    name: \"AGENTS.md\",\n    project: [\"AGENTS.md\", \"CLAUDE.md\"],\n  })\n}\n\nexport async function memoryMdPrompt(ctx: PromptCtx) {\n  return markdownPrompt(ctx, {\n    dotUser: [\"MEMORY.md\"],\n    name: \"MEMORY.md\",\n    project: [\".agents/MEMORY.md\"],\n  })\n}\n"],"mappings":";;;;AAgBA,eAAsB,eAAe,KAAgB,MAA8C;CACjG,MAAM,YAAsB,CAAC;CAC7B,MAAM,UAAU,UAAU,QAAQ,IAAI,GAAG;CAEzC,IAAI,KAAK,SAAS;EAChB,MAAM,SAAS,KAAK,QAAQ,SAAS,SAAS,CAC5C,KAAK,UAAU,QAAQ,IAAI,GAC3B,aAAa,MACf,CAAC;EACD,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,OAAO,SAAS,KAAK;GAC3B,IAAI,SAAS,IAAI,CAAC,EAAE,OAAO,GAAG;IAC5B,UAAU,KAAK,IAAI;IACnB;GACF;EACF;CACF;CAEA,IAAI,KAAK,SAAS;EAChB,MAAM,OAAO,OAAO,IAAI,KAAK,KAAK,SAAS;GAAE,MAAM,QAAQ;GAAM,MAAM;EAAO,CAAC;EAC/E,IAAI,MAAM,UAAU,KAAK,IAAI;CAC/B;CAEA,IAAI,UAAU,WAAW,GAAG,OAAO;CAEnC,MAAM,WAAW,MAAM,QAAQ,IAAI,UAAU,KAAK,MAAM,aAAa,CAAC,CAAC,CAAC;CACxE,MAAM,MAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,UAAU,SAAS;EACzB,IAAI,CAAC,SAAS;EACd,MAAM,IAAI,UAAU;EACpB,IAAI,KAAK,MAAM,KAAK,KAAK,IAAI,EAAE,OAAO,QAAQ,KAAK,GAAG;CACxD;CACA,OAAO,IAAI,KAAK,MAAM;AACxB;AAEA,eAAsB,eAAe,KAAgB;CACnD,OAAO,eAAe,KAAK;EACzB,SAAS,CAAC,WAAW;EACrB,MAAM;EACN,SAAS,CAAC,aAAa,WAAW;CACpC,CAAC;AACH;AAEA,eAAsB,eAAe,KAAgB;CACnD,OAAO,eAAe,KAAK;EACzB,SAAS,CAAC,WAAW;EACrB,MAAM;EACN,SAAS,CAAC,mBAAmB;CAC/B,CAAC;AACH"}

package/dist/{masker-ZoP381jN.mjs → masker-DEgR_ntk.mjs}

@@ -1,7 +1,7 @@
-import { r as tokenStats, t as estimatePart } from "./src-C852Q6gy.mjs";
+import { r as tokenStats, t as estimatePart } from "./src-C04Qk9KE.mjs";
 import { safeStringify, toValue } from "@zaly/shared";
 import { isAttachment, safeParseToolParams } from "@zaly/ai";
-//#region src/context/scoring.ts
+// src/context/scoring.ts
 const DEFAULT_HALF_LIFE = 40;
 const DEFAULT_WEIGHT = 1;
 const DEFAULT_GAMMA = .5;
@@ -226,8 +226,7 @@ var ContextScoring = class {
 		return groups;
 	}
 };
-//#endregion
-//#region src/masker.ts
+// src/masker.ts
 const defaults = {
 	delta: .25,
 	enabled: true,
@@ -390,7 +389,6 @@ var Masker = class {
 		});
 	}
 };
-//#endregion
 export { Masker };
 
-//# sourceMappingURL=masker-ZoP381jN.mjs.map
+//# sourceMappingURL=masker-DEgR_ntk.mjs.map