@miraland-labs/conduit-bridge 0.16.24 → 0.16.25

package/dist/client.js

@@ -80,6 +80,30 @@ export class ConduitClient {
         const active = this.attempt(taskId);
         return this.request(`/runner/v1/tasks/${taskId}/${action}`, { method: "POST", body: JSON.stringify({ ...body, attempt_id: active.attemptId, lease_token: active.leaseToken }) });
     }
+    async listInstructions(taskId, after = "") {
+        const active = this.attempt(taskId);
+        const query = new URLSearchParams({ attempt_id: active.attemptId, ...(after ? { after } : {}) });
+        const data = await this.request(`/runner/v1/tasks/${taskId}/instructions?${query}`);
+        return Array.isArray(data.instructions)
+            ? data.instructions.flatMap((row) => {
+                if (!row || typeof row !== "object")
+                    return [];
+                const instruction = row;
+                return typeof instruction.id === "string"
+                    && typeof instruction.payload_json === "string"
+                    && typeof instruction.created_at === "string"
+                    ? [{ id: instruction.id, payload_json: instruction.payload_json, created_at: instruction.created_at }]
+                    : [];
+            })
+            : [];
+    }
+    async acknowledgeInstruction(taskId, instructionId) {
+        const active = this.attempt(taskId);
+        await this.attemptRequest(taskId, `instructions/${instructionId}/ack`, {
+            instruction_id: instructionId,
+            idempotency_key: `bridge:instruction-ack:${active.attemptId}:${instructionId}`,
+        });
+    }
     async updateAttempt(taskId, patch) {
         const active = this.attempt(taskId);
         for (const key of Object.keys(patch)) {

package/dist/execution.js

@@ -411,6 +411,79 @@ export async function renewLeases(client, config) {
         }
     }
 }
+/**
+ * Poll while the headless CLI owns the worktree, then hand owner guidance to its next session turn.
+ * Driver stdin is intentionally closed after the initial prompt, so pretending a mid-process write
+ * is portable would silently lose guidance on most lanes. The first safe common checkpoint is the
+ * driver's completed turn, before Bridge validates or submits its delivery.
+ */
+function pollCheckpointInstructions(client, taskId, state, intervalMs = 15_000) {
+    let stopped = false;
+    let inFlight = null;
+    const pending = new Map();
+    const poll = async () => {
+        const rows = await client.listInstructions(taskId, state.cursor);
+        for (const row of rows) {
+            state.cursor = `${row.created_at}|${row.id}`;
+            if (state.seen.has(row.id))
+                continue;
+            state.seen.add(row.id);
+            const parsed = parseCheckpointInstruction(row);
+            if (parsed && state.acceptedCount < 10 && state.acceptedCharacters + parsed.message.length <= 40_000) {
+                pending.set(parsed.id, parsed);
+                state.acceptedCount += 1;
+                state.acceptedCharacters += parsed.message.length;
+            }
+            else if (parsed) {
+                console.error(`Instruction ${parsed.id} exceeded the checkpoint guidance bound and was not acknowledged.`);
+            }
+        }
+    };
+    const runPoll = () => {
+        if (stopped || inFlight)
+            return;
+        inFlight = poll()
+            .catch((error) => console.error(`Instruction poll failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`))
+            .finally(() => { inFlight = null; });
+    };
+    runPoll();
+    const timer = setInterval(runPoll, intervalMs);
+    timer.unref?.();
+    return {
+        stop: async () => {
+            stopped = true;
+            clearInterval(timer);
+            await inFlight;
+            await poll().catch((error) => console.error(`Final instruction poll failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
+            return [...pending.values()];
+        },
+    };
+}
+function parseCheckpointInstruction(row) {
+    try {
+        const payload = JSON.parse(row.payload_json);
+        if (payload.changes_scope === true) {
+            console.error(`Refusing scope-changing instruction ${row.id}; revise the approved initiative contract instead.`);
+            return null;
+        }
+        const message = typeof payload.message === "string" ? payload.message.trim() : "";
+        return message ? { id: row.id, message: message.slice(0, 20_000), createdAt: row.created_at } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function checkpointInstructionPrompt(instructions) {
+    return [
+        "OWNER INSTRUCTIONS AT CHECKPOINT",
+        "These messages refine the current run only. They do not amend approved scope, boundaries, acceptance criteria, or grants.",
+        ...instructions.map((instruction) => `- ${instruction.message}`),
+        "",
+        "Apply the guidance within the approved contract, re-check the resulting work, then return a complete final report.",
+        "Return only one fenced ```json object with exactly this shape:",
+        agentReportTemplate,
+    ].join("\n");
+}
 function resolveAttemptDriver(config, active, fallback) {
     if (active.driverId && DRIVERS[active.driverId])
         return DRIVERS[active.driverId];
@@ -983,7 +1056,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         // turn already "finished" makes the agent reply conversationally without the report block.
         const resumeSessionId = options.forceResumeSessionId
             ?? (reworkFeedback && task.repair_mode !== "briefed" ? config.sessions?.[taskId] : undefined);
-        const result = await driver.run({
+        const runInput = {
             prompt,
             workspace: attemptWorkspace,
             grants,
@@ -997,7 +1070,40 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             model: selection.model,
             fuel,
             fuelSource,
-        });
+        };
+        let result;
+        let currentRunInput = runInput;
+        const instructionPollState = {
+            cursor: "",
+            seen: new Set(),
+            acceptedCount: 0,
+            acceptedCharacters: 0,
+        };
+        let instructionsInPrompt = [];
+        for (let round = 0;; round += 1) {
+            const instructionPoll = diagnosis ? null : pollCheckpointInstructions(client, taskId, instructionPollState);
+            let polled = [];
+            try {
+                result = await driver.run(currentRunInput);
+            }
+            finally {
+                polled = await instructionPoll?.stop() ?? polled;
+            }
+            if (instructionsInPrompt.length > 0) {
+                await Promise.all(instructionsInPrompt.map((instruction) => client.acknowledgeInstruction(taskId, instruction.id).catch((error) => console.error(`Instruction acknowledgement failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`))));
+            }
+            // One initial turn plus at most two bounded checkpoint turns. Guidance arriving after that
+            // remains unacknowledged rather than creating an unbounded owner-driven agent loop.
+            if (diagnosis || result.status !== "completed" || polled.length === 0 || round >= 2)
+                break;
+            instructionsInPrompt = polled;
+            const followup = checkpointInstructionPrompt(instructionsInPrompt);
+            currentRunInput = {
+                ...runInput,
+                prompt: result.sessionId ? followup : `${prompt}\n\n${followup}`,
+                resumeSessionId: result.sessionId ?? undefined,
+            };
+        }
         if (result.sessionId)
             config.sessions = { ...config.sessions, [taskId]: result.sessionId };
         await learnDriverFuel(config, driver.name, fuelSource, result);

package/dist/workspace-bootstrap.js

@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 function defaultRunner(command, args, workspace) {
     const result = spawnSync(command, args, {
@@ -10,17 +10,64 @@ function defaultRunner(command, args, workspace) {
     });
     return { status: result.status, ...(result.error ? { error: result.error } : {}) };
 }
-/** Install locked JavaScript dependencies before a Conduit-managed checkout advertises readiness. */
+/** Install dependencies with the repository's own committed package-manager identity. */
 export function bootstrapManagedWorkspace(workspace, run = defaultRunner) {
-    if (!existsSync(join(workspace, "package.json")))
+    const packagePath = join(workspace, "package.json");
+    if (!existsSync(packagePath))
         return "not_applicable";
-    if (!existsSync(join(workspace, "package-lock.json"))) {
-        throw new Error("managed_workspace_bootstrap_package_lock_required");
-    }
-    const result = run("npm", ["ci", "--include=optional", "--no-audit", "--no-fund"], workspace);
+    const install = lockedInstall(workspace, packagePath);
+    const result = run(install.command, install.args, workspace);
     if (result.error)
-        throw new Error(`managed_workspace_bootstrap_failed:${result.error.message}`);
+        throw new Error(`managed_workspace_bootstrap_failed:${install.id}:${result.error.message}`);
     if (result.status !== 0)
-        throw new Error(`managed_workspace_bootstrap_failed:exit_${result.status ?? "unknown"}`);
+        throw new Error(`managed_workspace_bootstrap_failed:${install.id}:exit_${result.status ?? "unknown"}`);
     return "installed";
 }
+function lockedInstall(workspace, packagePath) {
+    const declared = declaredPackageManager(packagePath);
+    const managers = [
+        existsSync(join(workspace, "package-lock.json")) || existsSync(join(workspace, "npm-shrinkwrap.json")) ? "npm" : null,
+        existsSync(join(workspace, "pnpm-lock.yaml")) ? "pnpm" : null,
+        existsSync(join(workspace, "yarn.lock")) ? "yarn" : null,
+        existsSync(join(workspace, "bun.lock")) || existsSync(join(workspace, "bun.lockb")) ? "bun" : null,
+    ].filter((manager) => manager !== null);
+    if (managers.length === 0)
+        throw new Error("managed_workspace_bootstrap_lockfile_required");
+    if (declared && !managers.includes(declared)) {
+        throw new Error(`managed_workspace_bootstrap_package_manager_lockfile_mismatch:${declared}:${managers.join(",")}`);
+    }
+    const selected = declared ?? (managers.length === 1 ? managers[0] : null);
+    if (!selected)
+        throw new Error(`managed_workspace_bootstrap_lockfile_ambiguous:${managers.join(",")}`);
+    if (selected === "npm")
+        return { id: selected, command: "npm", args: ["ci", "--include=optional", "--no-audit", "--no-fund"] };
+    if (selected === "pnpm")
+        return { id: selected, command: "pnpm", args: ["install", "--frozen-lockfile"] };
+    if (selected === "bun")
+        return { id: selected, command: "bun", args: ["install", "--frozen-lockfile"] };
+    const modernYarn = existsSync(join(workspace, ".yarnrc.yml")) || declaredPackageManagerMajor(packagePath, "yarn") >= 2;
+    return { id: selected, command: "yarn", args: ["install", modernYarn ? "--immutable" : "--frozen-lockfile"] };
+}
+function declaredPackageManager(packagePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+        const match = typeof parsed.packageManager === "string" ? /^(npm|pnpm|yarn|bun)@/.exec(parsed.packageManager.trim()) : null;
+        const id = match?.[1];
+        return id === "npm" || id === "pnpm" || id === "yarn" || id === "bun" ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+function declaredPackageManagerMajor(packagePath, manager) {
+    try {
+        const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+        const match = typeof parsed.packageManager === "string"
+            ? new RegExp(`^${manager}@(\\d+)`).exec(parsed.packageManager.trim())
+            : null;
+        return match ? Number(match[1]) : 0;
+    }
+    catch {
+        return 0;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.24",
+  "version": "0.16.25",
   "description": "Conduit Bridge CLI — 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": {