@hawkeyexl/manni 4.4.1 → 4.6.0

package/dist/{chunk-MYMBCTDE.js → chunk-XXDXIIQ4.js}

@@ -4,7 +4,7 @@ import {
   NS,
   PREFIXES,
   byCodeUnit
-} from "./chunk-M2JCK5F6.js";
+} from "./chunk-6KKZXB2O.js";
 import {
   packageRoot
 } from "./chunk-TIUTIOFB.js";
@@ -384,4 +384,4 @@ export {
   bundledShapesPath,
   validateGraph
 };
-//# sourceMappingURL=chunk-MYMBCTDE.js.map
+//# sourceMappingURL=chunk-XXDXIIQ4.js.map

package/dist/chunk-YGFIQ6Y5.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  ToolError
+} from "./chunk-G3T47CFV.js";
+
+// src/lint/types.ts
+var LintError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "LintError";
+  }
+};
+
+export {
+  LintError
+};
+//# sourceMappingURL=chunk-YGFIQ6Y5.js.map

package/dist/chunk-YGFIQ6Y5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lint/types.ts"],"sourcesContent":["/**\n * The contract every other module is written against.\n *\n * Two shapes matter. `DocumentTree` is what a parser owes the rest of the tool:\n * a nested section tree with real source positions, in a vocabulary that has\n * nothing to do with Markdown. `Finding` is what the tool owes its caller.\n * Everything between the two - matching, rules, reporting - touches neither\n * mdast nor Asciidoctor nor parse5, which is what lets a new input format be\n * one file plus a line in the parser registry.\n */\n\nimport { ToolError } from \"../shared/errors.js\";\nimport type { Severity } from \"../shared/severity.js\";\n\n/**\n * Operational/usage failure. Exits 2; never used for lint findings.\n *\n * Extends the umbrella's `ToolError`, which is what the shared bin runner\n * matches on; the subclass stays so this tool's tests and library callers can\n * match on it by name. Named for its domain, as `A11yError`, `CiteError` and\n * `KeyError` are.\n */\nexport class LintError extends ToolError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"LintError\";\n  }\n}\n\n/** A point in a source file. Line and column are 1-based, offset 0-based. */\nexport interface Point {\n  line: number;\n  column: number;\n  offset: number;\n}\n\n/** A half-open source span, `start` inclusive and `end` exclusive. */\nexport interface Position {\n  start: Point;\n  end: Point;\n}\n\n/**\n * Content kinds a section can hold, named generically so a rule written once\n * works on every format. Each parser maps its own AST onto these: mdast\n * `paragraph`/`code`/`list`, Asciidoctor `paragraph`/`listing`/`ulist`|`olist`,\n * HTML `<p>`/`<pre>`/`<ul>` - all three onto `paragraph`/`codeBlock`/`list`.\n *\n * The vocabulary is wider than any one parser emits today. `table`,\n * `admonition`, `image`, `blockquote`, `definitionList`, and `element` are\n * declared here, and in each `DocumentParser.kinds`, only once a parser\n * actually produces them - see `src/lint/parsers/index.ts`.\n */\nexport type ContentKind =\n  | \"paragraph\"\n  | \"codeBlock\"\n  | \"list\"\n  | \"listItem\"\n  | \"table\"\n  | \"tableRow\"\n  | \"tableCell\"\n  | \"admonition\"\n  | \"image\"\n  | \"blockquote\"\n  | \"definitionList\"\n  | \"definitionItem\"\n  | \"element\";\n\nexport interface ContentNodeBase {\n  kind: ContentKind;\n  position: Position;\n  /** Plain-text rendering, used by pattern rules. */\n  text: string;\n}\n\nexport interface ParagraphNode extends ContentNodeBase {\n  kind: \"paragraph\";\n}\n\nexport interface CodeNode extends ContentNodeBase {\n  kind: \"codeBlock\";\n  /** Language, when the format carries one. */\n  language?: string;\n  /** The info-string tail after the language, when the format carries one. */\n  fenceInfo?: string;\n}\n\nexport interface ListItemNode {\n  kind: \"listItem\";\n  position: Position;\n  text: string;\n  /** Nested content, so item-level paragraph/code/list rules can run. */\n  children: ContentNode[];\n}\n\nexport interface ListNode extends ContentNodeBase {\n  kind: \"list\";\n  ordered: boolean;\n  items: ListItemNode[];\n}\n\nexport interface TableCellNode extends ContentNodeBase {\n  kind: \"tableCell\";\n  children: ContentNode[];\n}\n\nexport interface TableRowNode extends ContentNodeBase {\n  kind: \"tableRow\";\n  header: boolean;\n  children: TableCellNode[];\n}\n\nexport interface TableNode extends ContentNodeBase {\n  kind: \"table\";\n  children: TableRowNode[];\n}\n\n/**\n * A callout, and the flavor the source gave it.\n *\n * `variant` is optional because not every format names one this vocabulary\n * has. reStructuredText has `hint`, `attention`, `error` and a generic\n * `admonition` directive, and a bare HTML `<aside>` says nothing at all. Those\n * produce an admonition with no variant rather than an invented equivalence:\n * mapping `hint` onto `tip` would make `variant: tip` pass on a page that\n * never said tip. A `variant:` rule reports such a node as a mismatch, and a\n * plain count rule still counts it.\n */\nexport interface AdmonitionNode extends ContentNodeBase {\n  kind: \"admonition\";\n  variant?: \"note\" | \"tip\" | \"important\" | \"caution\" | \"warning\" | \"danger\";\n  children: ContentNode[];\n}\n\nexport interface ImageNode extends ContentNodeBase {\n  kind: \"image\";\n  url: string;\n  alt: string;\n  title?: string;\n}\n\nexport interface BlockquoteNode extends ContentNodeBase {\n  kind: \"blockquote\";\n  children: ContentNode[];\n}\n\nexport interface DefinitionItemNode {\n  kind: \"definitionItem\";\n  position: Position;\n  text: string;\n  term: string;\n  definition: ContentNode[];\n}\n\nexport interface DefinitionListNode extends ContentNodeBase {\n  kind: \"definitionList\";\n  children: DefinitionItemNode[];\n}\n\n/**\n * A named wrapper - an MDX/JSX component today, and where HTML and DITA may\n * eventually anchor a custom element. Its children are its own content, never\n * the enclosing section's: a rule reading a section's `children` must not see\n * inside an `<Element>` it did not ask about.\n */\nexport interface ElementNode extends ContentNodeBase {\n  kind: \"element\";\n  name: string;\n  attributes?: Record<string, string | true>;\n  children: ContentNode[];\n}\n\nexport type ContentNode =\n  | ParagraphNode\n  | CodeNode\n  | ListNode\n  | TableNode\n  | AdmonitionNode\n  | ImageNode\n  | BlockquoteNode\n  | DefinitionListNode\n  | ElementNode;\n\n/**\n * One section of a document, demarcated by a heading.\n *\n * `slug`/`title`/`level`/`order`/`parentSlug` intentionally match manni graph's\n * `Section` (dockg/src/types.ts), so its graph can be built from this tree.\n *\n * `children` is in document order and is the single source of truth: the\n * paragraph/codeBlock/list counts every rule needs are queries over it, not\n * separately maintained arrays.\n */\nexport interface SectionNode {\n  /** Slug of the heading, disambiguated across the document (`install-1`). */\n  slug: string;\n  /** Heading text, with inline markup flattened. */\n  title: string;\n  /** Heading level, 1-6. 0 for the implicit lead section before any heading. */\n  level: number;\n  /** 1-based position among siblings under the same parent. */\n  order: number;\n  /** Slug of the enclosing section, or null at the top level. */\n  parentSlug: string | null;\n  /** Span of the title itself. Null for the implicit lead section. */\n  titlePosition: Position | null;\n  /**\n   * The anchor the source itself gives this section, verbatim - an HTML `id`,\n   * a DITA `@id`, an AsciiDoc `[[id]]`, a reST `.. _label:` - when it gives\n   * one. `slug` stays the slugged title either way: a link written against\n   * the source's own id resolves through this, and nothing lint matches on\n   * reads it.\n   */\n  id?: string;\n  /**\n   * Set on the level-1 section `withMetadataTitle` made from a metadata\n   * `title`, so a consumer can tell it from a heading the author wrote. Its\n   * `titlePosition` is not enough: a reST title read back as docinfo shares\n   * its span with the frontmatter, written or not.\n   */\n  synthetic?: true;\n  /** Span of the whole section: its heading through the last node before the next sibling heading. */\n  position: Position;\n  /** Direct content, in document order, excluding anything owned by a subsection. */\n  children: ContentNode[];\n  /** Nested sections, in document order. */\n  sections: SectionNode[];\n}\n\n/** What a parser returns for one file. */\nexport interface DocumentTree {\n  /** Name of the parser that produced this (`markdown`, `asciidoc`, ...). */\n  format: string;\n  /** Path the content came from, for error messages. */\n  filePath: string;\n  /** Raw frontmatter/metadata values, or null when the file carries none. */\n  frontmatter: Record<string, unknown> | null;\n  /** Span of the frontmatter block, for anchoring findings about it. */\n  frontmatterPosition: Position | null;\n  /** Top-level sections, in document order. */\n  sections: SectionNode[];\n  /**\n   * Link targets exactly as the source wrote them, in document order, for\n   * `manni graph`. No lint rule reads them. Each parser decides what counts:\n   * an anchor to elsewhere does, and a stylesheet, a heading's own permalink,\n   * or a key reference resolved only at build time does not.\n   */\n  links: { target: string; position: Position }[];\n}\n\n/**\n * A parser for one input format.\n *\n * Shaped after docmeta's `MetadataExtractor` so the two registries read the\n * same way. A format is registered only when its parser reads it, so every\n * registered format is one the tool reads, and an extension no parser claims is\n * skipped by name rather than parsed as Markdown.\n */\nexport interface DocumentParser {\n  /** Stable name, also used as `DocumentTree.format`. */\n  name: string;\n  /** Human-readable label for `manni lint tools`. */\n  label: string;\n  /**\n   * The content kinds this parser actually emits today. A capability\n   * declaration, not the full `ContentKind` vocabulary: a kind absent here is\n   * one no rule will ever see from this parser's trees, whatever the format\n   * could in principle represent.\n   */\n  kinds: ContentKind[];\n  /** Lowercase file extensions this parser handles, incl. dot (e.g. \".md\"). */\n  extensions: string[];\n  /**\n   * Extensions safe to collect from a directory walk. Defaults to\n   * `extensions`.\n   *\n   * The two differ when an extension is a generic container rather than a\n   * documentation format. `.xml` is the case: this parser can read a DocBook\n   * or DITA document named explicitly, but a docs tree also contains\n   * `pom.xml`, `sitemap.xml`, and `.csproj`, and sweeping those in turns a\n   * clean run into a failure about files the user never asked to lint.\n   */\n  walkExtensions?: string[];\n  /** Parse raw file content into the generic tree. */\n  parse(content: string, filePath: string): DocumentTree;\n}\n\n/**\n * How much a finding weighs, on the one scale every manni tool speaks\n * (`src/shared/severity.ts`): `notice | warning | error`.\n *\n * Almost every structural finding is an `error`, since a template either\n * describes a document or it does not. `unsupported_content_kind` is the\n * exception and is a `warning`: the rule never ran, so the page may still be\n * fine, and a warning never moves the exit code.\n *\n * The scale is the family's and not this tool's private pair, because a flag\n * or config key two domains both have carries the same name *and* the same\n * values. Re-exported so `lint.Severity` names the same type a caller already\n * has.\n */\nexport type { Severity };\n\n/**\n * One structural violation.\n *\n * The field set is pinned by manni docevals' tool adapter, which reads\n * `{ type, heading, message, position }` off the JSON reporter. Additions are\n * safe; renames are not.\n */\nexport interface Finding {\n  /** Machine-readable rule id, e.g. `missing_section`. */\n  type: string;\n  /** Heading of the section the finding is anchored to, if any. */\n  heading: string | null;\n  message: string;\n  position: Position;\n  severity: Severity;\n}\n\n/**\n * Why a file was not linted.\n *\n * `unreadable` is the one that is not about the document: the file was found,\n * claimed by a parser, and then could not be opened - a denied permission, a\n * symlink loop, a page a doc build moved between the walk and the read. It is a\n * skip rather than a finding because nothing was checked, and calling it a\n * finding would report the docs as wrong when the filesystem was.\n */\nexport type SkipReason = \"no-template\" | \"unsupported-format\" | \"unreadable\";\n\n/** Result of linting one file. */\nexport interface FileResult {\n  file: string;\n  /** True when the file was linted and produced no findings. */\n  success: boolean;\n  findings: Finding[];\n  /** Template id/ref applied, or null when skipped. */\n  template: string | null;\n  /** Set when the file was skipped rather than linted. */\n  skipped?: SkipReason;\n}\n"],"mappings":";;;;;;AAsBO,IAAM,YAAN,cAAwB,UAAU;AAAA,EACvC,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;","names":[]}

package/dist/chunk-YLK2J5YK.js

@@ -0,0 +1,610 @@
+#!/usr/bin/env node
+import {
+  emptyWindow,
+  materialize,
+  windowOf
+} from "./chunk-CWXZ2MRT.js";
+import {
+  extractEvals,
+  findGitRoot,
+  listInTree,
+  resolveArtifacts,
+  safeRead
+} from "./chunk-APKH2T6E.js";
+import {
+  configDir
+} from "./chunk-4TSWU2SU.js";
+import {
+  extractFrontmatter
+} from "./chunk-KCOFEWV5.js";
+
+// src/tracevals/rules/turn.ts
+var INJECTED = /<(system-reminder|task-notification|ci-monitor-event|local-command-stdout|local-command-stderr|local-command-caveat)>[\s\S]*?<\/\1>/g;
+var MARKER = /^(?:Stop hook feedback:|SubagentStop hook feedback:|\[Request interrupted by user)/;
+var TYPED_TURN_ORIGINS = /* @__PURE__ */ new Set(["human", "sdk"]);
+var WORK = /* @__PURE__ */ new Set(["assistant", "tool_call", "tool_result"]);
+function isTypedPrompt(event) {
+  if (event.kind !== "user" || event.text === void 0) return false;
+  const { raw } = event;
+  if (raw.isMeta === true || raw.isCompactSummary === true) return false;
+  const origin = raw.origin;
+  if (typeof origin === "object" && origin !== null && "kind" in origin && typeof origin.kind === "string") {
+    if (!TYPED_TURN_ORIGINS.has(origin.kind)) return false;
+  } else if (typeof raw.turnOrigin === "string" && !TYPED_TURN_ORIGINS.has(raw.turnOrigin)) {
+    return false;
+  }
+  const rest = event.text.replace(INJECTED, "").trim();
+  return rest !== "" && !MARKER.test(rest);
+}
+function lastTurn(trace) {
+  const prompts = trace.events.filter((e) => e.sidechain !== true && isTypedPrompt(e));
+  const sessionTurnCount = prompts.length;
+  const to = trace.events.length - 1;
+  const last = prompts.at(-1);
+  if (last === void 0) {
+    return {
+      window: emptyWindow("turn", "last turn", "the trace holds no prompt the user typed"),
+      from: to + 1,
+      to,
+      sessionTurnCount
+    };
+  }
+  return slice(trace, last.index, [last], /* @__PURE__ */ new Set([void 0]), sessionTurnCount, {
+    label: "last turn",
+    reason: "nothing happened after the last prompt the user typed"
+  });
+}
+function subagentTurn(trace) {
+  const prompts = trace.events.filter(isTypedPrompt);
+  return slice(
+    trace,
+    0,
+    prompts,
+    new Set(trace.events.map((e) => e.branchId)),
+    prompts.length,
+    { label: "subagent run", reason: "the subagent recorded no work" }
+  );
+}
+function slice(trace, from, prompts, own, sessionTurnCount, words) {
+  const to = trace.events.length - 1;
+  const worked = trace.events.some((e) => e.index > from && WORK.has(e.kind));
+  if (!worked) {
+    return {
+      window: emptyWindow("turn", words.label, words.reason),
+      from,
+      to,
+      sessionTurnCount
+    };
+  }
+  const window = materialize(
+    trace,
+    "turn",
+    words.label,
+    [{ start: from, end: Number.POSITIVE_INFINITY }],
+    void 0,
+    own
+  );
+  window.userMessages = prompts.map((p) => p.text ?? "");
+  window.turnCount = sessionTurnCount;
+  return { window, from, to, sessionTurnCount };
+}
+
+// src/tracevals/rules/sources.ts
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import picomatch from "picomatch";
+var MAX_IMPORT_HOPS = 4;
+var Collector = class {
+  constructor(cwd, root, home, exclude) {
+    this.cwd = cwd;
+    this.root = root;
+    this.home = home;
+    const match = exclude.length > 0 ? picomatch(exclude, { dot: true }) : null;
+    this.excluded = (path) => match !== null && match(this.display(path));
+  }
+  cwd;
+  root;
+  home;
+  sources = [];
+  warnings = [];
+  seen = /* @__PURE__ */ new Set();
+  parsed = /* @__PURE__ */ new Map();
+  excluded;
+  display(path) {
+    const inRoot = relPosix(this.root, path);
+    if (inRoot !== null) return inRoot;
+    const inHome = relPosix(this.home, path);
+    if (inHome !== null) return `~/${inHome}`;
+    return path.split(sep).join("/");
+  }
+  has(path) {
+    return this.seen.has(key(path));
+  }
+  /** The file's front matter, or null when it has none or it does not parse. */
+  front(path, content) {
+    const k = key(path);
+    if (this.parsed.has(k)) return this.parsed.get(k) ?? null;
+    let parsed = null;
+    try {
+      const fm = extractFrontmatter(content, "markdown");
+      parsed = fm.present ? fm : null;
+    } catch (err) {
+      const loose = isCursorRule(path) ? cursorFront(content) : null;
+      if (loose !== null) {
+        this.parsed.set(k, loose);
+        return loose;
+      }
+      const first = (err instanceof Error ? err.message : String(err)).split("\n")[0] ?? "";
+      this.warnings.push(
+        `${this.display(path)}: front matter does not parse (${first}), so it is read as having none`
+      );
+    }
+    this.parsed.set(k, parsed);
+    return parsed;
+  }
+  /** Adds a source once. Returns it, or null when excluded or already listed. */
+  add(path, content, format, trigger, skill) {
+    if (this.has(path) || this.excluded(path)) return null;
+    this.seen.add(key(path));
+    const source = {
+      path,
+      displayPath: this.display(path),
+      format,
+      trigger,
+      content,
+      sha256: createHash("sha256").update(content).digest("hex")
+    };
+    if (skill !== void 0) source.skill = skill;
+    const declared = this.declared(path, content);
+    if (declared !== void 0) source.declaredRules = declared;
+    this.sources.push(source);
+    return source;
+  }
+  /**
+   * Adds a source that says what the session was asked. These never declare
+   * evals. With no file, its display path is its format, and no glob removes it.
+   */
+  addRequest(file, content, format, trigger) {
+    if (file !== null) {
+      if (this.has(file) || this.excluded(file)) return;
+      this.seen.add(key(file));
+    }
+    this.sources.push({
+      path: file ?? "",
+      displayPath: file === null ? format : this.display(file),
+      format,
+      trigger,
+      content,
+      sha256: createHash("sha256").update(content).digest("hex")
+    });
+  }
+  declared(path, content) {
+    const fm = this.front(path, content);
+    if (fm === null) return void 0;
+    const extracted = extractEvals(
+      { name: basename(path), type: "project-rules", path, content, origin: "project" },
+      fm
+    );
+    if (extracted.errors.length > 0) {
+      this.warnings.push(
+        `${this.display(path)}: metadata.evals does not validate (${extracted.errors[0]?.message ?? "invalid"}), so it declares no rules`
+      );
+      return void 0;
+    }
+    const rules = [];
+    for (const entry of extracted.evals) {
+      if (entry.grader !== "ai" || entry.assertion === void 0) continue;
+      const rule = { id: entry.id, text: entry.assertion };
+      const when = entry.options?.when;
+      if (isRecord(when)) rule.when = when;
+      rules.push(rule);
+    }
+    return rules.length > 0 ? rules : void 0;
+  }
+};
+async function resolveAlwaysSources(opts) {
+  const c = await collector(opts);
+  for (const candidate of await catalog(c, opts)) {
+    if (candidate.trigger.kind === "always") await addWithImports(c, candidate, "always");
+  }
+  await addDesignated(c, opts);
+  return { sources: c.sources, warnings: c.warnings };
+}
+async function resolveTurnSources(trace, turn, opts) {
+  const c = await collector(opts);
+  const touches = trace.fileAccesses.filter((a) => a.index <= turn.to).map((a) => {
+    const abs = resolve(c.cwd, a.path);
+    return { abs, rel: relPosix(c.root, abs), read: a.op === "read" };
+  });
+  const wasRead = new Set(touches.filter((t) => t.read).map((t) => key(t.abs)));
+  for (const candidate of await catalog(c, opts)) {
+    const { trigger } = candidate;
+    if (trigger.kind === "always") {
+      await addWithImports(c, candidate, "always");
+    } else if (trigger.kind === "read") {
+      if (wasRead.has(key(candidate.path))) await addWithImports(c, candidate, "read");
+    } else {
+      const match = picomatch(trigger.patterns, { dot: true });
+      const hit = touches.find((t) => t.rel !== null && match(t.rel));
+      if (hit !== void 0 && hit.rel !== null) {
+        await addWithImports(c, candidate, `${trigger.key} matched ${hit.rel}`);
+      }
+    }
+  }
+  const nested = /* @__PURE__ */ new Map();
+  for (const touch of touches) {
+    if (touch.rel === null) continue;
+    for (const dir of dirsBelowCwd(c, dirname(touch.abs))) {
+      if (!nested.has(dir)) nested.set(dir, touch.rel);
+    }
+  }
+  const dirs = [...nested.keys()].sort((a, b) => a.length - b.length);
+  for (const dir of dirs) {
+    const touched = nested.get(dir) ?? "";
+    for (const [name, format] of NESTED_FILES) {
+      const path = join(dir, name);
+      const content = await safeRead(path);
+      if (content !== null) {
+        await addWithImports(c, { path, format, trigger: { kind: "always" } }, `touched ${touched}`, content);
+      }
+    }
+  }
+  await addWindowed(c, trace, turn, touches, opts);
+  await addDesignated(c, opts);
+  addPrompts(c, trace, turn);
+  await addPlan(c, trace, turn, opts);
+  await addSpecs(c, touches, opts.plans ?? []);
+  return { sources: c.sources, warnings: c.warnings };
+}
+function addPrompts(c, trace, turn) {
+  const typed = trace.events.filter((e) => e.index <= turn.to && isTypedPrompt(e));
+  const main = typed.filter((e) => e.sidechain !== true);
+  const prompts = main.length > 0 ? main : typed;
+  if (prompts.length === 0) return;
+  const content = prompts.map((p, i) => `${String(i + 1)}. ${(p.text ?? "").trim()}`).join("\n\n");
+  c.addRequest(null, content, "prompt", `typed prompts 1-${String(prompts.length)}`);
+}
+async function addPlan(c, trace, turn, opts) {
+  const approved = trace.toolCalls.filter((call) => call.name === "ExitPlanMode" && call.index <= turn.to).filter((call) => isApproved(trace, call.index, turn.to)).at(-1);
+  if (approved === void 0) return;
+  const trigger = `approved at turn ${String(approved.index)}`;
+  const plan = approved.input.plan;
+  if (typeof plan === "string" && plan.trim() !== "") {
+    c.addRequest(null, plan, "plan", trigger);
+    return;
+  }
+  const plansDir = join(configDir(opts.env), "plans");
+  const file = trace.fileAccesses.filter((a) => a.op !== "read" && a.index < approved.index).map((a) => resolve(c.cwd, a.path)).filter((abs) => relPosix(plansDir, abs) !== null).at(-1);
+  if (file === void 0) return;
+  const content = await safeRead(file);
+  if (content !== null) c.addRequest(file, content, "plan", trigger);
+}
+function isApproved(trace, index, to) {
+  const id = trace.events.find((e) => e.index === index)?.raw.id;
+  if (typeof id !== "string") return false;
+  for (const event of trace.events) {
+    if (event.kind !== "tool_result" || event.index <= index || event.index > to) continue;
+    const message = event.raw.message;
+    const blocks = isRecord(message) ? message.content : void 0;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (isRecord(block) && block.type === "tool_result" && block.tool_use_id === id) {
+        return block.is_error !== true;
+      }
+    }
+  }
+  return false;
+}
+var SPEC_FILES = {
+  "speckit-spec": ["spec.md", "plan.md", "tasks.md"],
+  "kiro-spec": ["requirements.md", "design.md", "tasks.md"]
+};
+function specDirOf(rel) {
+  const parts = rel.split("/");
+  const [first, second, third] = parts;
+  if (first === "specs" && second !== void 0 && parts.length > 2) {
+    return { dir: `specs/${second}`, format: "speckit-spec" };
+  }
+  if (first === ".kiro" && second === "specs" && third !== void 0 && parts.length > 3) {
+    return { dir: `.kiro/specs/${third}`, format: "kiro-spec" };
+  }
+  if (first === "openspec" && second === "changes" && third !== void 0 && third !== "archive" && parts.length > 3) {
+    return { dir: `openspec/changes/${third}`, format: "openspec-change" };
+  }
+  return null;
+}
+async function addSpecs(c, touches, plans) {
+  const isPlan = plans.length > 0 ? picomatch(plans, { dot: true }) : null;
+  const done = /* @__PURE__ */ new Set();
+  for (const touch of touches) {
+    const { rel } = touch;
+    if (rel === null) continue;
+    const trigger = `touched ${rel}`;
+    const spec = specDirOf(rel);
+    if (spec !== null && !done.has(spec.dir)) {
+      done.add(spec.dir);
+      const dir = join(c.root, ...spec.dir.split("/"));
+      const files = spec.format === "openspec-change" ? await listInTree(dir, (p) => p.endsWith(".md")) : SPEC_FILES[spec.format].map((name) => join(dir, name));
+      for (const file of files) {
+        const content = await safeRead(file);
+        if (content !== null) c.addRequest(file, content, spec.format, trigger);
+      }
+    }
+    if (isPlan?.(rel) === true) {
+      const content = await safeRead(touch.abs);
+      if (content !== null) c.addRequest(touch.abs, content, "plans", trigger);
+    }
+  }
+}
+async function addDesignated(c, opts) {
+  const include = opts.include ?? [];
+  if (include.length === 0) return;
+  const match = picomatch(include, { dot: true });
+  const found = await listInTree(c.root, (abs) => {
+    const rel = relPosix(c.root, abs);
+    return rel !== null && match(rel);
+  });
+  for (const abs of found) {
+    if (c.has(abs)) continue;
+    const content = await safeRead(abs);
+    if (content === null) {
+      c.warnings.push(`${c.display(abs)}: matched conformance.include but could not be read`);
+      continue;
+    }
+    c.add(abs, content, "designated", "always");
+  }
+}
+async function addWindowed(c, trace, turn, touches, opts) {
+  const { artifacts } = await resolveArtifacts(
+    {
+      ...trace,
+      agentSpawns: opts.agentType === void 0 ? [] : [{ subagentType: opts.agentType, index: 0 }]
+    },
+    { projectDir: c.cwd, projectRoot: c.root, ...opts.env ? { env: opts.env } : {} }
+  );
+  for (const artifact of artifacts) {
+    if (artifact.type === "agent") {
+      c.add(artifact.path, artifact.content, "agent", "subagent run");
+      continue;
+    }
+    if (artifact.type !== "skill" && artifact.type !== "slash-command") continue;
+    const window = windowOf(trace, artifact);
+    if (!window.events.some((e) => e.index <= turn.to)) continue;
+    if (artifact.type === "slash-command") {
+      c.add(artifact.path, artifact.content, "slash-command", "slash command window");
+      continue;
+    }
+    c.add(artifact.path, artifact.content, "skill", "skill window", artifact.name);
+    const skillDir = dirname(artifact.path);
+    for (const touch of touches) {
+      if (!touch.read || relPosix(skillDir, touch.abs) === null || c.has(touch.abs)) continue;
+      const content = await safeRead(touch.abs);
+      if (content !== null) {
+        c.add(touch.abs, content, "skill", `read under skill ${artifact.name}`, artifact.name);
+      }
+    }
+  }
+}
+var ANCESTOR_FILES = [
+  ["CLAUDE.md", "claude-md"],
+  ["CLAUDE.local.md", "claude-md"],
+  [join(".claude", "CLAUDE.md"), "claude-md"],
+  ["AGENTS.md", "agents-md"],
+  [join(".claude", "AGENTS.md"), "agents-md"],
+  ["GEMINI.md", "gemini-md"]
+];
+var NESTED_FILES = [
+  ["CLAUDE.md", "claude-md"],
+  ["AGENTS.md", "agents-md"],
+  ["GEMINI.md", "gemini-md"]
+];
+async function catalog(c, opts) {
+  const out = [];
+  const userClaude = configDir(opts.env);
+  const always = { kind: "always" };
+  out.push({ path: join(userClaude, "CLAUDE.md"), format: "claude-md", trigger: always });
+  out.push({ path: join(c.home, ".gemini", "GEMINI.md"), format: "gemini-md", trigger: always });
+  for (const dir of ancestors(c.cwd, c.root).reverse()) {
+    for (const [name, format] of ANCESTOR_FILES) {
+      out.push({ path: join(dir, name), format, trigger: always });
+    }
+  }
+  const bases = c.cwd === c.root ? [c.root] : [c.root, c.cwd];
+  for (const dir of [join(userClaude, "rules"), ...bases.map((b) => join(b, ".claude", "rules"))]) {
+    for (const path of await listInTree(dir, (p) => p.endsWith(".md"))) {
+      out.push({ path, format: "claude-rule", trigger: await claudeRuleTrigger(c, path) });
+    }
+  }
+  for (const base of bases) {
+    const dir = join(base, ".cursor", "rules");
+    for (const path of await listInTree(dir, (p) => p.endsWith(".mdc") || p.endsWith(".md"))) {
+      const trigger = await cursorTrigger(c, path);
+      if (trigger !== null) out.push({ path, format: "cursor-rule", trigger });
+    }
+  }
+  for (const dir of [join(c.home, ".kiro", "steering"), ...bases.map((b) => join(b, ".kiro", "steering"))]) {
+    for (const path of await listInTree(dir, (p) => p.endsWith(".md"), { maxDepth: 0 })) {
+      out.push({ path, format: "kiro-steering", trigger: await kiroTrigger(c, path) });
+    }
+  }
+  for (const base of bases) {
+    out.push({
+      path: join(base, ".specify", "memory", "constitution.md"),
+      format: "speckit-constitution",
+      trigger: always
+    });
+    out.push({ path: join(base, "openspec", "project.md"), format: "openspec-project", trigger: { kind: "read" } });
+  }
+  return out;
+}
+async function frontOf(c, path) {
+  const content = await safeRead(path);
+  if (content === null) return null;
+  return c.front(path, content)?.data ?? null;
+}
+async function claudeRuleTrigger(c, path) {
+  const patterns = globList((await frontOf(c, path))?.paths);
+  return patterns.length > 0 ? { kind: "globs", key: "paths", patterns } : { kind: "always" };
+}
+async function cursorTrigger(c, path) {
+  const fm = await frontOf(c, path);
+  if (fm === null && !path.endsWith(".mdc")) return null;
+  if (fm?.alwaysApply === true) return { kind: "always" };
+  const patterns = globList(fm?.globs);
+  return patterns.length > 0 ? { kind: "globs", key: "globs", patterns } : { kind: "read" };
+}
+async function kiroTrigger(c, path) {
+  const fm = await frontOf(c, path);
+  const inclusion = fm?.inclusion;
+  if (inclusion === void 0 || inclusion === "always") return { kind: "always" };
+  if (inclusion === "fileMatch") {
+    const patterns = globList(fm?.fileMatchPattern);
+    if (patterns.length > 0) return { kind: "globs", key: "fileMatchPattern", patterns };
+  }
+  return { kind: "read" };
+}
+async function addWithImports(c, candidate, trigger, known) {
+  if (c.has(candidate.path)) return;
+  const content = known ?? await safeRead(candidate.path);
+  if (content === null) return;
+  const added = c.add(candidate.path, content, candidate.format, trigger);
+  if (added === null || candidate.format !== "claude-md" && candidate.format !== "gemini-md") {
+    return;
+  }
+  let frontier = [added];
+  for (let hop = 1; hop <= MAX_IMPORT_HOPS && frontier.length > 0; hop += 1) {
+    const next = [];
+    for (const importer of frontier) {
+      for (const ref of importsOf(importer.content)) {
+        const path = ref.startsWith("~/") ? join(c.home, ref.slice(2)) : resolve(dirname(importer.path), ref);
+        if (c.has(path)) continue;
+        const body = await safeRead(path);
+        if (body === null) continue;
+        const source = c.add(path, body, "import", `imported by ${importer.displayPath}`);
+        if (source !== null) next.push(source);
+      }
+    }
+    frontier = next;
+  }
+}
+function importsOf(content) {
+  const refs = [];
+  let fence = null;
+  for (const line of content.split(/\r?\n/)) {
+    const marker = /^\s*(`{3,}|~{3,})/.exec(line)?.[1];
+    if (marker !== void 0) {
+      const char = marker.charAt(0);
+      if (fence === null) {
+        fence = { char, length: marker.length };
+        continue;
+      }
+      if (char === fence.char && marker.length >= fence.length && line.trim() === marker) {
+        fence = null;
+        continue;
+      }
+    }
+    if (fence !== null) continue;
+    const prose = line.replace(/`[^`]*`/g, "");
+    for (const m of prose.matchAll(/(?:^|\s)@([^\s`]+)/g)) {
+      const ref = m[1]?.replace(/[.,;:!?)\]]+$/, "");
+      if (ref) refs.push(ref);
+    }
+  }
+  return refs;
+}
+async function collector(opts) {
+  const cwd = resolve(opts.projectDir);
+  const root = resolve(opts.projectRoot ?? await findGitRoot(cwd) ?? cwd);
+  return new Collector(cwd, root, homeDir(opts.env), opts.exclude ?? []);
+}
+function homeDir(env = process.env) {
+  const set = process.platform === "win32" ? env.USERPROFILE ?? env.HOME : env.HOME;
+  return resolve(set ?? homedir());
+}
+function ancestors(cwd, root) {
+  const dirs = [];
+  let current = cwd;
+  for (let depth = 0; depth < 32; depth += 1) {
+    dirs.push(current);
+    if (current === root) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return dirs;
+}
+function dirsBelowCwd(c, dir) {
+  const dirs = [];
+  let current = dir;
+  for (let depth = 0; depth < 64; depth += 1) {
+    if (relPosix(c.root, current) === null || relPosix(current, c.cwd) !== null) break;
+    dirs.push(current);
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return dirs;
+}
+function isCursorRule(path) {
+  return path.split(sep).join("/").includes("/.cursor/rules/");
+}
+function cursorFront(content) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content)?.[1];
+  if (block === void 0) return null;
+  const data = {};
+  for (const line of block.split(/\r?\n/)) {
+    const m = /^(description|globs|alwaysApply):\s*(.*)$/.exec(line);
+    const name = m?.[1];
+    const value = m?.[2]?.trim();
+    if (name === void 0 || value === void 0) continue;
+    data[name] = name === "alwaysApply" ? value === "true" : value;
+  }
+  if (Object.keys(data).length === 0) return null;
+  return { data, present: true, format: "markdown", lineFor: () => void 0 };
+}
+function globList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string" && v.trim() !== "").map((v) => v.trim());
+  }
+  if (typeof value !== "string") return [];
+  const out = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of value) {
+    if (ch === "{") depth += 1;
+    if (ch === "}") depth = Math.max(0, depth - 1);
+    if (ch === "," && depth === 0) {
+      out.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  out.push(current);
+  return out.map((p) => p.trim()).filter((p) => p !== "");
+}
+function relPosix(base, path) {
+  const rel = relative(base, path);
+  if (rel === "") return "";
+  if (rel.startsWith("..") || isAbsolute(rel)) return null;
+  return rel.split(sep).join("/");
+}
+function key(path) {
+  const abs = resolve(path);
+  return process.platform === "win32" ? abs.toLowerCase() : abs;
+}
+var pathKey = key;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  isTypedPrompt,
+  lastTurn,
+  subagentTurn,
+  resolveAlwaysSources,
+  resolveTurnSources,
+  pathKey
+};
+//# sourceMappingURL=chunk-YLK2J5YK.js.map