@miraland-labs/conduit-bridge 0.16.132 → 0.16.135

package/dist/config.js

@@ -29,22 +29,6 @@ const runtimePath = join(directory, "runtime.json");
 const lockPath = join(directory, "config.lock");
 const pendingPath = join(directory, "pending-connect.json");
 const installationPath = join(directory, "installation.json");
-/**
- * Prefer runtime.json; when absent, adopt legacy activeAttempts/sessions still on config.json
- * so one Bridge upgrade does not strand in-flight claims.
- */
-export function adoptLegacyRuntimeClaims(input) {
-    if (input.runtime) {
-        return {
-            activeAttempts: input.runtime.activeAttempts ?? {},
-            sessions: input.runtime.sessions,
-        };
-    }
-    return {
-        activeAttempts: input.legacyAttempts,
-        sessions: input.legacySessions,
-    };
-}
 export async function loadConfig() {
     const config = await loadConfigIfPresent();
     if (!config)
@@ -71,13 +55,9 @@ export async function loadConfigIfPresent() {
         }
     }
     const runtime = await loadRuntime();
-    const adopted = adoptLegacyRuntimeClaims({
-        runtime,
-        legacyAttempts: config.activeAttempts && typeof config.activeAttempts === "object" ? config.activeAttempts : {},
-        legacySessions: config.sessions && typeof config.sessions === "object" ? config.sessions : undefined,
-    });
-    config.activeAttempts = adopted.activeAttempts;
-    config.sessions = adopted.sessions;
+    // Claims live only in runtime.json; a fresh install has none.
+    config.activeAttempts = runtime?.activeAttempts ?? {};
+    config.sessions = runtime?.sessions;
     for (const active of Object.values(config.activeAttempts))
         active.phase ??= "agent_running";
     if (config.fuelSource !== "local" && config.fuelSource !== "conduit")
@@ -264,24 +244,10 @@ export async function saveConfig(config, options = {}) {
                 diskPrefs = JSON.parse(await readFile(path, "utf8"));
             }
             catch { /* no prior config */ }
-            // One-time migrate: if runtime.json is missing, preserve legacy activeAttempts from config.json.
-            const existingRuntime = await loadRuntime();
-            if (!existingRuntime && diskPrefs) {
-                const legacyAttempts = diskPrefs.activeAttempts && typeof diskPrefs.activeAttempts === "object"
-                    ? diskPrefs.activeAttempts
-                    : {};
-                const legacySessions = diskPrefs.sessions && typeof diskPrefs.sessions === "object"
-                    ? diskPrefs.sessions
-                    : undefined;
-                if (Object.keys(legacyAttempts).length || legacySessions) {
-                    await writeJsonAtomic(runtimePath, { activeAttempts: legacyAttempts, sessions: legacySessions });
-                }
-            }
             const prefs = { ...snapshot, drivers: mergeCurrentDriverQuota(diskPrefs, snapshot.drivers) };
             delete prefs.activeAttempts;
             delete prefs.sessions;
-            const prefsForDisk = { ...prefs, activeAttempts: {}, sessions: undefined };
-            await writeJsonAtomic(path, prefsForDisk);
+            await writeJsonAtomic(path, prefs);
             if (!options.prefsOnly) {
                 const disk = await loadRuntime();
                 await writeJsonAtomic(runtimePath, mergeRuntimeState(disk, {
@@ -342,7 +308,7 @@ async function updateDriverLane(driverId, update) {
             if (!lane || typeof lane !== "object")
                 return;
             update(lane);
-            await writeJsonAtomic(path, { ...prefs, activeAttempts: {}, sessions: undefined });
+            await writeJsonAtomic(path, prefs);
         });
     };
     const next = saveChain.then(run, run);

package/dist/driver.js

@@ -787,15 +787,6 @@ export function claudeCodeFuelEnv(fuelSource, model) {
         return undefined;
     return { ANTHROPIC_MODEL: model, ANTHROPIC_SMALL_FAST_MODEL: model, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1" };
 }
-/** Map Conduit grants → Codex sandbox (privileged grants never widen the sandbox). */
-export function codexSandboxForGrants(grants) {
-    if (grants.includes("repo_write") || grants.includes("branch_create") || grants.includes("pr_create") || grants.includes("test_run")) {
-        return "workspace-write";
-    }
-    if (grants.includes("repo_read"))
-        return "read-only";
-    return null;
-}
 /**
  * Codex exec arguments. The sandbox is the enforcement boundary: network stays
  * off inside workspace-write unless the class/capabilities require it.
@@ -2075,12 +2066,6 @@ export function hasGrokLogin(env = process.env) {
     // `~/.grok` exists after install; auth.json is the `grok login` / cached_token file.
     return Boolean(home && existsSync(join(home, ".grok", "auth.json")));
 }
-/** True when local fuel can use a host vendor login for at least one supported agent. */
-export function hasLocalVendorLogin(env = process.env) {
-    return hasClaudeLogin(env) || hasOpenAiLogin(env) || hasCursorLogin(env)
-        || hasOpenCodeLogin(env) || hasKiroLogin(env) || hasAntigravityLogin(env)
-        || hasGrokLogin(env);
-}
 /** Exported for tests — builds the stripped process env with optional Conduit fuel. */
 export function agentProcessEnv(fuel, fuelSource = "conduit", extraEnv) {
     return boundedEnvironment(fuel, fuelSource, extraEnv);

package/dist/execution.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { resolveAgentTimeout } from "./execution-budget.js";
 import { AttemptStalledError, createAttemptWatchdog, withTimeout } from "./attempt-watchdog.js";
+import { workPackageSchema } from "./work-package-schema.js";
 import { ConduitRequestError, reportAssignmentPollShapeMismatch } from "./client.js";
 import { redactSecrets, saveDriverOutcome, saveDriverQuota, tierCandidates } from "./config.js";
 import { DRIVERS, acceptanceCriteriaLines, acceptanceReportSkeleton, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, isSafeModelName, driverExecutable, requireStampedExecutionClass, tierForRisk } from "./driver.js";
@@ -412,30 +413,6 @@ const executionContractSchema = z.object({
     prior_pull_request_url: z.string().nullable().optional().default(null),
     prior_head_commit: z.string().nullable().optional().default(null),
 });
-const workPackageSchema = z.object({
-    work_role: z.string().nullable().optional(),
-    goal: z.string().nullable().optional(),
-    scope: z.array(z.string()).optional(),
-    boundaries: z.array(z.string()).optional(),
-    acceptance: z.array(z.string()).optional(),
-    change_scope: z.array(z.string()).optional(),
-    required_evidence: z.array(z.string()).optional(),
-    deliverable: z.enum(["repository", "artifact"]).optional().default("repository"),
-    initiative: z.object({
-        title: z.string().nullable().optional(),
-        desired_outcome: z.string().nullable().optional(),
-        boundaries: z.array(z.string()).optional(),
-        context: z.string().max(20_000).nullable().optional(),
-    }).optional(),
-    decisions: z.array(z.object({ question: z.string(), decision: z.string() })).optional(),
-    rework_feedback: z.string().nullable().optional(),
-    diagnostic_context: z.object({
-        source_attempt_id: z.string().uuid(),
-        failure_output: z.string().min(1).max(12_000),
-    }).optional(),
-    working_language: z.enum(["en", "zh"]).optional(),
-    max_duration_ms: z.number().int().min(60_000).max(4 * 60 * 60_000).optional(),
-}).nullable().optional();
 const diagnosticRepairBriefSchema = z.object({
     root_cause: z.string().trim().min(1).max(2_000),
     wrong_approach: z.string().trim().max(2_000).default(""),
@@ -1052,7 +1029,15 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
     const detail = await client.request(`/runner/v1/tasks/${taskId}`);
     const task = taskDetailSchema.parse(detail.task);
     const executionContract = executionContractSchema.parse(detail.execution_contract ?? {});
-    const workPackage = workPackageSchema.parse(detail.work_package) ?? null;
+    const parsedPackage = workPackageSchema.safeParse(detail.work_package);
+    if (!parsedPackage.success) {
+        // A strict refusal before any worktree or agent spend: a key this Bridge does not know would
+        // otherwise be dropped with no error, and the agent would run without it.
+        const issues = parsedPackage.error.issues.map((issue) => `${issue.path.join(".") || "work_package"}: ${issue.message}`).join("; ");
+        await queueTerminal(client, taskId, { action: "fail", body: { error: `Work package refused: ${issues}`, retryable: false, failure: bridgeCause("work_package_invalid", issues), idempotency_key: `bridge:work-package-invalid:${active.attemptId}` } });
+        return;
+    }
+    const workPackage = parsedPackage.data;
     const agentTimeout = resolveAgentTimeout({
         machineCeilingMs: timeoutMs,
         packageBudgetMs: workPackage?.max_duration_ms,

package/dist/failure-signal.js

@@ -128,6 +128,7 @@ export const BRIDGE_CAUSES = {
     agent_execution_failed: { class: "transient", disposition: "retry", responsible_party: "conduit", message: "The agent run failed before delivery.", next_action: "Conduit will retry with bounded backoff while the authoring budget remains. No technical constraints are required from the owner." },
     verification_failed_after_run: { class: "transient", disposition: "retry", responsible_party: "conduit", message: "The agent run failed its own verification before delivery.", next_action: "Conduit will diagnose the retained failed run and brief the next authoring attempt." },
     bridge_finalize_failed: { class: "platform", disposition: "stop", responsible_party: "conduit", message: "Bridge stopped while finishing the delivery report.", next_action: "Inspect Bridge logs for the finalize fault. Fix Bridge or open a revision if the plan is wrong, then Retry." },
+    work_package_invalid: { class: "platform", disposition: "stop", responsible_party: "conduit", message: "Bridge refused this work package: this Bridge release does not know its shape.", next_action: "Update Bridge and Conduit to the same release, then Retry. The work package itself needs no change from you." },
     bridge_preflight_missing: { class: "environment", disposition: "hold", responsible_party: "computer_operator", message: "This computer has not reported Bridge readiness.", next_action: "Run Bridge Doctor and reinstall or restart the background service, then recheck readiness." },
     bridge_preflight_stale: { class: "environment", disposition: "hold", responsible_party: "computer_operator", message: "This computer's Bridge readiness report is stale.", next_action: "Wake or restart the Bridge and wait for a fresh heartbeat, then recheck readiness." },
     hosted_computer: { class: "environment", disposition: "hold", responsible_party: "conduit", message: "This hosted computer is Conduit's responsibility.", next_action: "Conduit fixes the hosted computer; Recheck runs the work package again." },

package/dist/work-package-schema.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+/**
+ * The work package: what the control plane sends with a claimed attempt, and what Bridge runs.
+ *
+ * The Bridge source is packages/conduit-bridge/src/work-package-schema.ts. The control-plane copy at
+ * src/conductor/work-package-schema.ts is generated by `npm run sync:twins`. Do not edit that copy.
+ * Bridge cannot import from the control plane, and the other way round.
+ *
+ * One declaration for both ends. The control plane's builder returns `WorkPackage`, so a key it
+ * emits and this schema does not name is a type error; Bridge parses the package strictly, so a key
+ * it does not know is a refusal, never a silent drop. Every change to this schema raises
+ * `MINIMUM_BRIDGE_VERSION` in the same change, so the two copies cannot disagree at runtime.
+ */
+export const workPackageSchema = z.object({
+    organization_id: z.string(),
+    project_id: z.string(),
+    /** implement | review | research | diagnose — guides agent behavior; matching still uses capabilities. */
+    work_role: z.enum(["implement", "review", "research", "diagnose"]).nullable(),
+    objective: z.string(),
+    goal: z.string().nullable(),
+    scope: z.array(z.string()),
+    boundaries: z.array(z.string()),
+    acceptance: z.array(z.string()),
+    change_scope: z.array(z.string()),
+    required_evidence: z.array(z.string()),
+    normative_refs: z.array(z.object({
+        label: z.string(),
+        repository: z.string(),
+        paths: z.array(z.string()),
+        revision: z.string().optional(),
+        markers: z.array(z.string()).optional(),
+    }).strict()),
+    /** repository | artifact — artifact output is produced and published, never committed. */
+    deliverable: z.enum(["repository", "artifact"]),
+    risk_level: z.string().nullable(),
+    /** Server-derived per-agent-turn request; Bridge clamps it to the machine ceiling. */
+    max_duration_ms: z.number().int().min(60_000).max(4 * 60 * 60_000).optional(),
+    grants: z.array(z.string()),
+    repository: z.object({ url: z.string().optional(), base_commit: z.string().optional() }).strict().nullable(),
+    initiative: z.object({
+        id: z.string().nullable(),
+        objective: z.string().nullable(),
+        title: z.string().nullable(),
+        desired_outcome: z.string().nullable(),
+        boundaries: z.array(z.string()),
+        /**
+         * The brief's own context, verbatim. The planner distils the brief into the package, and a brief
+         * that is mostly data (release notes, a catalog diff) lost that data on the way to the agent.
+         */
+        context: z.string().max(20_000).nullable(),
+    }).strict(),
+    /** Explicit human decisions for this project — bounded, never auto-promoted chat. */
+    decisions: z.array(z.object({ question: z.string(), decision: z.string() }).strict()),
+    rework_feedback: z.string().nullable(),
+    /** Present only for Conductor's internal, read-only Option C assignment. */
+    diagnostic_context: z.object({
+        source_attempt_id: z.string().uuid(),
+        failure_output: z.string().min(1).max(12_000),
+    }).strict().optional(),
+    /** Working/Delivery language for Bridge assignment prose. */
+    working_language: z.enum(["en", "zh"]).optional(),
+}).strict();

package/package.json

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