@hawkeyexl/manni 4.5.0 → 4.7.0

package/dist/chunk-D6RO54QD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/rules/turn.ts","../src/tracevals/rules/sources.ts"],"sourcesContent":["/**\n * The turn a Stop or SubagentStop judges (proposal 0079). A turn starts at the\n * last prompt the user typed; tool results and hook feedback do not start one.\n * Under SubagentStop the turn is the subagent's whole run.\n *\n * Which user records are typed prompts is read from the record shape Claude\n * Code writes, not guessed from wording alone:\n *\n *  - `isMeta: true` marks harness injections: a skill's \"Base directory\" body,\n *    `<local-command-caveat>`, peer and scheduled messages, hook feedback.\n *  - `isCompactSummary: true` is the \"session is being continued\" summary.\n *  - `origin.kind` is `human` for a typed prompt and `task-notification` or\n *    `peer` otherwise. Older records carry only `turnOrigin`, whose non-typed\n *    values are `task_notification`, `scheduled` and `peer`.\n *  - A record whose text is nothing but `<system-reminder>`,\n *    `<task-notification>`, `<ci-monitor-event>` or `<local-command-*>` blocks\n *    is an injection. A typed prompt Claude Code prefixed with a reminder keeps\n *    the text after it, so it still counts.\n *  - `Stop hook feedback:` and `[Request interrupted by user…]` are markers,\n *    never prompts.\n *\n * A `<command-name>` record is a slash command someone typed, so it counts.\n */\nimport {\n  emptyWindow,\n  materialize,\n  type TraceWindow,\n} from \"../graders/util.js\";\nimport type { Trace, TraceEvent } from \"../trace/types.js\";\n\nexport interface TurnSlice {\n  window: TraceWindow;\n  /** Ordinal in `trace.events` of the turn's first event. */\n  from: number;\n  /** Ordinal of its last event, inclusive. Less than `from` when there is no turn. */\n  to: number;\n  /** Typed prompts in the whole session, which `turn-count-above` reads. */\n  sessionTurnCount: number;\n}\n\nconst INJECTED =\n  /<(system-reminder|task-notification|ci-monitor-event|local-command-stdout|local-command-stderr|local-command-caveat)>[\\s\\S]*?<\\/\\1>/g;\nconst MARKER =\n  /^(?:Stop hook feedback:|SubagentStop hook feedback:|\\[Request interrupted by user)/;\n/**\n * Origins of a prompt a person sent: typed in the CLI, or sent through the SDK.\n * Both record formats name it, as `origin.kind` or the older `turnOrigin`,\n * and both are read against this one set.\n */\nconst TYPED_TURN_ORIGINS = new Set([\"human\", \"sdk\"]);\nconst WORK = new Set<TraceEvent[\"kind\"]>([\"assistant\", \"tool_call\", \"tool_result\"]);\n\nexport function isTypedPrompt(event: TraceEvent): boolean {\n  if (event.kind !== \"user\" || event.text === undefined) return false;\n  const { raw } = event;\n  if (raw.isMeta === true || raw.isCompactSummary === true) return false;\n  const origin = raw.origin;\n  if (\n    typeof origin === \"object\" &&\n    origin !== null &&\n    \"kind\" in origin &&\n    typeof origin.kind === \"string\"\n  ) {\n    if (!TYPED_TURN_ORIGINS.has(origin.kind)) return false;\n  } else if (\n    typeof raw.turnOrigin === \"string\" &&\n    !TYPED_TURN_ORIGINS.has(raw.turnOrigin)\n  ) {\n    return false;\n  }\n  const rest = event.text.replace(INJECTED, \"\").trim();\n  return rest !== \"\" && !MARKER.test(rest);\n}\n\n/** The last turn of a session: its last typed prompt to the end of the trace. */\nexport function lastTurn(trace: Trace): TurnSlice {\n  const prompts = trace.events.filter((e) => e.sidechain !== true && isTypedPrompt(e));\n  const sessionTurnCount = prompts.length;\n  const to = trace.events.length - 1;\n  const last = prompts.at(-1);\n  if (last === undefined) {\n    return {\n      window: emptyWindow(\"turn\", \"last turn\", \"the trace holds no prompt the user typed\"),\n      from: to + 1,\n      to,\n      sessionTurnCount,\n    };\n  }\n  return slice(trace, last.index, [last], new Set([undefined]), sessionTurnCount, {\n    label: \"last turn\",\n    reason: \"nothing happened after the last prompt the user typed\",\n  });\n}\n\n/**\n * A subagent's sidecar transcript parsed alone. Every record is a sidechain,\n * so the parser keeps no prompts; the turn is the whole run, and its prompts\n * are the task the subagent was given.\n */\nexport function subagentTurn(trace: Trace): TurnSlice {\n  const prompts = trace.events.filter(isTypedPrompt);\n  return slice(\n    trace,\n    0,\n    prompts,\n    new Set(trace.events.map((e) => e.branchId)),\n    prompts.length,\n    { label: \"subagent run\", reason: \"the subagent recorded no work\" },\n  );\n}\n\nfunction slice(\n  trace: Trace,\n  from: number,\n  prompts: TraceEvent[],\n  own: Set<string | undefined>,\n  sessionTurnCount: number,\n  words: { label: string; reason: string },\n): TurnSlice {\n  const to = trace.events.length - 1;\n  const worked = trace.events.some((e) => e.index > from && WORK.has(e.kind));\n  if (!worked) {\n    return {\n      window: emptyWindow(\"turn\", words.label, words.reason),\n      from,\n      to,\n      sessionTurnCount,\n    };\n  }\n  const window = materialize(\n    trace,\n    \"turn\",\n    words.label,\n    [{ start: from, end: Number.POSITIVE_INFINITY }],\n    undefined,\n    own,\n  );\n  // Only typed prompts are prompts here, and `turnCount` is the session's,\n  // because the one condition that reads it counts session turns.\n  window.userMessages = prompts.map((p) => p.text ?? \"\");\n  window.turnCount = sessionTurnCount;\n  return { window, from, to, sessionTurnCount };\n}\n","/**\n * Which files govern the agent in a turn (proposal 0079, \"Rule sources and\n * their triggers\"). Resolution is deterministic, from the filesystem and the\n * trace; no model decides which files count.\n *\n * The list of formats is closed. Reading a file never makes it a source: a\n * README or a product docs page describes other systems, so only the known\n * formats, files named by `include`, and what a skill or an `@path` import\n * pulls in are ever returned. `exclude` removes a file from every row.\n *\n * To touch a file is to Read, Write or Edit it, anywhere in the session up to\n * the turn's end, which is Claude Code's own trigger for path-scoped rules.\n *\n * Six more formats say what the session was asked (proposal 0080): the typed\n * prompts, the approved plan, a touched Spec Kit feature, Kiro spec or live\n * OpenSpec change, and a touched file `conformance.plans` names. None is known\n * at session start, so only a turn resolves them, and none declares evals.\n *\n * Two are read from the transcript itself (proposal 0081): the system prompt\n * of the last prompt snapshot, and a user output style. Claude Code's own\n * prompt is reported and never blocks; a prompt the user wrote blocks.\n */\nimport { createHash } from \"node:crypto\";\nimport { homedir } from \"node:os\";\nimport { basename, dirname, isAbsolute, join, relative, resolve, sep } from \"node:path\";\nimport picomatch from \"picomatch\";\nimport { extractFrontmatter } from \"../../meta/extractors/frontmatter.js\";\nimport type { ExtractedMetadata } from \"../../meta/types.js\";\nimport { resolveArtifacts } from \"../artifacts/resolve.js\";\nimport { findGitRoot, listInTree, safeRead } from \"../artifacts/fs.js\";\nimport { extractEvals } from \"../evals/extract.js\";\nimport { windowOf } from \"../graders/util.js\";\nimport { makeRedactor } from \"../judge/redact.js\";\nimport { configDir } from \"../trace/discover.js\";\nimport type { Trace } from \"../trace/types.js\";\nimport { isTypedPrompt } from \"./turn.js\";\n\nexport type RuleFormat =\n  | \"claude-md\"\n  | \"claude-rule\"\n  | \"agents-md\"\n  | \"gemini-md\"\n  | \"cursor-rule\"\n  | \"kiro-steering\"\n  | \"speckit-constitution\"\n  | \"openspec-project\"\n  | \"import\"\n  | \"skill\"\n  | \"slash-command\"\n  | \"agent\"\n  | \"designated\"\n  | \"prompt\"\n  | \"plan\"\n  | \"speckit-spec\"\n  | \"kiro-spec\"\n  | \"openspec-change\"\n  | \"plans\"\n  | \"system-prompt\"\n  | \"output-style\";\n\n/** An `ai` eval a source declares; its assertion is the rule (proposal 0079). */\nexport interface DeclaredRule {\n  id: string;\n  text: string;\n  when?: Record<string, unknown>;\n}\n\nexport interface RuleSource {\n  /** Absolute path on disk, or `\"\"` for the typed prompts, an inline plan and the system prompt. */\n  path: string;\n  /** Relative to the project root with forward slashes, or `~/…` under home. */\n  displayPath: string;\n  format: RuleFormat;\n  /** Why the file is in scope, in words: `always`, `read`, `touched src/a.ts`. */\n  trigger: string;\n  content: string;\n  /** sha256 of `content`, hex. */\n  sha256: string;\n  /** The skill a `skill` source belongs to. */\n  skill?: string;\n  /** Present when the file declares `ai` evals; they replace extraction. */\n  declaredRules?: DeclaredRule[];\n  /** False for Claude Code's default system prompt, whose rules are reported and never block. */\n  blocks: boolean;\n}\n\nexport interface SourceOptions {\n  /** The session's working directory, where the ancestor walk starts. */\n  projectDir: string;\n  /** Ceiling for the ancestor walk and base of `displayPath`; default the git root. */\n  projectRoot?: string;\n  /** `CLAUDE_CONFIG_DIR` finds `~/.claude`; `HOME` / `USERPROFILE` find `~/.gemini` and `~/.kiro`. */\n  env?: Record<string, string | undefined>;\n  /** `conformance.include`: globs, relative to the project root, in scope once read. */\n  include?: string[];\n  /** `conformance.exclude`: globs never treated as sources, in any row, and source names. */\n  exclude?: string[];\n  /** `judge.redact`: patterns scrubbed from what the transcript records of the system prompt. */\n  redact?: string[];\n  /** `conformance.plans`: globs, relative to the project root, in scope once touched. */\n  plans?: string[];\n  /** Set under SubagentStop: the subagent type whose definition governs the run. */\n  agentType?: string;\n}\n\nexport interface ResolvedSources {\n  sources: RuleSource[];\n  warnings: string[];\n}\n\n/** The turn's ordinal bounds in `trace.events`, inclusive. `lastTurn` returns them. */\nexport interface TurnBounds {\n  from: number;\n  to: number;\n}\n\n/** Imports followed from a `claude-md` or `gemini-md` file, as Claude Code does. */\nconst MAX_IMPORT_HOPS = 4;\n\ntype Trigger =\n  | { kind: \"always\" }\n  | { kind: \"read\" }\n  | { kind: \"globs\"; key: string; patterns: string[] };\n\ninterface Candidate {\n  path: string;\n  format: RuleFormat;\n  trigger: Trigger;\n}\n\ninterface Touch {\n  abs: string;\n  rel: string | null;\n  read: boolean;\n}\n\nclass Collector {\n  readonly sources: RuleSource[] = [];\n  readonly warnings: string[] = [];\n  private readonly seen = new Set<string>();\n  private readonly parsed = new Map<string, ExtractedMetadata | null>();\n  private readonly excluded: (path: string) => boolean;\n  /** Whether `exclude` lists, as it is, the name of a source with no file, such as `prompt`. */\n  readonly excludedName: (name: string) => boolean;\n\n  constructor(\n    readonly cwd: string,\n    readonly root: string,\n    readonly home: string,\n    exclude: string[],\n  ) {\n    const match = exclude.length > 0 ? picomatch(exclude, { dot: true }) : null;\n    this.excluded = (path) => match !== null && match(this.display(path));\n    // The whole name, never a glob: `**` names files, and keeps the prompt.\n    this.excludedName = (name) => exclude.includes(name);\n  }\n\n  display(path: string): string {\n    const inRoot = relPosix(this.root, path);\n    if (inRoot !== null) return inRoot;\n    const inHome = relPosix(this.home, path);\n    if (inHome !== null) return `~/${inHome}`;\n    return path.split(sep).join(\"/\");\n  }\n\n  has(path: string): boolean {\n    return this.seen.has(key(path));\n  }\n\n  /** The file's front matter, or null when it has none or it does not parse. */\n  front(path: string, content: string): ExtractedMetadata | null {\n    const k = key(path);\n    if (this.parsed.has(k)) return this.parsed.get(k) ?? null;\n    let parsed: ExtractedMetadata | null = null;\n    try {\n      const fm = extractFrontmatter(content, \"markdown\");\n      parsed = fm.present ? fm : null;\n    } catch (err) {\n      const loose = isCursorRule(path) ? cursorFront(content) : null;\n      if (loose !== null) {\n        this.parsed.set(k, loose);\n        return loose;\n      }\n      const first = (err instanceof Error ? err.message : String(err)).split(\"\\n\")[0] ?? \"\";\n      this.warnings.push(\n        `${this.display(path)}: front matter does not parse (${first}), so it is read as having none`,\n      );\n    }\n    this.parsed.set(k, parsed);\n    return parsed;\n  }\n\n  /** Adds a source once. Returns it, or null when excluded or already listed. */\n  add(\n    path: string,\n    content: string,\n    format: RuleFormat,\n    trigger: string,\n    skill?: string,\n  ): RuleSource | null {\n    if (this.has(path) || this.excluded(path)) return null;\n    this.seen.add(key(path));\n    const source: RuleSource = {\n      path,\n      displayPath: this.display(path),\n      format,\n      trigger,\n      content,\n      sha256: createHash(\"sha256\").update(content).digest(\"hex\"),\n      blocks: true,\n    };\n    if (skill !== undefined) source.skill = skill;\n    const declared = this.declared(path, content);\n    if (declared !== undefined) source.declaredRules = declared;\n    this.sources.push(source);\n    return source;\n  }\n\n  /**\n   * Adds a source that says what the session was asked, or one the transcript\n   * recorded. These never declare evals. With no file, its display path is its\n   * format, and `exclude` matches that name.\n   */\n  addRequest(\n    file: string | null,\n    content: string,\n    format: RuleFormat,\n    trigger: string,\n    blocks = true,\n  ): void {\n    // A named source goes by its name whether or not a file holds it, so\n    // `exclude: [plan]` drops a plan file as it drops an inline plan.\n    if (EXCLUDABLE_BY_NAME.has(format) && this.excludedName(format)) return;\n    if (file !== null) {\n      if (this.has(file) || this.excluded(file)) return;\n      this.seen.add(key(file));\n    }\n    this.sources.push({\n      path: file ?? \"\",\n      displayPath: file === null ? format : this.display(file),\n      format,\n      trigger,\n      content,\n      sha256: createHash(\"sha256\").update(content).digest(\"hex\"),\n      blocks,\n    });\n  }\n\n  private declared(path: string, content: string): DeclaredRule[] | undefined {\n    const fm = this.front(path, content);\n    if (fm === null) return undefined;\n    const extracted = extractEvals(\n      { name: basename(path), type: \"project-rules\", path, content, origin: \"project\" },\n      fm,\n    );\n    if (extracted.errors.length > 0) {\n      this.warnings.push(\n        `${this.display(path)}: metadata.evals does not validate (${extracted.errors[0]?.message ?? \"invalid\"}), so it declares no rules`,\n      );\n      return undefined;\n    }\n    const rules: DeclaredRule[] = [];\n    for (const entry of extracted.evals) {\n      if (entry.grader !== \"ai\" || entry.assertion === undefined) continue;\n      const rule: DeclaredRule = { id: entry.id, text: entry.assertion };\n      const when = entry.options?.when;\n      if (isRecord(when)) rule.when = when;\n      rules.push(rule);\n    }\n    return rules.length > 0 ? rules : undefined;\n  }\n}\n\n/** Every source whose trigger is \"always\", without a trace (for `prepare`). */\nexport async function resolveAlwaysSources(opts: SourceOptions): Promise<ResolvedSources> {\n  const c = await collector(opts);\n  for (const candidate of await catalog(c, opts)) {\n    if (candidate.trigger.kind === \"always\") await addWithImports(c, candidate, \"always\");\n  }\n  await addDesignated(c, opts);\n  return { sources: c.sources, warnings: c.warnings };\n}\n\n/** Every source in scope for one turn of `trace`. */\nexport async function resolveTurnSources(\n  trace: Trace,\n  turn: TurnBounds,\n  opts: SourceOptions,\n): Promise<ResolvedSources> {\n  const c = await collector(opts);\n  const touches: Touch[] = trace.fileAccesses\n    .filter((a) => a.index <= turn.to)\n    .map((a) => {\n      const abs = resolve(c.cwd, a.path);\n      return { abs, rel: relPosix(c.root, abs), read: a.op === \"read\" };\n    });\n  const wasRead = new Set(touches.filter((t) => t.read).map((t) => key(t.abs)));\n\n  for (const candidate of await catalog(c, opts)) {\n    const { trigger } = candidate;\n    if (trigger.kind === \"always\") {\n      await addWithImports(c, candidate, \"always\");\n    } else if (trigger.kind === \"read\") {\n      if (wasRead.has(key(candidate.path))) await addWithImports(c, candidate, \"read\");\n    } else {\n      const match = picomatch(trigger.patterns, { dot: true });\n      const hit = touches.find((t) => t.rel !== null && match(t.rel));\n      if (hit !== undefined && hit.rel !== null) {\n        await addWithImports(c, candidate, `${trigger.key} matched ${hit.rel}`);\n      }\n    }\n  }\n\n  // A subdirectory's memory file applies once a file under it is touched.\n  // Farther directories come first, so the nearest file reads last.\n  const nested = new Map<string, string>();\n  for (const touch of touches) {\n    if (touch.rel === null) continue;\n    for (const dir of dirsBelowCwd(c, dirname(touch.abs))) {\n      if (!nested.has(dir)) nested.set(dir, touch.rel);\n    }\n  }\n  const dirs = [...nested.keys()].sort((a, b) => a.length - b.length);\n  for (const dir of dirs) {\n    const touched = nested.get(dir) ?? \"\";\n    for (const [name, format] of NESTED_FILES) {\n      const path = join(dir, name);\n      const content = await safeRead(path);\n      if (content !== null) {\n        await addWithImports(c, { path, format, trigger: { kind: \"always\" } }, `touched ${touched}`, content);\n      }\n    }\n  }\n\n  await addWindowed(c, trace, turn, touches, opts);\n\n  await addDesignated(c, opts);\n\n  addPrompts(c, trace, turn);\n  await addPlan(c, trace, turn, opts);\n  await addSpecs(c, touches, opts.plans ?? []);\n  await addSystemPrompt(c, trace, turn, opts);\n  return { sources: c.sources, warnings: c.warnings };\n}\n\n// ── What the transcript recorded of the prompt ───────────────────\n\n/** The sources `conformance.exclude` matches by name (proposals 0080 and 0081). */\nconst EXCLUDABLE_BY_NAME: ReadonlySet<RuleFormat> = new Set<RuleFormat>([\"prompt\", \"plan\", \"system-prompt\"]);\n\n/** Claude Code's own block in its default prompt; a replaced prompt has none. */\nconst BOUNDARY_MARKER = \"__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__\";\n\ninterface Recorded {\n  index: number;\n  record: Record<string, unknown>;\n  attachment: Record<string, unknown>;\n}\n\n/** The last attachment of `type` at or before the turn's end, with its record. */\nfunction lastAttachment(trace: Trace, turn: TurnBounds, type: string): Recorded | undefined {\n  for (let i = trace.events.length - 1; i >= 0; i -= 1) {\n    const event = trace.events[i];\n    if (event === undefined || event.kind !== \"meta\" || event.index > turn.to) continue;\n    const attachment = event.raw.attachment;\n    if (event.raw.type === \"attachment\" && isRecord(attachment) && attachment.type === type) {\n      return { index: event.index, record: event.raw, attachment };\n    }\n  }\n  return undefined;\n}\n\n/**\n * The system prompt of the last `prompt_snapshot`, and the last output style.\n * A style a user file defines is its own source, holding the text the agent\n * saw; a built-in style's text joins the system prompt. The prompt is custom,\n * and blocks, when Claude Code's boundary marker is missing.\n */\nasync function addSystemPrompt(c: Collector, trace: Trace, turn: TurnBounds, opts: SourceOptions): Promise<void> {\n  const scrub = makeRedactor(opts.redact ?? []);\n  const style = lastAttachment(trace, turn, \"output_style_instructions\")?.attachment.style;\n  const styleName = isRecord(style) && typeof style.name === \"string\" ? style.name : undefined;\n  const stylePrompt = isRecord(style) && typeof style.prompt === \"string\" ? style.prompt : undefined;\n  let builtIn: string | undefined;\n  if (styleName !== undefined && stylePrompt !== undefined) {\n    const file = await userStyleFile(c, opts, styleName);\n    if (file === undefined) builtIn = stylePrompt;\n    else c.addRequest(file, scrub(stylePrompt), \"output-style\", `style ${styleName}`);\n  }\n\n  const snapshot = lastAttachment(trace, turn, \"prompt_snapshot\");\n  const recorded: unknown = snapshot?.attachment.systemPrompt;\n  if (snapshot === undefined || !Array.isArray(recorded)) return;\n  const blocks = recorded.filter((b): b is string => typeof b === \"string\");\n  const custom = !blocks.includes(BOUNDARY_MARKER);\n  const content = scrub([...blocks, ...(builtIn !== undefined ? [builtIn] : [])].join(\"\\n\\n\"));\n  const { version } = snapshot.record;\n  const by = typeof version === \"string\" ? `, Claude Code ${version}` : \"\";\n  const trigger = `recorded at turn ${String(snapshot.index)}${by}${custom ? \", custom\" : \"\"}`;\n  // A prompt the user replaced blocks; Claude Code's own default only reports.\n  c.addRequest(null, content, \"system-prompt\", trigger, /* blocks= */ custom);\n}\n\n/**\n * The user file that defines output style `name`: under the project's\n * `.claude/output-styles/`, then the user's. Its front matter `name`, or\n * its base name, matches.\n */\nasync function userStyleFile(c: Collector, opts: SourceOptions, name: string): Promise<string | undefined> {\n  // Where Claude Code reads styles: the project (cwd first, then the git root)\n  // and the user. No ancestor walk, since Claude Code does none for styles.\n  const dirs = [...new Set([c.cwd, c.root])].map((b) => join(b, \".claude\", \"output-styles\"));\n  dirs.push(join(configDir(opts.env), \"output-styles\"));\n  for (const dir of dirs) {\n    for (const path of await listInTree(dir, (p) => p.endsWith(\".md\"), { maxDepth: 0 })) {\n      const declared = (await frontOf(c, path))?.name;\n      if ((typeof declared === \"string\" ? declared : basename(path, \".md\")) === name) return path;\n    }\n  }\n  return undefined;\n}\n\n// ── What the session was asked ───────────────────────────────────\n\n/**\n * Every prompt typed up to the turn's end, as one numbered sequence. A\n * subagent's own run has only sidechain prompts, and its task is its request.\n */\nfunction addPrompts(c: Collector, trace: Trace, turn: TurnBounds): void {\n  const typed = trace.events.filter((e) => e.index <= turn.to && isTypedPrompt(e));\n  const main = typed.filter((e) => e.sidechain !== true);\n  const prompts = main.length > 0 ? main : typed;\n  if (prompts.length === 0) return;\n  const content = prompts\n    .map((p, i) => `${String(i + 1)}. ${(p.text ?? \"\").trim()}`)\n    .join(\"\\n\\n\");\n  c.addRequest(null, content, \"prompt\", `typed prompts 1-${String(prompts.length)}`);\n}\n\n/**\n * The plan of the last approved `ExitPlanMode` at or before the turn's end.\n * A call is approved when its result is not an error. The plan is the call's\n * `plan` input, or else the file the session last wrote under the user's\n * `plans/` directory before the call.\n */\nasync function addPlan(c: Collector, trace: Trace, turn: TurnBounds, opts: SourceOptions): Promise<void> {\n  const approved = trace.toolCalls\n    .filter((call) => call.name === \"ExitPlanMode\" && call.index <= turn.to)\n    .filter((call) => isApproved(trace, call.index, turn.to))\n    .at(-1);\n  if (approved === undefined) return;\n  const trigger = `approved at turn ${String(approved.index)}`;\n  const plan = approved.input.plan;\n  if (typeof plan === \"string\" && plan.trim() !== \"\") {\n    c.addRequest(null, plan, \"plan\", trigger);\n    return;\n  }\n  const plansDir = join(configDir(opts.env), \"plans\");\n  const file = trace.fileAccesses\n    .filter((a) => a.op !== \"read\" && a.index < approved.index)\n    .map((a) => resolve(c.cwd, a.path))\n    .filter((abs) => relPosix(plansDir, abs) !== null)\n    .at(-1);\n  if (file === undefined) return;\n  const content = await safeRead(file);\n  if (content !== null) c.addRequest(file, content, \"plan\", trigger);\n}\n\n/**\n * Whether the tool call at `index` has a result by `to` that is not an error.\n * A plan approved only after the turn ends is not yet a source; the next turn,\n * whose bounds include the result, picks it up.\n */\nfunction isApproved(trace: Trace, index: number, to: number): boolean {\n  const id = trace.events.find((e) => e.index === index)?.raw.id;\n  if (typeof id !== \"string\") return false;\n  for (const event of trace.events) {\n    if (event.kind !== \"tool_result\" || event.index <= index || event.index > to) continue;\n    const message = event.raw.message;\n    const blocks: unknown = isRecord(message) ? message.content : undefined;\n    if (!Array.isArray(blocks)) continue;\n    for (const block of blocks as unknown[]) {\n      if (isRecord(block) && block.type === \"tool_result\" && block.tool_use_id === id) {\n        return block.is_error !== true;\n      }\n    }\n  }\n  return false;\n}\n\n/** The files each spec format reads from a touched directory. */\nconst SPEC_FILES: Record<\"speckit-spec\" | \"kiro-spec\", string[]> = {\n  \"speckit-spec\": [\"spec.md\", \"plan.md\", \"tasks.md\"],\n  \"kiro-spec\": [\"requirements.md\", \"design.md\", \"tasks.md\"],\n};\n\n/** The spec directory a project-relative path lies under, and its format. */\nfunction specDirOf(rel: string): { dir: string; format: \"speckit-spec\" | \"kiro-spec\" | \"openspec-change\" } | null {\n  const parts = rel.split(\"/\");\n  const [first, second, third] = parts;\n  if (first === \"specs\" && second !== undefined && parts.length > 2) {\n    return { dir: `specs/${second}`, format: \"speckit-spec\" };\n  }\n  if (first === \".kiro\" && second === \"specs\" && third !== undefined && parts.length > 3) {\n    return { dir: `.kiro/specs/${third}`, format: \"kiro-spec\" };\n  }\n  // An archived change is done, so it never counts.\n  if (first === \"openspec\" && second === \"changes\" && third !== undefined && third !== \"archive\" && parts.length > 3) {\n    return { dir: `openspec/changes/${third}`, format: \"openspec-change\" };\n  }\n  return null;\n}\n\n/** A touched spec brings in its directory's files; a touched `plans` file brings in itself. */\nasync function addSpecs(c: Collector, touches: Touch[], plans: string[]): Promise<void> {\n  const isPlan = plans.length > 0 ? picomatch(plans, { dot: true }) : null;\n  const done = new Set<string>();\n  for (const touch of touches) {\n    const { rel } = touch;\n    if (rel === null) continue;\n    const trigger = `touched ${rel}`;\n    const spec = specDirOf(rel);\n    if (spec !== null && !done.has(spec.dir)) {\n      done.add(spec.dir);\n      const dir = join(c.root, ...spec.dir.split(\"/\"));\n      const files =\n        spec.format === \"openspec-change\"\n          ? await listInTree(dir, (p) => p.endsWith(\".md\"))\n          : SPEC_FILES[spec.format].map((name) => join(dir, name));\n      for (const file of files) {\n        const content = await safeRead(file);\n        if (content !== null) c.addRequest(file, content, spec.format, trigger);\n      }\n    }\n    if (isPlan?.(rel) === true) {\n      const content = await safeRead(touch.abs);\n      if (content !== null) c.addRequest(touch.abs, content, \"plans\", trigger);\n    }\n  }\n}\n\n/**\n * Files named in `conformance.include`. A person chose each one to govern the\n * agent, so it applies to every turn, as a `CLAUDE.md` does. Waiting for the\n * agent to read one would let a turn that skipped it escape its rules.\n */\nasync function addDesignated(c: Collector, opts: SourceOptions): Promise<void> {\n  const include = opts.include ?? [];\n  if (include.length === 0) return;\n  const match = picomatch(include, { dot: true });\n  const found = await listInTree(c.root, (abs) => {\n    const rel = relPosix(c.root, abs);\n    return rel !== null && match(rel);\n  });\n  for (const abs of found) {\n    if (c.has(abs)) continue;\n    const content = await safeRead(abs);\n    if (content === null) {\n      c.warnings.push(`${c.display(abs)}: matched conformance.include but could not be read`);\n      continue;\n    }\n    c.add(abs, content, \"designated\", \"always\");\n  }\n}\n\n// ── Skills, slash commands and the agent ─────────────────────────\n\nasync function addWindowed(\n  c: Collector,\n  trace: Trace,\n  turn: TurnBounds,\n  touches: Touch[],\n  opts: SourceOptions,\n): Promise<void> {\n  // The existing resolver settles which file a skill, command or agent names.\n  // Agents spawned in a main session govern their own runs, not this turn, so\n  // only the agent this run is (under SubagentStop) is asked for.\n  const { artifacts } = await resolveArtifacts(\n    {\n      ...trace,\n      agentSpawns:\n        opts.agentType === undefined ? [] : [{ subagentType: opts.agentType, index: 0 }],\n    },\n    { projectDir: c.cwd, projectRoot: c.root, ...(opts.env ? { env: opts.env } : {}) },\n  );\n  for (const artifact of artifacts) {\n    if (artifact.type === \"agent\") {\n      c.add(artifact.path, artifact.content, \"agent\", \"subagent run\");\n      continue;\n    }\n    if (artifact.type !== \"skill\" && artifact.type !== \"slash-command\") continue;\n    // In scope from the first invocation to the end of the session (proposal\n    // 0080): a skill's procedure spans the turns after it, and the skills it\n    // calls partway through do not end it. Batch `run` keeps ADR 01015's window.\n    const window = windowOf(trace, artifact);\n    if (!window.events.some((e) => e.index <= turn.to)) continue;\n    if (artifact.type === \"slash-command\") {\n      c.add(artifact.path, artifact.content, \"slash-command\", \"slash command window\");\n      continue;\n    }\n    c.add(artifact.path, artifact.content, \"skill\", \"skill window\", artifact.name);\n    const skillDir = dirname(artifact.path);\n    for (const touch of touches) {\n      if (!touch.read || relPosix(skillDir, touch.abs) === null || c.has(touch.abs)) continue;\n      const content = await safeRead(touch.abs);\n      if (content !== null) {\n        c.add(touch.abs, content, \"skill\", `read under skill ${artifact.name}`, artifact.name);\n      }\n    }\n  }\n}\n\n// ── The catalog of known formats ─────────────────────────────────\n\n/** Memory files read at cwd, each ancestor up to the root, and in their `.claude/`. */\nconst ANCESTOR_FILES: [string, RuleFormat][] = [\n  [\"CLAUDE.md\", \"claude-md\"],\n  [\"CLAUDE.local.md\", \"claude-md\"],\n  [join(\".claude\", \"CLAUDE.md\"), \"claude-md\"],\n  [\"AGENTS.md\", \"agents-md\"],\n  [join(\".claude\", \"AGENTS.md\"), \"agents-md\"],\n  [\"GEMINI.md\", \"gemini-md\"],\n];\n\n/** Memory files a touch under a subdirectory brings in. */\nconst NESTED_FILES: [string, RuleFormat][] = [\n  [\"CLAUDE.md\", \"claude-md\"],\n  [\"AGENTS.md\", \"agents-md\"],\n  [\"GEMINI.md\", \"gemini-md\"],\n];\n\nasync function catalog(c: Collector, opts: SourceOptions): Promise<Candidate[]> {\n  const out: Candidate[] = [];\n  const userClaude = configDir(opts.env);\n  const always: Trigger = { kind: \"always\" };\n\n  out.push({ path: join(userClaude, \"CLAUDE.md\"), format: \"claude-md\", trigger: always });\n  out.push({ path: join(c.home, \".gemini\", \"GEMINI.md\"), format: \"gemini-md\", trigger: always });\n  for (const dir of ancestors(c.cwd, c.root).reverse()) {\n    for (const [name, format] of ANCESTOR_FILES) {\n      out.push({ path: join(dir, name), format, trigger: always });\n    }\n  }\n\n  // Project-level directories live at the root; a cwd below it is checked too.\n  const bases = c.cwd === c.root ? [c.root] : [c.root, c.cwd];\n\n  for (const dir of [join(userClaude, \"rules\"), ...bases.map((b) => join(b, \".claude\", \"rules\"))]) {\n    for (const path of await listInTree(dir, (p) => p.endsWith(\".md\"))) {\n      out.push({ path, format: \"claude-rule\", trigger: await claudeRuleTrigger(c, path) });\n    }\n  }\n\n  for (const base of bases) {\n    const dir = join(base, \".cursor\", \"rules\");\n    for (const path of await listInTree(dir, (p) => p.endsWith(\".mdc\") || p.endsWith(\".md\"))) {\n      const trigger = await cursorTrigger(c, path);\n      if (trigger !== null) out.push({ path, format: \"cursor-rule\", trigger });\n    }\n  }\n\n  for (const dir of [join(c.home, \".kiro\", \"steering\"), ...bases.map((b) => join(b, \".kiro\", \"steering\"))]) {\n    for (const path of await listInTree(dir, (p) => p.endsWith(\".md\"), { maxDepth: 0 })) {\n      out.push({ path, format: \"kiro-steering\", trigger: await kiroTrigger(c, path) });\n    }\n  }\n\n  for (const base of bases) {\n    out.push({\n      path: join(base, \".specify\", \"memory\", \"constitution.md\"),\n      format: \"speckit-constitution\",\n      trigger: always,\n    });\n    out.push({ path: join(base, \"openspec\", \"project.md\"), format: \"openspec-project\", trigger: { kind: \"read\" } });\n  }\n  return out;\n}\n\nasync function frontOf(c: Collector, path: string): Promise<Record<string, unknown> | null> {\n  const content = await safeRead(path);\n  if (content === null) return null;\n  return c.front(path, content)?.data ?? null;\n}\n\nasync function claudeRuleTrigger(c: Collector, path: string): Promise<Trigger> {\n  const patterns = globList((await frontOf(c, path))?.paths);\n  return patterns.length > 0 ? { kind: \"globs\", key: \"paths\", patterns } : { kind: \"always\" };\n}\n\n/** Null for a `.md` file with no front matter, which Cursor does not read as a rule. */\nasync function cursorTrigger(c: Collector, path: string): Promise<Trigger | null> {\n  const fm = await frontOf(c, path);\n  if (fm === null && !path.endsWith(\".mdc\")) return null;\n  if (fm?.alwaysApply === true) return { kind: \"always\" };\n  const patterns = globList(fm?.globs);\n  return patterns.length > 0 ? { kind: \"globs\", key: \"globs\", patterns } : { kind: \"read\" };\n}\n\nasync function kiroTrigger(c: Collector, path: string): Promise<Trigger> {\n  const fm = await frontOf(c, path);\n  const inclusion = fm?.inclusion;\n  if (inclusion === undefined || inclusion === \"always\") return { kind: \"always\" };\n  if (inclusion === \"fileMatch\") {\n    const patterns = globList(fm?.fileMatchPattern);\n    if (patterns.length > 0) return { kind: \"globs\", key: \"fileMatchPattern\", patterns };\n  }\n  return { kind: \"read\" };\n}\n\n// ── Imports ──────────────────────────────────────────────────────\n\n/** Adds a candidate and, for a memory file, what its `@path` lines import. */\nasync function addWithImports(\n  c: Collector,\n  candidate: Candidate,\n  trigger: string,\n  known?: string,\n): Promise<void> {\n  if (c.has(candidate.path)) return;\n  const content = known ?? (await safeRead(candidate.path));\n  if (content === null) return;\n  const added = c.add(candidate.path, content, candidate.format, trigger);\n  if (added === null || (candidate.format !== \"claude-md\" && candidate.format !== \"gemini-md\")) {\n    return;\n  }\n  let frontier = [added];\n  for (let hop = 1; hop <= MAX_IMPORT_HOPS && frontier.length > 0; hop += 1) {\n    const next: RuleSource[] = [];\n    for (const importer of frontier) {\n      for (const ref of importsOf(importer.content)) {\n        const path = ref.startsWith(\"~/\")\n          ? join(c.home, ref.slice(2))\n          : resolve(dirname(importer.path), ref);\n        if (c.has(path)) continue;\n        const body = await safeRead(path);\n        if (body === null) continue;\n        const source = c.add(path, body, \"import\", `imported by ${importer.displayPath}`);\n        if (source !== null) next.push(source);\n      }\n    }\n    frontier = next;\n  }\n}\n\n/** `@path` references outside code fences and code spans. */\nfunction importsOf(content: string): string[] {\n  const refs: string[] = [];\n  // The open fence's character and length: CommonMark closes a fence only\n  // with the same character, at least as long, so a backtick line inside a\n  // tilde fence is text.\n  let fence: { char: string; length: number } | null = null;\n  for (const line of content.split(/\\r?\\n/)) {\n    const marker = /^\\s*(`{3,}|~{3,})/.exec(line)?.[1];\n    if (marker !== undefined) {\n      const char = marker.charAt(0);\n      if (fence === null) {\n        fence = { char, length: marker.length };\n        continue;\n      }\n      if (char === fence.char && marker.length >= fence.length && line.trim() === marker) {\n        fence = null;\n        continue;\n      }\n    }\n    if (fence !== null) continue;\n    const prose = line.replace(/`[^`]*`/g, \"\");\n    for (const m of prose.matchAll(/(?:^|\\s)@([^\\s`]+)/g)) {\n      const ref = m[1]?.replace(/[.,;:!?)\\]]+$/, \"\");\n      if (ref) refs.push(ref);\n    }\n  }\n  return refs;\n}\n\n// ── Helpers ──────────────────────────────────────────────────────\n\nasync function collector(opts: SourceOptions): Promise<Collector> {\n  const cwd = resolve(opts.projectDir);\n  const root = resolve(opts.projectRoot ?? (await findGitRoot(cwd)) ?? cwd);\n  return new Collector(cwd, root, homeDir(opts.env), opts.exclude ?? []);\n}\n\nfunction homeDir(env: Record<string, string | undefined> = process.env): string {\n  const set = process.platform === \"win32\" ? (env.USERPROFILE ?? env.HOME) : env.HOME;\n  return resolve(set ?? homedir());\n}\n\n/** cwd and each ancestor up to the root, nearest first. */\nfunction ancestors(cwd: string, root: string): string[] {\n  const dirs: string[] = [];\n  let current = cwd;\n  for (let depth = 0; depth < 32; depth += 1) {\n    dirs.push(current);\n    if (current === root) break;\n    const parent = dirname(current);\n    if (parent === current) break;\n    current = parent;\n  }\n  return dirs;\n}\n\n/** `dir` and its ancestors inside the root that are not cwd or above it. */\nfunction dirsBelowCwd(c: Collector, dir: string): string[] {\n  const dirs: string[] = [];\n  let current = dir;\n  for (let depth = 0; depth < 64; depth += 1) {\n    if (relPosix(c.root, current) === null || relPosix(current, c.cwd) !== null) break;\n    dirs.push(current);\n    const parent = dirname(current);\n    if (parent === current) break;\n    current = parent;\n  }\n  return dirs;\n}\n\n/** One glob, a comma-separated string, or a list. Commas inside braces stay. */\nfunction isCursorRule(path: string): boolean {\n  return path.split(sep).join(\"/\").includes(\"/.cursor/rules/\");\n}\n\n/**\n * Cursor reads its front matter line by line, so `globs: **\\/*.ts` is a rule\n * there and invalid YAML (an alias) here. This reads the three keys Cursor\n * defines the way Cursor does, as `key: rest of line`.\n */\nfunction cursorFront(content: string): ExtractedMetadata | null {\n  const block = /^---\\r?\\n([\\s\\S]*?)\\r?\\n---(?:\\r?\\n|$)/.exec(content)?.[1];\n  if (block === undefined) return null;\n  const data: Record<string, unknown> = {};\n  for (const line of block.split(/\\r?\\n/)) {\n    const m = /^(description|globs|alwaysApply):\\s*(.*)$/.exec(line);\n    const name = m?.[1];\n    const value = m?.[2]?.trim();\n    if (name === undefined || value === undefined) continue;\n    data[name] = name === \"alwaysApply\" ? value === \"true\" : value;\n  }\n  if (Object.keys(data).length === 0) return null;\n  return { data, present: true, format: \"markdown\", lineFor: () => undefined };\n}\n\nfunction globList(value: unknown): string[] {\n  if (Array.isArray(value)) {\n    return value.filter((v): v is string => typeof v === \"string\" && v.trim() !== \"\").map((v) => v.trim());\n  }\n  if (typeof value !== \"string\") return [];\n  const out: string[] = [];\n  let depth = 0;\n  let current = \"\";\n  for (const ch of value) {\n    if (ch === \"{\") depth += 1;\n    if (ch === \"}\") depth = Math.max(0, depth - 1);\n    if (ch === \",\" && depth === 0) {\n      out.push(current);\n      current = \"\";\n    } else {\n      current += ch;\n    }\n  }\n  out.push(current);\n  return out.map((p) => p.trim()).filter((p) => p !== \"\");\n}\n\n/** `path` relative to `base` with forward slashes, or null when outside it. */\nfunction relPosix(base: string, path: string): string | null {\n  const rel = relative(base, path);\n  if (rel === \"\") return \"\";\n  if (rel.startsWith(\"..\") || isAbsolute(rel)) return null;\n  return rel.split(sep).join(\"/\");\n}\n\nfunction key(path: string): string {\n  const abs = resolve(path);\n  return process.platform === \"win32\" ? abs.toLowerCase() : abs;\n}\n\n/** A path as sources compare it: absolute, and case-folded on Windows. */\nexport const pathKey = key;\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-52PDIZKV.js → chunk-ECVQNGTH.js}

@@ -5,10 +5,10 @@ import {
   loadGraph,
   parseGraph,
   validateGraph
-} from "./chunk-BOIF2XGG.js";
+} from "./chunk-XXDXIIQ4.js";
 import {
   loadRunConfig
-} from "./chunk-B7XUEQF3.js";
+} from "./chunk-6KKZXB2O.js";
 import {
   escapeWorkflowCommandMessage,
   escapeWorkflowCommandProperty
@@ -85,4 +85,4 @@ export {
   runCheck,
   renderCheck
 };
-//# sourceMappingURL=chunk-52PDIZKV.js.map
+//# sourceMappingURL=chunk-ECVQNGTH.js.map

package/dist/chunk-FQGLRJGX.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+// src/tracevals/graders/glob.ts
+var literal = (ch) => ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+var compiled = /* @__PURE__ */ new Map();
+function globToRegExp(glob) {
+  const cached = compiled.get(glob);
+  if (cached !== void 0) return cached;
+  const built = compile(glob);
+  compiled.set(glob, built);
+  return built;
+}
+function compile(glob) {
+  const spec = glob.replace(/\\/g, "/").toLowerCase().replace(/(?:\*\*\/)+/g, "**/");
+  let out = "";
+  for (let i = 0; i < spec.length; i += 1) {
+    const ch = spec[i];
+    if (ch === "?") {
+      out += "[^/]";
+      continue;
+    }
+    if (ch !== "*") {
+      out += literal(ch);
+      continue;
+    }
+    if (spec[i + 1] !== "*") {
+      out += "[^/]*";
+      continue;
+    }
+    i += 1;
+    if (spec[i + 1] === "/") {
+      i += 1;
+      if (out !== "") out += "(?:.*/)?";
+    } else if (out.endsWith("/")) {
+      out = `${out.slice(0, -1)}(?:/.*)?`;
+    } else {
+      out += ".*";
+    }
+  }
+  return new RegExp(`^(?:.*/)?${out}$`);
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").toLowerCase();
+}
+function matchesGlob(path, glob) {
+  return globToRegExp(glob).test(normalizePath(path));
+}
+
+// src/tracevals/graders/when.ts
+var stringValue = (kind) => (value) => typeof value === "string" && value.length > 0 ? void 0 : `options.when.${kind} must be a string`;
+var compiled2 = /* @__PURE__ */ new Map();
+function compiledRe(pattern) {
+  const cached = compiled2.get(pattern);
+  if (cached !== void 0) return cached;
+  const built = new RegExp(pattern);
+  compiled2.set(pattern, built);
+  return built;
+}
+var CONDITIONS = {
+  "file-access": {
+    validate: stringValue("file-access"),
+    test: (value, window) => window.fileAccesses.some((a) => matchesGlob(a.path, value)),
+    reason: (value) => `no file matching "${value}" was accessed`
+  },
+  "tool-used": {
+    validate: stringValue("tool-used"),
+    test: (value, window) => window.toolCalls.some((c) => c.name === value),
+    reason: (value) => `the ${value} tool was never used`
+  },
+  "prompt-matches": {
+    validate: (value) => {
+      const shape = stringValue("prompt-matches")(value);
+      if (shape !== void 0) return shape;
+      try {
+        new RegExp(value);
+      } catch (err) {
+        return `options.when.prompt-matches is not a valid regular expression: ${err.message}`;
+      }
+      return void 0;
+    },
+    test: (value, window) => {
+      const re = compiledRe(value);
+      return window.userMessages.some((text) => re.test(text));
+    },
+    reason: (value) => `no prompt matched /${value}/`
+  },
+  "command-matches": {
+    validate: (value) => {
+      const shape = stringValue("command-matches")(value);
+      if (shape !== void 0) return shape;
+      try {
+        new RegExp(value);
+      } catch (err) {
+        return `options.when.command-matches is not a valid regular expression: ${err.message}`;
+      }
+      return void 0;
+    },
+    test: (value, window) => {
+      const re = compiledRe(value);
+      return window.toolCalls.some(
+        (c) => c.name === "Bash" && typeof c.input.command === "string" && re.test(c.input.command)
+      );
+    },
+    reason: (value) => `no Bash command matched /${value}/`
+  },
+  "turn-count-above": {
+    validate: (value) => {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return "options.when.turn-count-above must be a whole number";
+      }
+      if (value < 0) return "options.when.turn-count-above must be at least 0";
+      return void 0;
+    },
+    test: (value, window) => window.turnCount > value,
+    reason: (value, window) => `${window.turnCount} turn(s) is not more than ${value}`
+  }
+};
+var WHEN_CONDITIONS = Object.keys(
+  CONDITIONS
+);
+function validateWhen(options) {
+  const when = options.when;
+  if (when === void 0) return void 0;
+  if (typeof when !== "object" || when === null || Array.isArray(when)) {
+    return "options.when must be an object of conditions";
+  }
+  const conditions = when;
+  const keys = Object.keys(conditions);
+  if (keys.length === 0) {
+    return `options.when needs at least one of: ${WHEN_CONDITIONS.join(", ")}`;
+  }
+  for (const key of keys) {
+    const condition = CONDITIONS[key];
+    if (condition === void 0) {
+      return `options.when.${key} is not a known condition; expected one of: ${WHEN_CONDITIONS.join(", ")}`;
+    }
+    const invalid = condition.validate(conditions[key]);
+    if (invalid !== void 0) return invalid;
+  }
+  return void 0;
+}
+function evaluateWhen(options, window) {
+  const when = options.when;
+  if (when === void 0) return { armed: true };
+  for (const name of WHEN_CONDITIONS) {
+    const value = when[name];
+    if (value === void 0) continue;
+    const condition = CONDITIONS[name];
+    if (condition.test(value, window)) continue;
+    return {
+      armed: false,
+      reason: `trigger not met (${window.label}): ${condition.reason(value, window)}`
+    };
+  }
+  return { armed: true };
+}
+function rejectWhen(kind, options) {
+  if (options.when === void 0) return void 0;
+  return `options.when is not supported by the ${kind} grader, which grades the whole session rather than a window`;
+}
+function skippedTrigger(trigger) {
+  return { findings: [], skipped: trigger.reason ?? "trigger not met" };
+}
+
+export {
+  globToRegExp,
+  matchesGlob,
+  WHEN_CONDITIONS,
+  validateWhen,
+  evaluateWhen,
+  rejectWhen,
+  skippedTrigger
+};
+//# sourceMappingURL=chunk-FQGLRJGX.js.map

package/dist/chunk-FQGLRJGX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/graders/glob.ts","../src/tracevals/graders/when.ts"],"sourcesContent":["/**\n * A small path glob, for grader options that name a set of files rather than\n * one (ADR 01016).\n *\n * Deliberately not a dependency: the syntax needed here is `**`, `*`, and `?`\n * over already-normalized paths, and a matcher that small is easier to pin than\n * to pick. Matching follows the same rule as the `file-access` grader's\n * suffix compare — separators normalized, case folded, anchored at a path\n * segment boundary — so `docs/**` reads the same whatever the checkout root is.\n * `file-access` reaches that rule by compiling its literal path through here,\n * so the two cannot drift.\n *\n * **The pattern is untrusted input.** It comes from the *evaluated* project's\n * front matter and is tested against every file access in a window, so a\n * pattern that compiles to nested optional-greedy groups is a denial of service\n * on the runner rather than a slow match. Two things keep that impossible: a\n * run of double-star segments collapses to one, so the optional greedy group\n * never nests, and compilation is memoised per pattern string.\n */\n\n/** Escapes every regex metacharacter; `*` and `?` are handled by the caller. */\nconst literal = (ch: string): string => ch.replace(/[.+^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n/**\n * Compiled patterns, keyed by the pattern string. Bounded because the key\n * space is: a run grades a fixed set of evals, each carrying a fixed set of\n * globs, and the compiled form depends on nothing else.\n */\nconst compiled = new Map<string, RegExp>();\n\nexport function globToRegExp(glob: string): RegExp {\n  const cached = compiled.get(glob);\n  if (cached !== undefined) return cached;\n  const built = compile(glob);\n  compiled.set(glob, built);\n  return built;\n}\n\nfunction compile(glob: string): RegExp {\n  // A run of `**/` means exactly what one does — \"any number of segments\" —\n  // so collapsing it here is a normalization, not an approximation. Left\n  // uncollapsed, each repeat added another optional greedy group over the same\n  // input and the cost of a failed match grew multiplicatively.\n  const spec = glob\n    .replace(/\\\\/g, \"/\")\n    .toLowerCase()\n    .replace(/(?:\\*\\*\\/)+/g, \"**/\");\n  let out = \"\";\n  for (let i = 0; i < spec.length; i += 1) {\n    const ch = spec[i] as string;\n    if (ch === \"?\") {\n      out += \"[^/]\";\n      continue;\n    }\n    if (ch !== \"*\") {\n      out += literal(ch);\n      continue;\n    }\n    if (spec[i + 1] !== \"*\") {\n      out += \"[^/]*\";\n      continue;\n    }\n    // `**` spans separators, and must allow *zero* segments: `docs/**` has to\n    // match `docs` itself, and `docs/**/x` has to match `docs/x`. Both cases\n    // absorb one adjacent separator rather than requiring it.\n    i += 1;\n    if (spec[i + 1] === \"/\") {\n      i += 1;\n      // A leading `**/` is already covered by the unconditional ancestor\n      // prefix below, so emitting a second optional group here would give the\n      // engine two interchangeable ways to consume the same segments — the\n      // shape that turns a failed match exponential.\n      if (out !== \"\") out += \"(?:.*/)?\";\n    } else if (out.endsWith(\"/\")) {\n      out = `${out.slice(0, -1)}(?:/.*)?`;\n    } else {\n      out += \".*\";\n    }\n  }\n  // Trace paths are absolute and machine-specific, so a spec matches any\n  // ancestor prefix — but only whole segments, so `docs/**` does not match\n  // `docsite/`.\n  return new RegExp(`^(?:.*/)?${out}$`);\n}\n\n/** Separators normalized and case folded, the one way both matchers see paths. */\nexport function normalizePath(path: string): string {\n  return path.replace(/\\\\/g, \"/\").toLowerCase();\n}\n\n/** True when `path` matches `glob`, both normalized the same way. */\nexport function matchesGlob(path: string, glob: string): boolean {\n  return globToRegExp(glob).test(normalizePath(path));\n}\n","/**\n * Conditional triggers (ADR 01016): `options.when` arms an eval only for the\n * sessions it is about.\n *\n * The point is to make the *absence* of an artifact checkable. You cannot hang\n * an eval on a skill that never loaded — nothing resolves it, so nothing plans\n * it — but you can hang it on `CLAUDE.md`, which resolves for every session.\n * `when` is what lets that always-planned eval stay quiet on the sessions it\n * has nothing to say about.\n *\n * **A trigger that does not fire is `skipped`, never `pass`.** A check that\n * never armed has not been satisfied, and reporting it as a pass would make a\n * green report out of an eval that never ran — the same reasoning that makes an\n * empty window a skip (ADR 01015).\n *\n * **`when` is a general trigger, not one grader's feature.** Every windowed\n * grader routes its options through `validateWhen` and its window through\n * `evaluateWhen`, because `options` is an open bag: a grader that merely\n * ignored an unrecognised `when` would leave the eval armed on every session,\n * which is the exact failure this module exists to prevent. `cost` and\n * `json-output` are the abstainers, and they say so: both grade the whole\n * session rather than a window (ADR 01015), so there is nothing to evaluate a\n * predicate over, and `rejectWhen` turns the option into a loud error.\n *\n * Predicates are pure trace facts, evaluated over the artifact's window, and\n * every listed one must hold.\n *\n * `options` is an open object by schema decree — \"validated by the grader at\n * run time — a grader's options evolve on the grader's schedule\" — so this\n * costs no schema change and no upstream docmeta proposal (ADR 01010).\n */\nimport { matchesGlob } from \"./glob.js\";\nimport type { TraceWindow } from \"./util.js\";\nimport type { Options } from \"./util.js\";\n\n/**\n * One condition, defined once.\n *\n * The three facets used to live in three unlinked places — the name list, the\n * validator's type grouping, and the evaluator's if-chain — so adding a\n * condition meant three coordinated edits, and an incomplete one failed\n * *silently in the arming direction*: an unvalidated key would be rejected as\n * unknown, but an unevaluated one would simply never constrain anything.\n * Keeping them together makes an incomplete condition a type error.\n */\ninterface Condition {\n  /** Rejects a malformed value without a trace, for `fill` (ADR 01004). */\n  validate(value: unknown): string | undefined;\n  /** True when the condition holds over the window. */\n  test(value: unknown, window: TraceWindow): boolean;\n  /** The half of the reason that names what was missing. */\n  reason(value: unknown, window: TraceWindow): string;\n}\n\nconst stringValue =\n  (kind: string) =>\n  (value: unknown): string | undefined =>\n    typeof value === \"string\" && value.length > 0\n      ? undefined\n      : `options.when.${kind} must be a string`;\n\n/**\n * Compiled once per pattern, as `globToRegExp` does. The pattern is fixed by\n * the artifact, so rebuilding it for every eval on every trace of a batch is\n * work with no new answer. No `g` flag here, so a shared instance carries no\n * `lastIndex` between calls.\n */\nconst compiled = new Map<string, RegExp>();\n\nfunction compiledRe(pattern: string): RegExp {\n  const cached = compiled.get(pattern);\n  if (cached !== undefined) return cached;\n  const built = new RegExp(pattern);\n  compiled.set(pattern, built);\n  return built;\n}\n\nconst CONDITIONS = {\n  \"file-access\": {\n    validate: stringValue(\"file-access\"),\n    test: (value, window) =>\n      window.fileAccesses.some((a) => matchesGlob(a.path, value as string)),\n    reason: (value) => `no file matching \"${value as string}\" was accessed`,\n  },\n  \"tool-used\": {\n    validate: stringValue(\"tool-used\"),\n    test: (value, window) => window.toolCalls.some((c) => c.name === value),\n    reason: (value) => `the ${value as string} tool was never used`,\n  },\n  \"prompt-matches\": {\n    validate: (value) => {\n      const shape = stringValue(\"prompt-matches\")(value);\n      if (shape !== undefined) return shape;\n      try {\n        new RegExp(value as string);\n      } catch (err) {\n        return `options.when.prompt-matches is not a valid regular expression: ${(err as Error).message}`;\n      }\n      return undefined;\n    },\n    test: (value, window) => {\n      const re = compiledRe(value as string);\n      return window.userMessages.some((text) => re.test(text));\n    },\n    reason: (value) => `no prompt matched /${value as string}/`,\n  },\n  \"command-matches\": {\n    validate: (value) => {\n      const shape = stringValue(\"command-matches\")(value);\n      if (shape !== undefined) return shape;\n      try {\n        new RegExp(value as string);\n      } catch (err) {\n        return `options.when.command-matches is not a valid regular expression: ${(err as Error).message}`;\n      }\n      return undefined;\n    },\n    test: (value, window) => {\n      const re = compiledRe(value as string);\n      return window.toolCalls.some(\n        (c) =>\n          c.name === \"Bash\" &&\n          typeof c.input.command === \"string\" &&\n          re.test(c.input.command),\n      );\n    },\n    reason: (value) => `no Bash command matched /${value as string}/`,\n  },\n  \"turn-count-above\": {\n    validate: (value) => {\n      if (typeof value !== \"number\" || !Number.isInteger(value)) {\n        return \"options.when.turn-count-above must be a whole number\";\n      }\n      if (value < 0) return \"options.when.turn-count-above must be at least 0\";\n      return undefined;\n    },\n    test: (value, window) => window.turnCount > (value as number),\n    reason: (value, window) =>\n      `${window.turnCount} turn(s) is not more than ${value as number}`,\n  },\n} satisfies Record<string, Condition>;\n\n/** Every recognised condition. Unknown keys are an error, never ignored. */\nexport const WHEN_CONDITIONS = Object.keys(\n  CONDITIONS,\n) as readonly WhenCondition[];\n\nexport type WhenCondition = keyof typeof CONDITIONS;\n\n/** What a trigger decided, and — when it did not fire — why. */\nexport interface TriggerResult {\n  armed: boolean;\n  /** Reason phrase for the skip; set only when `armed` is false. */\n  reason?: string;\n}\n\n/**\n * Validate `options.when` without a trace, so `fill` can ground-check a\n * proposal before writing it (ADR 01004).\n *\n * An unrecognised condition is rejected rather than dropped. A silently\n * ignored `file-acess` would leave the eval armed on every session — the loud\n * failure is the safe one, and it mirrors how `metadata.eval*` reserves its\n * own prefix in `src/evals/extract.ts`.\n */\nexport function validateWhen(options: Options): string | undefined {\n  const when = options.when;\n  if (when === undefined) return undefined;\n  if (typeof when !== \"object\" || when === null || Array.isArray(when)) {\n    return \"options.when must be an object of conditions\";\n  }\n  const conditions = when as Record<string, unknown>;\n  const keys = Object.keys(conditions);\n  if (keys.length === 0) {\n    // A trigger with no conditions arms on every session, which is the same as\n    // having no trigger — but reads like a scoped check.\n    return `options.when needs at least one of: ${WHEN_CONDITIONS.join(\", \")}`;\n  }\n  for (const key of keys) {\n    const condition = (CONDITIONS as Record<string, Condition>)[key];\n    if (condition === undefined) {\n      return `options.when.${key} is not a known condition; expected one of: ${WHEN_CONDITIONS.join(\", \")}`;\n    }\n    const invalid = condition.validate(conditions[key]);\n    if (invalid !== undefined) return invalid;\n  }\n  return undefined;\n}\n\n/**\n * Decide whether the trigger fires over a window. Conjunctive: the first\n * condition that fails names itself in the reason, so a skipped eval says\n * which half of its trigger was missing rather than only that it was.\n *\n * Evaluation walks `WHEN_CONDITIONS`, not the caller's key order, so the\n * reason a skip carries is stable across two spellings of the same trigger.\n */\nexport function evaluateWhen(options: Options, window: TraceWindow): TriggerResult {\n  const when = options.when as Record<string, unknown> | undefined;\n  if (when === undefined) return { armed: true };\n\n  for (const name of WHEN_CONDITIONS) {\n    const value = when[name];\n    if (value === undefined) continue;\n    const condition = CONDITIONS[name] as Condition;\n    if (condition.test(value, window)) continue;\n    return {\n      armed: false,\n      reason: `trigger not met (${window.label}): ${condition.reason(value, window)}`,\n    };\n  }\n\n  return { armed: true };\n}\n\n/**\n * Reject `when` outright, for a grader that has no window to evaluate it over.\n *\n * Silence is the one answer not available. `options` is an open bag, so a\n * `when` a grader neither evaluates nor rejects validates clean and is\n * ignored — and an ignored trigger is an eval left armed on every session,\n * which is precisely the outcome its author wrote `when` to avoid. `cost` is\n * unwindowed by design (ADR 01015) and `json-output` reads the session's final\n * text; for both, the honest answer is that the option does not apply.\n */\nexport function rejectWhen(kind: string, options: Options): string | undefined {\n  if (options.when === undefined) return undefined;\n  return (\n    `options.when is not supported by the ${kind} grader, ` +\n    \"which grades the whole session rather than a window\"\n  );\n}\n\n/**\n * The skip a grader returns for an unfired trigger. One helper rather than one\n * per grader, so every grader's wording — and the fact that it is a skip and\n * not a pass — comes from a single place.\n */\nexport function skippedTrigger(trigger: TriggerResult): {\n  findings: never[];\n  skipped: string;\n} {\n  return { findings: [], skipped: trigger.reason ?? \"trigger not met\" };\n}\n"],"mappings":"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","names":["compiled"]}

package/dist/{chunk-NGK3N6F2.js → chunk-GCC52YZD.js}

@@ -6,10 +6,10 @@ import {
   shortPin,
   shortSrc,
   spellAt
-} from "./chunk-TA42STP7.js";
+} from "./chunk-2ZWTSRE5.js";
 import {
   parseSrc
-} from "./chunk-UK2I3ACY.js";
+} from "./chunk-IZBBXKMJ.js";
 import {
   palette
 } from "./chunk-RNVYGWIC.js";
@@ -452,4 +452,4 @@ export {
   removalLine,
   renderRemovePretty
 };
-//# sourceMappingURL=chunk-NGK3N6F2.js.map
+//# sourceMappingURL=chunk-GCC52YZD.js.map

package/dist/chunk-HX44GB4Z.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  programName
+} from "./chunk-OWBRDNRZ.js";
+
+// src/shared/warn.ts
+var said = /* @__PURE__ */ new Set();
+function warn(message) {
+  if (said.has(message)) return;
+  said.add(message);
+  process.stderr.write(`${programName()}: ${message}
+`);
+}
+function notice(message) {
+  process.stderr.write(`${programName()}: ${message}
+`);
+}
+var noticed = /* @__PURE__ */ new Set();
+function noticeOnce(message) {
+  if (noticed.has(message)) return;
+  noticed.add(message);
+  notice(message);
+}
+
+export {
+  warn,
+  notice,
+  noticeOnce
+};
+//# sourceMappingURL=chunk-HX44GB4Z.js.map

package/dist/chunk-HX44GB4Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/warn.ts"],"sourcesContent":["/**\n * Warnings for the user: stderr, prefixed, and said once.\n *\n * stderr, because stdout belongs to the report (`--format json` has to stay\n * parseable). Once, because the same deprecated config file is discovered by\n * every command core a run touches, and a warning repeated five times reads as\n * five problems. Dedup is on the exact text, per process.\n */\nimport { programName } from \"./program-name.js\";\n\nconst said = new Set<string>();\n\nexport function warn(message: string): void {\n  if (said.has(message)) return;\n  said.add(message);\n  process.stderr.write(`${programName()}: ${message}\\n`);\n}\n\n/**\n * Diagnostics from a command core. Always stderr, never stdout: `json` and\n * `github` output has to stay parseable, and a note is not the report.\n * Unlike `warn`, said every time: a notice reports what a run did, not a\n * condition that holds.\n */\nexport function notice(message: string): void {\n  process.stderr.write(`${programName()}: ${message}\n`);\n}\n\nconst noticed = new Set<string>();\n\n/**\n * A notice about something a run meets many times, said the first time. What\n * `--local` replaced is the case: an eval naming a hosted provider is selected\n * once per ensemble, but the user needs to read it once per eval.\n */\nexport function noticeOnce(message: string): void {\n  if (noticed.has(message)) return;\n  noticed.add(message);\n  notice(message);\n}\n\n/** Forget what has been said, so a test can assert a warning fires again. */\nexport function resetWarnings(): void {\n  said.clear();\n  noticed.clear();\n}\n"],"mappings":";;;;;;AAUA,IAAM,OAAO,oBAAI,IAAY;AAEtB,SAAS,KAAK,SAAuB;AAC1C,MAAI,KAAK,IAAI,OAAO,EAAG;AACvB,OAAK,IAAI,OAAO;AAChB,UAAQ,OAAO,MAAM,GAAG,YAAY,CAAC,KAAK,OAAO;AAAA,CAAI;AACvD;AAQO,SAAS,OAAO,SAAuB;AAC5C,UAAQ,OAAO,MAAM,GAAG,YAAY,CAAC,KAAK,OAAO;AAAA,CAClD;AACD;AAEA,IAAM,UAAU,oBAAI,IAAY;AAOzB,SAAS,WAAW,SAAuB;AAChD,MAAI,QAAQ,IAAI,OAAO,EAAG;AAC1B,UAAQ,IAAI,OAAO;AACnB,SAAO,OAAO;AAChB;","names":[]}

package/dist/{chunk-NN4ASVTY.js → chunk-IIFADWWI.js}

@@ -10,7 +10,7 @@ import {
   CONCEPT_FIELDS,
   fieldPointer,
   valueAt
-} from "./chunk-QCBICNKC.js";
+} from "./chunk-CR3HZERW.js";
 import {
   STDIN_LABEL,
   STDIN_TOKEN,
@@ -20,13 +20,13 @@ import {
   gitignoreOptions,
   locateFrontmatter,
   resolveTargetSet
-} from "./chunk-527HHQPS.js";
+} from "./chunk-MSMB6XOS.js";
 import {
   findConfigFile,
   readConfigFile,
   selectCollections,
   valeConfigPath
-} from "./chunk-Q35YIDBV.js";
+} from "./chunk-XKBEHKWO.js";
 import {
   ToolError,
   errorMessage
@@ -1972,4 +1972,4 @@ export {
   valeConfigFor,
   plural
 };
-//# sourceMappingURL=chunk-NN4ASVTY.js.map
+//# sourceMappingURL=chunk-IIFADWWI.js.map

package/dist/{chunk-OIZ3XMKB.js → chunk-IOL74S4J.js}

@@ -5,12 +5,12 @@ import {
   loadTemplateFile,
   resolveLintRun,
   resolveStructureTool
-} from "./chunk-DE7JSWXV.js";
+} from "./chunk-ZNE25EAR.js";
 import {
   parserByName,
   parserForExtension,
   unsupportedFormatMessage
-} from "./chunk-ELZ2IIOF.js";
+} from "./chunk-6URSCTTX.js";
 import {
   BLOCK_KINDS,
   BLOCK_KIND_NODE
@@ -20,7 +20,7 @@ import {
 } from "./chunk-YGFIQ6Y5.js";
 import {
   writeTextAtomic
-} from "./chunk-HVFR66GQ.js";
+} from "./chunk-5UB47BEV.js";
 import {
   ToolError,
   errorMessage
@@ -298,4 +298,4 @@ export {
   BUILT_IN_DEFAULTS,
   runTools
 };
-//# sourceMappingURL=chunk-OIZ3XMKB.js.map
+//# sourceMappingURL=chunk-IOL74S4J.js.map

package/dist/{chunk-UK2I3ACY.js → chunk-IZBBXKMJ.js}

@@ -11,7 +11,7 @@ import {
   lineSpec,
   parseLines,
   sliceLines
-} from "./chunk-HVFR66GQ.js";
+} from "./chunk-5UB47BEV.js";
 import {
   __default3 as __default,
   extractorByName,
@@ -19,10 +19,10 @@ import {
   hasFrontmatterFence,
   locateFrontmatter,
   supportedExtensions
-} from "./chunk-527HHQPS.js";
+} from "./chunk-MSMB6XOS.js";
 import {
   isEncryptedValue
-} from "./chunk-Q35YIDBV.js";
+} from "./chunk-XKBEHKWO.js";
 import {
   ToolError
 } from "./chunk-G3T47CFV.js";
@@ -976,4 +976,4 @@ export {
   citationInputs,
   readPage
 };
-//# sourceMappingURL=chunk-UK2I3ACY.js.map
+//# sourceMappingURL=chunk-IZBBXKMJ.js.map

package/dist/{chunk-YA63PVWI.js → chunk-K52CS4KT.js}

@@ -19,10 +19,10 @@ import {
   sha256,
   splitBody,
   urlManifestRefusal
-} from "./chunk-7OQAU4EA.js";
+} from "./chunk-LDKIIZDW.js";
 import {
   turnBudgetSkipReason
-} from "./chunk-LJ2RDH3F.js";
+} from "./chunk-XG6PVB5S.js";
 import {
   isExecutionGrant,
   unknownGrantsMessage
@@ -33,7 +33,7 @@ import {
 import {
   externalWriteWarnings,
   offerExternalHomes
-} from "./chunk-3YHAYXBC.js";
+} from "./chunk-CR3HZERW.js";
 import {
   LOCATION_KEYWORD,
   Validator,
@@ -41,21 +41,23 @@ import {
   readManifestOrEmpty,
   readManifestValue,
   spliceManifestValue
-} from "./chunk-HVFR66GQ.js";
+} from "./chunk-5UB47BEV.js";
 import {
   writeFileAtomic
-} from "./chunk-527HHQPS.js";
+} from "./chunk-MSMB6XOS.js";
+import {
+  noticeOnce,
+  warn
+} from "./chunk-HX44GB4Z.js";
 import {
   assertKnownProvider,
   assertLocalFlag,
   assertModelHasProvider,
   localNotice,
-  noticeOnce,
   providerSpecFor,
   resolveIdentity,
-  selectProvider,
-  warn
-} from "./chunk-Q35YIDBV.js";
+  selectProvider
+} from "./chunk-QCHVR4ZM.js";
 import {
   errorMessage
 } from "./chunk-G3T47CFV.js";
@@ -1039,4 +1041,4 @@ export {
   makeGenerateScripts,
   runRun
 };
-//# sourceMappingURL=chunk-YA63PVWI.js.map
+//# sourceMappingURL=chunk-K52CS4KT.js.map