vigiles 29.1.0 → 30.0.1

package/dist/adapters/opencode/layout.js

@@ -1,28 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeLayout = void 0;
+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");
 exports.opencodeLayout = {
     name: "opencode",
     manifestPath: "opencode.json",
-    // Vestigial: OpenCode hooks are JS plugin modules under `.opencode/plugin`, not
-    // shell-hook settings, so the shell-hook settings round-trip does NOT apply here
-    // (the adapter declares shellHooks:false; assertAdapterLoadsHooks is skipped).
-    hooksConventionPath: ".opencode/plugin",
+    // No `hooksConventionPath`: OpenCode hooks are JS plugin modules under
+    // `.opencode/plugin`, which is a DIRECTORY. The field names a standalone
+    // hooks FILE, and every reader treats it as one (dirname it, parse it,
+    // round-trip it), so naming a directory there made each of them wrong about
+    // it. The field is optional now and this layout omits it; the adapter already
+    // declares `shellHooks: false`, so no shell-hook reader asks.
     settingsPath: "opencode.json",
-    settingsFormat: "json",
+    settings: settings_codec_js_1.jsonSettingsCodec,
     instructionFile: "AGENTS.md",
-    // OpenCode's surfaces already live UNDER `.opencode/` at the source, so they
-    // are NOT relocated — materializeRoot is "" (no prefix) to avoid doubling the
-    // `.opencode/` segment. (Contrast Claude Code: root-level `skills/` surfaces
-    // relocated under `.claude`.)
-    surfaceDirs: [".opencode/agent", ".opencode/command"],
-    skillDir: ".opencode/skill",
-    agentDir: ".opencode/agent",
-    commandDir: ".opencode/command",
-    materializeRoot: "",
+    surfaces: {
+        skill: ".opencode/skill",
+        agent: ".opencode/agent",
+        command: ".opencode/command",
+    },
+    // No `userSurfaceRoot`: OpenCode's surfaces already live UNDER `.opencode/`
+    // at the source, so they are NOT relocated and the materialize prefix is ""
+    // (doubling the `.opencode/` segment is what a prefix here would do).
+    // Contrast Claude Code: root-level `skills/` surfaces relocated under
+    // `.claude`.
+    //
+    // No `hookScriptsDir`: there are no hook SCRIPTS to scan — the hooks are
+    // in-process code modules, which is the same fact `shellHooks: false` states
+    // on the adapter.
     pluginRootToken: "${OPENCODE_PLUGIN_ROOT}",
     mcpConfigFile: "opencode.json",
     mcpManifestKey: "mcp",
-    intraRefDirs: [".opencode/agent", ".opencode/command"],
+    // The root file plus whatever `opencode.json#instructions` names: a concrete
+    // path is an import, a glob is a PATTERN that is reported and never walked.
+    // This is the only implementation here that populates `patterns`.
+    instructionChain(files) {
+        return (0, instruction_chain_js_2.opencodeInstructionChain)(files, {
+            instructionFile: exports.opencodeLayout.instructionFile,
+            settingsPaths: (0, instruction_chain_js_1.settingsSourcePaths)(exports.opencodeLayout),
+            parseSettings: (text) => exports.opencodeLayout.settings.parse(text),
+        });
+    },
 };
 //# sourceMappingURL=layout.js.map

package/dist/adoptability.d.ts

@@ -1,4 +1,11 @@
-import { type AgentRunner, type ModelOutputParser } from "./eval.js";
+import { type AgentRunner, type ModelOutputParser, type EvalDriver, type RunOut } from "./eval.js";
+/**
+ * The harness CLI did not run, as distinct from running and finding nothing.
+ * A named class so the caller can tell the two apart without matching prose.
+ */
+export declare class DraftRunFailed extends Error {
+    constructor(reason: string);
+}
 /** A reference the model proposes as machine-verifiable. */
 export interface DraftedRef {
     readonly kind: "enforce" | "file" | "cmd" | "dir";
@@ -36,9 +43,32 @@ export interface DraftOptions {
     readonly cwd?: string;
     readonly runner?: AgentRunner;
     readonly parse?: ModelOutputParser;
+    /**
+     * The driver's own reader for a failure the exit code does not carry — a
+     * refusal, or a turn error inside a zero-exit run. Supplied by
+     * {@link draftWith}; absent means the exit code is the only signal.
+     */
+    readonly runError?: (out: RunOut) => string | null;
 }
 /** Injectable drafter — the real one calls a model; tests pass a fake. */
 export type Drafter = (content: string) => Promise<DraftedRef[]>;
+/**
+ * Build the real drafter from a harness's EVAL DRIVER, instead of the hard-wired
+ * `spawnAgent` + `parseClaudeRun` defaults above.
+ *
+ * 🔴 THIS IS WHY THE PREVIEW IS NOT CLAUDE-CODE-ONLY. `defaultDraft`'s two
+ * defaults ARE the two members of the Claude eval driver, and nothing else in
+ * the drafter is harness-specific: the prompt is over an instruction file's
+ * prose, and prose is prose. The VERIFIER is deterministic and harness-free
+ * ("LLM proposes, deterministic disposes", this file's header), so "M broken
+ * right now" is exactly as trustworthy driven by one harness as by another;
+ * only the draft's RECALL varies by model, which it already does across models
+ * of the same harness.
+ *
+ * `model` is passed through to whichever runner: the trigger tier already does
+ * this, and a runner that does not understand the alias ignores it.
+ */
+export declare function draftWith(driver: EvalDriver, opts?: DraftOptions): Drafter;
 export interface AdoptabilityTierOptions {
     readonly instructionContent: string;
     readonly basePath: string;

package/dist/adoptability.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DraftRunFailed = void 0;
 exports.verifyDraftedRefs = verifyDraftedRefs;
 exports.parseDraftJson = parseDraftJson;
+exports.draftWith = draftWith;
 exports.runAdoptabilityTier = runAdoptabilityTier;
 exports.formatAdoptability = formatAdoptability;
 /**
@@ -26,6 +28,17 @@ const linters_js_1 = require("./core/linters.js");
 const compile_js_1 = require("./core/compile.js");
 const hash_js_1 = require("./core/hash.js");
 const eval_js_1 = require("./eval.js");
+/**
+ * The harness CLI did not run, as distinct from running and finding nothing.
+ * A named class so the caller can tell the two apart without matching prose.
+ */
+class DraftRunFailed extends Error {
+    constructor(reason) {
+        super(`could not run the drafting model — ${reason}`);
+        this.name = "DraftRunFailed";
+    }
+}
+exports.DraftRunFailed = DraftRunFailed;
 /** Verify ONE drafted ref against the real repo; null = resolves, else the breakage. */
 function verifyOne(r, basePath) {
     switch (r.kind) {
@@ -163,8 +176,52 @@ async function defaultDraft(content, opts = {}) {
         timeoutMs: 120000,
         env: process.env,
     });
+    // 🔴 THE EXIT CODE IS READ, AND IT WAS NOT. A runner that could not start the
+    // harness binary returns code 1 with empty stdout; `parse` then yields no
+    // output, `parseDraftJson` yields `[]`, and the report prints "no
+    // machine-verifiable references found" — a valid-looking answer to a question
+    // nothing ever asked. Found on review of #265: the unconditional
+    // `subscription` on the Codex driver lets this path run with no binary
+    // present, and unlike the behavioral probe there is nothing here that
+    // self-reports unavailability.
+    //
+    // Thrown rather than returned empty, because "the run failed" and "the model
+    // found nothing" are different answers and the caller has to be able to say
+    // which. `runError` is the driver's own reader for a failure the exit code
+    // does not carry — a refusal or a turn error inside a zero-exit run.
+    if (out.code !== 0) {
+        throw new DraftRunFailed(`the harness CLI exited ${String(out.code)}${out.stderr ? `: ${out.stderr.trim().slice(0, 200)}` : " with no output"}`);
+    }
+    const driverError = opts.runError?.(out);
+    if (driverError !== null && driverError !== undefined) {
+        throw new DraftRunFailed(driverError);
+    }
     return parseDraftJson(parse(out).output);
 }
+/**
+ * Build the real drafter from a harness's EVAL DRIVER, instead of the hard-wired
+ * `spawnAgent` + `parseClaudeRun` defaults above.
+ *
+ * 🔴 THIS IS WHY THE PREVIEW IS NOT CLAUDE-CODE-ONLY. `defaultDraft`'s two
+ * defaults ARE the two members of the Claude eval driver, and nothing else in
+ * the drafter is harness-specific: the prompt is over an instruction file's
+ * prose, and prose is prose. The VERIFIER is deterministic and harness-free
+ * ("LLM proposes, deterministic disposes", this file's header), so "M broken
+ * right now" is exactly as trustworthy driven by one harness as by another;
+ * only the draft's RECALL varies by model, which it already does across models
+ * of the same harness.
+ *
+ * `model` is passed through to whichever runner: the trigger tier already does
+ * this, and a runner that does not understand the alias ignores it.
+ */
+function draftWith(driver, opts = {}) {
+    return (content) => defaultDraft(content, {
+        ...opts,
+        runner: driver.runner,
+        parse: driver.parse,
+        runError: driver.runError,
+    });
+}
 /**
  * Run the preview: draft refs from the instruction file (model), then verify them
  * (deterministic). The composition root of "LLM proposes, deterministic disposes".