vigiles 29.1.0 → 30.0.1

package/dist/adapters/codex/eval.js

@@ -27,7 +27,7 @@
  * not be re-read); pair with a behavioral/judged check for certainty.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codexEvalDriver = exports.CODEX_TRIGGER_RATE_EXPERIMENTAL = void 0;
+exports.codexLiveDriver = exports.codexEvalDriver = exports.CODEX_TRIGGER_RATE_EXPERIMENTAL = void 0;
 exports.parseCodexEvalRun = parseCodexEvalRun;
 exports.codexRunError = codexRunError;
 exports.codexSkillFired = codexSkillFired;
@@ -244,6 +244,53 @@ exports.codexEvalDriver = {
     // Codex-only: the trigger-rate number is not validated (see the constant above).
     experimental: exports.CODEX_TRIGGER_RATE_EXPERIMENTAL,
 };
+/**
+ * The Codex {@link HarnessLiveDriver} — the EXECUTING tiers' side of the
+ * adapter, reached through `codexAdapter.liveDriver()`.
+ *
+ * It is the object `scan-behavioral.ts:buildProbe` used to build from
+ * `harness === "codex"`: the same four answers, now carried by the adapter that
+ * knows them instead of switched on by a name in the application layer.
+ */
+exports.codexLiveDriver = {
+    evalDriver: exports.codexEvalDriver,
+    // 🔴 ANSWERED WITHOUT TOUCHING THE MACHINE, and that is a CONSTRAINT of the
+    // caller rather than a property of this harness. `access` is read on the
+    // AUDIT path, before `decideExecute` and `resolveExecution` have established
+    // consent — including `--json`, `--no-interactive` and a remembered "no" —
+    // and that path promises to execute nothing. A first draft probed the binary
+    // with `codexDriver.available()`, which spawns `codex --version`; harmless in
+    // itself, and still a process this run had no permission to start.
+    //
+    // Claude Code's `access` reads env only, so with this one the guarantee stops
+    // being a property of whichever adapter happens to be driving and becomes
+    // structural: NO adapter executes anything to answer it.
+    //
+    // What that costs, stated rather than hidden: a machine with no codex binary
+    // is told the tier is reachable and finds out at RUN time instead, where the
+    // probe self-reports unavailable and the tier reports a miss. That is exactly
+    // what shipped before the port existed (`adapter.name === "codex"` was true
+    // with no probe at all), so this is not a regression — it is the old answer
+    // with the reason written down. The remedy string that used to ride on
+    // `{ kind: "none", fix }` is deleted rather than parked: it had no reader
+    // left, and an exported constant nothing prints is a claim, not a feature.
+    //
+    // "Subscription" rather than "metered": the codex CLI carries its own auth
+    // (a ChatGPT plan or an API key) and nothing outside a run can tell which,
+    // so the CLI words this harness $0 metered, as it always has.
+    access: () => ({ kind: "subscription" }),
+    // NO skill-selection event exists here, so firing is INFERRED from the
+    // SKILL.md read — wrong in both directions (see the constant above). The
+    // caveat travels with the signal so a report can never print the number bare,
+    // and the selection-collision matrix refuses this driver at the type level.
+    firing: { kind: "inferred", caveat: exports.CODEX_TRIGGER_RATE_EXPERIMENTAL },
+    // No namespace: firing is the SKILL.md read, which carries the bare name.
+    firedFor: (skill) => (t) => codexSkillFired(t, skill),
+    // A MEASURED LIMITATION, not a capability: stubbing a Claude-shaped plugin
+    // for Codex is unvalidated, so the real skills are installed and firing is
+    // detected regardless of body.
+    installsStubs: false,
+};
 /**
  * Spawn real `codex exec --json` for the eval tier (real model, the user's codex
  * auth — NOT the mock). CONFIRMED flags (codex 0.139.0): `--json` for the event

package/dist/adapters/codex/hook-protocol.d.ts

@@ -3,7 +3,8 @@
  * Finding: it is essentially IDENTICAL to Claude Code's (exit 2 / `decision:block`
  * / `permissionDecision:deny`) — the thin `HookProtocol` port was the right call.
  * The genuine deltas are the env vars a hook receives + the TOML config format
- * (the latter lives in PluginLayout.settingsFormat, not here).
+ * (the ENCODING lives in PluginLayout.settings, a codec; the entry SHAPE is
+ * `registration`/`mergeRegistrations` below).
  *
  * Context injection (`hookSpecificOutput.additionalContext`) is ALSO shared — same
  * shape, confirmed against the official Codex hooks docs

package/dist/adapters/codex/hook-protocol.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codexHookProtocol = void 0;
+const hook_install_js_1 = require("../../hook-install.js");
 exports.codexHookProtocol = {
     name: "codex",
     blockExitCode: 2,
@@ -27,5 +28,14 @@ exports.codexHookProtocol = {
         "permission_mode",
         "PLUGIN_ROOT",
     ],
+    // Codex is FLAT: `[[hooks.<event>]]` carries one `{matcher?, command}` per
+    // entry. Same fact `toTomlEntries` encodes on the merge side.
+    registration(on, matcher, command) {
+        const entry = matcher === undefined ? { command } : { matcher, command };
+        return { hooks: { [on]: [entry] } };
+    },
+    mergeRegistrations(existing, compiled, managedBy) {
+        return (0, hook_install_js_1.mergeHooksToml)(existing, compiled, managedBy);
+    },
 };
 //# sourceMappingURL=hook-protocol.js.map

package/dist/adapters/codex/instruction-chain.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Codex's instruction chain — the one file a repo-root session loads, and why
+ * every other `AGENTS.md`-shaped file in the map does not.
+ *
+ * Verbatim from the vendor page (`https://developers.openai.com/codex/guides/agents-md`,
+ * fetched 2026-09-21 and recorded in zernie/vigiles#262): starting at the
+ * project root Codex walks DOWN to the current working directory, taking **at
+ * most one file per directory** along that path, checking `AGENTS.override.md`
+ * first, then `AGENTS.md`, then fallback names the repo itself declares via
+ * `project_doc_fallback_filenames` in `config.toml`. The files are concatenated
+ * root-down and truncated at a byte cap on file boundaries.
+ *
+ * 🔴 SO `"**\/AGENTS.md"` WAS NOT MERELY UNBOUNDED, IT WAS WRONG. At a repo-root
+ * session the chain is the ROOT DIRECTORY ALONE — cwd and root are the same
+ * directory, so there is no path to walk down. Summing every nested `AGENTS.md`
+ * added up files that never load together: a monorepo with twelve package-level
+ * files was told it was 12× over a budget no session ever approaches. Codex
+ * TRUNCATES silently over its budget, so this number is the only warning a user
+ * gets, and it was crying wolf on the harness where wolf means "your rules do
+ * not exist".
+ *
+ * And `AGENTS.override.md` is the mirror image of Claude Code's local file: it
+ * REPLACES the committed file rather than being appended after it. That is the
+ * difference the `replaced` reason exists to carry — the combination rule is the
+ * harness's, the fact that a file was hidden is reported to the core.
+ */
+import type { InstructionChain } from "../../core/instruction-chain.js";
+/** `AGENTS.md` → `AGENTS.override.md`: the per-machine file that REPLACES it. */
+export declare function overrideSiblingOf(instructionFile: string): string;
+/** Inputs the layout supplies so this module names no path of its own. */
+export interface CodexChainInput {
+    /** `AGENTS.md`. */
+    readonly instructionFile: string;
+    /** The settings files, in precedence order (repo, then the local sibling). */
+    readonly settingsPaths: readonly string[];
+    /** The layout's own codec — this module does not know the encoding. */
+    readonly parseSettings: (text: string) => Record<string, unknown>;
+}
+export declare function codexInstructionChain(files: Readonly<Record<string, string>>, input: CodexChainInput): InstructionChain;
+//# sourceMappingURL=instruction-chain.d.ts.map

package/dist/adapters/codex/instruction-chain.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overrideSiblingOf = overrideSiblingOf;
+exports.codexInstructionChain = codexInstructionChain;
+const instruction_chain_js_1 = require("../../core/instruction-chain.js");
+/** The `config.toml` key by which a repo declares its own instruction names. */
+const FALLBACK_NAMES_KEY = "project_doc_fallback_filenames";
+/** `AGENTS.md` → `AGENTS.override.md`: the per-machine file that REPLACES it. */
+function overrideSiblingOf(instructionFile) {
+    return (0, instruction_chain_js_1.siblingNamed)(instructionFile, "override");
+}
+/** `project_doc_fallback_filenames`, in the order the repo declared them. */
+function fallbackNames(files, input) {
+    const out = [];
+    for (const path of input.settingsPaths) {
+        const text = files[path];
+        if (text === undefined)
+            continue;
+        let value;
+        try {
+            value = input.parseSettings(text);
+        }
+        catch {
+            // A config mid-merge must not decide which instructions load; falling
+            // back to "the documented names only" is the conservative reading.
+            continue;
+        }
+        const raw = value[FALLBACK_NAMES_KEY];
+        if (!Array.isArray(raw))
+            continue;
+        for (const name of raw) {
+            if (typeof name === "string" && name !== "" && !out.includes(name)) {
+                out.push(name);
+            }
+        }
+    }
+    return out;
+}
+function codexInstructionChain(files, input) {
+    const override = overrideSiblingOf(input.instructionFile);
+    // The root directory's ONE slot, in the vendor's precedence order.
+    //
+    // 🔴 THE OVERRIDE IS A REPOSITORY FILE, NOT A PER-MACHINE ONE. It used to be
+    // `scope: "local"` on the reasoning "like Claude Code's, it is a per-machine
+    // file" — an analogy, and the vendor does not support it. Codex's guide:
+    // "In each directory along the path, it checks for `AGENTS.override.md`,
+    // then `AGENTS.md`". The one override it calls temporary is the GLOBAL
+    // `~/.codex/AGENTS.override.md`; the guide never mentions `.gitignore`.
+    // Measured on the browser engine, where every file is committed by
+    // construction: a repository holding both files published `committed 0`,
+    // while Codex loads the override's bytes. Same class as the invented
+    // `.codex/config.local.toml` earlier in this PR — a sibling modelled by
+    // analogy instead of by observation.
+    const candidates = [
+        { path: override, role: "root", scope: "repo" },
+        { path: input.instructionFile, role: "root", scope: "repo" },
+        ...fallbackNames(files, input).map((name) => ({
+            path: name,
+            role: "fallback",
+            scope: "repo",
+        })),
+    ];
+    const loaded = [];
+    const unloaded = [];
+    for (const candidate of candidates) {
+        if (files[candidate.path] === undefined)
+            continue;
+        const winner = loaded[0];
+        if (winner === undefined) {
+            loaded.push(candidate);
+            continue;
+        }
+        // AT MOST ONE FILE PER DIRECTORY. Everything after the winner is present
+        // and does not load, and says by whom it was replaced — which is the whole
+        // content of the field #262 called `shadows`.
+        unloaded.push({
+            ...candidate,
+            reason: { kind: "replaced", by: winner.path },
+        });
+    }
+    // A nested `AGENTS.md` is NOT loaded at a repo-root session: the walk goes
+    // root→cwd, and at the root those are the same directory. The domain's bound
+    // never enumerates one, so this branch is reached only by a caller holding a
+    // wider map — and then the honest answer is "only when the session runs in
+    // that directory", not "always".
+    const named = new Set([...loaded, ...unloaded].map((e) => e.path));
+    const leaves = new Set([input.instructionFile, override]);
+    for (const path of Object.keys(files).sort()) {
+        if (named.has(path) || !path.includes("/"))
+            continue;
+        if (!leaves.has(path.slice(path.lastIndexOf("/") + 1)))
+            continue;
+        unloaded.push({
+            path,
+            role: "root",
+            scope: "repo",
+            reason: { kind: "on-demand", when: "subdirectory" },
+        });
+    }
+    // No imports and no patterns: Codex's project doc has no include mechanism —
+    // an empty array here is a STATEMENT, not a stub, and the property tests hold
+    // over it the same way they hold over a populated one.
+    return { loaded, unloaded, imports: [], patterns: [], redirects: [] };
+}
+//# sourceMappingURL=instruction-chain.js.map

package/dist/adapters/codex/layout.d.ts

@@ -52,7 +52,7 @@
  * - MCP detection (`mcpConfigFile`/`mcpManifestKey`) is JSON-shaped, so it won't
  *   see Codex's `[mcp_servers]` TOML table — a known layout-port gap.
  * 🔴 THE PATHS BELOW ARE DOCUMENTED IN `docs/configuration.md`. Change any of
- * them — `instructionFile`, `surfaceDirs`, `userSurfaceRoot`, `rulesDir` — and
+ * them — `instructionFile`, `surfaces`, `userSurfaceRoot`, `rulesDir` — and
  * that page is wrong until you edit it too. The page marks this symbol with
  * `vigiles:symbol`, so RENAMING it turns `vigiles lint` red and forces the
  * edit; changing a VALUE in place does not, and nothing today catches that.

package/dist/adapters/codex/layout.js

@@ -1,30 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codexLayout = 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.codexLayout = {
     name: "codex",
     manifestPath: ".codex/config.toml",
     hooksConventionPath: ".codex/hooks.json",
     settingsPath: ".codex/config.toml",
-    settingsFormat: "toml",
+    settings: settings_codec_js_1.tomlSettingsCodec,
     instructionFile: "AGENTS.md",
-    // Surfaces carry their OWN prefix and `materializeRoot` is "" — the OpenCode
-    // style, not the Claude Code one. Codex's skills and its prompts do NOT share a
-    // parent (`.agents/` vs `.codex/`), so no single `materializeRoot` can name
+    // Surfaces carry their OWN prefix and the materialize prefix is "" — the
+    // OpenCode style, not the Claude Code one. Codex's skills and its prompts do
+    // NOT share a parent (`.agents/` vs `.codex/`), so no single root can name
     // both; spelling each dir in full is the only shape that keeps the reported key
     // equal to the real on-disk path.
-    surfaceDirs: [".agents/skills", "prompts"],
-    skillDir: ".agents/skills",
-    agentDir: "", // Codex `[agents]` is a TOML concurrency table, not a subagent dir
-    // Custom prompts are documented ONLY at `~/.codex/prompts` (user-global,
-    // top-level `.md`, and marked deprecated in favour of skills). No repo-level
-    // location is documented, so this prototype's root-level `prompts/` is left as
-    // it was rather than moved on a guess.
-    commandDir: "prompts",
-    materializeRoot: "",
+    surfaces: {
+        skill: ".agents/skills",
+        // No `agent` key: Codex `[agents]` is a TOML concurrency table, not a
+        // subagent dir. An ABSENT key is the only spelling of "this harness has no
+        // such surface" — it used to be `agentDir: ""`, a second spelling that every
+        // reader had to remember to test for.
+        //
+        // Custom prompts are documented ONLY at `~/.codex/prompts` (user-global,
+        // top-level `.md`, and marked deprecated in favour of skills). No repo-level
+        // location is documented, so this prototype's root-level `prompts/` is left
+        // as it was rather than moved on a guess.
+        command: "prompts",
+    },
+    // No `userSurfaceRoot`: the surfaces carry their own prefix, so the
+    // materialize prefix is "" and a file-map key equals the on-disk path. That
+    // used to be spelled twice, as `materializeRoot: ""` beside an absent
+    // `userSurfaceRoot`.
+    //
+    // ⚠️ `hookScriptsDir: "hooks"` carries over the value the hand-written
+    // `intraRefDirs` had. NOTHING in the vendor pages confirms a repo-level
+    // `hooks/` directory for Codex; it is kept as it was rather than "aligned"
+    // from a guess, the same stance `installCodexSkills` takes above.
+    hookScriptsDir: "hooks",
     pluginRootToken: "${PLUGIN_ROOT}",
     mcpConfigFile: ".mcp.json",
     mcpManifestKey: "mcp_servers",
-    intraRefDirs: [".agents/skills", "prompts", "hooks"],
+    // The root directory's ONE slot — override, then the committed file, then the
+    // names the repo itself declares in `config.toml`. See ./instruction-chain.ts
+    // for the vendor wording and for why `"**/AGENTS.md"` was not merely unbounded
+    // but wrong about what a root session loads.
+    instructionChain(files) {
+        return (0, instruction_chain_js_2.codexInstructionChain)(files, {
+            instructionFile: exports.codexLayout.instructionFile,
+            settingsPaths: (0, instruction_chain_js_1.settingsSourcePaths)(exports.codexLayout),
+            parseSettings: (text) => exports.codexLayout.settings.parse(text),
+        });
+    },
 };
 //# sourceMappingURL=layout.js.map

package/dist/adapters/opencode/adapter.d.ts

@@ -1,3 +1,34 @@
-import type { HarnessAdapter } from "../../core/adapter.js";
-export declare const opencodeAdapter: HarnessAdapter;
+/**
+ * opencodeAdapter — EXPERIMENTAL, internal-only prototype `HarnessAdapter`. It
+ * exists to PROVE the kit generalizes to the optional-transport-port shape: a
+ * harness that does pillar 1 AND is mockable (openai-compatible) BUT whose hooks
+ * are in-process JS/TS plugin modules, not shell processes. So it declares
+ * `shellHooks: false`, ships NO `hookProtocol`, and the conformance kit must
+ * accept it without demanding a fake one. This is the pillar-1-only,
+ * no-shell-hooks shape the capability gating was built for.
+ *
+ * 🔴 AND IT IS THE PORT'S THIRD IMPLEMENTATION, which is why two of the port's
+ * illegal states were live HERE and nowhere else: a port validated against two
+ * implementations cannot see a state only the third can reach. The other one
+ * was in its layout (a skill dir outside `surfaceDirs`).
+ *
+ * It is deliberately NOT registered in `src/adapter-registry.ts` and NOT exported
+ * from any `vigiles/*` subpath, so the CLI never auto-detects OpenCode and
+ * consumers can't import it. Promote it (register + `vigiles/opencode` export +
+ * the deferred transport renderers) only when OpenCode support actually ships.
+ */
+import type { DetectSignal } from "../../core/adapter.js";
+export declare const opencodeAdapter: {
+    readonly name: "opencode";
+    readonly harnessTesting: false;
+    readonly shellHooks: false;
+    readonly subagents: true;
+    readonly dialect: import("../claude-code/dialect.js").HarnessDialect;
+    readonly layout: import("../../adapter.js").PluginLayout;
+    readonly claims: (path: string) => boolean;
+    readonly detect: (exists: (repoRelative: string) => boolean) => DetectSignal;
+    /** Nothing to say about an opencode install — see the Codex adapter for why
+     *  `[]` is the answer rather than an absent capability. */
+    readonly advisories: () => readonly string[];
+};
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/opencode/adapter.js

@@ -1,55 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeAdapter = void 0;
-/**
- * opencodeAdapter — EXPERIMENTAL, internal-only prototype `HarnessAdapter`. It
- * exists to PROVE the kit generalizes to the optional-transport-port shape: a
- * harness that does pillar 1 AND is mockable (openai-compatible) BUT whose hooks
- * are in-process JS/TS plugin modules, not shell processes. So it declares
- * `shellHooks: false`, ships NO `hookProtocol`, and the conformance kit must
- * accept it without demanding a fake one. This is the pillar-1-+-mockable-but-
- * no-shell-hooks shape the capability gating was built for.
- *
- * It is deliberately NOT registered in `src/adapter-registry.ts` and NOT exported
- * from any `vigiles/*` subpath, so the CLI never auto-detects OpenCode and
- * consumers can't import it. Promote it (register + `vigiles/opencode` export +
- * the deferred transport renderers) only when OpenCode support actually ships.
- */
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const dialect_js_1 = require("./dialect.js");
 const layout_js_1 = require("./layout.js");
 const surface_discovery_js_1 = require("../../core/surface-discovery.js");
-const runtime_js_1 = require("./runtime.js");
-const model_mock_js_1 = require("./model-mock.js");
+// `opencodeRuntime` / `opencodeModelMock` are NOT imported: with
+// `harnessTesting: false` the type gives those fields `?: never`, so carrying
+// them would be a compile error. The modules stay on disk for the commit that
+// adds a driver and flips the flag back.
 exports.opencodeAdapter = {
     name: "opencode",
-    // Pillar 1 + mockable (openai-chat SSE), but hooks are in-process JS/TS plugin
-    // modules — no shell-hook tier, hence shellHooks:false and NO hookProtocol.
-    capabilities: {
-        referenceVerification: true,
-        harnessTesting: true,
-        shellHooks: false,
-        subagents: true,
-    },
+    // 🔴 `harnessTesting: false`, AND IT USED TO SAY `true`. That declaration was
+    // the port's second live illegal state: the flag was set, `runtime` and
+    // `modelMock` were present, and there was NO `harnessTestDriver` behind them
+    // — so `runHarnessTest` threw "declares harnessTesting but carries no
+    // harnessTestDriver" at run time, and the conformance kit missed it because
+    // it checked the two ports it knew about and not the thunk.
+    //
+    // The declaration was also simply untrue, and the repo said so elsewhere:
+    // `docs/harnesses.md` records OpenCode's mockable tier as "declared but not
+    // yet built". So this is not a downgrade — it is the flag catching up with
+    // the tier, and `runtime`/`modelMock` come off with it because the `false`
+    // arm of `TestingPorts` types them `?: never`. Set it back to `true` in the
+    // same commit that adds a driver; the type will refuse anything else.
+    harnessTesting: false,
+    // Hooks are in-process JS/TS plugin modules — no shell-hook tier, hence
+    // shellHooks:false and NO hookProtocol (the `false` arm types it `?: never`,
+    // so shipping one is now an error rather than dead weight).
+    shellHooks: false,
+    subagents: true,
     dialect: dialect_js_1.opencodeDialect,
     layout: layout_js_1.opencodeLayout,
-    runtime: runtime_js_1.opencodeRuntime,
-    modelMock: model_mock_js_1.opencodeModelMock,
-    // No hookProtocol: OpenCode hooks are code modules, not shell processes.
     // Derived from the layout, never listed again here — see `claims` on
     // `HarnessAdapter` for why this method takes a PATH and not a root.
     claims(path) {
         return (0, surface_discovery_js_1.layoutClaims)(layout_js_1.opencodeLayout, path);
     },
-    detect(root) {
+    detect(exists) {
         // An `opencode.json` is a strong signal; a bare AGENTS.md is weak (many
-        // harnesses read it). (Unused while unregistered — kept for symmetry.)
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, "opencode.json")))
-            return 3;
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, layout_js_1.opencodeLayout.instructionFile)))
-            return 1;
-        return 0;
+        // harnesses read it). (Unused while unregistered — kept for symmetry, and
+        // so the property tests have a THIRD implementation to run against.)
+        if (exists(layout_js_1.opencodeLayout.manifestPath))
+            return { specificity: 3, via: "manifest" };
+        if (exists(layout_js_1.opencodeLayout.instructionFile))
+            return { specificity: 1, via: "instruction-file" };
+        return { specificity: 0, via: "instruction-file" };
+    },
+    /** Nothing to say about an opencode install — see the Codex adapter for why
+     *  `[]` is the answer rather than an absent capability. */
+    advisories() {
+        return [];
     },
 };
 //# sourceMappingURL=adapter.js.map

package/dist/adapters/opencode/dialect.js

@@ -30,7 +30,7 @@ exports.opencodeDialect = {
     instructionTargets: ["AGENTS.md", "CLAUDE.md"],
     pluginRootToken: "${OPENCODE_PLUGIN_ROOT}",
     // OpenCode reads the minimal cross-tool SKILL.md frontmatter (name +
-    // description); the CC-only keys are not part of its format.
-    skillFrontmatter: "minimal",
+    // description); the richer keys are not part of its format.
+    skillFrontmatterKeys: ["name", "description"],
 };
 //# sourceMappingURL=dialect.js.map

package/dist/adapters/opencode/instruction-chain.d.ts

@@ -0,0 +1,37 @@
+/**
+ * OpenCode's instruction chain — EXPERIMENTAL, like the rest of this adapter.
+ *
+ * It exists because it is the port's THIRD implementation, and the third one is
+ * where a shape has room to go wrong: both of the layout port's live illegal
+ * states were here, in the implementation the contract suite did not range over.
+ * For `instructionChain` it earns its keep a second way — it is the only
+ * implementation in this repo that populates {@link InstructionChain.patterns},
+ * so without it that half of the interface would be typed, documented and
+ * exercised by nothing.
+ *
+ * ⚠️ SOURCE OF THE `instructions` FACT, NAMED RATHER THAN IMPLIED. The key and
+ * its glob shape (`instructions: ["packages/*\/AGENTS.md"]`) are taken from
+ * `docs/design/port-redesign-round-2-2026-09-21.md` §1, which is where this
+ * adapter's other shapes come from too. It is NOT a vendor page this session
+ * fetched, and the adapter is unregistered and unexported, so nothing a user
+ * runs depends on it being exactly right. Do not promote it to a registered
+ * adapter without re-reading the vendor.
+ *
+ * What it does NOT do is expand those globs. A pattern is reported so the weight
+ * can say "plus N pattern(s) not weighed" instead of printing a number that is
+ * quietly missing them — the same stance the Codex chain takes towards a nested
+ * file, and the opposite of what the glob list this replaced did, which was to
+ * expand an adapter's pattern by walking the user's repository.
+ */
+import type { InstructionChain } from "../../core/instruction-chain.js";
+/** Inputs the layout supplies so this module names no path of its own. */
+export interface OpencodeChainInput {
+    /** `AGENTS.md`. */
+    readonly instructionFile: string;
+    /** `opencode.json` — both the manifest and the settings file here. */
+    readonly settingsPaths: readonly string[];
+    /** The layout's own codec — this module does not know the encoding. */
+    readonly parseSettings: (text: string) => Record<string, unknown>;
+}
+export declare function opencodeInstructionChain(files: Readonly<Record<string, string>>, input: OpencodeChainInput): InstructionChain;
+//# sourceMappingURL=instruction-chain.d.ts.map

package/dist/adapters/opencode/instruction-chain.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeInstructionChain = opencodeInstructionChain;
+const instruction_chain_js_1 = require("../../core/instruction-chain.js");
+/** The manifest key listing extra instruction files, as the design records it. */
+const INSTRUCTIONS_KEY = "instructions";
+/** A value the domain would have to WALK to expand, rather than look up. */
+function isPattern(value) {
+    return /[*?[\]{}]/.test(value) || value.includes("://");
+}
+/** The `instructions` entries one settings file declares, in declared order. */
+function declaredInstructions(files, input) {
+    const out = [];
+    for (const from of input.settingsPaths) {
+        const text = files[from];
+        if (text === undefined)
+            continue;
+        let value;
+        try {
+            value = input.parseSettings(text);
+        }
+        catch {
+            continue;
+        }
+        const raw = value[INSTRUCTIONS_KEY];
+        if (!Array.isArray(raw))
+            continue;
+        for (const entry of raw) {
+            if (typeof entry === "string" && entry !== "") {
+                // The token AS WRITTEN is the manifest string itself — OpenCode names
+                // a path directly rather than prefixing it, so token === path here.
+                out.push({ path: entry, token: entry, from });
+            }
+        }
+    }
+    return out;
+}
+function opencodeInstructionChain(files, input) {
+    const loaded = [];
+    const imports = [];
+    const patterns = [];
+    if (files[input.instructionFile] !== undefined) {
+        loaded.push({ path: input.instructionFile, role: "root", scope: "repo" });
+    }
+    for (const entry of declaredInstructions(files, input)) {
+        if (isPattern(entry.path)) {
+            patterns.push({ pattern: entry.path, from: entry.from });
+            continue;
+        }
+        if (!(0, instruction_chain_js_1.isRepoRootedImport)(entry.path))
+            continue;
+        imports.push(entry);
+        if (files[entry.path] === undefined)
+            continue;
+        if (loaded.some((e) => e.path === entry.path))
+            continue;
+        loaded.push({
+            path: entry.path,
+            role: "import",
+            scope: "repo",
+            via: { from: entry.from, token: entry.token },
+        });
+    }
+    // No `unloaded`, and no `redirects`: nothing in OpenCode's documented shape
+    // hides one file behind another, and its extra instruction files are named in
+    // the MANIFEST rather than inside the root file, so the root file cannot be a
+    // pure pointer. Empty arrays are the statement, not a gap.
+    return { loaded, unloaded: [], imports, patterns, redirects: [] };
+}
+//# sourceMappingURL=instruction-chain.js.map

package/dist/adapters/opencode/layout.d.ts

@@ -3,6 +3,25 @@
  * OpenCode: `opencode.json` manifest/settings, `AGENTS.md`, `.opencode/`
  * surfaces, `${OPENCODE_PLUGIN_ROOT}`. Validates the layout port against real
  * OpenCode shapes. NOT exported / NOT registered.
+ *
+ * 🔴 IT IS THE PORT'S THIRD IMPLEMENTATION, AND IT SHIPPED BROKEN — which is
+ * exactly the job a third implementation has. Until 2026-09-21 this descriptor
+ * read:
+ *
+ *     surfaceDirs: [".opencode/agent", ".opencode/command"],
+ *     skillDir: ".opencode/skill",
+ *
+ * Two fields naming the same set of directories, disagreeing. Everything that
+ * materializes, counts or scans a surface ranged over `surfaceDirs`, so
+ * OpenCode's skills were NAMED by the port and READ by nothing: a repo with
+ * skills under `.opencode/skill` graded as having none. Nothing caught it,
+ * because a port validated against two implementations cannot see a state only
+ * the third can reach.
+ *
+ * It cannot be written now: `surfaces` is one record keyed by kind, so there is
+ * no second field to disagree with, and `surfaceDirs()` is derived from it.
+ * Listing the skill dir here is therefore also a BEHAVIOUR change for this
+ * prototype — its skills become readable for the first time.
  */
 import type { PluginLayout } from "../../core/layout.js";
 export declare const opencodeLayout: PluginLayout;