zidane 6.2.11 → 6.2.13

package/dist/read-state-Dq_TXUX1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-state-Dq_TXUX1.js","names":[],"sources":["../src/aliasing.ts","../src/tools/read-state.ts"],"sourcesContent":["/**\n * Tool-name aliasing helpers.\n *\n * Aliasing is applied at the LLM boundary only: the provider sees the aliased\n * name, but hooks and persisted turns use canonical names. See `AgentOptions.toolAliases`.\n */\n\nimport type { SessionContentBlock, SessionMessage } from './types'\nimport { fnv1aBase36 } from './hash'\n\n/** Forward + reverse lookup between canonical and aliased tool names */\nexport interface AliasMaps {\n  /** canonical → alias (only entries where alias !== canonical) */\n  aliasByCanonical: Map<string, string>\n  /** alias → canonical (only entries where alias !== canonical) */\n  canonicalByAlias: Map<string, string>\n}\n\n/**\n * Build alias lookup maps from a `toolAliases` record.\n *\n * Validates:\n * - No two canonical names map to the same alias (collision).\n * - No alias collides with another canonical tool name (would shadow).\n *\n * Silently ignores alias entries whose canonical name isn't in `canonicalNames` —\n * preset/agent authors can declare aliases for tools that may be added later via MCP.\n *\n * @param aliases - The `toolAliases` map from the agent options.\n * @param canonicalNames - All tool canonical names currently in scope (agent + MCP).\n */\nexport function buildAliasMaps(\n  aliases: Record<string, string> | undefined,\n  canonicalNames: Iterable<string>,\n): AliasMaps {\n  const aliasByCanonical = new Map<string, string>()\n  const canonicalByAlias = new Map<string, string>()\n\n  if (!aliases) {\n    return { aliasByCanonical, canonicalByAlias }\n  }\n\n  const canonicalSet = new Set(canonicalNames)\n\n  // A canonical name is \"genuinely remapped\" when it has an alias entry that is\n  // both non-empty and different from itself. Identity aliases or missing keys\n  // mean the tool still answers to its canonical name on the wire.\n  function isRemappedAway(canonical: string): boolean {\n    const mapped = aliases![canonical]\n    return typeof mapped === 'string' && mapped.length > 0 && mapped !== canonical\n  }\n\n  for (const [canonical, alias] of Object.entries(aliases)) {\n    if (typeof alias !== 'string' || alias.length === 0)\n      throw new Error(`Tool alias for \"${canonical}\" must be a non-empty string`)\n\n    if (alias === canonical)\n      continue\n\n    if (!canonicalSet.has(canonical))\n      continue\n\n    // When the alias matches an existing canonical tool name, only allow it if\n    // that other canonical is itself being remapped away (i.e. a name swap).\n    // Otherwise the wire name would shadow a real tool.\n    if (canonicalSet.has(alias) && !isRemappedAway(alias)) {\n      throw new Error(`Tool alias \"${canonical}\" -> \"${alias}\" collides with an existing canonical tool name`)\n    }\n\n    const existingCanonical = canonicalByAlias.get(alias)\n    if (existingCanonical && existingCanonical !== canonical) {\n      throw new Error(\n        `Tool alias collision: both \"${existingCanonical}\" and \"${canonical}\" map to alias \"${alias}\"`,\n      )\n    }\n\n    aliasByCanonical.set(canonical, alias)\n    canonicalByAlias.set(alias, canonical)\n  }\n\n  return { aliasByCanonical, canonicalByAlias }\n}\n\n/** Return the alias for a canonical name, falling back to the canonical name itself. */\nexport function toWireName(canonical: string, maps: AliasMaps): string {\n  return maps.aliasByCanonical.get(canonical) ?? canonical\n}\n\n/** Return the canonical name for a wire name, falling back to the wire name itself. */\nexport function toCanonicalName(wire: string, maps: AliasMaps): string {\n  return maps.canonicalByAlias.get(wire) ?? wire\n}\n\n/**\n * Tool names must match `^[a-zA-Z0-9_-]{1,N}$`. The charset is universal; the\n * length cap is taken as the STRICTEST across providers (OpenAI/-compat: 64;\n * Anthropic allows 128) so a sanitized name is valid on EVERY provider — and so\n * a mid-session model switch can never make the provider-level drop guard\n * (`sanitizeToolSpecs`) discard a tool we could have kept.\n *\n * MCP tool names are minted verbatim as `mcp_<server>_<tool>` (see\n * `connectMcpServers`), so a server configured as `SSH Ipseity` yields\n * `mcp_SSH Ipseity_exec` — the space (and `.`/`:`/`/`, unicode, or a >64-char\n * join) 400s the request the instant that tool lands in the `tools` array:\n * `tools.N.custom.name: String should match pattern ...`.\n */\nconst WIRE_NAME_MAX = 64\nconst WIRE_NAME_OK = /^[\\w-]{1,64}$/\nconst WIRE_NAME_BAD_CHAR = /[^\\w-]/g\n\n/**\n * Build OUTBOUND wire aliases that coerce any tool name violating the provider\n * name constraint into a valid one. Only offenders get an entry; clean setups\n * return `undefined` (no alias map churn, prompt cache untouched).\n *\n * Returned as a `Record` so it merges into `effectiveToolAliases` upstream of\n * BOTH wire-name computations — the `tool_search` catalog and the `tools` array\n * — keeping them in lockstep. Canonical names (dispatch, hooks, persisted\n * turns) never change; only the bytes the model sees do.\n *\n * Scoped to MCP names (the only third-party-controlled, thus only realistically\n * invalid, source). The hash suffix keeps distinct originals distinct even when\n * they collapse to the same replacement; `taken` guards the residual collision.\n */\nexport function buildSanitizedWireAliases(\n  names: Iterable<string>,\n  existing: Record<string, string> | undefined,\n): Record<string, string> | undefined {\n  const wireOf = (name: string): string => {\n    const alias = existing?.[name]\n    return typeof alias === 'string' && alias.length > 0 ? alias : name\n  }\n\n  // Already-valid wire names stay occupied so a freshly minted one can never\n  // shadow another tool.\n  const taken = new Set<string>()\n  const offenders: string[] = []\n  for (const name of names) {\n    const wire = wireOf(name)\n    if (WIRE_NAME_OK.test(wire))\n      taken.add(wire)\n    else\n      offenders.push(name)\n  }\n  if (offenders.length === 0)\n    return undefined\n\n  const out: Record<string, string> = {}\n  for (const name of offenders) {\n    const sanitized = sanitizeWireName(wireOf(name), taken)\n    out[name] = sanitized\n    taken.add(sanitized)\n  }\n  return out\n}\n\nfunction sanitizeWireName(name: string, taken: ReadonlySet<string>): string {\n  let base = name.replace(WIRE_NAME_BAD_CHAR, '_')\n  if (base.length === 0)\n    base = 'tool'\n  // Hash the ORIGINAL so `a.b` vs `a/b` (both → `a_b`) and truncated long\n  // names stay distinct and deterministic across runs.\n  const hash = fnv1aBase36(name)\n  const withSuffix = (suffix: string): string =>\n    `${base.slice(0, Math.max(1, WIRE_NAME_MAX - suffix.length))}${suffix}`\n  let candidate = withSuffix(`_${hash}`)\n  for (let n = 1; taken.has(candidate); n++)\n    candidate = withSuffix(`_${hash}_${n}`)\n  return candidate\n}\n\n/**\n * Augment {@link AliasMaps} with INBOUND-ONLY aliases for the Claude Code\n * `mcp__server__tool` double-underscore naming convention. For every MCP\n * tool registered with the canonical `mcp_<server>_<tool>` form, add a\n * `canonicalByAlias` entry mapping the double-underscore variant to the\n * same canonical name. Outbound (`aliasByCanonical`) is left untouched —\n * the model still sees the single-underscore canonical on the wire, so\n * the tools-array byte count (and the provider prompt cache) is\n * unaffected.\n *\n * Why: SDK consumers and tool descriptions across the ecosystem\n * inconsistently reference one form or the other (Anthropic's docs use\n * double, zidane uses single). A Claude-Code-trained model emitting\n * `mcp__acme__apply_migration` against a server zidane registered as\n * `mcp_acme_apply_migration` would otherwise trip the `tool:unknown`\n * path and waste a turn on the correction.\n *\n * Idempotent: a canonical that already has a double-underscore alias\n * mapped (host's explicit `toolAliases` got there first) is left alone.\n * Tools whose canonical name DOESN'T start with `mcp_` (or that contain\n * no inner separator) are skipped — we don't want to invent aliases for\n * non-MCP tools or malformed names.\n *\n * Mutates `maps.canonicalByAlias` in place and returns the same object\n * for chaining.\n */\nexport function augmentMcpDoubleUnderscoreAliases(\n  maps: AliasMaps,\n  canonicalNames: Iterable<string>,\n): AliasMaps {\n  for (const canonical of canonicalNames) {\n    if (!canonical.startsWith('mcp_'))\n      continue\n    // Strip leading `mcp_`, then require AT LEAST one more `_` so the\n    // remainder is `<server>_<tool>` (a degenerate `mcp_foo` with no\n    // tool segment has nothing meaningful to double-underscore).\n    const tail = canonical.slice(4)\n    const sep = tail.indexOf('_')\n    if (sep <= 0 || sep >= tail.length - 1)\n      continue\n    const server = tail.slice(0, sep)\n    const tool = tail.slice(sep + 1)\n    const doubleForm = `mcp__${server}__${tool}`\n    if (doubleForm === canonical)\n      continue // shouldn't happen but defensive\n    if (maps.canonicalByAlias.has(doubleForm))\n      continue // host alias or earlier pass got there first\n    maps.canonicalByAlias.set(doubleForm, canonical)\n  }\n  return maps\n}\n\n/**\n * Rewrite `tool_call` block names in a content array from canonical → wire for outbound\n * messages sent to the provider. Mutation is non-destructive (returns a new array).\n */\nexport function rewriteContentToWire(\n  content: SessionContentBlock[],\n  maps: AliasMaps,\n): SessionContentBlock[] {\n  if (maps.aliasByCanonical.size === 0)\n    return content\n  return content.map((block) => {\n    if (block.type !== 'tool_call')\n      return block\n    const wire = maps.aliasByCanonical.get(block.name)\n    if (!wire || wire === block.name)\n      return block\n    return { ...block, name: wire }\n  })\n}\n\n/**\n * Rewrite `tool_call` block names in a content array from wire → canonical for inbound\n * messages received from the provider. Non-destructive.\n */\nexport function rewriteContentToCanonical(\n  content: SessionContentBlock[],\n  maps: AliasMaps,\n): SessionContentBlock[] {\n  if (maps.canonicalByAlias.size === 0)\n    return content\n  return content.map((block) => {\n    if (block.type !== 'tool_call')\n      return block\n    const canonical = maps.canonicalByAlias.get(block.name)\n    if (!canonical || canonical === block.name)\n      return block\n    return { ...block, name: canonical }\n  })\n}\n\n/**\n * Rewrite every `SessionMessage.content` in an array from canonical → wire.\n * Returns a new array of new message objects — input messages are not mutated.\n * When the alias map is empty, returns the input by reference (no allocation).\n */\nexport function rewriteMessagesToWire(\n  messages: SessionMessage[],\n  maps: AliasMaps,\n): SessionMessage[] {\n  if (maps.aliasByCanonical.size === 0)\n    return messages\n  return messages.map(msg => ({ ...msg, content: rewriteContentToWire(msg.content, maps) }))\n}\n","/**\n * Per-session file read tracking + tool-dedup state.\n *\n * Two concerns, one module so they can share the `WeakMap<Session, …>`\n * pattern (state lives as long as the session does, GC'd alongside it —\n * no public schema changes, no persistence). Each section below stands\n * on its own; the two maps don't share keys or behavior.\n *\n * ## Read-state\n *\n * Shared between `read_file` (dedup re-reads) and `edit` / `multi_edit`\n * (`requireReadBeforeEdit` guard). The state map records, per canonical\n * absolute file path:\n *\n * - `contentHash` — 64-bit FNV-style hash of the bytes the model last saw. Identical\n *   re-reads return a stub; edits compare against this hash to detect\n *   stale content.\n * - `(offset, limit, maxBytes, lineNumbers)` — slice / shape of the last\n *   read, so a wider re-read invalidates the prior stub and a different\n *   `lineNumbers` mode doesn't dedup against the previous shape.\n * - `mtimeMs` — wall-clock at last read, diagnostic only.\n *\n * Resolution is split between two helpers so consumers don't have to\n * juggle the `Session` vs. explicit-map cases themselves:\n *\n * - {@link getReadState} returns the map keyed by `Session` instance.\n * - {@link resolveReadStateMap} prefers an explicit `ctx.readState`\n *   (the path `spawn`'s `shareReadState` uses to forward the parent's\n *   map into a sessionless child) and falls back to the session-keyed\n *   lookup. Tools should call this helper, not `getReadState` directly.\n *\n * ## Tool-dedup\n *\n * Backs `behavior.dedupTools`. Records the most recent `(hash, result)`\n * per canonical tool name within a session. Same WeakMap pattern; no\n * cross-talk with the read-state map.\n */\n\nimport type { AliasMaps } from '../aliasing'\nimport type { Session } from '../session'\nimport type { SessionTurn, ToolResultContent } from '../types'\nimport { resolve } from 'node:path'\nimport { toCanonicalName } from '../aliasing'\nimport { toolResultToText } from '../types'\nimport { resolveOldString, styleReplacementForVia } from './edit-utils'\n\n// ---------------------------------------------------------------------------\n// Read-state\n// ---------------------------------------------------------------------------\n\nexport interface ReadStateEntry {\n  contentHash: string\n  /** Slice parameters for the last read. */\n  offset: number\n  limit: number\n  maxBytes: number\n  /**\n   * Whether the prior read emitted line-number prefixes. Tracked so a\n   * read with `lineNumbers: true` doesn't dedup against one with\n   * `lineNumbers: false` (or vice versa) — the dedup stub would mislead\n   * the model about the prior output's shape.\n   */\n  lineNumbers?: boolean\n  /** Wall-clock at last read — diagnostic only, not used for invalidation. */\n  mtimeMs: number\n  /**\n   * Set when stale-read elision removed this path's read output from the\n   * on-wire history. The entry stays registered — `requireReadBeforeEdit`\n   * must keep passing (the contentHash still guards against disk drift;\n   * un-registering here is what degraded models into shell-edit one-liner\n   * workarounds) — but `read_file`'s dedup must MISS on the next identical\n   * re-read: the \"unchanged since the previous read\" stub would point at\n   * content the model can no longer see. Cleared by the next fresh read\n   * (`rememberRead` writes a flag-less entry).\n   */\n  elided?: true\n}\n\nexport type ReadStateMap = Map<string, ReadStateEntry>\n\nconst STATE = new WeakMap<Session, ReadStateMap>()\n\n/**\n * Get or lazily create the per-session read-state map. Returns `undefined`\n * when no session is provided.\n *\n * Most tool callers should prefer {@link resolveReadStateMap}, which\n * additionally honors an explicit `ctx.readState` (the path\n * `spawn`'s `shareReadState: true` uses to forward the parent's map\n * into a sessionless child). Use this helper directly only when the\n * Session-keyed map is exactly what you want and you don't need to\n * accept an override.\n */\nexport function getReadState(session: Session | undefined): ReadStateMap | undefined {\n  if (!session)\n    return undefined\n  let map = STATE.get(session)\n  if (!map) {\n    map = new Map()\n    STATE.set(session, map)\n  }\n  return map\n}\n\n/**\n * Resolve the active read-state map from a tool context. An explicit\n * `ctx.readState` wins (used by `spawn`'s `shareReadState` opt-in to\n * forward the parent's map into a sessionless child); otherwise the\n * usual `Session`-keyed lookup applies.\n *\n * Tools should call this helper instead of `getReadState(ctx.session)`\n * directly so the `shareReadState` plumbing is honored uniformly.\n */\nexport function resolveReadStateMap(ctx: {\n  session?: Session\n  readState?: ReadStateMap\n}): ReadStateMap | undefined {\n  return ctx.readState ?? getReadState(ctx.session)\n}\n\n/**\n * Mark a read-state entry as elided from the on-wire history WITHOUT\n * un-registering it.\n *\n * Used by the loop's `elideStaleReads` pass. The entry must survive —\n * deleting it made the `requireReadBeforeEdit` gate reject the very next\n * edit on a file the model had demonstrably read and just edited (the\n * gate's failure mode then defeats the gate: models degrade to raw shell\n * edits that bypass the guard entirely). The `elided` flag instead\n * defeats only the dedup stub: the next identical re-read returns the\n * full body again, and `rememberRead` clears the flag.\n *\n * No-op when the path has no entry in the resolved map(s).\n */\nexport function markReadStateElided(ctx: {\n  session?: Session\n  readState?: ReadStateMap\n}, cwd: string, path: string): void {\n  const key = readStateKey(cwd, path)\n  for (const map of [ctx.readState, ctx.session ? STATE.get(ctx.session) : undefined]) {\n    const entry = map?.get(key)\n    if (entry && entry.elided !== true)\n      map!.set(key, { ...entry, elided: true })\n  }\n}\n\n/**\n * Canonical read-state key for a `(cwd, path)` pair.\n *\n * `ctx.execution.readFile(handle, path)` resolves the model-provided\n * path against `handle.cwd` before touching disk — so `src/App.tsx`,\n * `./src/App.tsx`, and `/abs/cwd/src/App.tsx` all read the **same**\n * bytes. The read-state map MUST mirror that resolution: without it,\n * a model that reads `src/App.tsx` and then edits `./src/App.tsx`\n * trips the `requireReadBeforeEdit` gate for a file it demonstrably\n * already saw (the gate's \"has not been read in this session\" message\n * fires on a stale key).\n *\n * `node:path`'s `resolve(cwd, path)` short-circuits when `path` is\n * already absolute, so absolute and relative shapes converge on the\n * same canonical form. We don't `realpath()` symlinks — the file IS\n * the path the model addressed, not the realpath behind it; the host's\n * execution context decides how to dereference.\n */\nexport function readStateKey(cwd: string, path: string): string {\n  return resolve(cwd, path)\n}\n\n/**\n * 64-bit content hash: two independent 32-bit FNV-1a-style lanes (different\n * offset bases + multipliers) concatenated as 16 hex chars. Fast,\n * non-cryptographic — but wide enough that the `requireReadBeforeEdit`\n * drift gate, which silently corrupts a file on a false \"unchanged\"\n * verdict, isn't betting on a 32-bit birthday bound (~1 in 4 billion per\n * pair; uncomfortably reachable over many files × many sessions). Entries\n * live only in per-session in-memory maps, so widening needs no\n * stored-format migration. Still cheaper than allocating a Buffer and\n * pulling in `crypto`.\n */\nexport function hashContent(text: string): string {\n  let h1 = 0x811C9DC5 // FNV-1a offset basis\n  let h2 = 0x7EE36237 // arbitrary distinct basis for the second lane\n  for (let i = 0; i < text.length; i++) {\n    const c = text.charCodeAt(i)\n    h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0 // FNV prime 16777619\n    h2 = Math.imul(h2 ^ c, 0x85EBCA6B) >>> 0 // murmur3 fmix multiplier\n  }\n  return h1.toString(16).padStart(8, '0') + h2.toString(16).padStart(8, '0')\n}\n\nexport interface HydrateReadStateOptions {\n  /** Canonical read-file tool name. Defaults to `read_file`. */\n  readFileToolName?: string\n  /** Canonical write-file tool name. Defaults to `write_file`. */\n  writeFileToolName?: string\n  /** Canonical edit tool name. Defaults to `edit`. */\n  editToolName?: string\n  /** Canonical multi-edit tool name. Defaults to `multi_edit`. */\n  multiEditToolName?: string\n  /** Agent-level default for omitted `read_file.lineNumbers`. */\n  defaultLineNumbers?: boolean\n  /**\n   * Optional replay-only fallback for read_file results whose transcript output\n   * is partial/truncated. Receives the model-provided path and should return\n   * the current full text bytes to hash exactly like live read_file.\n   */\n  readFileForHash?: (path: string) => Promise<string | null | undefined>\n  /**\n   * Tool-name aliases in effect for the transcript being replayed. zidane's\n   * loop canonicalizes tool-call names before persisting, so durable turns\n   * normally already carry canonical names — but a transcript captured from a\n   * host that persists WIRE names (the aliased form the model saw, e.g.\n   * `Read` / `Edit`), or one imported from another stack, would otherwise be\n   * unrecognized and hydrate nothing. When provided, each tool-call name is\n   * resolved to canonical (`toCanonicalName`) before matching, so both the\n   * canonical and the aliased shape are honored. No-op for already-canonical\n   * names.\n   */\n  aliasMaps?: AliasMaps\n}\n\ntype NormalizedHydrateReadStateOptions = Required<Omit<HydrateReadStateOptions, 'readFileForHash' | 'aliasMaps'>> & {\n  readFileForHash?: HydrateReadStateOptions['readFileForHash']\n  aliasMaps?: AliasMaps\n}\n\ninterface PendingToolCall {\n  name: string\n  input: Record<string, unknown>\n}\n\ninterface KnownFile {\n  content: string\n  entry: ReadStateEntry\n}\n\nconst READ_FILE_DEFAULT_OFFSET = 1\nconst READ_FILE_DEFAULT_LIMIT = 2000\nconst READ_FILE_DEFAULT_MAX_BYTES = 262_144\nconst READ_FILE_FOOTER_RE = /\\n\\n…(?:read lines|truncated)/\nconst READ_FILE_LINE_RE = /^\\d{1,9}\\t(.*)$/\n\n/**\n * Rebuild the per-session read-state map from durable session turns.\n *\n * Durable replay runtimes may return recorded tool results without re-running\n * the tool body, so in-memory side effects like `readState.set(...)` can be\n * missing even though the transcript contains the successful `read_file`.\n * This helper is intentionally opt-in: live hosts keep the normal side-effect\n * behavior unless they call it themselves.\n *\n * Hydration only fills missing keys. Live in-memory state may already reflect a\n * newer read or edit from the current run, and durable history cannot prove it\n * is fresher. Relative paths are resolved against the current execution cwd,\n * matching replay hosts that run sessions from a stable workspace.\n */\nexport function hydrateReadStateFromSession(\n  session: Session | undefined,\n  cwd: string,\n  options: HydrateReadStateOptions = {},\n): number {\n  if (!session)\n    return 0\n\n  const readState = getReadState(session)\n  if (!readState)\n    return 0\n\n  const normalized = normalizeHydrateReadStateOptions(options)\n  const pending = new Map<string, PendingToolCall>()\n  const known = new Map<string, KnownFile>()\n  const preexistingKeys = new Set(readState.keys())\n  let hydrated = 0\n\n  for (const turn of session.turns) {\n    for (const block of turn.content) {\n      if (block.type === 'tool_call') {\n        // Resolve wire aliases (e.g. `Read`/`Edit`) to canonical before\n        // matching, and STORE the canonical name in `pending` so the\n        // downstream `stateFromToolResult` dispatch (which keys off the\n        // canonical tool-name options) lines up regardless of how the\n        // transcript spelled the call.\n        const canonicalName = canonicalToolCallName(block.name, normalized)\n        if (\n          canonicalName === normalized.readFileToolName\n          || canonicalName === normalized.writeFileToolName\n          || canonicalName === normalized.editToolName\n          || canonicalName === normalized.multiEditToolName\n        ) {\n          pending.set(block.id, { name: canonicalName, input: block.input })\n        }\n        continue\n      }\n\n      if (block.type !== 'tool_result')\n        continue\n\n      const call = pending.get(block.callId)\n      if (!call)\n        continue\n      pending.delete(block.callId)\n      if (block.isError === true)\n        continue\n\n      const output = toolResultToText(block.output)\n      const next = stateFromToolResult(call, output, turn, cwd, normalized, known)\n      if (!next)\n        continue\n\n      if (!preexistingKeys.has(next.key)) {\n        readState.set(next.key, next.file.entry)\n        hydrated += 1\n      }\n      known.set(next.key, next.file)\n    }\n  }\n\n  return hydrated\n}\n\n/**\n * Async replay hydrator for durable hosts that can cheaply read the current\n * full file through their execution context. Transcript-only reconstruction is\n * still preferred for full reads; partial/truncated read_file entries fall back\n * to `readFileForHash` and hash those full current bytes.\n */\nexport async function hydrateReadStateFromSessionAsync(\n  session: Session | undefined,\n  cwd: string,\n  options: HydrateReadStateOptions = {},\n): Promise<number> {\n  if (!session)\n    return 0\n\n  const readState = getReadState(session)\n  if (!readState)\n    return 0\n\n  const normalized = normalizeHydrateReadStateOptions(options)\n  const pending = new Map<string, PendingToolCall>()\n  const known = new Map<string, KnownFile>()\n  const preexistingKeys = new Set(readState.keys())\n  let hydrated = 0\n\n  for (const turn of session.turns) {\n    for (const block of turn.content) {\n      if (block.type === 'tool_call') {\n        // Resolve wire aliases (e.g. `Read`/`Edit`) to canonical before\n        // matching, and STORE the canonical name in `pending` so the\n        // downstream `stateFromToolResult` dispatch (which keys off the\n        // canonical tool-name options) lines up regardless of how the\n        // transcript spelled the call.\n        const canonicalName = canonicalToolCallName(block.name, normalized)\n        if (\n          canonicalName === normalized.readFileToolName\n          || canonicalName === normalized.writeFileToolName\n          || canonicalName === normalized.editToolName\n          || canonicalName === normalized.multiEditToolName\n        ) {\n          pending.set(block.id, { name: canonicalName, input: block.input })\n        }\n        continue\n      }\n\n      if (block.type !== 'tool_result')\n        continue\n\n      const call = pending.get(block.callId)\n      if (!call)\n        continue\n      pending.delete(block.callId)\n      if (block.isError === true)\n        continue\n\n      const output = toolResultToText(block.output)\n      const next = await stateFromToolResultAsync(call, output, turn, cwd, normalized, known)\n      if (!next)\n        continue\n\n      if (!preexistingKeys.has(next.key)) {\n        readState.set(next.key, next.file.entry)\n        hydrated += 1\n      }\n      known.set(next.key, next.file)\n    }\n  }\n\n  return hydrated\n}\n\nfunction normalizeHydrateReadStateOptions(options: HydrateReadStateOptions): NormalizedHydrateReadStateOptions {\n  return {\n    readFileToolName: options.readFileToolName ?? 'read_file',\n    writeFileToolName: options.writeFileToolName ?? 'write_file',\n    editToolName: options.editToolName ?? 'edit',\n    multiEditToolName: options.multiEditToolName ?? 'multi_edit',\n    defaultLineNumbers: options.defaultLineNumbers ?? true,\n    ...(options.readFileForHash ? { readFileForHash: options.readFileForHash } : {}),\n    ...(options.aliasMaps ? { aliasMaps: options.aliasMaps } : {}),\n  }\n}\n\n/**\n * Resolve a transcript tool-call name to its canonical form for matching.\n * Honors `aliasMaps` (wire → canonical) when present; otherwise the name is\n * already canonical (zidane persists canonical names) and passes through.\n */\nfunction canonicalToolCallName(name: string, options: NormalizedHydrateReadStateOptions): string {\n  return options.aliasMaps ? toCanonicalName(name, options.aliasMaps) : name\n}\n\nfunction stateFromToolResult(\n  call: PendingToolCall,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n  options: NormalizedHydrateReadStateOptions,\n  known: Map<string, KnownFile>,\n): { key: string, file: KnownFile } | undefined {\n  if (call.name === options.readFileToolName)\n    return readFileStateFromResult(call.input, output, resultTurn, cwd, options.defaultLineNumbers)\n  if (call.name === options.writeFileToolName)\n    return writeFileStateFromResult(call.input, output, resultTurn, cwd)\n  if (call.name === options.editToolName)\n    return editStateFromResult(call.input, output, resultTurn, cwd, known)\n  if (call.name === options.multiEditToolName)\n    return multiEditStateFromResult(call.input, output, resultTurn, cwd, known)\n  return undefined\n}\n\nasync function stateFromToolResultAsync(\n  call: PendingToolCall,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n  options: NormalizedHydrateReadStateOptions,\n  known: Map<string, KnownFile>,\n): Promise<{ key: string, file: KnownFile } | undefined> {\n  if (call.name === options.readFileToolName) {\n    return await readFileStateFromResultAsync(call.input, output, resultTurn, cwd, {\n      defaultLineNumbers: options.defaultLineNumbers,\n      readFileForHash: options.readFileForHash,\n    })\n  }\n  return stateFromToolResult(call, output, resultTurn, cwd, options, known)\n}\n\nfunction readFileStateFromResult(\n  input: Record<string, unknown>,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n  defaultLineNumbers: boolean,\n): { key: string, file: KnownFile } | undefined {\n  const path = typeof input.path === 'string' ? input.path : undefined\n  if (!path || !isSuccessfulFullReadOutput(output))\n    return undefined\n\n  const lineNumbers = typeof input.lineNumbers === 'boolean' ? input.lineNumbers : defaultLineNumbers\n  const content = lineNumbers ? stripReadFileLineNumbers(output) : output\n  if (content === undefined)\n    return undefined\n\n  const entry: ReadStateEntry = {\n    contentHash: hashContent(content),\n    offset: normalizeReadInteger(input.offset, READ_FILE_DEFAULT_OFFSET),\n    limit: normalizeReadInteger(input.limit, READ_FILE_DEFAULT_LIMIT),\n    maxBytes: normalizeReadInteger(input.maxBytes, READ_FILE_DEFAULT_MAX_BYTES),\n    lineNumbers,\n    mtimeMs: resultTurn.createdAt,\n  }\n  return { key: readStateKey(cwd, path), file: { content, entry } }\n}\n\nasync function readFileStateFromResultAsync(\n  input: Record<string, unknown>,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n  options: {\n    defaultLineNumbers: boolean\n    readFileForHash?: HydrateReadStateOptions['readFileForHash']\n  },\n): Promise<{ key: string, file: KnownFile } | undefined> {\n  const reconstructed = readFileStateFromResult(input, output, resultTurn, cwd, options.defaultLineNumbers)\n  if (reconstructed)\n    return reconstructed\n\n  const path = typeof input.path === 'string' ? input.path : undefined\n  if (!path || !options.readFileForHash || !isSuccessfulReadOutput(output))\n    return undefined\n\n  let content: string | null | undefined\n  try {\n    content = await options.readFileForHash(path)\n  }\n  catch {\n    return undefined\n  }\n  if (typeof content !== 'string')\n    return undefined\n\n  const lineNumbers = typeof input.lineNumbers === 'boolean' ? input.lineNumbers : options.defaultLineNumbers\n  const entry: ReadStateEntry = {\n    contentHash: hashContent(content),\n    offset: normalizeReadInteger(input.offset, READ_FILE_DEFAULT_OFFSET),\n    limit: normalizeReadInteger(input.limit, READ_FILE_DEFAULT_LIMIT),\n    maxBytes: normalizeReadInteger(input.maxBytes, READ_FILE_DEFAULT_MAX_BYTES),\n    lineNumbers,\n    mtimeMs: resultTurn.createdAt,\n  }\n  return { key: readStateKey(cwd, path), file: { content, entry } }\n}\n\nfunction writeFileStateFromResult(\n  input: Record<string, unknown>,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n): { key: string, file: KnownFile } | undefined {\n  const path = typeof input.path === 'string' ? input.path : undefined\n  const content = typeof input.content === 'string' ? input.content : undefined\n  if (!path || content === undefined)\n    return undefined\n  if (!output.startsWith(`Created ${path} (`) && !output.startsWith(`Updated ${path} (`))\n    return undefined\n\n  return {\n    key: readStateKey(cwd, path),\n    file: {\n      content,\n      entry: {\n        contentHash: hashContent(content),\n        offset: 0,\n        limit: Number.POSITIVE_INFINITY,\n        maxBytes: Number.POSITIVE_INFINITY,\n        mtimeMs: resultTurn.createdAt,\n      },\n    },\n  }\n}\n\nfunction editStateFromResult(\n  input: Record<string, unknown>,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n  known: Map<string, KnownFile>,\n): { key: string, file: KnownFile } | undefined {\n  const path = typeof input.path === 'string' ? input.path : undefined\n  const oldString = typeof input.old_string === 'string' ? input.old_string : undefined\n  const newString = typeof input.new_string === 'string' ? input.new_string : undefined\n  if (!path || oldString === undefined || newString === undefined)\n    return undefined\n  if (!output.startsWith(`Edited ${path}: replaced `))\n    return undefined\n\n  const key = readStateKey(cwd, path)\n  const prior = known.get(key)\n  if (!prior)\n    return undefined\n\n  const nextContent = applyEdit(prior.content, oldString, newString, input.replace_all === true)\n  if (nextContent === undefined)\n    return undefined\n\n  return {\n    key,\n    file: {\n      content: nextContent,\n      entry: { ...prior.entry, contentHash: hashContent(nextContent), mtimeMs: resultTurn.createdAt },\n    },\n  }\n}\n\ninterface MultiEditStep {\n  old_string?: unknown\n  new_string?: unknown\n  replace_all?: unknown\n}\n\nfunction multiEditStateFromResult(\n  input: Record<string, unknown>,\n  output: string,\n  resultTurn: SessionTurn,\n  cwd: string,\n  known: Map<string, KnownFile>,\n): { key: string, file: KnownFile } | undefined {\n  const path = typeof input.path === 'string' ? input.path : undefined\n  const edits = Array.isArray(input.edits) ? (input.edits as MultiEditStep[]) : undefined\n  if (!path || !edits)\n    return undefined\n  if (!output.startsWith(`Edited ${path}: applied `))\n    return undefined\n\n  const key = readStateKey(cwd, path)\n  const prior = known.get(key)\n  if (!prior)\n    return undefined\n\n  const applied = parseMultiEditAppliedSteps(output, edits.length)\n  let current = prior.content\n  for (let i = 0; i < edits.length; i++) {\n    if (!applied.has(i))\n      continue\n    const step = edits[i]\n    if (typeof step.old_string !== 'string' || typeof step.new_string !== 'string')\n      return undefined\n    const next = applyEdit(current, step.old_string, step.new_string, step.replace_all === true)\n    if (next === undefined)\n      return undefined\n    current = next\n  }\n\n  return {\n    key,\n    file: {\n      content: current,\n      entry: { ...prior.entry, contentHash: hashContent(current), mtimeMs: resultTurn.createdAt },\n    },\n  }\n}\n\nfunction applyEdit(content: string, oldString: string, newString: string, replaceAll: boolean): string | undefined {\n  const match = resolveOldString(content, oldString)\n  if (!match)\n    return undefined\n  if (match.occurrences > 1 && !replaceAll)\n    return undefined\n  const styledReplacement = styleReplacementForVia(newString, match.via, match.actual)\n  return replaceAll\n    ? content.split(match.actual).join(styledReplacement)\n    : content.replace(match.actual, styledReplacement)\n}\n\nfunction parseMultiEditAppliedSteps(output: string, editCount: number): Set<number> {\n  const annotationMatch = /<edit-outcomes>\\n([\\s\\S]*?)\\n<\\/edit-outcomes>/.exec(output)\n  if (!annotationMatch) {\n    return new Set(Array.from({ length: editCount }, (_, i) => i))\n  }\n\n  const applied = new Set<number>()\n  for (const line of annotationMatch[1].split('\\n')) {\n    const match = /^#(\\d+) applied$/.exec(line.trim())\n    if (!match)\n      continue\n    const index = Number(match[1]) - 1\n    if (index >= 0 && index < editCount)\n      applied.add(index)\n  }\n  return applied\n}\n\nfunction isSuccessfulFullReadOutput(output: string): boolean {\n  // Live read_file stores a hash of the raw full file before pagination or\n  // truncation. Durable turns only contain rendered output, so partial reads\n  // cannot be reconstructed safely; skip them and require a real re-read.\n  if (!isSuccessfulReadOutput(output) || READ_FILE_FOOTER_RE.test(output))\n    return false\n  return true\n}\n\nfunction isSuccessfulReadOutput(output: string): boolean {\n  if (output.length === 0)\n    return true\n  if (\n    output.startsWith('File not found:')\n    || output.startsWith('[binary file:')\n    || output.startsWith('Image:')\n    || output.startsWith('Document:')\n    || output.startsWith('[image too large to inline:')\n    || output.startsWith('[document:')\n    || output.startsWith('[document too large to attach:')\n    || output.startsWith('Image read failed:')\n    || output.startsWith('Document read failed:')\n    || output.includes(' unchanged since the previous read in this session ')\n  ) {\n    return false\n  }\n  return true\n}\n\nfunction stripReadFileLineNumbers(output: string): string | undefined {\n  const lines = output.split('\\n')\n  const stripped: string[] = []\n  for (const line of lines) {\n    const match = READ_FILE_LINE_RE.exec(line)\n    if (!match)\n      return undefined\n    stripped.push(match[1])\n  }\n  return stripped.join('\\n')\n}\n\nfunction normalizeReadInteger(value: unknown, fallback: number): number {\n  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)\n    return fallback\n  return Math.floor(value)\n}\n\n// ---------------------------------------------------------------------------\n// Tool-dedup\n// ---------------------------------------------------------------------------\n\nexport interface ToolDedupEntry {\n  hash: string\n  result: string | ToolResultContent[]\n  /**\n   * Number of replay-hits accumulated against this `(name, hash)` since\n   * the most recent fresh dispatch. `0` immediately after a fresh\n   * dispatch; incremented every time a `tool:gate` handler returns the\n   * cached result for an identical input. Used by `dedup-tools` to\n   * implement `mode: 'block-after'` — when the count crosses the\n   * configured threshold, the gate stops replaying and refuses the call\n   * with a `Blocked:` tool_result so the model breaks out of the loop.\n   *\n   * Resets to `0` on a hash change (a different input under the same\n   * tool name is treated as a fresh sequence). Optional for back-compat\n   * with consumers that built the entry directly; absent is treated as\n   * `0`.\n   */\n  repeats?: number\n}\n\nexport type ToolDedupMap = Map<string, ToolDedupEntry>\n\nconst TOOL_DEDUP_STATE = new WeakMap<Session, ToolDedupMap>()\n\n/**\n * Get or lazily create the per-session tool-dedup map. Returns `undefined`\n * when no session is provided — middleware should treat that as \"no dedup\".\n */\nexport function getToolDedupState(session: Session | undefined): ToolDedupMap | undefined {\n  if (!session)\n    return undefined\n  let map = TOOL_DEDUP_STATE.get(session)\n  if (!map) {\n    map = new Map()\n    TOOL_DEDUP_STATE.set(session, map)\n  }\n  return map\n}\n"],"mappings":"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"}

package/dist/skills-CDpejYOf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skills-CDpejYOf.js","names":[],"sources":["../src/skills/install.ts","../src/skills/index.ts"],"sourcesContent":["/**\n * Skill installation — fetch a skill (or a collection of skills) from\n * GitHub / npm / skills.sh and land it under the zidane skills root,\n * where the existing discovery scan picks it up.\n *\n * Built on the shared install layer (`src/install/source.ts`), so the\n * spec grammar, transports, download caps, and subdir containment are\n * byte-identical with the extensions installer. What differs:\n *\n *   - **Validation never executes code.** A skill is data: candidates\n *     are validated by parsing `SKILL.md` (lenient parser, same one\n *     discovery uses) — unlike extensions, whose validation must import\n *     the module. Installing a hostile skill can plant instructions,\n *     never run a process.\n *   - **skills.sh interop, two-way.** The spec grammar accepts pasted\n *     `https://skills.sh/<owner>/<repo>[/<skill>]` catalog URLs (mapped\n *     to the GitHub repo + a skill selector — skills.sh uses GitHub as\n *     its registry). And when the `skills` CLI is on PATH,\n *     {@link installSkillFromSpec} delegates to it (`skills add … -y`)\n *     so installs land in the user's cross-agent `.agents/skills/`\n *     layout and feed the skills.sh lockfile/leaderboard; without the\n *     CLI the native fetch path installs the same repos directly.\n *   - **Target roots**: `~/.zidane/skills/<name>` (user) or\n *     `<gitRoot>/.zidane/skills/<name>` (project) — both already on\n *     discovery's default scan paths.\n *\n * Same hardening as extensions: staged `mkdtemp` fetch, physical\n * symlink containment for `:subdir`, folder-safe names, overwrite with\n * backup/rollback, and a provenance file (`.zidane-install.json`) so a\n * future update flow can replay the spec.\n */\n\nimport type { InstallIo, InstallScope, InstallSource } from '../install/source'\nimport { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'\nimport { tmpdir } from 'node:os'\nimport { basename, join, resolve } from 'node:path'\nimport { projectUserPaths } from '../chat/project-user-paths'\nimport { errorMessage } from '../errors'\nimport { defaultExec, defaultWhich, fetchInstallSource, InstallSourceError, lastLine, parseInstallSource, resolveSubdirRoot } from '../install/source'\nimport { parseSkillFile } from './discovery'\nimport { validateSkillName } from './validate'\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\nexport type SkillInstallErrorCode\n  = | 'invalid-source'\n    | 'fetch-failed'\n    | 'no-skill'\n    | 'multiple-candidates'\n    | 'validate-failed'\n    | 'exists'\n    | 'cli-failed'\n    | 'io-failed'\n\nexport class SkillInstallError extends InstallSourceError {\n  declare readonly code: SkillInstallErrorCode\n  /**\n   * Frontmatter metadata per candidate, parallel to `candidates` — set on\n   * the selector-less `multiple-candidates` error so host pickers can show\n   * descriptions without re-fetching the source. Best-effort: candidates\n   * whose SKILL.md fails to parse appear with no description.\n   */\n  readonly details?: readonly SkillCandidateDetail[]\n  constructor(code: SkillInstallErrorCode, message: string, candidates?: readonly string[], details?: readonly SkillCandidateDetail[]) {\n    super(code, message, candidates)\n    this.name = 'SkillInstallError'\n    if (details)\n      this.details = details\n  }\n}\n\n/** One pickable candidate surfaced to host UIs — see {@link SkillInstallError.details}. */\nexport interface SkillCandidateDetail {\n  /** Root-relative path — the unambiguous selector (`skills` option). */\n  rel: string\n  /** Frontmatter description, when the candidate's SKILL.md parses. */\n  description?: string\n}\n\nfunction rethrowAsSkillError(err: unknown): never {\n  if (err instanceof InstallSourceError && !(err instanceof SkillInstallError))\n    throw new SkillInstallError(err.code as SkillInstallErrorCode, err.message, err.candidates)\n  throw err\n}\n\n// ---------------------------------------------------------------------------\n// Spec parsing (shared grammar + the skills.sh catalog URL form)\n// ---------------------------------------------------------------------------\n\nconst SKILLS_SH_URL_RE = /^(?:https?:\\/\\/)?(?:www\\.)?skills\\.sh\\/([\\w.-]+)\\/([\\w.-]+)(?:\\/([\\w.-]+))?\\/?$/\n\n/**\n * Pasted install commands, as printed by skill READMEs and skills.sh\n * pages — `npx skills add owner/repo`, `bunx skills add …`,\n * `pnpm dlx skills add … --skill x`, or a bare `skills add …`. The\n * runner + `add` verb are stripped and the remaining tokens re-enter\n * the normal grammar, so users can copy a whole command into the\n * install input verbatim.\n */\nconst SKILLS_CLI_COMMAND_RE = /^(?:(?:npx|bunx|yarn\\s+dlx|pnpm\\s+dlx)\\s+)?skills(?:@\\S+)?\\s+add\\s+(\\S.*)$/i\n\nexport interface SkillInstallSpec {\n  source: InstallSource\n  /**\n   * Skill name selector for multi-skill sources. From a skills.sh URL's\n   * third segment or the caller's explicit pick after a\n   * `multiple-candidates` error.\n   */\n  skill?: string\n  /**\n   * The spec string to hand the `skills` CLI (its `add` argument).\n   * skills.sh URLs pass through verbatim — the CLI understands them —\n   * while parsed shorthand re-serializes to `owner/repo`.\n   */\n  cliSpec: string\n}\n\n/**\n * Parse a raw skill source. Accepts everything the shared grammar does\n * (`owner/repo[#ref][:subdir]`, GitHub URLs, `pkg@version`, …) plus\n * pasted skills.sh catalog URLs — `skills.sh/vercel-labs/agent-skills/\n * react-best-practices` maps to the backing GitHub repo with the third\n * segment as the skill selector.\n */\nexport function parseSkillInstallSpec(raw: string): SkillInstallSpec {\n  const spec = raw.trim()\n  const cliCommand = SKILLS_CLI_COMMAND_RE.exec(spec)\n  if (cliCommand)\n    return parseCliAddCommand(cliCommand[1] as string)\n  const skillsSh = SKILLS_SH_URL_RE.exec(spec)\n  if (skillsSh) {\n    return {\n      source: { kind: 'github', owner: skillsSh[1] as string, repo: skillsSh[2] as string },\n      ...(skillsSh[3] ? { skill: skillsSh[3] } : {}),\n      cliSpec: `${skillsSh[1]}/${skillsSh[2]}`,\n    }\n  }\n  try {\n    const source = parseInstallSource(spec)\n    return { source, cliSpec: spec }\n  }\n  catch (err) {\n    rethrowAsSkillError(err)\n  }\n}\n\n/**\n * Parse the argument tail of a pasted `skills add …` command. Honors\n * `--skill <name>` / `--skill=<name>` (their per-skill selector — an\n * explicit selector in the URL/shorthand form wins over it), ignores\n * flags that are the dialog's job here (`-y`, `-g`, `--global`, …),\n * and routes the first non-flag token back through\n * {@link parseSkillInstallSpec} so URLs and shorthands inside the\n * command parse identically to a bare paste.\n */\nfunction parseCliAddCommand(rest: string): SkillInstallSpec {\n  const tokens = rest.split(/\\s+/).filter(t => t.length > 0)\n  let sourceToken: string | undefined\n  let skill: string | undefined\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i] as string\n    if (token === '--skill' || token === '-s') {\n      skill = tokens[i + 1]\n      i += 1\n      continue\n    }\n    const inline = /^--skill=(.+)$/.exec(token)\n    if (inline) {\n      skill = inline[1] as string\n      continue\n    }\n    if (token.startsWith('-'))\n      continue\n    if (sourceToken === undefined)\n      sourceToken = token\n  }\n  if (sourceToken === undefined)\n    throw new SkillInstallError('invalid-source', 'Pasted skills command has no source — expected “skills add <owner/repo>”.')\n  const parsed = parseSkillInstallSpec(sourceToken)\n  return { ...parsed, ...(skill !== undefined && parsed.skill === undefined ? { skill } : {}) }\n}\n\n// ---------------------------------------------------------------------------\n// Candidate enumeration + validation (data-only — no code execution)\n// ---------------------------------------------------------------------------\n\nexport interface SkillInstallCandidate {\n  /** Directory name candidate (validated against SKILL.md frontmatter later). */\n  name: string\n  dir: string\n  /**\n   * Root-relative path (`engineering/tdd`) — the unambiguous selector\n   * when the same skill NAME exists in several category directories.\n   */\n  rel: string\n}\n\n/**\n * How deep the candidate walk descends. Real-world collections nest\n * skills under category directories (`skills/engineering/tdd/SKILL.md`\n * in mattpocock/skills; `.github/skills/…` elsewhere) — one-level\n * enumeration missed all of them. Four levels covers every observed\n * layout while keeping the walk trivially bounded on the staged tree.\n */\nconst CANDIDATE_WALK_MAX_DEPTH = 4\n\n/**\n * List installable skills inside a fetched tree.\n *\n * A skill is ANY directory containing a `SKILL.md` — found by a\n * bounded recursive walk (depth {@link CANDIDATE_WALK_MAX_DEPTH}),\n * skipping dot-dirs and `node_modules`, and never descending INTO a\n * skill (its `references/` / `scripts/` subtree ships with it, it\n * doesn't nest further candidates). A root-level `SKILL.md` means\n * \"repo IS the skill\" and short-circuits, named from the fallback.\n *\n * Candidates carry their root-relative path (`rel`) so same-named\n * skills in different categories stay individually addressable.\n * Sorted by `rel`.\n */\nexport function listSkillCandidates(dir: string, fallbackName: string): SkillInstallCandidate[] {\n  if (existsSync(join(dir, 'SKILL.md')))\n    return [{ name: sanitizeName(fallbackName), dir, rel: '.' }]\n  const out: SkillInstallCandidate[] = []\n  const walk = (current: string, rel: string, depth: number): void => {\n    if (depth > CANDIDATE_WALK_MAX_DEPTH)\n      return\n    for (const entry of readdirSync(current, { withFileTypes: true })) {\n      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules')\n        continue\n      const childDir = join(current, entry.name)\n      const childRel = rel.length === 0 ? entry.name : `${rel}/${entry.name}`\n      if (existsSync(join(childDir, 'SKILL.md')))\n        out.push({ name: entry.name, dir: childDir, rel: childRel })\n      else\n        walk(childDir, childRel, depth + 1)\n    }\n  }\n  walk(dir, '', 1)\n  return out.sort((a, b) => a.rel.localeCompare(b.rel))\n}\n\n/**\n * Frontmatter details for a host picker, parallel to the candidate list.\n * Parsing is best-effort per candidate — a malformed SKILL.md yields a\n * detail row without a description rather than failing the enumeration.\n */\nasync function candidateDetails(candidates: readonly SkillInstallCandidate[]): Promise<SkillCandidateDetail[]> {\n  return Promise.all(candidates.map(async (c) => {\n    const parsed = await parseSkillFile(join(c.dir, 'SKILL.md')).catch(() => null)\n    const description = parsed?.description.trim()\n    return { rel: c.rel, ...(description ? { description } : {}) }\n  }))\n}\n\n/** Human-readable candidate list for error messages — capped, rel-qualified when ambiguous. */\nfunction describeCandidates(candidates: readonly SkillInstallCandidate[]): string {\n  const nameCounts = new Map<string, number>()\n  for (const c of candidates)\n    nameCounts.set(c.name, (nameCounts.get(c.name) ?? 0) + 1)\n  const labels = candidates.map(c => ((nameCounts.get(c.name) ?? 0) > 1 ? c.rel : c.name))\n  const shown = labels.slice(0, 20)\n  const more = labels.length - shown.length\n  return shown.join(', ') + (more > 0 ? `, … and ${more} more` : '')\n}\n\n/**\n * Validate a staged candidate by PARSING its SKILL.md — the same lenient\n * parser discovery runs, so \"installs cleanly\" and \"discovers cleanly\"\n * are the same predicate. Returns the frontmatter name (which wins over\n * the directory-derived candidate name for the target folder).\n */\nasync function validateSkillCandidate(candidate: SkillInstallCandidate): Promise<{ name: string }> {\n  const parsed = await parseSkillFile(join(candidate.dir, 'SKILL.md'))\n  if (!parsed)\n    throw new SkillInstallError('validate-failed', `${candidate.dir}/SKILL.md is not a valid skill (missing name or description in frontmatter).`)\n  const name = parsed.name\n  if (!validateSkillName(name))\n    throw new SkillInstallError('validate-failed', `Skill name \"${name}\" is invalid (lowercase alphanumerics + single hyphens, max 64 chars).`)\n  return { name }\n}\n\n// ---------------------------------------------------------------------------\n// Install\n// ---------------------------------------------------------------------------\n\nexport interface SkillInstallOptions {\n  /** Raw source spec — see {@link parseSkillInstallSpec} for the grammar. */\n  source: string\n  scope: InstallScope\n  /** Pick one skill from a multi-skill source (names from the `multiple-candidates` error). */\n  skill?: string\n  /**\n   * Install EVERY skill a multi-skill source contains (the affirmative\n   * answer to the host's \"import all?\" prompt after a\n   * `multiple-candidates` error). Native engine only — already-installed\n   * names are skipped (reported via `SkillInstallResult.skipped`) rather\n   * than failing the batch, unless `overwrite` is also set. Ignored when\n   * a `skill` selector is present.\n   */\n  all?: boolean\n  /**\n   * Install a picked SUBSET of a multi-skill source — the host's checkbox\n   * picker over the `multiple-candidates` list. Entries match a skill's\n   * name or its root-relative path (same rules as `skill`); duplicates\n   * collapse. Batch semantics mirror `all` (skip existing, pre-validate,\n   * native engine). Takes precedence over `all` and is ignored when a\n   * `skill` selector is present.\n   */\n  skills?: readonly string[]\n  /** Overwrite an existing install of the same name. */\n  overwrite?: boolean\n  cwd?: string\n  home?: string\n  /** Storage prefix (default `.zidane`) — mirrors `ResolvedConfig.prefix`. */\n  prefix?: string\n  io?: InstallIo\n  onProgress?: (message: string) => void\n  /**\n   * Prefer the skills.sh CLI when `skills` is on PATH (default true).\n   * The CLI owns scope + layout decisions (`.agents/skills/`, their\n   * lockfile); the native path is the fallback and the forced path in\n   * tests. Set false to always install natively.\n   */\n  preferSkillsCli?: boolean\n}\n\nexport interface SkillInstallResult {\n  /** Final skill name(s) installed. The CLI path reports the spec, not names. */\n  installed: readonly string[]\n  /** Names skipped during an `all` import because they were already installed. */\n  skipped?: readonly string[]\n  /** Candidate paths excluded from an `all` import because they failed validation. */\n  failed?: readonly string[]\n  /** Absolute target directory (native path only — the CLI owns its layout). */\n  dir?: string\n  /** `skills-cli` when delegated to the skills.sh CLI, else `native`. */\n  engine: 'skills-cli' | 'native'\n  provenance?: string\n}\n\n/**\n * Install a skill (or one skill out of a multi-skill source).\n *\n * Engine selection: targeted installs (an explicit skill selector) go\n * through the skills.sh CLI when present on PATH (unless\n * `preferSkillsCli: false`) — keeping their cross-agent layout and\n * lockfile — else the native fetch pipeline. Selector-less installs are\n * ALWAYS native: only native enumeration can tell single- from\n * multi-skill sources, and the host's \"import all?\" prompt rides on the\n * `multiple-candidates` error — delegating them to `skills add … -y`\n * would let the CLI's own multi-skill behavior silently decide instead.\n * `all: true` batches are native for the same reason (skip-existing +\n * per-skill provenance are our semantics).\n */\nexport async function installSkillFromSpec(opts: SkillInstallOptions): Promise<SkillInstallResult> {\n  const io = opts.io ?? {}\n  const which = io.which ?? defaultWhich\n  const spec = parseSkillInstallSpec(opts.source)\n  const skillSelector = opts.skill ?? spec.skill\n\n  // Batch modes (`all` / `skills` subset) are always native — see JSDoc.\n  const batchMode = opts.all === true || (opts.skills?.length ?? 0) > 0\n  if (!batchMode && skillSelector !== undefined && (opts.preferSkillsCli ?? true) && which('skills'))\n    return await installViaSkillsCli(spec, skillSelector, opts)\n\n  return await installNatively(spec, skillSelector, opts)\n}\n\n/**\n * Delegate to the skills.sh CLI. Non-interactive by construction: `-y`\n * skips confirmation prompts, `-g` maps our `user` scope to their\n * global scope (project scope is their default, keyed off cwd). The CLI\n * decides the on-disk layout (`.agents/skills/`), which zidane's\n * discovery already scans.\n */\nasync function installViaSkillsCli(\n  spec: SkillInstallSpec,\n  skillSelector: string | undefined,\n  opts: SkillInstallOptions,\n): Promise<SkillInstallResult> {\n  const exec = opts.io?.exec ?? defaultExec\n  const args = ['add', spec.cliSpec, '-y']\n  if (skillSelector)\n    args.push('--skill', skillSelector)\n  if (opts.scope === 'user')\n    args.push('-g')\n  opts.onProgress?.(`skills add ${spec.cliSpec}${skillSelector ? ` --skill ${skillSelector}` : ''}…`)\n  const res = await exec('skills', args, { cwd: opts.cwd ?? process.cwd() })\n  if (!res.ok)\n    throw new SkillInstallError('cli-failed', `skills.sh CLI failed: ${lastLine(res.stderr) || lastLine(res.stdout) || 'unknown error'}`)\n  return {\n    installed: [skillSelector ?? spec.cliSpec],\n    engine: 'skills-cli',\n  }\n}\n\nasync function installNatively(\n  spec: SkillInstallSpec,\n  skillSelector: string | undefined,\n  opts: SkillInstallOptions,\n): Promise<SkillInstallResult> {\n  const io = opts.io ?? {}\n  const source = spec.source\n  const stage = mkdtempSync(join(tmpdir(), 'zidane-skill-install-'))\n  try {\n    const fetchedInto = join(stage, 'fetched')\n    mkdirSync(fetchedInto, { recursive: true })\n    let provenance: string\n    try {\n      provenance = (await fetchInstallSource(source, fetchedInto, io, opts.onProgress)).provenance\n    }\n    catch (err) {\n      rethrowAsSkillError(err)\n    }\n\n    // `:subdir` re-roots the search — same physical containment as\n    // extensions (hostile symlinks must not walk out of the stage).\n    let candidateRoot = fetchedInto\n    let fallbackName = source.kind === 'github' ? source.repo : source.pkg\n    if (source.kind === 'github' && source.subdir) {\n      const rooted = resolveSubdirRoot(fetchedInto, source.subdir)\n      if (!rooted.ok) {\n        if (rooted.reason === 'missing')\n          throw new SkillInstallError('no-skill', `\"${source.subdir}\" is not a directory in ${source.owner}/${source.repo}.`)\n        throw new SkillInstallError('invalid-source', `Subdirectory \"${source.subdir}\" escapes the repository root${rooted.reason === 'escape-symlink' ? ' through a symlink' : ''}.`)\n      }\n      candidateRoot = rooted.dir\n      fallbackName = basename(resolve(fetchedInto, source.subdir))\n    }\n\n    const candidates = listSkillCandidates(candidateRoot, fallbackName)\n    if (candidates.length === 0)\n      throw new SkillInstallError('no-skill', `No skill found in ${opts.source} — no SKILL.md anywhere in the tree (searched ${CANDIDATE_WALK_MAX_DEPTH} levels deep).`)\n    let picked: SkillInstallCandidate[]\n    if (!skillSelector && opts.skills && opts.skills.length > 0) {\n      // Host-picked subset (checkbox picker over the `multiple-candidates`\n      // list). Each entry resolves with the same name-or-rel-path rules as\n      // the single selector; duplicate picks collapse to one install.\n      const byRel = new Map<string, SkillInstallCandidate>()\n      for (const sel of opts.skills) {\n        const matches = candidates.filter(c => c.name === sel || c.rel === sel)\n        if (matches.length === 0)\n          throw new SkillInstallError('no-skill', `No skill named \"${sel}\" in ${opts.source}. Available: ${describeCandidates(candidates)}`, candidates.map(c => c.rel))\n        if (matches.length > 1)\n          throw new SkillInstallError('multiple-candidates', `\"${sel}\" is ambiguous in ${opts.source} — pick a path: ${matches.map(c => c.rel).join(', ')}`, matches.map(c => c.rel))\n        const match = matches[0] as SkillInstallCandidate\n        byRel.set(match.rel, match)\n      }\n      picked = [...byRel.values()]\n    }\n    else if (skillSelector) {\n      // Selector matches the skill name OR its root-relative path — the\n      // path form disambiguates same-named skills in different category\n      // directories (`engineering/tdd` vs `personal/tdd`).\n      const matches = candidates.filter(c => c.name === skillSelector || c.rel === skillSelector)\n      if (matches.length === 0)\n        throw new SkillInstallError('no-skill', `No skill named \"${skillSelector}\" in ${opts.source}. Available: ${describeCandidates(candidates)}`, candidates.map(c => c.rel))\n      if (matches.length > 1)\n        throw new SkillInstallError('multiple-candidates', `\"${skillSelector}\" is ambiguous in ${opts.source} — pick a path: ${matches.map(c => c.rel).join(', ')}`, matches.map(c => c.rel))\n      picked = [matches[0] as SkillInstallCandidate]\n    }\n    else if (candidates.length > 1 && !opts.all) {\n      throw new SkillInstallError(\n        'multiple-candidates',\n        `${opts.source} contains ${candidates.length} skills — pick one: ${describeCandidates(candidates)}`,\n        candidates.map(c => c.rel),\n        await candidateDetails(candidates),\n      )\n    }\n    else {\n      picked = [...candidates]\n    }\n\n    const root = scopeRoot(opts)\n    const installed: string[] = []\n    const skipped: string[] = []\n    const failed: string[] = []\n    let lastDir: string | undefined\n    const batch = picked.length > 1\n\n    // Validate the whole batch BEFORE installing anything — one malformed\n    // candidate must not abort a half-applied import. Batch mode collects\n    // failures (reported via `SkillInstallResult.failed`) and installs the\n    // rest; a targeted single install keeps the hard throw.\n    const resolved: Array<{ candidate: SkillInstallCandidate, name: string }> = []\n    // Intra-batch name conflicts: two candidates whose frontmatter\n    // validates to the same name (`engineering/tdd` + `personal/tdd`)\n    // would otherwise install the first and mislabel the second as\n    // \"already installed\" (or, with overwrite, silently last-wins).\n    // First occurrence wins; later ones are reported as conflicts.\n    const nameToRel = new Map<string, string>()\n    for (const candidate of picked) {\n      try {\n        // Frontmatter name wins over the directory-derived candidate name —\n        // mirrors \"target folder is named from the VALIDATED definition\".\n        const { name } = await validateSkillCandidate(candidate)\n        const conflict = nameToRel.get(name)\n        if (conflict !== undefined) {\n          // Only reachable in batch mode — a single pick can't conflict.\n          failed.push(candidate.rel)\n          opts.onProgress?.(`skipping \"${candidate.rel}\" — name \"${name}\" conflicts with \"${conflict}\"`)\n          continue\n        }\n        nameToRel.set(name, candidate.rel)\n        resolved.push({ candidate, name })\n      }\n      catch (err) {\n        if (!batch)\n          throw err\n        failed.push(candidate.rel)\n        opts.onProgress?.(`skipping \"${candidate.rel}\" — ${errorMessage(err)}`)\n      }\n    }\n\n    for (const { candidate, name } of resolved) {\n      const targetDir = join(root, name)\n      const backupDir = `${targetDir}.zidane-backup`\n      if (existsSync(targetDir) && !opts.overwrite) {\n        // Batch imports skip collisions (already-installed skills are the\n        // common case when re-importing a repo); a targeted single install\n        // keeps the hard error so the overwrite decision stays explicit.\n        if (batch) {\n          skipped.push(name)\n          opts.onProgress?.(`skipping \"${name}\" — already installed`)\n          continue\n        }\n        throw new SkillInstallError('exists', `Skill \"${name}\" is already installed at ${targetDir}. Overwrite to replace it.`)\n      }\n\n      mkdirSync(root, { recursive: true })\n      const hadPrevious = existsSync(targetDir)\n      if (hadPrevious) {\n        rmSync(backupDir, { recursive: true, force: true })\n        renameSync(targetDir, backupDir)\n      }\n      try {\n        // `dereference` materializes in-tree symlinked files so the install\n        // has no dangling links once the stage is deleted.\n        cpSync(candidate.dir, targetDir, { recursive: true, dereference: true })\n        writeProvenance(targetDir, { spec: opts.source, ...(skillSelector ? { skill: skillSelector } : {}), scope: opts.scope, provenance, installedAt: Date.now() })\n      }\n      catch (err) {\n        rmSync(targetDir, { recursive: true, force: true })\n        if (hadPrevious)\n          renameSync(backupDir, targetDir)\n        throw new SkillInstallError('io-failed', `Writing ${targetDir} failed: ${errorMessage(err)}`)\n      }\n      rmSync(backupDir, { recursive: true, force: true })\n      installed.push(name)\n      lastDir = targetDir\n      if (batch)\n        opts.onProgress?.(`installed \"${name}\" (${installed.length}/${resolved.length})`)\n    }\n\n    if (installed.length === 0 && skipped.length > 0)\n      throw new SkillInstallError('exists', `All ${skipped.length} installable skills from ${opts.source} are already installed: ${skipped.join(', ')}. Overwrite to replace them.`)\n    if (installed.length === 0 && failed.length > 0)\n      throw new SkillInstallError('validate-failed', `No skill from ${opts.source} was installable — invalid: ${failed.join(', ')}.`)\n\n    return {\n      installed,\n      ...(skipped.length > 0 ? { skipped } : {}),\n      ...(failed.length > 0 ? { failed } : {}),\n      ...(lastDir !== undefined ? { dir: lastDir } : {}),\n      engine: 'native',\n      provenance,\n    }\n  }\n  finally {\n    rmSync(stage, { recursive: true, force: true })\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/** Provenance sidecar — lets a future update flow replay the recorded spec. */\nexport const SKILL_PROVENANCE_FILE = '.zidane-install.json'\n\ninterface SkillProvenance {\n  spec: string\n  skill?: string\n  scope: InstallScope\n  provenance: string\n  installedAt: number\n}\n\nfunction writeProvenance(dir: string, data: SkillProvenance): void {\n  writeFileSync(join(dir, SKILL_PROVENANCE_FILE), `${JSON.stringify(data, null, 2)}\\n`)\n}\n\n/** Read a skill directory's install provenance, `null` for hand-authored skills. */\nexport function readSkillProvenance(dir: string): (SkillProvenance & { spec: string }) | null {\n  try {\n    const raw = JSON.parse(readFileSync(join(dir, SKILL_PROVENANCE_FILE), 'utf8')) as Partial<SkillProvenance>\n    return typeof raw.spec === 'string' && raw.spec.length > 0 ? (raw as SkillProvenance) : null\n  }\n  catch {\n    return null\n  }\n}\n\n/**\n * Native-install target root: the `<prefix>/skills` flavor of the\n * project/user convention (`~/.zidane/skills`, `<gitRoot>/.zidane/skills`).\n * The `.agents/skills` siblings stay read-only for us — they belong to\n * the cross-agent ecosystem (and the skills.sh CLI writes there).\n */\nfunction scopeRoot(opts: SkillInstallOptions): string {\n  const roots = projectUserPaths({\n    subPath: 'skills',\n    ...(opts.cwd ? { cwd: opts.cwd } : {}),\n    ...(opts.home ? { home: opts.home } : {}),\n    ...(opts.prefix ? { prefix: opts.prefix } : {}),\n  })\n  const root = roots.find(r => r.source === opts.scope && r.path.includes(`.${(opts.prefix ?? '.zidane').replace(/^\\./, '')}`))\n  if (!root)\n    throw new SkillInstallError('io-failed', `No ${opts.scope} skills root resolved.`)\n  return root.path\n}\n\nfunction sanitizeName(raw: string): string {\n  const cleaned = raw.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').replace(/-{2,}/g, '-')\n  return cleaned.length > 0 ? cleaned : 'skill'\n}\n","import type { SkillConfig } from './types'\nimport { validateSkillForWrite } from './validate'\n\nexport {\n  type ActivationVia,\n  type ActiveSkill,\n  createSkillActivationState,\n  type DeactivationReason,\n  type SkillActivationState,\n  type SkillActivationStateOptions,\n} from './activation'\nexport {\n  IMPLICITLY_ALLOWED_SKILL_TOOLS,\n  installAllowedToolsGate,\n} from './allowed-tools'\nexport { buildCatalog } from './catalog'\nexport {\n  discoverSkills,\n  getDefaultScanPaths,\n  inferSource,\n  parseFrontmatter,\n  parseSkillFile,\n} from './discovery'\nexport type { SourcedScanPath } from './discovery'\nexport {\n  installSkillFromSpec,\n  listSkillCandidates,\n  parseSkillInstallSpec,\n  readSkillProvenance,\n  SKILL_PROVENANCE_FILE,\n  SkillInstallError,\n} from './install'\nexport type {\n  SkillCandidateDetail,\n  SkillInstallCandidate,\n  SkillInstallErrorCode,\n  SkillInstallOptions,\n  SkillInstallResult,\n  SkillInstallSpec,\n} from './install'\nexport { interpolateShellCommands, stripShellInterpolations } from './interpolate'\nexport type { InterpolateShellCommandsOptions } from './interpolate'\nexport { resolveSkills } from './resolve'\nexport type {\n  ShellInterpolationApproval,\n  SkillConfig,\n  SkillDiagnostic,\n  SkillResource,\n  SkillsConfig,\n  SkillSource,\n} from './types'\nexport {\n  isToolAllowedByUnion,\n  matchesAllowedTool,\n  parseAllowedToolPattern,\n  validateResourcePath,\n  validateResourcePathReal,\n  validateSkillForWrite,\n  validateSkillName,\n} from './validate'\nexport type { SkillValidationIssue, SkillValidationResult } from './validate'\nexport { writeSkillsToDisk, writeSkillToDisk } from './writer'\n\n// ---------------------------------------------------------------------------\n// defineSkill helper\n// ---------------------------------------------------------------------------\n\n/**\n * Define an inline skill configuration.\n *\n * Strict-validates at author-time — throws if the config would be rejected by\n * `writeSkillToDisk` or the spec. Source defaults to `'inline'`.\n */\nexport function defineSkill(config: Omit<SkillConfig, 'source'> & { source?: SkillConfig['source'] }): SkillConfig {\n  const normalized: SkillConfig = {\n    ...config,\n    source: config.source ?? 'inline',\n  }\n  const result = validateSkillForWrite(normalized)\n  if (!result.valid) {\n    const summary = result.errors.map(e => `  - [${e.code}] ${e.message}`).join('\\n')\n    throw new Error(`Invalid skill \"${normalized.name}\":\\n${summary}`)\n  }\n  return normalized\n}\n"],"mappings":"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"}