@miraland-labs/conduit-bridge 0.16.2 → 0.16.3

package/dist/ensure-land-commit.js

@@ -0,0 +1,77 @@
+/**
+ * Mechanical land completion — commit scoped dirty work the agent left uncommitted before finalize.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { commitsAheadOfBase } from "./ensure-pull-request.js";
+import { AgentNoLandCommitError, filterPathsInScope, requiresLandCommit, } from "./land-contract.js";
+const execFileAsync = promisify(execFile);
+async function workspaceHeadCommit(workspace) {
+    const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], {
+        timeout: 30_000,
+        maxBuffer: 1_000_000,
+    });
+    const head = stdout.trim();
+    if (!head)
+        throw new Error("Could not read workspace HEAD");
+    return head;
+}
+async function uncommittedPaths(workspace) {
+    const { stdout } = await execFileAsync("git", ["-C", workspace, "status", "--porcelain"], {
+        timeout: 30_000,
+        maxBuffer: 8_000_000,
+    });
+    const paths = [];
+    for (const line of stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const entry = line.slice(3).trim();
+        if (!entry)
+            continue;
+        const path = entry.includes(" -> ")
+            ? entry.slice(entry.lastIndexOf(" -> ") + 4).trim()
+            : entry;
+        if (path)
+            paths.push(path.replace(/^"|"$/g, ""));
+    }
+    return paths;
+}
+async function commitScopedPaths(workspace, paths) {
+    if (!paths.length)
+        throw new Error("Cannot land an empty path set");
+    await execFileAsync("git", ["-C", workspace, "add", "--", ...paths], {
+        timeout: 120_000,
+        maxBuffer: 8_000_000,
+    });
+    await execFileAsync("git", ["-C", workspace, "commit", "-m", "Conduit: land scoped agent changes"], { timeout: 120_000, maxBuffer: 8_000_000 });
+}
+/**
+ * When the land contract applies, ensure the attempt branch has at least one commit after base.
+ * Commits scoped dirty files Bridge can see; throws AgentNoLandCommitError when nothing is landable.
+ */
+export async function ensureLandCommit(input) {
+    if (!requiresLandCommit({ grants: input.grants, spec: input.spec })) {
+        return { kind: "skipped" };
+    }
+    const base = input.spec.repository?.base_commit;
+    if (!base)
+        return { kind: "skipped" };
+    const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
+    const readHead = input.readHeadCommit ?? workspaceHeadCommit;
+    const listPending = input.listUncommittedPaths ?? uncommittedPaths;
+    const commitPaths = input.commitPaths ?? commitScopedPaths;
+    const ahead = await countAhead(input.workspace, base);
+    if (ahead !== null && ahead > 0) {
+        return { kind: "already_landed", headCommit: await readHead(input.workspace) };
+    }
+    const pending = filterPathsInScope(await listPending(input.workspace), input.spec.change_scope ?? []);
+    if (!pending.length) {
+        throw new AgentNoLandCommitError(base);
+    }
+    await commitPaths(input.workspace, pending);
+    const afterAhead = await countAhead(input.workspace, base);
+    if (afterAhead === 0) {
+        throw new AgentNoLandCommitError(base);
+    }
+    return { kind: "committed", headCommit: await readHead(input.workspace), paths: pending };
+}

package/dist/ensure-pull-request.js

@@ -6,6 +6,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { normalizeRepositoryUrl } from "./brief.js";
+import { agentNoLandCommitMessage } from "./land-contract.js";
 const execFileAsync = promisify(execFile);
 /** Mirror execution.ts FORGE_TRANSPORT_PATTERN — keep local to avoid import cycles. */
 const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
@@ -197,7 +198,7 @@ export async function ensureDeliveryPullRequest(input) {
     if (base) {
         const ahead = await countAhead(input.workspace, base);
         if (ahead === 0) {
-            throw new Error(`The attempt branch has no commit after base ${base.slice(0, 12)}; this run produced no change to deliver`);
+            throw new Error(agentNoLandCommitMessage(base));
         }
     }
     await push(input.workspace);

package/dist/execution.js

@@ -11,6 +11,8 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
+import { ensureLandCommit } from "./ensure-land-commit.js";
+import { AgentNoLandCommitError, requiresLandCommit } from "./land-contract.js";
 const execFileAsync = promisify(execFile);
 import { captureVerificationFailure, ensureTestEvidence } from "./ensure-test-evidence.js";
 /** Keep a Mac awake only while an assignment is active; display sleep remains allowed. */
@@ -63,7 +65,7 @@ export function forgeTransportFailure(message) {
 /** Environment faults that must Hold — mirror CP ENVIRONMENT_FAILURES message patterns. */
 const FINALIZE_ENVIRONMENT_PATTERN = /base[_ ]not[_ ]ancestor|required base commit is not available|source[_ ]workspace[_ ]dirty|uncommitted changes|dirty workspace|workspace[_ ]head[_ ]changed|workspace[_ ]repository|workspace[_ ]unavailable|driver[_ ]not[_ ]authenticated|not logged in|no login|not authenticated|login required|no[_ ]online[_ ]driver|bridge[_ ]preflight|stale bridge|bridge version/i;
 /** Delivery-report / grant / evidence contract defects (non-retryable rework). */
-const FINALIZE_CONTRACT_PATTERN = /missing required evidence|without the repo_write grant|pull_request_url|Artifact delivery requires|outside the approved scope|head commit|test evidence must include|Met acceptance criteria|Agent report|Agent reported|Delivery report/i;
+const FINALIZE_CONTRACT_PATTERN = /missing required evidence|without the repo_write grant|pull_request_url|Artifact delivery requires|outside the approved scope|head commit|test evidence must include|Met acceptance criteria|Agent report|Agent reported|Agent did not land repository changes|Delivery report/i;
 /**
  * Classify throws from ensureDeliveryPullRequest + validateDeliveryReport.
  * Unknown non-contract faults must not be laundered as execution_contract_failed.
@@ -852,6 +854,23 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             console.error(`Assignment ${taskId} failed: ${redactSecrets(message)}`);
             return;
         }
+        if (requiresLandCommit({ grants, spec })) {
+            try {
+                const land = await ensureLandCommit({ workspace: attemptWorkspace, spec, grants });
+                if (land.kind === "committed") {
+                    await client.attemptRequest(taskId, "progress", {
+                        phase: "preparing_delivery",
+                        message: `Bridge committed scoped agent changes that were left uncommitted (${land.paths.join(", ")}).`,
+                        idempotency_key: `bridge:progress:${active.attemptId}:land-commit`,
+                    });
+                }
+            }
+            catch (error) {
+                if (!(error instanceof AgentNoLandCommitError))
+                    throw error;
+            }
+        }
+        let agentSessionId = result.sessionId ?? undefined;
         let report;
         let reportText = result.resultText ?? "";
         try {
@@ -900,6 +919,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 if (repaired.sessionId) {
                     config.sessions = { ...config.sessions, [taskId]: repaired.sessionId };
                     resumeSessionId = repaired.sessionId;
+                    agentSessionId = repaired.sessionId;
                 }
                 if (repaired.status === "failed") {
                     const message = repaired.error ?? "Delivery report repair failed";
@@ -952,6 +972,25 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             report = parsed;
         }
         try {
+            report = await finalizeRepositoryLand({
+                client,
+                taskId,
+                attemptId: active.attemptId,
+                workspace: attemptWorkspace,
+                spec,
+                grants,
+                report,
+                driver,
+                executionClass,
+                capabilities: spec.required_capabilities ?? [],
+                verificationCommands: attemptBrief?.verification ?? [],
+                objective: task.objective,
+                selection,
+                fuel,
+                fuelSource,
+                timeoutMs,
+                resumeSessionId: agentSessionId,
+            });
             // Mechanical land path: agent may forget gh; Bridge pushes and the control plane opens the PR.
             report = await ensureDeliveryPullRequest({
                 client,
@@ -1037,6 +1076,92 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         }
     }
 }
+function buildLandContinuationPrompt(input) {
+    const scope = input.spec.change_scope ?? [];
+    return [
+        "The implementation turn finished without landing repository changes on the attempt branch.",
+        "Perform exactly one land-only continuation: make the minimal scoped edits required by the approved plan, commit them on the current branch, run any bounded verification commands you are allowed to run, then return one fenced ```json Delivery object.",
+        "Do not open a pull request — Bridge opens it after finalize when pr_create is granted.",
+        "Your working branch is already checked out. Use git add and git commit; report the resulting sha as head_commit.",
+        "",
+        "OBJECTIVE",
+        input.objective,
+        "",
+        "APPROVED CHANGE SCOPE",
+        ...(scope.length ? scope.map((path) => `- ${path}`) : ["- (none — stay within the plan)"]),
+        "",
+        "APPROVED ACCEPTANCE CRITERIA",
+        ...(input.acceptance.length ? input.acceptance.map((criterion) => `- ${criterion}`) : ["- None"]),
+        "",
+        "REQUIRED DELIVERY SHAPE",
+        agentReportTemplate,
+    ].join("\n");
+}
+function bindLandHeadCommit(report, headCommit) {
+    return { ...report, head_commit: headCommit };
+}
+async function finalizeRepositoryLand(input) {
+    if (!requiresLandCommit({ grants: input.grants, spec: input.spec }))
+        return input.report;
+    const applyLand = async (report) => {
+        const land = await ensureLandCommit({
+            workspace: input.workspace,
+            spec: input.spec,
+            grants: input.grants,
+        });
+        if (land.kind === "committed") {
+            await input.client.attemptRequest(input.taskId, "progress", {
+                phase: "preparing_delivery",
+                message: `Bridge committed scoped agent changes that were left uncommitted (${land.paths.join(", ")}).`,
+                idempotency_key: `bridge:progress:${input.attemptId}:land-commit`,
+            });
+        }
+        if (land.kind === "already_landed" || land.kind === "committed") {
+            return bindLandHeadCommit(report, land.headCommit);
+        }
+        return report;
+    };
+    try {
+        return await applyLand(input.report);
+    }
+    catch (error) {
+        if (!(error instanceof AgentNoLandCommitError))
+            throw error;
+    }
+    await input.client.attemptRequest(input.taskId, "progress", {
+        phase: "changing",
+        message: "Agent finished without landing repository changes; starting one land-only continuation turn.",
+        idempotency_key: `bridge:progress:${input.attemptId}:land-continuation`,
+    });
+    const continuation = await input.driver.run({
+        prompt: buildLandContinuationPrompt({
+            objective: input.objective,
+            spec: input.spec,
+            acceptance: input.spec.acceptance ?? [],
+        }),
+        workspace: input.workspace,
+        grants: input.grants,
+        capabilities: input.capabilities,
+        verificationCommands: input.verificationCommands,
+        executionClass: "mutate_repo",
+        resumeSessionId: input.resumeSessionId ?? undefined,
+        timeoutMs: input.timeoutMs,
+        model: input.selection.model ?? undefined,
+        fuel: input.fuel,
+        fuelSource: input.fuelSource,
+    });
+    if (continuation.status === "failed") {
+        throw new AgentNoLandCommitError(input.spec.repository?.base_commit ?? "unknown");
+    }
+    let report = input.report;
+    try {
+        report = parseAgentReport(continuation.resultText ?? "", input.spec.acceptance ?? []);
+    }
+    catch {
+        // Land may have succeeded even when the continuation envelope is malformed — git is authoritative.
+    }
+    return applyLand(report);
+}
 function buildDeliveryRepairPrompt(parseError, previousReply, acceptance) {
     const replyTail = redactSecrets(previousReply.slice(-8_000));
     return [

package/dist/land-contract.js

@@ -0,0 +1,47 @@
+/**
+ * Land contract — when a repository delivery must carry a commit on the attempt branch.
+ * Mirrors driver mustCommit / executionClassPromptRules; observe/verify/artifact paths stay out.
+ */
+/** True when finalize must prove a commit after the plan base on the attempt branch. */
+export function requiresLandCommit(input) {
+    if (input.spec.deliverable === "artifact")
+        return false;
+    const executionClass = input.spec.execution_class;
+    if (executionClass === "observe" || executionClass === "observe_network" || executionClass === "verify") {
+        return false;
+    }
+    if (executionClass === "publish_artifact")
+        return false;
+    return input.grants.includes("repo_write") && input.grants.includes("branch_create");
+}
+/** Stable prefix for classifyFinalizeFailure and the control-plane failure envelope. */
+export const AGENT_NO_LAND_COMMIT_PREFIX = "Agent did not land repository changes";
+export function agentNoLandCommitMessage(baseCommit) {
+    return `${AGENT_NO_LAND_COMMIT_PREFIX}: the attempt branch has no commit after base ${baseCommit.slice(0, 12)}.`;
+}
+/** Legacy ensureDeliveryPullRequest text — kept recognizable for stored failures. */
+export const LEGACY_NO_LAND_COMMIT_PATTERN = /no commit after base .*; this run produced no change to deliver/i;
+export function isAgentNoLandCommitMessage(message) {
+    return message.startsWith(AGENT_NO_LAND_COMMIT_PREFIX) || LEGACY_NO_LAND_COMMIT_PATTERN.test(message);
+}
+export class AgentNoLandCommitError extends Error {
+    baseCommit;
+    constructor(baseCommit) {
+        super(agentNoLandCommitMessage(baseCommit));
+        this.name = "AgentNoLandCommitError";
+        this.baseCommit = baseCommit;
+    }
+}
+export function pathMatchesScope(path, scope) {
+    const normalized = scope.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+    if (normalized.endsWith("/**")) {
+        const prefix = normalized.slice(0, -3);
+        return path === prefix || path.startsWith(`${prefix}/`);
+    }
+    return path === normalized;
+}
+export function filterPathsInScope(paths, changeScope) {
+    if (!changeScope.length)
+        return [...paths];
+    return paths.filter((path) => changeScope.some((scope) => pathMatchesScope(path, scope)));
+}

package/dist/ops.js

@@ -9,9 +9,11 @@ import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
+import { ensureCheckout } from "./checkout.js";
 import { detectInstalledClients, probeAgentHealth } from "./detect.js";
 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";
 export const OPS_VERBS = [
     "connect", "enroll", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
@@ -154,6 +156,17 @@ export async function resolveDrivers(env, argv, detect = detectInstalledClients)
     throw new Error("No coding agent found on this computer. Install one (Claude Code, Codex, Cursor, OpenCode, Pi, Kiro, Antigravity, Grok Build), " +
         "then retry — or set CONDUIT_DRIVERS / pass driver ids explicitly.");
 }
+/** When CONDUIT_DRIVERS is unset, shared-capacity machines should not auto-online every detected IDE. */
+export function resolveInstallDrivers(env, argv, detect = detectInstalledClients) {
+    return resolveDrivers(env, argv, detect).then((drivers) => {
+        if (argv.length || splitOpsList(env.CONDUIT_DRIVERS).length || drivers.length <= 1)
+            return drivers;
+        const preferred = drivers.includes("claude-code") ? "claude-code" : drivers[0];
+        console.log(`Multiple agents detected — bringing only ${preferred} online. ` +
+            "Set CONDUIT_DRIVERS in ops.env to choose lanes explicitly.");
+        return [preferred];
+    });
+}
 /** Quote args for a copy-pasteable shell/cmd line (paths with spaces). */
 export function shellQuoteArgs(args) {
     return args.map((arg) => {
@@ -220,6 +233,11 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log(`Repo: ${env.CONDUIT_REPO || "(none)"}`);
             console.log(`Drivers: ${env.CONDUIT_DRIVERS || "(auto-detect installed agents)"}`);
             console.log(`Roles: ${env.CONDUIT_ROLES}`);
+            if (env.CONDUIT_WORKSPACE) {
+                for (const warning of runnerServiceWorkspaceWarnings(resolve(expandOpsValue(env.CONDUIT_WORKSPACE)))) {
+                    console.warn(`WARNING: ${warning}`);
+                }
+            }
             console.log("");
         }
         else {
@@ -232,10 +250,15 @@ export async function runOps(verb, argv = [], deps = {}) {
         requireOpsEnv(env);
         if (!env.CONDUIT_WORKSPACE)
             throw new Error(`Set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
+        applyRunnerToolPath();
         const config = await (deps.loadBridgeConfig ?? loadConfig)();
+        const workspace = resolve(expandOpsValue(env.CONDUIT_WORKSPACE));
+        for (const warning of runnerServiceWorkspaceWarnings(workspace)) {
+            console.warn(`WARNING: ${warning}`);
+        }
         const report = await (deps.preflight ?? runBridgePreflight)({
             config,
-            workspace: resolve(expandOpsValue(env.CONDUIT_WORKSPACE)),
+            workspace,
             expectedRepository: env.CONDUIT_REPO || undefined,
         });
         const installed = await detectInstalledClients();
@@ -257,6 +280,12 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log("");
         }
         if (report.ready) {
+            const serviceWarnings = runnerServiceWorkspaceWarnings(workspace);
+            if (serviceWarnings.length) {
+                for (const warning of serviceWarnings)
+                    console.warn(`WARNING: ${warning}`);
+                throw new Error("Background runner service workspace does not match ops.env");
+            }
             console.log("Workspace, online lanes, local fuel, CLI availability, and authentication are ready.");
             return;
         }
@@ -446,12 +475,20 @@ export async function runOps(verb, argv = [], deps = {}) {
             throw new Error(`No workspace declared. Rerun with --workspace /path/to/repo, or set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
         }
         const workspace = resolve(expandOpsValue(installEnv.CONDUIT_WORKSPACE));
-        const drivers = await resolveDrivers(installEnv, installArgv);
+        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}`);
+        }
         // Prove the exact local environment before installing a service that advertises availability.
         runBridge(["ops", "doctor"]);
         const installArgs = ["install-service", "--workspace", workspace];

package/dist/service.js

@@ -1,7 +1,7 @@
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
-import { dirname, join } from "node:path";
-import { realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 export const SERVICE_LABEL = "io.miraland.conduit-runner";
 function configDir() {
@@ -124,8 +124,88 @@ function escapeSystemd(value) {
 function launchAgentsPath() {
     return join(homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
 }
-function systemdUnitPath() {
-    return join(homedir(), ".config", "systemd", "user", "conduit-runner.service");
+export function systemdUnitPath(home = homedir()) {
+    return join(home, ".config", "systemd", "user", "conduit-runner.service");
+}
+export function systemdDropInDir(home = homedir()) {
+    return join(home, ".config", "systemd", "user", "conduit-runner.service.d");
+}
+/** Parse `--workspace` from a runner argv list or systemd ExecStart line. */
+export function parseRunnerWorkspaceFromProgramArguments(args) {
+    const index = args.indexOf("--workspace");
+    return index >= 0 && args[index + 1] ? args[index + 1] : null;
+}
+export function parseRunnerWorkspaceFromExecStart(execStart) {
+    const match = /--workspace(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s]+))/.exec(execStart);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function dropInOverridesExecStart(content) {
+    return /^\s*ExecStart\s*=/m.test(content);
+}
+/** Drop-in fragments that override ExecStart can silently hijack ops install — strip them. */
+export async function removeExecStartOverridesFromSystemdDropIns(home = homedir()) {
+    const dir = systemdDropInDir(home);
+    if (!existsSync(dir))
+        return [];
+    const removed = [];
+    for (const name of await readdir(dir)) {
+        if (!name.endsWith(".conf"))
+            continue;
+        const path = join(dir, name);
+        const content = await readFile(path, "utf8");
+        if (!dropInOverridesExecStart(content))
+            continue;
+        const kept = content.split(/\r?\n/).filter((line) => {
+            const trimmed = line.trim();
+            return trimmed && !trimmed.startsWith("#") && !/^ExecStart\s*=/.test(trimmed);
+        });
+        if (kept.length === 0) {
+            await unlink(path);
+        }
+        else {
+            const next = content.split(/\r?\n/).filter((line) => !/^\s*ExecStart\s*=/.test(line)).join("\n").trimEnd();
+            await writeFile(path, next ? `${next}\n` : "", { mode: 0o644 });
+            if (!next)
+                await unlink(path).catch(() => undefined);
+        }
+        removed.push(name);
+    }
+    return removed;
+}
+export async function readStoredRunnerServiceWorkspace(home = homedir()) {
+    try {
+        const stored = JSON.parse(await readFile(serviceStatePath(), "utf8"));
+        return stored.options.workspace
+            ?? parseRunnerWorkspaceFromProgramArguments(stored.programArguments)
+            ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Effective workspace from the installed supervisor (systemd user unit on Linux). */
+export function readEffectiveLinuxRunnerWorkspace(home = homedir()) {
+    if (platform() !== "linux")
+        return null;
+    const result = spawnSync("systemctl", ["--user", "cat", "conduit-runner.service"], { encoding: "utf8" });
+    if (result.status !== 0)
+        return null;
+    let execStart = null;
+    for (const line of result.stdout.split(/\r?\n/)) {
+        if (line.startsWith("ExecStart="))
+            execStart = line.slice("ExecStart=".length);
+    }
+    return execStart ? parseRunnerWorkspaceFromExecStart(execStart) : null;
+}
+export function runnerServiceWorkspaceWarnings(declaredWorkspace, home = homedir()) {
+    const declared = resolve(declaredWorkspace);
+    const warnings = [];
+    const stored = platform() === "linux" ? readEffectiveLinuxRunnerWorkspace(home) : null;
+    if (stored && resolve(stored) !== declared) {
+        warnings.push(`Background runner service uses workspace ${stored}, but ops.env declares ${declaredWorkspace}. ` +
+            "Run ops install to realign the service, or remove stale systemd drop-ins under conduit-runner.service.d/.");
+    }
+    return warnings;
 }
 export const WINDOWS_TASK_NAME = "ConduitBridgeRunner";
 /** Quote one argv token for a Windows Task Scheduler /TR command line. */
@@ -256,6 +336,11 @@ export async function installRunnerService(options = {}) {
         return { path: plistPath, platform: "darwin" };
     }
     const unitPath = systemdUnitPath();
+    const removedDropIns = await removeExecStartOverridesFromSystemdDropIns();
+    if (removedDropIns.length) {
+        console.warn(`Removed stale systemd drop-in(s) that overrode ExecStart: ${removedDropIns.join(", ")}. ` +
+            "Those files can silently point the runner at the wrong checkout after ops switch.");
+    }
     await mkdir(dirname(unitPath), { recursive: true });
     await mkdir(linuxLogDir(), { recursive: true });
     await writeFile(unitPath, systemdUserUnit(programArguments, configDir()), { mode: 0o644 });

package/package.json

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