@miraland-labs/conduit-bridge 0.16.16 → 0.16.18

package/dist/checkout.js

@@ -35,16 +35,39 @@ async function gitOriginUrl(workspace, exec) {
     }
 }
 /** A control-plane repository fingerprint needs a transport before Git can clone it. */
-function cloneRepositoryUrl(repositoryUrl) {
+function cloneRepositoryUrls(repositoryUrl) {
     const value = repositoryUrl.trim();
     const slash = value.indexOf("/");
     if (slash <= 0 || value.startsWith(".") || value.includes("\\") || /^[^/@\s]+@[^:]+:/.test(value))
-        return value;
+        return [value];
     const host = value.slice(0, slash);
     const path = value.slice(slash + 1);
     if (!host.includes(".") || /\s/.test(value) || path.split("/").filter(Boolean).length < 2)
-        return value;
-    return `https://${value}`;
+        return [value];
+    return [`https://${value}`, `git@${host}:${path}${path.endsWith(".git") ? "" : ".git"}`];
+}
+async function cloneWorkspace(workspace, repositoryUrls, exec, accessFn, readdirFn) {
+    let lastError;
+    for (const [index, repositoryUrl] of repositoryUrls.entries()) {
+        try {
+            await exec("git", ["clone", "--", repositoryUrl, workspace], {
+                timeout: 300_000,
+                maxBuffer: 2_000_000,
+            });
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (index === repositoryUrls.length - 1)
+                break;
+            const exists = await pathExists(workspace, accessFn);
+            const entries = exists ? await readdirFn(workspace).catch(() => null) : [];
+            if (entries === null || entries.length > 0)
+                break;
+        }
+    }
+    const detail = lastError instanceof Error ? lastError.message : "clone_failed";
+    throw new Error(`ensure_checkout_clone_failed:${detail}`);
 }
 /**
  * Ensure `workspace` is a checkout of `repositoryUrl`.
@@ -61,20 +84,11 @@ export async function ensureCheckout(workspace, repositoryUrl, deps = {}) {
     const wanted = normalizeRepositoryUrl(repositoryUrl);
     if (!wanted)
         throw new Error("ensure_checkout_invalid_url");
-    const cloneUrl = cloneRepositoryUrl(repositoryUrl);
+    const cloneUrls = cloneRepositoryUrls(repositoryUrl);
     const exists = await pathExists(workspace, accessFn);
     if (!exists) {
         await mkdirFn(dirname(workspace), { recursive: true });
-        try {
-            await exec("git", ["clone", "--", cloneUrl, workspace], {
-                timeout: 300_000,
-                maxBuffer: 2_000_000,
-            });
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : "clone_failed";
-            throw new Error(`ensure_checkout_clone_failed:${detail}`);
-        }
+        await cloneWorkspace(workspace, cloneUrls, exec, accessFn, readdirFn);
         const origin = await gitOriginUrl(workspace, exec);
         if (!origin || normalizeRepositoryUrl(origin) !== wanted) {
             throw new Error("ensure_checkout_clone_mismatch");
@@ -85,16 +99,7 @@ export async function ensureCheckout(workspace, repositoryUrl, deps = {}) {
     if (entries === null)
         throw new Error("ensure_checkout_path_unreadable");
     if (entries.length === 0) {
-        try {
-            await exec("git", ["clone", "--", cloneUrl, workspace], {
-                timeout: 300_000,
-                maxBuffer: 2_000_000,
-            });
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : "clone_failed";
-            throw new Error(`ensure_checkout_clone_failed:${detail}`);
-        }
+        await cloneWorkspace(workspace, cloneUrls, exec, accessFn, readdirFn);
         return "cloned";
     }
     const origin = await gitOriginUrl(workspace, exec);

package/dist/driver.js

@@ -324,16 +324,21 @@ export function parseAgentReport(text, acceptance) {
         throw new Error(`Agent report is invalid${at}: ${issue?.message ?? "unknown validation error"}`);
     }
     const reportedKeys = parsed.data.acceptance_results.map((item) => criterionKey(item.criterion));
+    const approvedKeys = new Set(acceptance.map(criterionKey));
     const duplicated = parsed.data.acceptance_results
         .filter((item, index) => reportedKeys.indexOf(criterionKey(item.criterion)) !== index)
         .map((item) => item.criterion);
     const missing = acceptance.filter((criterion) => !reportedKeys.includes(criterionKey(criterion)));
-    if (missing.length || duplicated.length) {
+    const unapproved = parsed.data.acceptance_results
+        .filter((item) => !approvedKeys.has(criterionKey(item.criterion)))
+        .map((item) => item.criterion);
+    if (missing.length || duplicated.length || unapproved.length) {
         // Name the criterion. This text becomes the failure detail and the Conductor repair brief, and
         // "one of them is wrong" gives the next run nothing to act on.
         const detail = [
             missing.length ? `missing: ${missing.map(quoteCriterion).join("; ")}` : "",
             duplicated.length ? `reported more than once: ${duplicated.map(quoteCriterion).join("; ")}` : "",
+            unapproved.length ? `not approved: ${unapproved.map(quoteCriterion).join("; ")}` : "",
         ].filter(Boolean).join(" | ");
         throw new Error(`Agent report must include every acceptance criterion exactly once (${detail})`);
     }

package/dist/execution.js

@@ -1406,9 +1406,13 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             return;
         }
         await client.updateAttempt(taskId, { phase: "agent_finished", delivery: { spec, report } });
-        await submitFinishedDelivery(client, taskId);
-        deliverySubmitted = true;
-        console.log(`Assignment ${taskId} delivered for review and acceptance.`);
+        const response = await submitFinishedDelivery(client, taskId);
+        retainAttemptWorktree = response.retain_worktree === true;
+        deliverySubmitted = response.status !== "failed";
+        if (deliverySubmitted)
+            console.log(`Assignment ${taskId} delivered for review and acceptance.`);
+        else
+            console.error(`Assignment ${taskId} Delivery was rejected and routed to Conductor repair.`);
     }
     finally {
         releaseIdleSleep();
@@ -1579,7 +1583,7 @@ async function submitFinishedDelivery(client, taskId) {
         throw new Error("Finished agent run is missing its persisted Delivery data");
     const terminal = await prepareDelivery(client, active.attemptId, taskId, active.delivery.report);
     await client.attemptRequest(taskId, "progress", { phase: "preparing_delivery", message: "Agent finished; submitting the Delivery.", idempotency_key: `bridge:progress:${active.attemptId}:delivery` });
-    await queueTerminal(client, taskId, terminal);
+    return queueTerminal(client, taskId, terminal);
 }
 export const modelListCache = new Map();
 const MODEL_LIST_TTL_MS = 6 * 60 * 60 * 1000;
@@ -1869,6 +1873,31 @@ export async function flushTerminal(client, taskId) {
             await client.clearAttempt(taskId);
             return { accepted: false, status: "invalid_lease" };
         }
+        if (error instanceof ConduitRequestError
+            && error.code === "criterion_unapproved"
+            && active.terminal.action === "complete") {
+            const detail = `Delivery report rejected by the Control Plane: ${error.message}`;
+            await client.updateAttempt(taskId, {
+                terminal: {
+                    action: "fail",
+                    body: {
+                        error: detail,
+                        retryable: false,
+                        failure: {
+                            code: "delivery_report_invalid",
+                            class: "contract",
+                            disposition: "rework",
+                            responsible_party: "conduit",
+                            message: "The completed delivery report did not match the owner-approved acceptance criteria.",
+                            next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
+                            diagnostic_detail: detail,
+                        },
+                        idempotency_key: `bridge:delivery-rejected:${active.attemptId}`,
+                    },
+                },
+            });
+            return flushTerminal(client, taskId);
+        }
         throw error;
     }
 }

package/package.json

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