vigiles 33.0.0 → 33.2.0

package/dist/adapter-conformance.js

@@ -21,6 +21,19 @@ const event_capability_js_1 = require("./core/event-capability.js");
 const dialect_js_1 = require("./core/dialect.js");
 const layout_js_1 = require("./core/layout.js");
 const tmp_root_js_1 = require("./core/tmp-root.js");
+/** Every optional path a layout names, with the field it sits in. */
+function optionalPaths(layout) {
+    return [
+        ["rulesDir", layout.rulesDir],
+        ["outputStyles.dir", layout.outputStyles?.dir],
+        ["hookScriptsDir", layout.hookScriptsDir],
+        ["hooksConventionPath", layout.hooksConventionPath],
+        ["userSurfaceRoot", layout.userSurfaceRoot],
+        ["surfaces.skill", layout.surfaces.skill],
+        ["surfaces.agent", layout.surfaces.agent],
+        ["surfaces.command", layout.surfaces.command],
+    ];
+}
 /** Check an adapter against the port contracts; returns the (possibly empty) failure list. */
 function checkAdapterConformance(adapter) {
     const failures = [];
@@ -76,16 +89,7 @@ function checkAdapterConformance(adapter) {
     // second spelling of absent" rule is a test for every optional path. An
     // absent key already means "this harness has no such thing"; `""` would be a
     // second one, and every reader would have to remember to test for both.
-    const optionalPaths = [
-        ["rulesDir", adapter.layout.rulesDir],
-        ["hookScriptsDir", adapter.layout.hookScriptsDir],
-        ["hooksConventionPath", adapter.layout.hooksConventionPath],
-        ["userSurfaceRoot", adapter.layout.userSurfaceRoot],
-        ["surfaces.skill", adapter.layout.surfaces.skill],
-        ["surfaces.agent", adapter.layout.surfaces.agent],
-        ["surfaces.command", adapter.layout.surfaces.command],
-    ];
-    for (const [field, value] of optionalPaths)
+    for (const [field, value] of optionalPaths(adapter.layout))
         need(value === undefined || value.length > 0, `layout.${field} is "" — absence is spelled by omitting the key, never by an empty string`);
     // A7: `hooksConventionPath` names a FILE, and every reader treats it as one
     // (dirname it, parse it, round-trip it). `opencodeLayout` used to name the

package/dist/adapter.d.ts

@@ -18,6 +18,8 @@
 export type { HarnessAdapter, AdapterCapabilities } from "./core/adapter.js";
 export type { HarnessDialect } from "./core/dialect.js";
 export type { PluginLayout, SurfaceDirs, SurfaceKind } from "./core/layout.js";
+export type { OutputStyle, OutputStyleRules } from "./core/output-style.js";
+export type { ModelRequest } from "./core/harness-driver.js";
 export { executableSourceDirs, materializePrefix, surfaceDirs, } from "./core/layout.js";
 /**
  * The instruction-chain vocabulary `PluginLayout.instructionChain` speaks.

package/dist/adapters/claude-code/layout.js

@@ -15,6 +15,7 @@ const layout_js_1 = require("../../core/layout.js");
 const instruction_chain_js_1 = require("../../core/instruction-chain.js");
 const settings_codec_js_1 = require("../../core/settings-codec.js");
 const instruction_chain_js_2 = require("./instruction-chain.js");
+const output_style_js_1 = require("./output-style.js");
 exports.claudeCodeLayout = {
     name: "claude-code",
     manifestPath: ".claude-plugin/plugin.json",
@@ -30,6 +31,8 @@ exports.claudeCodeLayout = {
     userSurfaceRoot: ".claude",
     // `.claude/rules/*.md` — path-scoped project instructions (see PluginLayout).
     rulesDir: "rules",
+    // `.claude/output-styles/**/*.md` — see output-style.ts for how a style is named and selected.
+    outputStyles: output_style_js_1.claudeCodeOutputStyles,
     // `.claude/settings.local.json` — the per-machine layer, gitignored by
     // `init`. Declared because only this adapter knows the word; Codex and
     // OpenCode name none, so none is synthesized for them.

package/dist/adapters/claude-code/output-style.d.ts

@@ -0,0 +1,3 @@
+import type { OutputStyleRules } from "../../core/output-style.js";
+export declare const claudeCodeOutputStyles: OutputStyleRules;
+//# sourceMappingURL=output-style.d.ts.map

package/dist/adapters/claude-code/output-style.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeCodeOutputStyles = void 0;
+/**
+ * How Claude Code keeps output styles and switches one on. Every rule here was
+ * measured on Claude Code 2.1.291; the tests beside this file hold the cases.
+ */
+const node_path_1 = require("node:path");
+// `yaml` is the lazy loader: this module hangs off the layout, which is on the
+// hook path, so a top-level `js-yaml` import would load into every hook decision.
+const frontmatter_read_js_1 = require("../../core/frontmatter-read.js");
+/** Claude Code puts this line, then the body, into the first user message. */
+const HEADER = "# Output Style: ";
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** YAML as Claude Code reads it: the core schema, and a repeated key keeps the last value. */
+const parse = (block) => {
+    try {
+        const { CORE_SCHEMA, load } = (0, frontmatter_read_js_1.yaml)();
+        const value = load(block, { schema: CORE_SCHEMA, json: true });
+        if (value === null || value === undefined)
+            return {};
+        return isRecord(value) ? value : null;
+    }
+    catch (e) {
+        if (e instanceof (0, frontmatter_read_js_1.yaml)().YAMLException)
+            return null;
+        throw e;
+    }
+};
+/** `name: Status: Block` is not YAML, but Claude Code takes the rest of the line. */
+const quoteColonValues = (block) => block
+    .split("\n")
+    .map((line) => {
+    const m = /^([A-Za-z0-9_-]+): (.*)$/.exec(line.replace(/\r$/, ""));
+    if (m === null)
+        return line;
+    const [, key = "", value = ""] = m;
+    const needsQuotes = /: |:$/.test(value) && !/^["'[{|>]/.test(value);
+    return needsQuotes ? `${key}: ${JSON.stringify(value)}` : line;
+})
+    .join("\n");
+const readBlock = (block) => parse(block) ?? parse(quoteColonValues(block));
+/** A declared name if there is one, else the file name; null when unknowable. */
+const nameFrom = (text, stem) => {
+    const { block } = (0, frontmatter_read_js_1.readFrontmatter)(text);
+    if (block === null)
+        return stem;
+    const data = readBlock(block);
+    if (data === null)
+        return null;
+    const name = data["name"];
+    if (typeof name === "string")
+        return name === "" ? stem : name;
+    if (typeof name === "number" || typeof name === "boolean")
+        return String(name);
+    return name === null || name === undefined ? stem : null;
+};
+const squash = (s) => s.replace(/\s+/g, " ").trim();
+const read = (path, text) => ({
+    path,
+    name: nameFrom(text, (0, node_path_1.basename)(path).replace(/\.md$/, "")),
+    body: (0, frontmatter_read_js_1.frontmatterBody)(text).trim(),
+});
+/** The header and the whole body, in the system prompt or in any message. */
+const reached = (style, request) => {
+    if (style.name === null)
+        return false;
+    const probe = squash(`${HEADER}${style.name}\n${style.body}`);
+    return [request.system, ...request.messages.map((m) => m.text)].some((text) => squash(text).includes(probe));
+};
+exports.claudeCodeOutputStyles = {
+    dir: "output-styles",
+    isStyleFile: (pathInDir) => pathInDir.endsWith(".md"),
+    read,
+    select: (name) => ({ outputStyle: name }),
+    // A user-wide `outputStyle` in `~/.claude/settings.json` loads in every
+    // project; the project's own `default` wins over it (measured on 2.1.292).
+    selectNone: { outputStyle: "default" },
+    reached,
+};
+//# sourceMappingURL=output-style.js.map

package/dist/adapters/claude-code/replies.d.ts

@@ -0,0 +1,14 @@
+/** Whether the model answered at all: any `assistant` event, subagents included. */
+export declare function reachedModel(streamJson: string): boolean;
+/**
+ * The main agent's replies, one per message that ended a turn. A message
+ * streamed as several events (one per content block) is joined under its
+ * `message.id`. Left out: a subagent's messages (a non-null
+ * `parent_tool_use_id`); a message that also calls a tool, whose text is
+ * narration on the way to the call (measured on Claude Code 2.1.292: the
+ * narration and the `tool_use` share one id); a message with no text.
+ * `undefined` when the output is not a stream, so a check can say the run
+ * was not streamed instead of reading "no replies".
+ */
+export declare function parseReplies(streamJson: string): readonly string[] | undefined;
+//# sourceMappingURL=replies.d.ts.map

package/dist/adapters/claude-code/replies.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reachedModel = reachedModel;
+exports.parseReplies = parseReplies;
+/**
+ * Every reply the agent ended a turn with, in order — read off Claude Code's
+ * `--output-format stream-json`. The `result` event carries only the LAST one,
+ * so a reply a Stop hook made the agent follow up on was invisible to a test,
+ * and with it anything that reply printed (a second status footer, measured on
+ * Claude Code 2.1.291: two `assistant` events, one `result` holding the second).
+ */
+const zod_1 = require("zod");
+/** The parts of an `assistant` stream line this reads; the rest is ignored. */
+const AssistantLineSchema = zod_1.z.object({
+    type: zod_1.z.literal("assistant"),
+    parent_tool_use_id: zod_1.z.string().nullish(),
+    message: zod_1.z.object({
+        id: zod_1.z.string().optional(),
+        content: zod_1.z.array(zod_1.z.unknown()),
+    }),
+});
+const TextBlock = zod_1.z.object({ type: zod_1.z.literal("text"), text: zod_1.z.string() });
+const textOf = (content) => content
+    .map((block) => TextBlock.safeParse(block))
+    .flatMap((r) => (r.success ? [r.data.text] : []))
+    .join("");
+const parseJson = (line) => {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+};
+const parseLine = (line) => {
+    const r = AssistantLineSchema.safeParse(parseJson(line));
+    return r.success ? r.data : null;
+};
+/** A stream-json run opens with a `system` event; plain `json` output has none. */
+const StreamStartSchema = zod_1.z.object({ type: zod_1.z.literal("system") });
+const isStream = (lines) => lines.some((l) => StreamStartSchema.safeParse(parseJson(l)).success ||
+    parseLine(l) !== null);
+const ToolUseBlock = zod_1.z.object({ type: zod_1.z.literal("tool_use") });
+/** Whether the model answered at all: any `assistant` event, subagents included. */
+function reachedModel(streamJson) {
+    return streamJson.split("\n").some((l) => parseLine(l) !== null);
+}
+/**
+ * The main agent's replies, one per message that ended a turn. A message
+ * streamed as several events (one per content block) is joined under its
+ * `message.id`. Left out: a subagent's messages (a non-null
+ * `parent_tool_use_id`); a message that also calls a tool, whose text is
+ * narration on the way to the call (measured on Claude Code 2.1.292: the
+ * narration and the `tool_use` share one id); a message with no text.
+ * `undefined` when the output is not a stream, so a check can say the run
+ * was not streamed instead of reading "no replies".
+ */
+function parseReplies(streamJson) {
+    const lines = streamJson.split("\n");
+    if (!isStream(lines))
+        return undefined;
+    const events = lines.map(parseLine).flatMap((e, i) => e !== null && (e.parent_tool_use_id ?? null) === null
+        ? [
+            {
+                id: e.message.id ?? `#${String(i)}`,
+                text: textOf(e.message.content),
+                callsTool: e.message.content.some((b) => ToolUseBlock.safeParse(b).success),
+            },
+        ]
+        : []);
+    const ids = [...new Set(events.map((e) => e.id))];
+    return ids
+        .map((id) => events.filter((e) => e.id === id))
+        .filter((parts) => !parts.some((e) => e.callsTool))
+        .map((parts) => parts.map((e) => e.text).join(""))
+        .filter((text) => text !== "");
+}
+//# sourceMappingURL=replies.js.map

package/dist/audit-report.d.ts

@@ -55,6 +55,11 @@ export interface AuditInventory {
     readonly agents: number;
     readonly hooks: number;
     readonly commands: number;
+    /**
+     * Output styles found, or `"not-supported"` when the harness has none.
+     * Omitted when there are zero, so a report without styles is unchanged.
+     */
+    readonly outputStyles?: number | "not-supported";
     readonly mcp: boolean;
     /** Surfaces covered by NEITHER tier — the union count (unchanged). */
     readonly untested: number;

package/dist/audit-report.js

@@ -46,6 +46,34 @@ function buildAdoptable(surfaces) {
         createAllCommand: CREATE_ALL_COMMAND,
     };
 }
+/** What the scanned harness ships, as the report's `inventory`. */
+function inventoryOf(report) {
+    return {
+        skills: report.skills.length,
+        agents: report.agents.length,
+        // All hooks, file-backed + inline — matches formatScanReport and the
+        // emptiness/scoring count, so a JSON/HTML "What it ships" never reports 0
+        // hooks for an inline-hook-only harness.
+        hooks: report.hooks.length + report.inlineHooks,
+        commands: report.commands,
+        ...outputStylesField(report.outputStyles),
+        mcp: report.mcp,
+        untested: report.untested,
+        ...(report.untestedHarness !== undefined
+            ? { untestedHarness: report.untestedHarness }
+            : {}),
+        ...(report.unevaluated !== undefined
+            ? { unevaluated: report.unevaluated }
+            : {}),
+        ...(report.coverageEvidence
+            ? { coverageEvidence: report.coverageEvidence }
+            : {}),
+    };
+}
+/** The inventory's `outputStyles` entry: present unless there are none to report. */
+function outputStylesField(n) {
+    return n === undefined || n === 0 ? {} : { outputStyles: n };
+}
 /**
  * Assemble the versioned {@link AuditReport} from a scan report — pure, no clock.
  * The CLI attaches `meta.generatedAt` when it writes the JSON artifact; the
@@ -68,26 +96,7 @@ function buildAuditReport(report, opts) {
         score,
         verdict,
         recommendations,
-        inventory: {
-            skills: report.skills.length,
-            agents: report.agents.length,
-            // All hooks, file-backed + inline — matches formatScanReport and the
-            // emptiness/scoring count, so a JSON/HTML "What it ships" never reports 0
-            // hooks for an inline-hook-only harness.
-            hooks: report.hooks.length + report.inlineHooks,
-            commands: report.commands,
-            mcp: report.mcp,
-            untested: report.untested,
-            ...(report.untestedHarness !== undefined
-                ? { untestedHarness: report.untestedHarness }
-                : {}),
-            ...(report.unevaluated !== undefined
-                ? { unevaluated: report.unevaluated }
-                : {}),
-            ...(report.coverageEvidence
-                ? { coverageEvidence: report.coverageEvidence }
-                : {}),
-        },
+        inventory: inventoryOf(report),
         ...(report.danglingRefs.length
             ? { brokenReferences: report.danglingRefs }
             : {}),