@miraland-labs/conduit-bridge 0.16.15 → 0.16.16

package/dist/checkout.js

@@ -34,6 +34,18 @@ async function gitOriginUrl(workspace, exec) {
         return null;
     }
 }
+/** A control-plane repository fingerprint needs a transport before Git can clone it. */
+function cloneRepositoryUrl(repositoryUrl) {
+    const value = repositoryUrl.trim();
+    const slash = value.indexOf("/");
+    if (slash <= 0 || value.startsWith(".") || value.includes("\\") || /^[^/@\s]+@[^:]+:/.test(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}`;
+}
 /**
  * Ensure `workspace` is a checkout of `repositoryUrl`.
  *
@@ -49,11 +61,12 @@ 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 exists = await pathExists(workspace, accessFn);
     if (!exists) {
         await mkdirFn(dirname(workspace), { recursive: true });
         try {
-            await exec("git", ["clone", "--", repositoryUrl, workspace], {
+            await exec("git", ["clone", "--", cloneUrl, workspace], {
                 timeout: 300_000,
                 maxBuffer: 2_000_000,
             });
@@ -73,7 +86,7 @@ export async function ensureCheckout(workspace, repositoryUrl, deps = {}) {
         throw new Error("ensure_checkout_path_unreadable");
     if (entries.length === 0) {
         try {
-            await exec("git", ["clone", "--", repositoryUrl, workspace], {
+            await exec("git", ["clone", "--", cloneUrl, workspace], {
                 timeout: 300_000,
                 maxBuffer: 2_000_000,
             });

package/dist/execution.js

@@ -243,6 +243,7 @@ const taskDetailSchema = z.object({
     execution_mode: z.enum(["agent", "human"]).optional().default("agent"),
     execution_kind: z.enum(["authoring", "diagnosis"]).optional().default("authoring"),
     source_attempt_id: z.string().uuid().nullable().optional().default(null),
+    repair_mode: z.enum(["none", "briefed", "blind"]).optional().default("none"),
 });
 const taskSpecSchema = z.object({
     goal: z.string().optional(), scope: z.array(z.string()).optional(), boundaries: z.array(z.string()).optional(),
@@ -952,7 +953,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         // A fresh attempt after a failed delivery must start clean: resuming a session whose last
         // turn already "finished" makes the agent reply conversationally without the report block.
         const resumeSessionId = options.forceResumeSessionId
-            ?? (reworkFeedback ? config.sessions?.[taskId] : undefined);
+            ?? (reworkFeedback && task.repair_mode !== "briefed" ? config.sessions?.[taskId] : undefined);
         const result = await driver.run({
             prompt,
             workspace: attemptWorkspace,

package/dist/ops.js

@@ -5,7 +5,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
@@ -15,6 +15,7 @@ import { driverIdsFromDetectedLabels } from "./drivers.js";
 import { BRIDGE_PROTOCOL_VERSION, describePreflightIssue, runBridgePreflight } from "./preflight.js";
 import { applyRunnerToolPath, runnerServiceWorkspaceWarnings } from "./service.js";
 import { bridgeVersion } from "./version.js";
+import { bootstrapManagedWorkspace } from "./workspace-bootstrap.js";
 export const OPS_VERBS = [
     "connect", "enroll", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
 ];
@@ -529,19 +530,35 @@ export async function runOps(verb, argv = [], deps = {}) {
         }
         const workspace = resolve(expandOpsValue(installEnv.CONDUIT_WORKSPACE));
         const drivers = await (deps.resolveInstallDrivers ?? resolveInstallDrivers)(installEnv, installArgv);
-        for (const id of drivers) {
-            if (LOCAL_FUEL_DRIVERS.has(id))
-                runBridge(["drivers", "fuel", id, "local"]);
-        }
-        runBridge(["drivers", "online", ...drivers]);
-        applyRunnerToolPath();
         if (installEnv.CONDUIT_REPO) {
             const checkout = deps.ensureCheckout ?? ensureCheckout;
             const result = await checkout(workspace, installEnv.CONDUIT_REPO);
             console.log(result === "cloned"
                 ? `Cloned ${installEnv.CONDUIT_REPO} into ${workspace}`
                 : `Workspace already matches ${installEnv.CONDUIT_REPO}`);
+            const managedRoot = installEnv.CONDUIT_MANAGED_ROOT
+                ? resolve(expandOpsValue(installEnv.CONDUIT_MANAGED_ROOT))
+                : null;
+            const managedRelative = managedRoot ? relative(managedRoot, workspace) : "";
+            const managedCheckout = Boolean(managedRoot
+                && managedRelative
+                && managedRelative !== ".."
+                && !managedRelative.startsWith(`..${sep}`)
+                && !isAbsolute(managedRelative));
+            if (managedCheckout) {
+                const bootstrap = deps.bootstrapWorkspace ?? bootstrapManagedWorkspace;
+                const bootstrapResult = bootstrap(workspace);
+                if (bootstrapResult === "installed")
+                    console.log(`Installed locked project dependencies in ${workspace}`);
+            }
         }
+        // Do not advertise an executable lane until a managed checkout has completed bootstrap.
+        for (const id of drivers) {
+            if (LOCAL_FUEL_DRIVERS.has(id))
+                runBridge(["drivers", "fuel", id, "local"]);
+        }
+        runBridge(["drivers", "online", ...drivers]);
+        applyRunnerToolPath();
         // A managed root is intentionally empty until the console assigns its first repository. It
         // still needs a resident runner, and `ops install` is also the recovery path after enrollment.
         const waitingOnManagedAssignment = Boolean(installEnv.CONDUIT_MANAGED_ROOT

package/dist/workspace-bootstrap.js

@@ -0,0 +1,26 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+function defaultRunner(command, args, workspace) {
+    const result = spawnSync(command, args, {
+        cwd: workspace,
+        env: process.env,
+        stdio: "inherit",
+        timeout: 10 * 60_000,
+    });
+    return { status: result.status, ...(result.error ? { error: result.error } : {}) };
+}
+/** Install locked JavaScript dependencies before a Conduit-managed checkout advertises readiness. */
+export function bootstrapManagedWorkspace(workspace, run = defaultRunner) {
+    if (!existsSync(join(workspace, "package.json")))
+        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);
+    if (result.error)
+        throw new Error(`managed_workspace_bootstrap_failed:${result.error.message}`);
+    if (result.status !== 0)
+        throw new Error(`managed_workspace_bootstrap_failed:exit_${result.status ?? "unknown"}`);
+    return "installed";
+}

package/package.json

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