vigiles 18.0.0 → 18.1.0

package/dist/adapters/claude-code/agent-result.js

@@ -39,8 +39,17 @@ function fieldMatches(value, type) {
             return typeof value === "boolean";
         case "string[]":
             return Array.isArray(value) && value.every((v) => typeof v === "string");
+        default:
+            // An enum, declared as a readonly tuple of the permitted literals.
+            return typeof value === "string" && type.includes(value);
     }
 }
+/** How a field type reads in a message to a human: `string`, or `"CUT" | "MERGE"`. */
+function typeName(type) {
+    return typeof type === "string"
+        ? type
+        : type.map((v) => JSON.stringify(v)).join(" | ");
+}
 /**
  * Validate a parsed object against a contract track; null when it conforms.
  *
@@ -54,7 +63,9 @@ function shapeError(obj, shape) {
         if (!(field in obj))
             return `missing field "${field}"`;
         if (!fieldMatches(obj[field], type)) {
-            return `field "${field}" should be ${type}`;
+            // `typeName`, not `type`: an enum interpolated raw renders as `CUT,MERGE,KEEP`,
+            // which reads like a value rather than a choice among values.
+            return `field "${field}" should be ${typeName(type)}`;
         }
     }
     return null;

package/dist/core/compile.js

@@ -899,7 +899,9 @@ function renderAgentSections(sections, basePath) {
 /** Render a result-contract track shape as a compact `{ "f": type, … }` line. */
 function renderShape(shape) {
     const fields = Object.entries(shape)
-        .map(([k, t]) => `"${k}": ${t}`)
+        // An enum renders as the choice itself — `"verdict": "CUT" | "MERGE" | "KEEP"` — so
+        // the fenced rail shows a worker the same permitted values the tool schema shows.
+        .map(([k, t]) => `"${k}": ${typeof t === "string" ? t : t.map((v) => JSON.stringify(v)).join(" | ")}`)
         .join(", ");
     return fields ? `{ ${fields} }` : "{}";
 }

package/dist/core/spec.d.ts

@@ -695,8 +695,22 @@ export type OkOf<T> = T extends TypedOutcome<infer Ok, Shape> ? Ok : Shape;
  * erased `Shape`, and the value is still a plain `AgentSpec` — backwards-compatible.
  */
 export declare function agent<const P extends AuthoredPurity | undefined = undefined, V extends ToolVocabulary = OpenToolVocabulary, Ok extends Shape = Shape, Err extends Shape = Shape>(spec: AgentSpecInput<P, V, Ok, Err>): TypedAgentSpec<Ok, Err>;
-/** The field types a result contract can declare (kept tiny + dependency-free). */
-export type OutputFieldType = "string" | "number" | "boolean" | "string[]";
+/**
+ * The field types a result contract can declare (kept tiny + dependency-free).
+ *
+ * The literal-array member is an ENUM: `["CUT", "MERGE", "KEEP"] as const` declares a
+ * field whose value must be one of those strings. It is the ONLY extension to this union,
+ * and it was added because a measured failure had no other cure: across 14 real payloads
+ * a `verdict: "string"` field held 3 mutually incomparable invented categories over 3
+ * runs, and vocabulary compliance was 3/19 — 16%. `string` cannot express "one of these",
+ * so nothing downstream could notice.
+ *
+ * Nothing RELATIONAL follows it — no `object[]`, no tuples, no per-element enums.
+ * Declaring one throws rather than rendering an unsatisfiable schema, because the body of
+ * a result is prose by decision: on those same 14 payloads, 23 scalar values carried
+ * every assertion anyone made while 80,981 characters of prose carried none.
+ */
+export type OutputFieldType = "string" | "number" | "boolean" | "string[]" | readonly [string, ...string[]];
 /** A field SHAPE — a record of field-name → field-type, kept in the TYPE so a
  *  typed pipeline can cross-reference one agent's `ok` against the next agent's
  *  `needs`. The erased runtime form is `Record<string, OutputFieldType>`. */

package/dist/experimental-emit.d.ts

@@ -68,8 +68,11 @@ export type EmitFieldSchema = {
     readonly items: {
         readonly type: "string";
     };
+} | {
+    readonly type: "string";
+    readonly enum: readonly string[];
 };
-/** The `track` discriminator's schema — the only enum this surface emits. */
+/** The `track` discriminator's schema — the enum this module owns, not the author's. */
 export interface EmitTrackSchema {
     readonly type: "string";
     readonly enum: readonly ["ok", "err"];

package/dist/experimental-emit.js

@@ -62,6 +62,11 @@ const agent_result_js_1 = require("./adapters/claude-code/agent-result.js");
 /** The default tool name, when `options.name` is not given. */
 const DEFAULT_EMIT_TOOL = "emit_result";
 function fieldSchema(type) {
+    // An enum reaches the model as a JSON-Schema `enum`, which is the whole point: the
+    // permitted values travel WITH the tool definition instead of living in prose the
+    // model may or may not have read.
+    if (typeof type !== "string")
+        return { type: "string", enum: [...type] };
     switch (type) {
         case "string":
             return { type: "string" };
@@ -189,8 +194,41 @@ function isEmitCall(observed, name) {
  */
 function experimental_parseEmitted(toolCalls, contract, options = {}) {
     const name = options.name ?? DEFAULT_EMIT_TOOL;
-    const calls = toolCalls.filter((c) => isEmitCall(c.name, name));
+    const all = toolCalls.filter((c) => isEmitCall(c.name, name));
+    // 🔴 A CALL THAT ERRORED IS NOT AN EMISSION, AND USED TO PARSE AS ONE.
+    //
+    // Measured 2026-08-19: a permission-denied call carrying a perfectly valid payload
+    // returned `{"kind":"ok", …}`, because this function filtered by NAME and never looked
+    // at `ToolCall.isError` — a field that has been on the type all along. The call never
+    // reached the server; the reader reported success. That is the exact shape of defect
+    // this channel exists to remove from the fenced rail, reproduced inside the channel.
+    //
+    // Denial is not hypothetical: it is what a wrong `allowedTools` spelling produces, and
+    // MCP tool names mangle per host (`mcp__plugin_<plugin>_<server>__emit_result` on Claude
+    // Code, two segments on Codex), so mis-spelling it is the likely case, not the exotic one.
+    //
+    // The errored calls get their OWN branch rather than being dropped or counted, because
+    // all three collapses lie in a different direction:
+    //   - counting them → this defect, success for a call nobody received;
+    //   - dropping them silently → "no tool call in the run", which sends the reader to the
+    //     skill's instructions when the fault is in permissions;
+    //   - lumping them with "called twice" → a model that retries a denied call produces a
+    //     true signal under a false name. (Observed: two denials in one run.)
+    // A successful call ALONGSIDE a denied one is one successful emission; the denial is
+    // mentioned, not fatal, because the contract was in fact satisfied.
+    // `isError` is a required boolean on ToolCall, so truthiness is exact here.
+    const errored = all.filter((c) => c.isError);
+    const calls = all.filter((c) => !c.isError);
     if (calls.length === 0) {
+        if (errored.length > 0) {
+            return {
+                kind: "malformed",
+                reason: `the \`${name}\` call itself errored or was denied ` +
+                    `(${String(errored.length)} attempt${errored.length === 1 ? "" : "s"}); nothing reached the ` +
+                    `server, so nothing was emitted. Check the tool's permissions and the exact spelling ` +
+                    `in \`allowedTools\` — MCP names are host-mangled.`,
+            };
+        }
         return { kind: "malformed", reason: `no \`${name}\` tool call in the run` };
     }
     if (calls.length > 1) {

package/dist/scaffold-test.js

@@ -118,6 +118,10 @@ assertTriggerRate(report, { min: 0.8, maxFalsePositive: 0.3 });
 }
 /** A JSON value placeholder for an `OutputFieldType`, for the `vigiles:ok` block. */
 function placeholderFor(type) {
+    // An enum's placeholder must be a MEMBER, or the scaffolded test fails the moment it
+    // is run — a generated test that cannot pass teaches the author to distrust the tool.
+    if (Array.isArray(type) && type.length > 0)
+        return type[0];
     switch (type) {
         case "number":
             return 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "18.0.0",
+  "version": "18.1.0",
   "description": "Audit, test and measure the harness your AI agent runs on — grade your CLAUDE.md / AGENTS.md, skills, subagents and hooks, run them against a scripted model, and measure whether they actually fire.",
   "keywords": [
     "claude-code",