@miraland-labs/conduit-bridge 0.16.100 → 0.16.102

package/dist/execution.js

@@ -28,7 +28,7 @@ const execFileAsync = promisify(execFile);
 import { 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, worktreeStateFingerprint, worktreeWrittenPaths } from "./git-witness.js";
+import { changedPathsSince, compareWorktreeState, diffStatSince, worktreeStateFingerprint, worktreeWrittenPaths } from "./git-witness.js";
 import { assertNormativeRefsMaterialized, checkNormativeMarkers, materializeNormativeRefs, NORMATIVE_MARKER_PREFIX, NORMATIVE_REF_PREFIX, parseNormativeRefs, } from "./normative-refs.js";
 import { checkIntegrationObligations, INTEGRATION_OBLIGATION_PREFIX, parseIntegrationObligations, } from "./integration-obligations.js";
 /** Keep a Mac awake only while an assignment is active; display sleep remains allowed. */
@@ -831,14 +831,18 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
     for (const released of releasedWorktrees) {
         // T96: resolve the released attempt's own repository under the managed root, not the runner's
         // default workspace, so a retained tree in another managed checkout is actually swept.
-        const releaseWorkspace = released.repository_fingerprint && options.managedRoot?.trim()
-            ? managedWorkspacePath(options.managedRoot.trim(), released.repository_fingerprint)
-            : workspace;
-        const worktree = attemptWorktreePath(releaseWorkspace, released.attempt_id);
-        await removeAttemptWorktree(releaseWorkspace, worktree)
-            .then((removed) => { if (removed)
-            console.log(`Released settled diagnostic worktree ${worktree}`); })
-            .catch((error) => console.error(`Diagnostic worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
+        try {
+            const releaseWorkspace = released.repository_fingerprint && options.managedRoot?.trim()
+                ? managedWorkspacePath(options.managedRoot.trim(), released.repository_fingerprint)
+                : workspace;
+            const worktree = attemptWorktreePath(releaseWorkspace, released.attempt_id);
+            await removeAttemptWorktree(releaseWorkspace, worktree)
+                .then((removed) => { if (removed)
+                console.log(`Released settled diagnostic worktree ${worktree}`); });
+        }
+        catch (error) {
+            console.error(`Diagnostic worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+        }
     }
     const assignment = assignments[0];
     if (!assignment)
@@ -1713,6 +1717,11 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                 : null;
             // The vendor named the model as the cause, so the model is what the retry must change. The
             // model rides in the prefix: the control plane cannot read Bridge's selection any other way.
+            const diffStat = verificationDetail && attemptWorkspace && startCommit
+                ? await diffStatSince(attemptWorkspace, startCommit)
+                    .then((stat) => stat?.slice(0, 8_000) ?? null)
+                    .catch(() => null)
+                : null;
             const abortPrefix = agentModelAbortPrefix(selection.model);
             const modelAborted = agentModelAborted(`${agentMessage}\n${result.signal?.stderr_tail ?? ""}`);
             // T52: the epoch's second abort is not a retryable model swap — the first one already bought
@@ -1720,7 +1729,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             // "Agent Looping Detected" runs on the cursor CLI default). Hold on the tier instead.
             const bindingRequired = modelAborted && !verificationDetail && modelBindingRequired(selection);
             const message = verificationDetail
-                ? `Verification failed after the agent run.\n${verificationDetail}`
+                ? `Verification failed after the agent run.\n${verificationDetail}${diffStat ? `\n\nChanged files:\n${diffStat}` : ""}`
                 : bindingRequired
                     ? `${modelBindingRequiredPrefix(selection.tier, driver.name)}${agentMessage}`
                     : modelAborted ? `${abortPrefix}${agentMessage}` : agentMessage;
@@ -1740,7 +1749,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                     ? { phase: "agent", witness: "vendor", kind: "quota", vendor_message: agentMessage.slice(0, 2_000) }
                     : result.signal
                         ? verificationDetail
-                            ? { ...result.signal, phase: "verification", witness: "bridge", stderr_tail: undefined, stdout_tail: undefined }
+                            ? { ...result.signal, phase: "verification", witness: "bridge", stderr_tail: undefined, stdout_tail: undefined, ...(diffStat ? { diff_stat: diffStat } : {}) }
                             : result.signal
                         : undefined;
             const response = await queueTerminal(client, taskId, { action: "fail", body: {
@@ -2168,8 +2177,13 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             // exact tree and send the witness marker that arms Conductor diagnosis. Treating it as a
             // delivery-envelope defect would stop before Invariant 23 ever ran.
             const verificationFailed = /^Agent report: Verification failed \(/.test(message);
+            const diffStat = verificationFailed && attemptWorkspace
+                ? await diffStatSince(attemptWorkspace, deliveryBaseCommit)
+                    .then((stat) => stat?.slice(0, 8_000) ?? null)
+                    .catch(() => null)
+                : null;
             const classified = verificationFailed
-                ? { retryable: true, error: `Verification failed after the agent run.\n${message}` }
+                ? { retryable: true, error: `Verification failed after the agent run.\n${message}${diffStat ? `\n\nChanged files:\n${diffStat}` : ""}` }
                 // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail
                 // closed (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
                 : classifyFinalizeFailure(message);
@@ -2180,6 +2194,12 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
                 body: {
                     error: classified.error,
                     retryable: classified.retryable,
+                    ...(verificationFailed ? { signal: {
+                            phase: "verification",
+                            witness: "bridge",
+                            kind: "verification_failed",
+                            ...(diffStat ? { diff_stat: diffStat } : {}),
+                        } } : {}),
                     // A rework's own PR may already be open (ensureDeliveryPullRequest ran before this
                     // gate). Carry the URL so the control plane can close it instead of littering.
                     ...(report.pull_request_url ? { pull_request_url: report.pull_request_url } : {}),

package/dist/failure-signal.js

@@ -24,6 +24,8 @@ export const failureSignalSchema = z.object({
     paths: z.array(z.string().max(300)).max(20).optional(),
     /** The base commit the dry run ran against, when a gate already fails there. */
     base_commit: z.string().max(200).optional(),
+    /** Short git diff --stat of files modified in the attempt worktree. */
+    diff_stat: z.string().max(8_000).optional(),
     exit_code: z.number().int().nullable().optional(),
     /** The vendor envelope's own status, e.g. agy's "ERROR". */
     vendor_status: z.string().max(200).optional(),

package/dist/git-witness.js

@@ -123,11 +123,20 @@ export function compareWorktreeState(before, after) {
 /** Short stat summary for change evidence artifacts. */
 export async function diffStatSince(worktree, startCommit) {
     try {
-        const { stdout } = await execFileAsync("git", ["-C", worktree, "diff", "--stat", `${startCommit}..HEAD`], {
-            timeout: 30_000,
-            maxBuffer: 2_000_000,
-        });
-        const text = stdout.trim();
+        const [{ stdout }, { stdout: untracked }] = await Promise.all([
+            execFileAsync("git", ["-C", worktree, "diff", "--stat", startCommit], {
+                timeout: 30_000,
+                maxBuffer: 2_000_000,
+            }),
+            execFileAsync("git", ["-C", worktree, "ls-files", "--others", "--exclude-standard", "-z"], {
+                timeout: 30_000,
+                maxBuffer: 2_000_000,
+                encoding: "buffer",
+            }),
+        ]);
+        const untrackedLines = untracked.toString("utf8").split("\0").filter(Boolean)
+            .map((path) => ` ${path} | untracked`);
+        const text = [stdout.trim(), ...untrackedLines].filter(Boolean).join("\n");
         return text || null;
     }
     catch {

package/dist/managed-workspace-path.js

@@ -1,7 +1,12 @@
 import { normalizeRepositoryUrl } from "./brief.js";
 /** Where a managed computer keeps `repositoryUrl` — `<root>/<owner>/<repo>`. */
 export function managedWorkspacePath(managedRoot, repositoryUrl) {
+    if (repositoryUrl.includes("\\"))
+        throw new Error("managed_workspace_repository_invalid");
     const parts = normalizeRepositoryUrl(repositoryUrl.trim()).split("/").filter(Boolean);
+    if (parts.length === 0 || parts.some((part) => part === "." || part === "..")) {
+        throw new Error("managed_workspace_repository_invalid");
+    }
     const name = parts[parts.length - 1] || "workspace";
     const owner = parts.length >= 2 ? parts[parts.length - 2] : null;
     const root = managedRoot.trim().replace(/[/]+$/, "");

package/dist/on-shift-apply.js

@@ -3,7 +3,7 @@
  * machine-wide ops.env. The rebound runner's matching heartbeat clears the intent;
  * installation alone is not proof that the new process is actually bound.
  */
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { expandOpsValue } from "./ops.js";
 import { ensureCheckout } from "./checkout.js";
 import { bootstrapManagedWorkspace } from "./workspace-bootstrap.js";
@@ -21,7 +21,12 @@ function pathsEqual(left, right) {
  * gives a managed checkout.
  */
 export async function switchManagedWorkspace(managedRoot, repositoryUrl, deps = {}) {
+    const root = resolve(expandOpsValue(managedRoot));
     const target = resolve(expandOpsValue(managedWorkspacePath(managedRoot, repositoryUrl)));
+    const fromRoot = relative(root, target);
+    if (!fromRoot || fromRoot === ".." || fromRoot.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || resolve(root, fromRoot) !== target) {
+        throw new Error("managed_workspace_path_outside_root");
+    }
     const checkout = deps.ensureCheckout ?? ensureCheckout;
     const result = await checkout(target, repositoryUrl);
     if (result === "cloned") {

package/package.json

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