@miraland-labs/conduit-bridge 0.16.109 → 0.16.111

package/dist/driver.js

@@ -7,6 +7,18 @@ import { mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { z } from "zod";
 import { allowsExternalFetch, deniedCommands, executionClassPromptRules, isRunnableVerificationCommand, parsePiJsonl, projectClaude, projectCoarseMode, projectCodex, projectCursor, projectGrok, projectKiroTools, projectPi, requireStampedExecutionClass, } from "./execution-class.js";
+/**
+ * Classify one Cursor `status` / Kiro `whoami` probe. Signed-out phrases win; an unanswered
+ * probe (timeout, spawn error, empty output, or text that names neither state) is unknown.
+ */
+export function readSignInStatus(result, signedInPattern) {
+    const text = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    if (/not logged in|not authenticated|login required/i.test(text))
+        return "signed_out";
+    if (result.code === 0 && signedInPattern.test(text))
+        return "signed_in";
+    return "unknown";
+}
 /**
  * The bound for this turn.
  *
@@ -1017,10 +1029,10 @@ export const cursorDriver = {
             return { status: "failed", resultText: null, sessionId: null, error: "cursor preflight found no bounded verification command for the test_run grant" };
         }
         // A ~/.cursor directory exists even after logout — ask the CLI itself.
-        // `agent status` exits 0 either way, so the text is the signal.
+        // `agent status` exits 0 either way; only a definite signed_out fails closed.
         if (!process.env.CURSOR_API_KEY) {
             const status = await execute(executable, ["status"], input.workspace, 15_000, undefined, "local");
-            if (status.code !== 0 || !/logged in as/i.test(`${status.stdout}\n${status.stderr}`)) {
+            if (readSignInStatus(status, /logged in as/i) === "signed_out") {
                 return { status: "failed", resultText: null, sessionId: null, error: "cursor has no login (set CURSOR_API_KEY or run `agent login`)" };
             }
         }

package/dist/execution.js

@@ -2909,7 +2909,7 @@ export async function runDeliveryVerificationGates(input) {
     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/investigation.js

@@ -6,18 +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, changedPathsSince, runDeliveryVerificationGates } 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 { 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),
@@ -37,6 +41,8 @@ export const investigationAssignmentSchema = z.object({
     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
@@ -67,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);
 }
@@ -110,6 +131,9 @@ 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.",
@@ -125,11 +149,15 @@ export function buildDeliveryVerificationPrompt(assignment, commit, context) {
         `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) {
@@ -230,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",
@@ -393,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",
@@ -405,6 +582,7 @@ export async function executeNextInvestigation(client, config, workspace, brief,
                 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,

package/dist/preflight.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, normalizeRepositoryUrl } from "./brief.js";
 import { resolveMaxTurns } from "./execution-budget.js";
-import { hasAntigravityLogin, hasClaudeLogin, hasGrokLogin, hasOpenAiLogin, hasOpenCodeLogin, driverExecutable, } from "./driver.js";
+import { hasAntigravityLogin, hasClaudeLogin, hasGrokLogin, hasOpenAiLogin, hasOpenCodeLogin, driverExecutable, readSignInStatus, } from "./driver.js";
 import { laneQuota, laneTierBindings, localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 /** Protocol 3: read-only diagnosis can reuse a retained failed-attempt worktree. */
 // 4: each driver snapshot reports diagnosis_read_only, so the control plane can require a
@@ -128,7 +128,35 @@ async function driverCompatibilityFingerprint(driver, workspace, run) {
         features,
     })).digest("hex");
 }
-async function localAuthenticationReady(driver, workspace, run) {
+/** Last definite Cursor/Kiro sign-in answer. Unknown never writes here. */
+export const lastSignIn = new Map();
+export function resetSignInMemoryForTests() {
+    lastSignIn.clear();
+}
+/** Retry once on unknown, then the last definite answer, then signed-in with a warning. */
+export async function resolveSignInAnswer(driver, probe) {
+    const once = async () => {
+        try {
+            return await probe();
+        }
+        catch {
+            return "unknown";
+        }
+    };
+    let answer = await once();
+    if (answer === "unknown")
+        answer = await once();
+    if (answer !== "unknown") {
+        lastSignIn.set(driver, answer);
+        return answer;
+    }
+    const previous = lastSignIn.get(driver);
+    if (previous)
+        return previous;
+    console.warn(`sign-in unverified (${driver})`);
+    return "signed_in";
+}
+export async function localAuthenticationReady(driver, workspace, run) {
     if (driver === "claude-code")
         return hasClaudeLogin();
     if (driver === "codex")
@@ -142,14 +170,12 @@ async function localAuthenticationReady(driver, workspace, run) {
     if (driver === "cursor") {
         if (process.env.CURSOR_API_KEY)
             return true;
-        const status = await run(driverExecutable(driver), ["status"], workspace);
-        return status.code === 0 && /logged in as/i.test(`${status.stdout}\n${status.stderr}`);
+        return (await resolveSignInAnswer(driver, async () => readSignInStatus(await run(driverExecutable(driver), ["status"], workspace), /logged in as/i))) !== "signed_out";
     }
     if (driver === "kiro") {
         if (process.env.KIRO_API_KEY)
             return true;
-        const status = await run(driverExecutable(driver), ["whoami"], workspace);
-        return status.code === 0 && !/not logged in|not authenticated|login required/i.test(`${status.stdout}\n${status.stderr}`);
+        return (await resolveSignInAnswer(driver, async () => readSignInStatus(await run(driverExecutable(driver), ["whoami"], workspace), /\S/))) !== "signed_out";
     }
     // Pi stores provider auth in its own config; CLI has no stable whoami — version probe is enough.
     if (driver === "pi")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.109",
+  "version": "0.16.111",
   "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": {