@miraland-labs/conduit-bridge 0.16.108 → 0.16.110

package/dist/execution.js

@@ -25,7 +25,7 @@ import { ensureLandCommit } from "./ensure-land-commit.js";
 import { AGENT_NO_LAND_COMMIT_PREFIX, AgentNoLandCommitError, agentNoLandCommitMessage, requiresLandCommit } from "./land-contract.js";
 import { agentClaimsRepositoryWork, claimsVsGitMismatch, isLandTreeEmpty, reportClaimsRepositoryWork, } from "./land-git-reality.js";
 const execFileAsync = promisify(execFile);
-import { captureVerificationFailure, detectGateRanNothing, ensureTestEvidence, needsTestEvidence, runBoundedVerificationCommand, verificationEvidenceCommands, VerificationGateRanNothingError } from "./ensure-test-evidence.js";
+import { boundedTail, captureVerificationFailure, detectGateRanNothing, ensureTestEvidence, needsTestEvidence, runBoundedVerificationCommand, verificationEvidenceCommands, VerificationGateRanNothingError } from "./ensure-test-evidence.js";
 import { ensureChangeEvidence } from "./ensure-change-evidence.js";
 import { ensureNormativeEvidence } from "./ensure-normative-evidence.js";
 import { changedPathsSince, compareWorktreeState, diffStatSince, worktreeStateFingerprint, worktreeWrittenPaths } from "./git-witness.js";
@@ -2872,8 +2872,44 @@ export async function verificationScopeDryRun(input) {
         : written.filter((path) => !input.changeScope.some((scope) => pathMatchesScope(path, scope)));
     return { ranNothing, redBase, outsideScope };
 }
+/** Prompt and failure lines keep a short tail; the investigation brief caps each failure at 1,000. */
+const DELIVERY_VERIFICATION_GATE_TAIL_CHARS = 800;
+/**
+ * Run the T191 gate set in the verification worktree at the delivered commit: declared
+ * `.conduit/verification` ∪ the commands the criteria name, else the discovered set. One at a
+ * time, same bounded runner as the pre-agent dry run. Writes the gates made are discarded so the
+ * agent still reads the delivered tree.
+ */
+export async function runDeliveryVerificationGates(input) {
+    const commands = verificationEvidenceCommands([...input.verificationCommands], input.declaredVerificationCommands ?? [], input.acceptance ?? []);
+    const run = input.runCommand ?? runBoundedVerificationCommand;
+    const results = [];
+    for (const command of commands) {
+        try {
+            const result = await run(command, input.workspace);
+            results.push({
+                command,
+                exitCode: result.code,
+                stdoutTail: boundedTail(result.stdout, DELIVERY_VERIFICATION_GATE_TAIL_CHARS),
+                stderrTail: boundedTail(result.stderr, DELIVERY_VERIFICATION_GATE_TAIL_CHARS),
+            });
+        }
+        catch (error) {
+            // A gate that could not run is a failed gate: record it so settlement still names it.
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+                command,
+                exitCode: -1,
+                stdoutTail: "",
+                stderrTail: boundedTail(message, DELIVERY_VERIFICATION_GATE_TAIL_CHARS),
+            });
+        }
+    }
+    await discardWorktreeWrites(input.workspace);
+    return results;
+}
 /** Return the worktree to its commit: tracked files restored, new files removed, ignored files kept. */
-async function discardWorktreeWrites(worktree) {
+export async function discardWorktreeWrites(worktree) {
     const options = { timeout: 60_000, maxBuffer: 2_000_000 };
     await execFileAsync("git", ["-C", worktree, "checkout", "--", "."], options).catch(() => undefined);
     await execFileAsync("git", ["-C", worktree, "clean", "-fd"], options).catch(() => undefined);

package/dist/failure-signal.js

@@ -75,6 +75,32 @@ export const failureSignalSchema = z.object({
      */
     model: z.string().max(200).optional(),
 });
+/**
+ * The class–disposition pairs a classified failure may carry. Disposition is a function of the
+ * cause, not of class: the six canonical pairs plus `contract`/`hold` (the work package is the
+ * defect; a rework would spend repair on code that is not at fault) and `environment`/`retry`
+ * (the computer hiccupped; the next lane runs it again).
+ *
+ * Declared once so the envelope schema and both twins share one list. `ClassifiedFailure` stays a
+ * free pair; this list is the boundary check.
+ */
+export const ADMITTED_FAILURE_PAIRS = [
+    ["transient", "retry"],
+    ["environment", "hold"],
+    ["environment", "retry"],
+    ["contract", "rework"],
+    ["contract", "hold"],
+    ["quality", "rework"],
+    ["authority", "decision"],
+    ["platform", "stop"],
+];
+/**
+ * Whether this class and disposition are one of the admitted pairs. The envelope schema calls it
+ * so a supplied envelope cannot carry a pairing the builders never emit.
+ */
+export function isAdmittedFailurePair(failureClass, disposition) {
+    return ADMITTED_FAILURE_PAIRS.some(([admittedClass, admittedDisposition]) => admittedClass === failureClass && admittedDisposition === disposition);
+}
 /**
  * The causes Bridge names itself — before the agent starts, or while finishing its report — as one
  * table keyed by code, so Bridge sends the envelope and the control plane validates it (K3).

package/dist/investigation.js

@@ -6,19 +6,22 @@
  * the worktree it reads is deleted whichever way the run ends.
  */
 import { z } from "zod";
-import { boundedTail } from "./ensure-test-evidence.js";
+import { boundedTail, runBoundedVerificationCommand } from "./ensure-test-evidence.js";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
 import { headCommitOrNull } from "./git.js";
 import { redactSecrets } from "./config.js";
-import { learnDriverFuel, resolveAssignmentModel } from "./execution.js";
+import { learnDriverFuel, resolveAssignmentModel, changedPathsSince, runDeliveryVerificationGates, discardWorktreeWrites } from "./execution.js";
 import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
 import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
-import { changedPathsSince } from "./execution.js";
 import { diffStatSince } from "./git-witness.js";
 import { switchManagedWorkspace } from "./on-shift-apply.js";
 import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { promisify } from "node:util";
+import { isRunnableVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
 const budgetSchema = z.object({
     max_files: z.number().int().min(1).max(24).optional().default(8),
@@ -36,6 +39,10 @@ export const investigationAssignmentSchema = z.object({
     /** T122: present on a delivery verification — the contract base the delivered head was built on. */
     base_commit: z.string().nullable().optional().default(null),
     source_attempt_id: z.string().uuid().nullable().optional().default(null),
+    /** Delivery verification: the task's acceptance strings. Absent or [] on a plain investigation. */
+    acceptance: z.array(z.string().trim().min(1).max(4_000)).max(20).optional().default([]),
+    /** Delivery verification: the brief's `[sN]` / `[kN]` lines. Absent or [] on a plain investigation. */
+    brief_keys: z.array(z.string().trim().min(1).max(4_000)).max(40).optional().default([]),
 });
 /**
  * Enforcement is a vendor's claim; verification is ours. Both run on every investigation — this only
@@ -66,9 +73,24 @@ const investigationBriefSchema = z.object({
     files_read: z.number().int().min(0).max(24).default(0),
     bytes_read: z.number().int().min(0).max(512 * 1024).default(0),
     commands_run: z.array(z.string().trim().min(1).max(200)).max(10).default([]),
+    /**
+     * K12: probe source the agent wrote. Bridge executes these; it never copies claimed results into
+     * step_witness. Unknown keys such as a claimed exit_code are stripped.
+     */
+    probes: z.array(z.object({
+        key: z.string().trim().min(1).max(40),
+        test: z.string().max(300).optional(),
+        lang: z.enum(["ts", "py", "sh"]).optional(),
+        source: z.string().max(8_000).optional(),
+        checks: z.string().max(500).optional().default(""),
+    })).max(20).default([]),
 });
 /** T122: a delivery verification is an investigation whose question carries this header. */
 export const DELIVERY_VERIFICATION_HEADER = "DELIVERY VERIFICATION";
+/** Owner-verbatim: the lane writes probe source; Bridge executes. Shown only when BRIEF KEYS are present. */
+export const DELIVERY_VERIFICATION_PROBE_INSTRUCTION = 'For every BRIEF KEY that states behaviour, add one entry to probes: either {"key":"[sN]","test":"<registered command that asserts it>","checks":"<one line: what it proves>"} or {"key":"[sN]","lang":"ts|py|sh","source":"<a short script that exits 0 only when the key holds at this commit and non-zero otherwise; it may import repository modules by absolute path from the working directory>","checks":"<one line>"}. You do not run probes; Bridge runs them after you finish. Keys that state no behaviour (wording, scope, docs) get no probe.';
+const BRIEF_JSON_EXAMPLE = '{"summary":"one paragraph: what the change does and whether it meets the criteria","findings":["grounded fact with file/symbol"],"verification":["command — result"],"limitations":["what you could not settle"],"criteria":[{"criterion":"c1","assessment":"supported|unsupported|unclear","reason":"what you saw"}],"command_failures":["command that exited non-zero — the decisive output line"],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}';
+const BRIEF_JSON_EXAMPLE_WITH_PROBES = '{"summary":"one paragraph: what the change does and whether it meets the criteria","findings":["grounded fact with file/symbol"],"verification":["command — result"],"limitations":["what you could not settle"],"criteria":[{"criterion":"c1","assessment":"supported|unsupported|unclear","reason":"what you saw"}],"command_failures":["command that exited non-zero — the decisive output line"],"probes":[],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}';
 export function isDeliveryVerification(assignment) {
     return assignment.question.trimStart().startsWith(DELIVERY_VERIFICATION_HEADER);
 }
@@ -95,7 +117,7 @@ export function buildInvestigationPrompt(assignment, commit, context) {
 }
 /**
  * T122: the Conductor's own check of a delivery, done the way a careful reviewer does it by hand —
- * run the registered commands at the delivered head, read the diff, judge every criterion. The
+ * read the gates Bridge already ran at the delivered head, read the diff, judge every criterion. The
  * verdict per criterion is the product; prose without verdicts is an unusable brief.
  */
 export function buildDeliveryVerificationPrompt(assignment, commit, context) {
@@ -109,27 +131,70 @@ export function buildDeliveryVerificationPrompt(assignment, commit, context) {
     const commands = context.verificationCommands.length
         ? `REGISTERED COMMANDS (the only commands your shell accepts)\n${context.verificationCommands.map((command) => `- ${command}`).join("\n")}`
         : "REGISTERED COMMANDS\n- none: this repository registers no verification command, so judge from the files only";
+    const keys = (assignment.brief_keys ?? []).map((key) => key.trim()).filter(Boolean);
+    const briefKeysBlock = keys.length ? `BRIEF KEYS\n${keys.join("\n")}` : "";
+    const probeBlock = keys.length ? DELIVERY_VERIFICATION_PROBE_INSTRUCTION : "";
     return [
         "You are Conductor's independent delivery verification. A coding agent delivered this commit against approved acceptance criteria; you check it the way a careful reviewer would, and you never take the agent's word for anything.",
         "You have repo_read and test_run only. Do not edit, create, delete, format, commit, branch, push, install, or change any file.",
         diff,
-        "Run every REGISTERED COMMAND the criteria name, exactly as registered, and read its real output. Run nothing that is not registered. Never start a server, deploy, or call a production system.",
+        formatGatesRunBlock(context.gatesRun ?? []),
+        "Bridge already ran the gates at this commit. The GATES RUN block is the only gate fact — use those exit codes and output tails; do not choose which commands count as gates. You may still run a REGISTERED COMMAND to read more. Run nothing that is not registered. Never start a server, deploy, or call a production system.",
         // T132: three verifications ended at the time limit with no brief. Order the work so the brief
         // exists before the budget does not.
-        "Order of work: run the registered commands first, one at a time and never two at once (a test suite that rewrites a source file and restores it races against itself when run concurrently, and a changed tree voids your run), then read the changed files that matter, then write the brief. Your time is limited: a brief with `unclear` verdicts for what you did not reach is the required outcome; a run that ends without a brief settles nothing.",
+        "Order of work: read the GATES RUN facts first, then the changed files that matter, then write the brief. You may run a registered command to read more, one at a time and never two at once (a test suite that rewrites a source file and restores it races against itself when run concurrently, and a changed tree voids your run). Your time is limited: a brief with `unclear` verdicts for what you did not reach is the required outcome; a run that ends without a brief settles nothing.",
         "Judge each ACCEPTANCE criterion by its key: supported only when you saw the code or the command output that meets it; unsupported when you saw it is not met, with the file or output that shows it; unclear when this commit and these commands cannot settle it. A criterion about wording in a pull request or a report is unclear here — you cannot see those.",
         "Do not quote secrets, credentials, tokens, or file bodies. Name paths, symbols, and command output lines instead.",
         "",
         `PINNED COMMIT ${commit}`,
         commands,
         assignment.question,
+        ...(briefKeysBlock ? [briefKeysBlock] : []),
+        ...(probeBlock ? [probeBlock] : []),
         `BUDGET\nAt most ${assignment.budget.max_files} files read in full; the change summary and command output are not counted.`,
         "",
         "Return only one fenced ```json object with exactly this shape:",
-        '{"summary":"one paragraph: what the change does and whether it meets the criteria","findings":["grounded fact with file/symbol"],"verification":["command — result"],"limitations":["what you could not settle"],"criteria":[{"criterion":"c1","assessment":"supported|unsupported|unclear","reason":"what you saw"}],"command_failures":["command that exited non-zero — the decisive output line"],"files_read":0,"bytes_read":0,"commands_run":["command you actually ran"]}',
-        "criteria has one entry per ACCEPTANCE key. Close the fence and add no prose after it.",
+        keys.length ? BRIEF_JSON_EXAMPLE_WITH_PROBES : BRIEF_JSON_EXAMPLE,
+        keys.length
+            ? "criteria has one entry per ACCEPTANCE key. probes has at most 20 entries, one per BRIEF KEY that states behaviour. Close the fence and add no prose after it."
+            : "criteria has one entry per ACCEPTANCE key. Close the fence and add no prose after it.",
     ].join("\n");
 }
+function formatGatesRunBlock(gates) {
+    const header = "GATES RUN (Bridge ran these at the pinned commit before you started; these are the only gate facts)";
+    if (!gates.length)
+        return `${header}\n- none`;
+    return `${header}\n${gates.map((gate) => {
+        const tail = gate.stderrTail.trim() || gate.stdoutTail.trim();
+        return tail
+            ? `- ${gate.command} — exit ${gate.exitCode}\n  ${tail.replace(/\n/g, "\n  ")}`
+            : `- ${gate.command} — exit ${gate.exitCode}`;
+    }).join("\n")}`;
+}
+function gateFailureLine(tail) {
+    const lines = tail.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const marked = lines.find((line) => /FAIL|Error|error|failed|✗/.test(line));
+    const chosen = marked ?? lines.at(-1) ?? tail;
+    return chosen.length > 1_000 ? chosen.slice(0, 1_000) : chosen;
+}
+function gateFailureFact(gate) {
+    const tail = gate.stderrTail.trim() || gate.stdoutTail.trim() || "exited non-zero";
+    return boundedTail(`${gate.command} — exit ${gate.exitCode}: ${gateFailureLine(tail)}`, 1_000);
+}
+function settleCommandsRun(gates, reported) {
+    const out = [];
+    const seen = new Set();
+    for (const command of [...gates.map((gate) => gate.command), ...reported]) {
+        const trimmed = command.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+        if (out.length === 10)
+            break;
+    }
+    return out;
+}
 /** One message for every unusable answer, so the retry decision reads it rather than guessing. */
 export const UNUSABLE_BRIEF = "Investigation returned no usable brief";
 /** T130: how much of an unusable reply travels with the failure, so the next run can be diagnosed. */
@@ -193,6 +258,146 @@ export async function verifyObservationOnly(input) {
     }
     return { ok: true };
 }
+const PROBE_TIMEOUT_MS = 60_000;
+const PROBE_MAX_BUFFER_BYTES = 2_000_000;
+const PROBE_TAIL_CHARS = 1_000;
+const PROBE_MAX = 20;
+const PROBE_COMMAND_MAX = 300;
+const PROBE_CHECKS_MAX = 500;
+const PROBE_KEY_MAX = 40;
+function probeEnv() {
+    const env = {};
+    if (process.env.PATH !== undefined)
+        env.PATH = process.env.PATH;
+    if (process.env.HOME !== undefined)
+        env.HOME = process.env.HOME;
+    return env;
+}
+function probeInterpreter(language) {
+    if (language === "ts")
+        return "node --import tsx";
+    if (language === "py")
+        return "python3";
+    return "bash";
+}
+function probeFilename(language) {
+    if (language === "ts")
+        return "probe.ts";
+    if (language === "py")
+        return "probe.py";
+    return "probe.sh";
+}
+function probeArgv(language, file) {
+    if (language === "ts")
+        return ["node", "--import", "tsx", file];
+    if (language === "py")
+        return ["python3", file];
+    return ["bash", file];
+}
+function clipWitnessField(value, max) {
+    return value.length > max ? value.slice(0, max) : value;
+}
+async function execProbe(argv, workspace) {
+    const bin = argv[0];
+    if (!bin)
+        throw new Error("Probe command is empty");
+    try {
+        const { stdout, stderr } = await execFileAsync(bin, argv.slice(1), {
+            cwd: workspace,
+            timeout: PROBE_TIMEOUT_MS,
+            maxBuffer: PROBE_MAX_BUFFER_BYTES,
+            env: probeEnv(),
+        });
+        return { stdout: String(stdout), stderr: String(stderr), code: 0 };
+    }
+    catch (error) {
+        const err = error;
+        if (typeof err.code === "string")
+            throw error;
+        return {
+            stdout: String(err.stdout ?? ""),
+            stderr: String(err.stderr || err.message || "probe failed"),
+            code: err.killed === true || typeof err.code !== "number" ? -1 : err.code,
+        };
+    }
+}
+function witnessRecord(input) {
+    return {
+        key: clipWitnessField(input.key, PROBE_KEY_MAX),
+        kind: input.kind,
+        command: clipWitnessField(input.command, PROBE_COMMAND_MAX),
+        exit_code: input.exitCode,
+        tail: boundedTail(`${input.stderr.trim()}\n${input.stdout.trim()}`.trim(), PROBE_TAIL_CHARS),
+        checks: clipWitnessField(input.checks, PROBE_CHECKS_MAX),
+    };
+}
+/**
+ * Run at most twenty agent-authored probes after the read-only proof. Records only what Bridge
+ * executed; agent-claimed exit codes never enter the witness.
+ */
+export async function runDeliveryVerificationProbes(input) {
+    const selected = [...input.probes].slice(0, PROBE_MAX);
+    const witnesses = [];
+    for (const probe of selected) {
+        const checks = probe.checks ?? "";
+        const named = probe.test?.trim() ?? "";
+        const source = probe.source?.trim() ?? "";
+        if (named) {
+            if (!isRunnableVerificationCommand(named)) {
+                witnesses.push(witnessRecord({
+                    key: probe.key, kind: "test", command: named, exitCode: -1, stdout: "", stderr: "not a registered command", checks,
+                }));
+                continue;
+            }
+            let exitCode = -1;
+            let stdout = "";
+            let stderr = "";
+            try {
+                const result = await (input.runCommand ?? runBoundedVerificationCommand)(named, input.workspace);
+                exitCode = result.code;
+                stdout = result.stdout;
+                stderr = result.stderr;
+            }
+            catch (error) {
+                stderr = error instanceof Error ? error.message : String(error);
+                exitCode = -1;
+            }
+            witnesses.push(witnessRecord({
+                key: probe.key, kind: "test", command: named, exitCode, stdout, stderr, checks,
+            }));
+            continue;
+        }
+        if (!source || !probe.lang)
+            continue;
+        const language = probe.lang;
+        const command = `${probeInterpreter(language)} ${probe.key}`;
+        let dir = null;
+        let exitCode = -1;
+        let stdout = "";
+        let stderr = "";
+        try {
+            dir = await mkdtemp(join(tmpdir(), "conduit-probe-"));
+            const file = join(dir, probeFilename(language));
+            await writeFile(file, source, { encoding: "utf8" });
+            const result = await execProbe(probeArgv(language, file), input.workspace);
+            exitCode = result.code;
+            stdout = result.stdout;
+            stderr = result.stderr;
+        }
+        catch (error) {
+            stderr = error instanceof Error ? error.message : String(error);
+            exitCode = -1;
+        }
+        finally {
+            if (dir)
+                await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        }
+        witnesses.push(witnessRecord({
+            key: probe.key, kind: "probe", command, exitCode, stdout, stderr, checks,
+        }));
+    }
+    return witnesses;
+}
 async function settle(client, investigationId, body) {
     await client.request(`/runner/v1/investigations/${investigationId}/settle`, {
         method: "POST",
@@ -303,9 +508,20 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             : undefined;
         // T126: the prompt names the commands of the repository this lane opened — not the control
         // plane's idea of them — and carries the diff stat Bridge computed, since the lane cannot run git.
+        const deliveryVerification = isDeliveryVerification(assignment);
+        const gatesRun = deliveryVerification
+            ? await runDeliveryVerificationGates({
+                workspace: attemptWorkspace,
+                verificationCommands: liveBrief?.verification ?? [],
+                declaredVerificationCommands: liveBrief?.declared_verification ?? [],
+                acceptance: assignment.acceptance ?? [],
+                runCommand: options.runVerificationCommand,
+            })
+            : [];
         const context = {
             verificationCommands: liveBrief?.verification ?? [],
             diffStat: assignment.base_commit ? await diffStatSince(attemptWorkspace, assignment.base_commit) : null,
+            gatesRun,
         };
         // T154: the lane resolves its model the way the authoring lane does. Without it Claude Code ran
         // at its CLI default, which Conduit's /v1 rejects as an unknown alias (hosted-1, 2026-09-10:
@@ -345,6 +561,15 @@ export async function executeNextInvestigation(client, config, workspace, brief,
             console.error(`Investigation ${assignment.id} discarded — ${check.error}: ${check.detail}`);
             return true;
         }
+        const stepWitness = deliveryVerification
+            ? await runDeliveryVerificationProbes({
+                workspace: attemptWorkspace,
+                probes: observed.probes ?? [],
+                runCommand: options.runProbeCommand,
+            })
+            : [];
+        if (deliveryVerification)
+            await discardWorktreeWrites(attemptWorkspace);
         await settle(client, assignment.id, {
             lease_token: leaseToken,
             status: "completed",
@@ -354,7 +579,10 @@ export async function executeNextInvestigation(client, config, workspace, brief,
                 verification: observed.verification,
                 limitations: observed.limitations,
                 criteria: observed.criteria,
-                command_failures: observed.command_failures,
+                command_failures: deliveryVerification
+                    ? gatesRun.filter((gate) => gate.exitCode !== 0).map(gateFailureFact).slice(0, 10)
+                    : observed.command_failures,
+                step_witness: stepWitness,
                 witness: {
                     repository_fingerprint: assignment.repository_fingerprint ?? liveRepository ?? "unknown",
                     commit,
@@ -362,7 +590,9 @@ export async function executeNextInvestigation(client, config, workspace, brief,
                     bounded_by: boundedByForDriver(driverId),
                     files_read: observed.files_read,
                     bytes_read: observed.bytes_read,
-                    commands_run: observed.commands_run,
+                    commands_run: deliveryVerification
+                        ? settleCommandsRun(gatesRun, observed.commands_run)
+                        : observed.commands_run,
                 },
             },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.108",
+  "version": "0.16.110",
   "description": "Conduit Bridge CLI \u2014 join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity / Grok Build agents for a Conduit organization",
   "type": "module",
   "bin": {