@runfusion/fusion 0.17.2 → 0.18.0

package/dist/bin.js

@@ -2773,7 +2773,7 @@ var init_db = __esm({
     "use strict";
     init_sqlite_adapter();
     init_types();
-    SCHEMA_VERSION = 59;
+    SCHEMA_VERSION = 60;
     SCHEMA_SQL = `
 -- Tasks table with JSON columns for nested data
 CREATE TABLE IF NOT EXISTS tasks (
@@ -2841,6 +2841,7 @@ CREATE TABLE IF NOT EXISTS tasks (
   missionId TEXT,
   sliceId TEXT,
   assignedAgentId TEXT,
+  pausedByAgentId TEXT,
   assigneeUserId TEXT,
   sourceType TEXT,
   sourceAgentId TEXT,
@@ -4638,6 +4639,12 @@ This means a caller passed a .fusion directory where a project root was expected
             this.db.exec(`CREATE INDEX IF NOT EXISTS idxInsightRunEventsRunIdSeq ON project_insight_run_events(runId, seq)`);
           });
         }
+        if (version < 60) {
+          this.applyMigration(60, () => {
+            this.addColumnIfMissing("tasks", "pausedByAgentId", "TEXT");
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idxTasksPausedByAgentId ON tasks(pausedByAgentId)`);
+          });
+        }
       }
       /**
        * Run a single migration step inside a transaction and bump the version.
@@ -5014,27 +5021,27 @@ var init_agent_store = __esm({
             }
             try {
               const content = await readFile(join3(runDir, file), "utf-8");
-              const run = JSON.parse(content);
-              if (typeof run.id !== "string" || typeof run.startedAt !== "string" || !["active", "completed", "terminated", "failed"].includes(String(run.status))) {
+              const run2 = JSON.parse(content);
+              if (typeof run2.id !== "string" || typeof run2.startedAt !== "string" || !["active", "completed", "terminated", "failed"].includes(String(run2.status))) {
                 continue;
               }
               const normalizedRun = {
-                id: run.id,
-                agentId: typeof run.agentId === "string" ? run.agentId : agentId,
-                startedAt: run.startedAt,
-                endedAt: typeof run.endedAt === "string" ? run.endedAt : null,
-                status: run.status,
-                invocationSource: run.invocationSource,
-                triggerDetail: run.triggerDetail,
-                processPid: run.processPid,
-                exitCode: run.exitCode,
-                sessionIdBefore: run.sessionIdBefore,
-                sessionIdAfter: run.sessionIdAfter,
-                usageJson: run.usageJson,
-                resultJson: run.resultJson,
-                contextSnapshot: run.contextSnapshot,
-                stdoutExcerpt: run.stdoutExcerpt,
-                stderrExcerpt: run.stderrExcerpt
+                id: run2.id,
+                agentId: typeof run2.agentId === "string" ? run2.agentId : agentId,
+                startedAt: run2.startedAt,
+                endedAt: typeof run2.endedAt === "string" ? run2.endedAt : null,
+                status: run2.status,
+                invocationSource: run2.invocationSource,
+                triggerDetail: run2.triggerDetail,
+                processPid: run2.processPid,
+                exitCode: run2.exitCode,
+                sessionIdBefore: run2.sessionIdBefore,
+                sessionIdAfter: run2.sessionIdAfter,
+                usageJson: run2.usageJson,
+                resultJson: run2.resultJson,
+                contextSnapshot: run2.contextSnapshot,
+                stdoutExcerpt: run2.stdoutExcerpt,
+                stderrExcerpt: run2.stderrExcerpt
               };
               const result = this.db.prepare(`
             INSERT OR IGNORE INTO agentRuns (id, agentId, data, startedAt, endedAt, status)
@@ -5962,16 +5969,16 @@ var init_agent_store = __esm({
       async startHeartbeatRun(agentId) {
         const runId = `run-${randomUUID().slice(0, 8)}`;
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        const run = {
+        const run2 = {
           id: runId,
           agentId,
           startedAt: now,
           endedAt: null,
           status: "active"
         };
-        await this.saveRun(run);
+        await this.saveRun(run2);
         await this.recordHeartbeat(agentId, "ok", runId);
-        return run;
+        return run2;
       }
       /**
        * End a heartbeat run.
@@ -6010,7 +6017,7 @@ var init_agent_store = __esm({
        */
       async getActiveHeartbeatRun(agentId) {
         const recentRuns = await this.getRecentRuns(agentId, 50);
-        return recentRuns.find((run) => run.status === "active") ?? null;
+        return recentRuns.find((run2) => run2.status === "active") ?? null;
       }
       /**
        * Get all completed heartbeat runs for an agent.
@@ -6022,7 +6029,7 @@ var init_agent_store = __esm({
        */
       async getCompletedHeartbeatRuns(agentId) {
         const recentRuns = await this.getRecentRuns(agentId, 50);
-        return recentRuns.filter((run) => run.status !== "active").sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+        return recentRuns.filter((run2) => run2.status !== "active").sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
       }
       // ─────────────────────────────────────────────────────────────────────────
       // Task Session Management
@@ -6165,7 +6172,7 @@ var init_agent_store = __esm({
        * Save a rich heartbeat run record (structured JSON, not JSONL events).
        * @param run - The heartbeat run data
        */
-      async saveRun(run) {
+      async saveRun(run2) {
         this.db.prepare(`
       INSERT INTO agentRuns (id, agentId, data, startedAt, endedAt, status)
       VALUES (?, ?, ?, ?, ?, ?)
@@ -6175,7 +6182,7 @@ var init_agent_store = __esm({
         startedAt = excluded.startedAt,
         endedAt = excluded.endedAt,
         status = excluded.status
-    `).run(run.id, run.agentId, JSON.stringify(run), run.startedAt, run.endedAt, run.status);
+    `).run(run2.id, run2.agentId, JSON.stringify(run2), run2.startedAt, run2.endedAt, run2.status);
         this.db.bumpLastModified();
       }
       /**
@@ -6203,7 +6210,7 @@ var init_agent_store = __esm({
       ORDER BY startedAt DESC
       LIMIT ?
     `).all(agentId, limit);
-        return rows.map((row) => this.parseJson(row.data, null)).filter((run) => run !== null);
+        return rows.map((row) => this.parseJson(row.data, null)).filter((run2) => run2 !== null);
       }
       // ─────────────────────────────────────────────────────────────────────────
       // Run-scoped log storage (JSONL files alongside run JSON in agentsDir)
@@ -9485,7 +9492,7 @@ var init_mission_store = __esm({
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const id = this.generateValidatorRunId();
         const newValidatorAttemptCount = (feature.validatorAttemptCount ?? 0) + 1;
-        const run = {
+        const run2 = {
           id,
           featureId,
           milestoneId: milestone.id,
@@ -9504,28 +9511,28 @@ var init_mission_store = __esm({
         INSERT INTO mission_validator_runs (id, featureId, milestoneId, sliceId, status, triggerType, implementationAttempt, validatorAttempt, taskId, startedAt, createdAt, updatedAt)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(
-            run.id,
-            run.featureId,
-            run.milestoneId,
-            run.sliceId,
-            run.status,
-            run.triggerType ?? "auto",
-            run.implementationAttempt,
-            run.validatorAttempt,
-            run.taskId ?? null,
-            run.startedAt,
-            run.createdAt,
-            run.updatedAt
+            run2.id,
+            run2.featureId,
+            run2.milestoneId,
+            run2.sliceId,
+            run2.status,
+            run2.triggerType ?? "auto",
+            run2.implementationAttempt,
+            run2.validatorAttempt,
+            run2.taskId ?? null,
+            run2.startedAt,
+            run2.createdAt,
+            run2.updatedAt
           );
           this.updateFeature(featureId, {
             validatorAttemptCount: newValidatorAttemptCount,
-            lastValidatorRunId: run.id,
+            lastValidatorRunId: run2.id,
             loopState: "validating"
           });
         });
         this.db.bumpLastModified();
-        this.emit("validator-run:started", run);
-        return run;
+        this.emit("validator-run:started", run2);
+        return run2;
       }
       /**
        * Complete a validator run with the given result.
@@ -9545,16 +9552,16 @@ var init_mission_store = __esm({
        * @throws Error if run not found
        */
       completeValidatorRun(runId, result, summary, blockedReason) {
-        const run = this.getValidatorRun(runId);
-        if (!run) {
+        const run2 = this.getValidatorRun(runId);
+        if (!run2) {
           throw new Error(`Validator run ${runId} not found`);
         }
-        if (run.status !== "running") {
+        if (run2.status !== "running") {
           throw new Error(`Validator run ${runId} is not in 'running' status`);
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const completedAt = now;
-        const startedAtMs = new Date(run.startedAt).getTime();
+        const startedAtMs = new Date(run2.startedAt).getTime();
         const completedAtMs = new Date(completedAt).getTime();
         const durationMs = Math.max(0, completedAtMs - startedAtMs);
         let featureLoopState;
@@ -9594,7 +9601,7 @@ var init_mission_store = __esm({
             now,
             runId
           );
-          this.updateFeature(run.featureId, {
+          this.updateFeature(run2.featureId, {
             loopState: featureLoopState,
             lastValidatorStatus: featureLastValidatorStatus
           });
@@ -9625,8 +9632,8 @@ var init_mission_store = __esm({
        * @returns The created failure records
        */
       recordValidatorFailures(runId, failures) {
-        const run = this.getValidatorRun(runId);
-        if (!run) {
+        const run2 = this.getValidatorRun(runId);
+        if (!run2) {
           throw new Error(`Validator run ${runId} not found`);
         }
         const createdRecords = [];
@@ -9709,8 +9716,8 @@ var init_mission_store = __esm({
         if (!sourceFeature) {
           throw new Error(`Feature ${sourceFeatureId} not found`);
         }
-        const run = this.getValidatorRun(runId);
-        if (!run) {
+        const run2 = this.getValidatorRun(runId);
+        if (!run2) {
           throw new Error(`Validator run ${runId} not found`);
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -9809,8 +9816,8 @@ var init_mission_store = __esm({
         }
         const validatorRuns = this.getValidatorRunsByFeature(featureId);
         const failures = [];
-        for (const run of validatorRuns) {
-          const runFailures = this.getFailuresForRun(run.id);
+        for (const run2 of validatorRuns) {
+          const runFailures = this.getFailuresForRun(run2.id);
           failures.push(...runFailures);
         }
         const sourceLineageRows = this.db.prepare(
@@ -12407,7 +12414,7 @@ var init_insight_store = __esm({
           null
         );
         this.db.bumpLastModified();
-        const run = {
+        const run2 = {
           id,
           projectId,
           trigger: input.trigger,
@@ -12424,8 +12431,8 @@ var init_insight_store = __esm({
           cancelledAt: null,
           lifecycle
         };
-        this.emit("run:created", run);
-        return run;
+        this.emit("run:created", run2);
+        return run2;
       }
       /**
        * Get a single run by ID.
@@ -12588,8 +12595,8 @@ var init_insight_store = __esm({
         return this.createRun(projectId, input);
       }
       appendRunEvent(runId, event) {
-        const run = this.getRun(runId);
-        if (!run) {
+        const run2 = this.getRun(runId);
+        if (!run2) {
           throw new Error(`Insight run not found: ${runId}`);
         }
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -12765,7 +12772,7 @@ var init_research_store = __esm({
       }
       createRun(input) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        const run = {
+        const run2 = {
           id: generateRunId2(),
           query: input.query,
           topic: input.topic,
@@ -12794,30 +12801,30 @@ var init_research_store = __esm({
         tokenUsage, tags, metadata, lifecycle, createdAt, updatedAt, startedAt, completedAt, cancelledAt
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-          run.id,
-          run.query,
-          run.topic ?? null,
-          run.status,
-          run.projectId ?? null,
-          run.trigger ?? null,
-          toJsonNullable(run.providerConfig),
-          toJson(run.sources),
-          toJson(run.events),
-          toJsonNullable(run.results),
+          run2.id,
+          run2.query,
+          run2.topic ?? null,
+          run2.status,
+          run2.projectId ?? null,
+          run2.trigger ?? null,
+          toJsonNullable(run2.providerConfig),
+          toJson(run2.sources),
+          toJson(run2.events),
+          toJsonNullable(run2.results),
           null,
           null,
-          toJson(run.tags),
-          toJsonNullable(run.metadata),
-          toJsonNullable(run.lifecycle),
-          run.createdAt,
-          run.updatedAt,
+          toJson(run2.tags),
+          toJsonNullable(run2.metadata),
+          toJsonNullable(run2.lifecycle),
+          run2.createdAt,
+          run2.updatedAt,
           null,
           null,
           null
         );
         this.db.bumpLastModified();
-        this.emit("run:created", run);
-        return run;
+        this.emit("run:created", run2);
+        return run2;
       }
       getRun(id) {
         const row = this.db.prepare("SELECT * FROM research_runs WHERE id = ?").get(id);
@@ -12907,8 +12914,8 @@ var init_research_store = __esm({
         return deleted;
       }
       addEvent(runId, event) {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
         const created = {
           id: generateId("REVT"),
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12926,12 +12933,12 @@ var init_research_store = __esm({
           seq2,
           created.type,
           created.message,
-          run.status,
+          run2.status,
           null,
           toJsonNullable(created.metadata),
           created.timestamp
         );
-        this.persistRun({ ...run, events: [...run.events, created], updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        this.persistRun({ ...run2, events: [...run2.events, created], updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
         this.db.bumpLastModified();
         this.emit("event:added", { runId, event: created });
         return created;
@@ -12940,8 +12947,8 @@ var init_research_store = __esm({
         return this.addEvent(runId, event);
       }
       appendLifecycleEvent(runId, event) {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         const lifecycleEvent = {
           id: generateId("REVT"),
@@ -12990,17 +12997,17 @@ var init_research_store = __esm({
         }));
       }
       addSource(runId, source) {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
         const created = { ...source, id: generateId("RSRC") };
-        this.updateRun(runId, { sources: [...run.sources, created] });
+        this.updateRun(runId, { sources: [...run2.sources, created] });
         this.emit("source:added", { runId, source: created });
         return created;
       }
       updateSource(runId, sourceId, updates) {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
-        const next = run.sources.map((source) => {
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
+        const next = run2.sources.map((source) => {
           if (source.id !== sourceId) return source;
           return {
             ...source,
@@ -13015,20 +13022,20 @@ var init_research_store = __esm({
         if (!updated) throw new Error(`Research run not found: ${runId}`);
       }
       updateStatus(runId, status, extra) {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
         const normalizedStatus = normalizeStatus(status);
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const patch = {
           ...extra ?? {},
           status: normalizedStatus,
           lifecycle: {
-            ...run.lifecycle ?? {}
+            ...run2.lifecycle ?? {}
           }
         };
-        if (normalizedStatus === "running" && !run.startedAt) patch.startedAt = now;
-        if (TERMINAL_STATUSES.has(normalizedStatus) && !run.completedAt) patch.completedAt = now;
-        if (normalizedStatus === "cancelled" && !run.cancelledAt) patch.cancelledAt = now;
+        if (normalizedStatus === "running" && !run2.startedAt) patch.startedAt = now;
+        if (TERMINAL_STATUSES.has(normalizedStatus) && !run2.completedAt) patch.completedAt = now;
+        if (normalizedStatus === "cancelled" && !run2.cancelledAt) patch.cancelledAt = now;
         if (normalizedStatus === "completed") {
           patch.lifecycle = { ...patch.lifecycle ?? {}, terminalReason: "completed", retryable: false, errorCode: void 0 };
         } else if (normalizedStatus === "failed") {
@@ -13160,18 +13167,18 @@ var init_research_store = __esm({
         }
       }
       requestCancellation(runId, reason = "Cancelled by user") {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
-        if (TERMINAL_STATUSES.has(run.status)) {
-          return run;
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
+        if (TERMINAL_STATUSES.has(run2.status)) {
+          return run2;
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        const alreadyCancelling = run.status === "cancelling";
+        const alreadyCancelling = run2.status === "cancelling";
         const updated = this.updateRun(runId, {
           status: "cancelling",
           lifecycle: {
-            ...run.lifecycle ?? {},
-            cancellationRequestedAt: run.lifecycle?.cancellationRequestedAt ?? now,
+            ...run2.lifecycle ?? {},
+            cancellationRequestedAt: run2.lifecycle?.cancellationRequestedAt ?? now,
             terminalCause: reason,
             errorCode: "RUN_CANCELLED",
             retryable: false
@@ -13184,34 +13191,34 @@ var init_research_store = __esm({
         return updated;
       }
       createRetryRun(runId, maxAttempts) {
-        const run = this.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
-        if (run.status !== "failed" && run.status !== "timed_out") {
-          throw new ResearchLifecycleError(`Run ${runId} is not retryable from status ${run.status}`, "invalid_transition");
+        const run2 = this.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
+        if (run2.status !== "failed" && run2.status !== "timed_out") {
+          throw new ResearchLifecycleError(`Run ${runId} is not retryable from status ${run2.status}`, "invalid_transition");
         }
-        const currentAttempt = run.lifecycle?.attempt ?? 1;
-        const configuredMaxAttempts = maxAttempts ?? run.lifecycle?.maxAttempts ?? 3;
+        const currentAttempt = run2.lifecycle?.attempt ?? 1;
+        const configuredMaxAttempts = maxAttempts ?? run2.lifecycle?.maxAttempts ?? 3;
         const nextAttempt = currentAttempt + 1;
         if (nextAttempt > configuredMaxAttempts) {
           this.updateRun(runId, { status: "retry_exhausted" });
           throw new ResearchLifecycleError(`Run ${runId} exhausted retries`, "not_retryable");
         }
-        if (!run.lifecycle?.retryable) {
+        if (!run2.lifecycle?.retryable) {
           throw new ResearchLifecycleError(`Run ${runId} is non-retryable`, "not_retryable");
         }
-        const rootRunId = run.lifecycle?.rootRunId ?? run.id;
+        const rootRunId = run2.lifecycle?.rootRunId ?? run2.id;
         const retryRun = this.createRun({
-          query: run.query,
-          topic: run.topic,
-          projectId: run.projectId,
-          trigger: run.trigger,
-          providerConfig: run.providerConfig,
-          tags: run.tags,
-          metadata: run.metadata,
+          query: run2.query,
+          topic: run2.topic,
+          projectId: run2.projectId,
+          trigger: run2.trigger,
+          providerConfig: run2.providerConfig,
+          tags: run2.tags,
+          metadata: run2.metadata,
           lifecycle: {
             attempt: nextAttempt,
             maxAttempts: configuredMaxAttempts,
-            retryOfRunId: run.id,
+            retryOfRunId: run2.id,
             rootRunId
           }
         });
@@ -13223,8 +13230,8 @@ var init_research_store = __esm({
         });
         this.appendLifecycleEvent(retryRun.id, {
           type: "retry_scheduled",
-          message: `Retry scheduled from ${run.id}`,
-          metadata: { retryOfRunId: run.id, rootRunId, attempt: nextAttempt }
+          message: `Retry scheduled from ${run2.id}`,
+          metadata: { retryOfRunId: run2.id, rootRunId, attempt: nextAttempt }
         });
         return retryRun;
       }
@@ -13232,7 +13239,7 @@ var init_research_store = __esm({
         const row = this.db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM research_run_events WHERE runId = ?").get(runId);
         return Number(row?.seq ?? 0) + 1;
       }
-      persistRun(run) {
+      persistRun(run2) {
         this.db.prepare(`
       UPDATE research_runs
       SET query = ?, topic = ?, status = ?, projectId = ?, trigger = ?, providerConfig = ?, sources = ?, events = ?,
@@ -13240,25 +13247,25 @@ var init_research_store = __esm({
           startedAt = ?, completedAt = ?, cancelledAt = ?
       WHERE id = ?
     `).run(
-          run.query,
-          run.topic ?? null,
-          run.status,
-          run.projectId ?? null,
-          run.trigger ?? null,
-          toJsonNullable(run.providerConfig),
-          toJson(run.sources),
-          toJson(run.events),
-          toJsonNullable(run.results),
-          run.error ?? null,
-          toJsonNullable(run.tokenUsage),
-          toJson(run.tags),
-          toJsonNullable(run.metadata),
-          toJsonNullable(run.lifecycle),
-          run.updatedAt,
-          run.startedAt ?? null,
-          run.completedAt ?? null,
-          run.cancelledAt ?? null,
-          run.id
+          run2.query,
+          run2.topic ?? null,
+          run2.status,
+          run2.projectId ?? null,
+          run2.trigger ?? null,
+          toJsonNullable(run2.providerConfig),
+          toJson(run2.sources),
+          toJson(run2.events),
+          toJsonNullable(run2.results),
+          run2.error ?? null,
+          toJsonNullable(run2.tokenUsage),
+          toJson(run2.tags),
+          toJsonNullable(run2.metadata),
+          toJsonNullable(run2.lifecycle),
+          run2.updatedAt,
+          run2.startedAt ?? null,
+          run2.completedAt ?? null,
+          run2.cancelledAt ?? null,
+          run2.id
         );
         this.db.bumpLastModified();
       }
@@ -16651,12 +16658,12 @@ var require_thunky = __commonJS({
     process.nextTick(upgrade, 42);
     module.exports = thunky;
     function thunky(fn) {
-      var state = run;
+      var state = run2;
       return thunk;
       function thunk(callback) {
         state(callback || noop);
       }
-      function run(callback) {
+      function run2(callback) {
         var stack = [callback];
         state = wait;
         fn(done);
@@ -16665,7 +16672,7 @@ var require_thunky = __commonJS({
         }
         function done(err) {
           var args = arguments;
-          state = isError(err) ? run : finished;
+          state = isError(err) ? run2 : finished;
           while (stack.length) finished(stack.shift());
           function finished(callback2) {
             nextTick2(apply2, callback2, args);
@@ -32647,6 +32654,7 @@ var init_store = __esm({
           missionId: row.missionId || void 0,
           sliceId: row.sliceId || void 0,
           assignedAgentId: row.assignedAgentId || void 0,
+          pausedByAgentId: row.pausedByAgentId || void 0,
           assigneeUserId: row.assigneeUserId || void 0,
           nodeId: row.nodeId || void 0,
           effectiveNodeId: row.effectiveNodeId || void 0,
@@ -32911,6 +32919,7 @@ ${recentText}` : void 0
           "missionId",
           "sliceId",
           "assignedAgentId",
+          "pausedByAgentId",
           "assigneeUserId",
           "nodeId",
           "effectiveNodeId",
@@ -33023,6 +33032,7 @@ ${outcome}`;
           "missionId",
           "sliceId",
           "assignedAgentId",
+          "pausedByAgentId",
           "assigneeUserId",
           "nodeId",
           "effectiveNodeId",
@@ -33073,9 +33083,9 @@ ${outcome}`;
         dependencies, steps, log, attachments, steeringComments,
         comments, workflowStepResults, prInfo, issueInfo,
         sourceIssueProvider, sourceIssueRepository, sourceIssueExternalIssueId, sourceIssueNumber, sourceIssueUrl,
-        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, assigneeUserId, nodeId, effectiveNodeId, effectiveNodeSource, sourceType, sourceAgentId, sourceRunId, sourceSessionId, sourceMessageId, sourceParentTaskId, sourceMetadata, checkedOutBy, checkedOutAt
+        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, pausedByAgentId, assigneeUserId, nodeId, effectiveNodeId, effectiveNodeSource, sourceType, sourceAgentId, sourceRunId, sourceSessionId, sourceMessageId, sourceParentTaskId, sourceMetadata, checkedOutBy, checkedOutAt
       ) VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
       )
       ON CONFLICT(id) DO UPDATE SET
         title = excluded.title,
@@ -33144,6 +33154,7 @@ ${outcome}`;
         missionId = excluded.missionId,
         sliceId = excluded.sliceId,
         assignedAgentId = excluded.assignedAgentId,
+        pausedByAgentId = excluded.pausedByAgentId,
         assigneeUserId = excluded.assigneeUserId,
         nodeId = excluded.nodeId,
         effectiveNodeId = excluded.effectiveNodeId,
@@ -33225,6 +33236,7 @@ ${outcome}`;
           task.missionId ?? null,
           task.sliceId ?? null,
           task.assignedAgentId ?? null,
+          task.pausedByAgentId ?? null,
           task.assigneeUserId ?? null,
           task.nodeId ?? null,
           task.effectiveNodeId ?? null,
@@ -34342,6 +34354,23 @@ ${newTask.description}
         const matches = [...activeMatches, ...archiveMatches];
         return limit >= 0 ? matches.slice(0, limit) : matches;
       }
+      async getTasksByAssignedAgent(agentId, options) {
+        const whereClauses = ["assignedAgentId = ?"];
+        const params = [agentId];
+        if (options?.pausedOnly) {
+          whereClauses.push("paused = 1");
+        }
+        if (options?.excludeArchived) {
+          whereClauses.push(`"column" != 'archived'`);
+        }
+        const selectClause = this.getTaskSelectClause(false);
+        const rows = this.db.prepare(`
+      SELECT ${selectClause} FROM tasks
+      WHERE ${whereClauses.join(" AND ")}
+      ORDER BY createdAt ASC
+    `).all(...params);
+        return rows.map((row) => this.rowToTask(row));
+      }
       async selectNextTaskForAgent(agentId) {
         const tasks = await this.listTasks({ slim: true });
         if (tasks.length === 0) {
@@ -34579,6 +34608,11 @@ ${newTask.description}
           } else if (updates.assignedAgentId !== void 0) {
             task.assignedAgentId = updates.assignedAgentId;
           }
+          if (updates.pausedByAgentId === null) {
+            task.pausedByAgentId = void 0;
+          } else if (updates.pausedByAgentId !== void 0) {
+            task.pausedByAgentId = updates.pausedByAgentId;
+          }
           if (updates.assigneeUserId === null) {
             task.assigneeUserId = void 0;
           } else if (updates.assigneeUserId !== void 0) {
@@ -34817,14 +34851,21 @@ ${newTask.description}
        * Pause or unpause a task. Paused tasks are excluded from all automated
        * agent and scheduler interaction. Logs the action and emits `task:updated`.
        */
-      async pauseTask(id, paused, runContext) {
+      async pauseTask(id, paused, runContext, agentOptions) {
         return this.withTaskLock(id, async () => {
           const dir2 = this.taskDir(id);
           const task = await this.readTaskJson(dir2);
           if (!task.log) {
             task.log = [];
           }
+          const previousPausedByAgentId = task.pausedByAgentId;
           task.paused = paused || void 0;
+          if (paused && agentOptions?.pausedByAgentId) {
+            task.pausedByAgentId = agentOptions.pausedByAgentId;
+          }
+          if (!paused) {
+            task.pausedByAgentId = void 0;
+          }
           if (task.column === "in-progress" || task.column === "in-review") {
             task.status = paused ? "paused" : void 0;
           }
@@ -34832,7 +34873,7 @@ ${newTask.description}
           task.updatedAt = now;
           const logEntry = {
             timestamp: now,
-            action: paused ? "Task paused" : "Task unpaused"
+            action: paused ? agentOptions?.pausedByAgentId ? `Task paused (agent ${agentOptions.pausedByAgentId} paused)` : "Task paused" : previousPausedByAgentId ? `Task unpaused (agent ${previousPausedByAgentId} resumed)` : "Task unpaused"
           };
           if (runContext) {
             logEntry.runContext = runContext;
@@ -39983,10 +40024,17 @@ var init_docker_client = __esm({
         }
         return this.createDockerInstance(hostConfig);
       }
-      async getContainerInfo(containerId) {
+      async getContainerInfo(containerId, hostConfig) {
         try {
-          const docker = await this.getInstance();
+          const docker = await this.getDockerInstance(hostConfig);
           const inspect = await docker.getContainer(containerId).inspect();
+          const ports = Object.entries(inspect.NetworkSettings?.Ports ?? {}).reduce((acc, [key, value]) => {
+            const binding = Array.isArray(value) && value.length > 0 ? value[0] : void 0;
+            if (binding?.HostPort) {
+              acc[key] = binding.HostPort;
+            }
+            return acc;
+          }, {});
           return {
             id: inspect.Id,
             name: (inspect.Name ?? "").replace(/^\//, ""),
@@ -39998,8 +40046,12 @@ var init_docker_client = __esm({
               paused: Boolean(inspect.State?.Paused),
               restarting: Boolean(inspect.State?.Restarting),
               dead: Boolean(inspect.State?.Dead),
-              error: inspect.State?.Error || void 0
-            }
+              error: inspect.State?.Error || void 0,
+              exitCode: typeof inspect.State?.ExitCode === "number" ? inspect.State.ExitCode : void 0,
+              startedAt: inspect.State?.StartedAt || void 0,
+              finishedAt: inspect.State?.FinishedAt || void 0
+            },
+            ports
           };
         } catch (error) {
           const message = toErrorMessage(error);
@@ -40009,6 +40061,18 @@ var init_docker_client = __esm({
           throw error;
         }
       }
+      async getContainerLogs(containerId, hostConfig, options) {
+        const docker = await this.getDockerInstance(hostConfig);
+        const stream = await docker.getContainer(containerId).logs({
+          stdout: true,
+          stderr: true,
+          tail: options?.tail ?? 100
+        });
+        if (Buffer.isBuffer(stream)) {
+          return stream.toString("utf8");
+        }
+        return String(stream ?? "");
+      }
       async getInstance() {
         if (!this.dockerInstance) {
           this.dockerInstance = await this.createDockerInstance(this.defaultHostConfig);
@@ -41509,17 +41573,17 @@ function patchForStatus(status, patch) {
   }
   return patch;
 }
-async function executeExistingRun(store, run, options) {
-  const started = store.updateRun(run.id, {
+async function executeExistingRun(store, run2, options) {
+  const started = store.updateRun(run2.id, {
     status: "running",
-    startedAt: run.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    startedAt: run2.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     lifecycle: {
-      ...run.lifecycle,
+      ...run2.lifecycle,
       maxAttempts: options.maxAttempts,
-      attempt: run.lifecycle.attempt ?? 1
+      attempt: run2.lifecycle.attempt ?? 1
     }
   });
-  let active = started ?? run;
+  let active = started ?? run2;
   store.appendRunEvent(active.id, { type: "status_changed", status: "running", message: "Run started" });
   for (let attempt = active.lifecycle.attempt ?? 1; attempt <= options.maxAttempts; attempt += 1) {
     const { signal, clear } = composeSignal(options.timeoutMs, options.signal);
@@ -41615,9 +41679,9 @@ async function executeExistingRun(store, run, options) {
 async function executeInsightRunLifecycle(options) {
   const maxAttempts = Math.max(1, options.maxAttempts ?? 2);
   const retryDelayMs = Math.max(0, options.retryDelayMs ?? 250);
-  let run;
+  let run2;
   try {
-    run = options.store.createRunOrThrowConflict(options.projectId, {
+    run2 = options.store.createRunOrThrowConflict(options.projectId, {
       ...options.input,
       lifecycle: {
         ...options.input.lifecycle,
@@ -41632,12 +41696,12 @@ async function executeInsightRunLifecycle(options) {
     }
     throw error;
   }
-  options.store.appendRunEvent(run.id, {
+  options.store.appendRunEvent(run2.id, {
     type: "status_changed",
     status: "pending",
     message: "Run created"
   });
-  return executeExistingRun(options.store, run, {
+  return executeExistingRun(options.store, run2, {
     ...options,
     maxAttempts,
     retryDelayMs
@@ -41654,7 +41718,7 @@ async function retryInsightRunLifecycle(options) {
   if (!original.lifecycle.retryable || original.lifecycle.failureClass !== "retryable_transient") {
     throw new InsightLifecycleError(`Run ${original.id} is non-retryable`, "not_retryable");
   }
-  const run = await executeInsightRunLifecycle({
+  const run2 = await executeInsightRunLifecycle({
     ...options,
     projectId: original.projectId,
     input: {
@@ -41667,7 +41731,7 @@ async function retryInsightRunLifecycle(options) {
       }
     }
   });
-  return { run, retryOf: original };
+  return { run: run2, retryOf: original };
 }
 var init_insight_run_executor = __esm({
   "../core/src/insight-run-executor.ts"() {
@@ -54701,7 +54765,7 @@ var init_research_orchestrator = __esm({
         this.semaphore = new AgentSemaphore(options.maxConcurrentRuns ?? 3);
       }
       createRun(config) {
-        const run = this.store.createRun({
+        const run2 = this.store.createRun({
           query: "",
           providerConfig: config,
           metadata: {
@@ -54712,12 +54776,12 @@ var init_research_orchestrator = __esm({
             }
           }
         });
-        return run.id;
+        return run2.id;
       }
       async startRun(runId, query, options = {}) {
-        const run = this.store.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
-        const config = run.providerConfig ?? {};
+        const run2 = this.store.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
+        const config = run2.providerConfig ?? {};
         const controller = new AbortController();
         if (options.abortSignal) {
           options.abortSignal.addEventListener("abort", () => controller.abort(options.abortSignal?.reason), { once: true });
@@ -54745,8 +54809,8 @@ var init_research_orchestrator = __esm({
       }
       cancelRun(runId) {
         const active = this.activeRuns.get(runId);
-        const run = this.store.getRun(runId);
-        if (!run) return false;
+        const run2 = this.store.getRun(runId);
+        if (!run2) return false;
         this.store.requestCancellation(runId);
         if (!active) {
           this.store.updateStatus(runId, "cancelled", { error: "Cancelled by user" });
@@ -54768,39 +54832,39 @@ var init_research_orchestrator = __esm({
         return true;
       }
       retryRun(runId) {
-        const run = this.store.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
-        if (run.status !== "failed" && run.status !== "cancelled") {
-          throw new Error(`Research run ${runId} is not retryable (status=${run.status})`);
+        const run2 = this.store.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
+        if (run2.status !== "failed" && run2.status !== "cancelled") {
+          throw new Error(`Research run ${runId} is not retryable (status=${run2.status})`);
         }
         const next = this.store.createRun({
-          query: run.query,
-          topic: run.topic,
-          providerConfig: run.providerConfig,
-          tags: [...run.tags],
+          query: run2.query,
+          topic: run2.topic,
+          providerConfig: run2.providerConfig,
+          tags: [...run2.tags],
           metadata: {
-            ...run.metadata ?? {},
-            retryOfRunId: run.id
+            ...run2.metadata ?? {},
+            retryOfRunId: run2.id
           }
         });
         this.store.addEvent(next.id, {
           type: "info",
-          message: `Retry run created from ${run.id}`,
-          metadata: { retryOfRunId: run.id }
+          message: `Retry run created from ${run2.id}`,
+          metadata: { retryOfRunId: run2.id }
         });
         return next.id;
       }
       getRunStatus(runId) {
-        const run = this.store.getRun(runId);
-        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const run2 = this.store.getRun(runId);
+        if (!run2) throw new Error(`Research run not found: ${runId}`);
         const active = this.activeRuns.get(runId);
-        const metadata = run.metadata?.orchestration ?? {};
-        const phase = active?.phase ?? metadata.phase ?? this.statusToPhase(run.status);
+        const metadata = run2.metadata?.orchestration ?? {};
+        const phase = active?.phase ?? metadata.phase ?? this.statusToPhase(run2.status);
         const stepIndex = active?.stepIndex ?? Number(metadata.stepIndex ?? 0);
         const totalSteps = active?.totalSteps ?? Number(metadata.totalSteps ?? 0);
         return {
           runId,
-          status: run.status,
+          status: run2.status,
           phase,
           stepIndex,
           totalSteps,
@@ -54974,8 +55038,8 @@ var init_research_orchestrator = __esm({
         });
       }
       onCancelled(runId) {
-        const run = this.store.getRun(runId);
-        if (!run || run.status === "cancelled") return;
+        const run2 = this.store.getRun(runId);
+        if (!run2 || run2.status === "cancelled") return;
         const cancellation = this.cancellation.get(runId);
         this.store.addEvent(runId, {
           type: "warning",
@@ -55097,9 +55161,9 @@ var init_research_orchestrator = __esm({
         }
       }
       canWriteRunData(runId) {
-        const run = this.store.getRun(runId);
-        if (!run) return false;
-        return !["cancelled", "completed", "failed", "timed_out", "retry_exhausted"].includes(run.status);
+        const run2 = this.store.getRun(runId);
+        if (!run2) return false;
+        return !["cancelled", "completed", "failed", "timed_out", "retry_exhausted"].includes(run2.status);
       }
     };
   }
@@ -55433,6 +55497,9 @@ function normalizePattern(pattern) {
 function isExclusionPattern(pattern) {
   return pattern.startsWith("-");
 }
+function bareSkillName(name) {
+  return name.replace(/\/SKILL\.md$/i, "");
+}
 function resolveSessionSkills(context) {
   const { requestedSkillNames } = context;
   const projectRootDir = resolveProjectRoot(context.projectRootDir);
@@ -55526,25 +55593,40 @@ function createSkillsOverrideFromSelection(selection, options = {}) {
     const hasRequestedNames = Boolean(requestedSkillNames && requestedSkillNames.length > 0);
     const hasExcluded = excludedSkillPaths.size > 0;
     let filteredSkills;
+    const skillNameMatches = (skill, pattern) => bareSkillName(skill.name).toLowerCase() === bareSkillName(pattern).toLowerCase() || skill.filePath === pattern;
+    const isExcluded = (skill) => {
+      for (const ep of excludedSkillPaths) {
+        if (skillNameMatches(skill, ep)) return true;
+      }
+      return false;
+    };
+    const isAllowed = (skill) => {
+      for (const ap of allowedSkillPaths) {
+        if (skillNameMatches(skill, ap)) return true;
+      }
+      return false;
+    };
     if (hasRequestedNames) {
-      const requestedNamesLower = new Set(requestedSkillNames.map((n) => n.toLowerCase()));
+      const requestedBareNamesLower = new Set(requestedSkillNames.map((n) => bareSkillName(n).toLowerCase()));
       filteredSkills = base.skills.filter(
-        (skill) => requestedNamesLower.has(skill.name.toLowerCase()) && !excludedSkillPaths.has(skill.filePath)
+        (skill) => requestedBareNamesLower.has(bareSkillName(skill.name).toLowerCase()) && !isExcluded(skill)
       );
     } else if (hasPatterns) {
       filteredSkills = base.skills.filter(
-        (skill) => allowedSkillPaths.has(skill.filePath) && !excludedSkillPaths.has(skill.filePath)
+        (skill) => isAllowed(skill) && !isExcluded(skill)
       );
     } else if (hasExcluded) {
-      filteredSkills = base.skills.filter((skill) => !excludedSkillPaths.has(skill.filePath));
+      filteredSkills = base.skills.filter((skill) => !isExcluded(skill));
     } else {
       filteredSkills = base.skills;
     }
     const newDiagnostics = [];
     const purpose = sessionPurpose ? ` [${sessionPurpose}]` : "";
-    const discoveredPaths = new Set(base.skills.map((s) => s.filePath));
+    const discoveredBareNames = new Set(base.skills.map((s) => bareSkillName(s.name).toLowerCase()));
+    const discoveredFilePaths = new Set(base.skills.map((s) => s.filePath));
+    const hasDiscoveredMatch = (pattern) => discoveredBareNames.has(bareSkillName(pattern).toLowerCase()) || discoveredFilePaths.has(pattern);
     for (const excludedPath of excludedSkillPaths) {
-      if (discoveredPaths.has(excludedPath)) {
+      if (hasDiscoveredMatch(excludedPath)) {
         newDiagnostics.push({
           type: "warning",
           message: `Skill at '${excludedPath}' exists but is disabled by project execution settings${purpose}`,
@@ -55553,7 +55635,7 @@ function createSkillsOverrideFromSelection(selection, options = {}) {
       }
     }
     for (const allowedPath of allowedSkillPaths) {
-      if (!discoveredPaths.has(allowedPath)) {
+      if (!hasDiscoveredMatch(allowedPath)) {
         newDiagnostics.push({
           type: "warning",
           message: `Configured skill pattern '${allowedPath}' not found in discovered skills${purpose}`,
@@ -55562,9 +55644,9 @@ function createSkillsOverrideFromSelection(selection, options = {}) {
       }
     }
     if (requestedSkillNames) {
-      const discoveredNamesLower = new Set(base.skills.map((s) => s.name.toLowerCase()));
+      const discoveredBareNamesLower = new Set(base.skills.map((s) => bareSkillName(s.name).toLowerCase()));
       for (const requestedName of requestedSkillNames) {
-        if (!discoveredNamesLower.has(requestedName.toLowerCase()) && !isBuiltInFallbackRequest(requestedName)) {
+        if (!discoveredBareNamesLower.has(bareSkillName(requestedName).toLowerCase()) && !isBuiltInFallbackRequest(requestedName)) {
           const purpose2 = sessionPurpose ? ` [${sessionPurpose}]` : "";
           newDiagnostics.push({
             type: "warning",
@@ -55918,6 +56000,11 @@ async function promptSessionAndCheck(session, prompt, options) {
         piLog.warn(`pi state error \u2014 failed to inspect transcript: ${inspectErr instanceof Error ? inspectErr.message : String(inspectErr)}`);
       }
     }
+    if (/Provider finish_reason:\s*repeat\b/i.test(stateError)) {
+      piLog.warn(`pi state error \u2014 treating provider finish_reason=repeat as soft stop: ${stateError}`);
+      clearSessionStateError(session);
+      return;
+    }
     throw new Error(stateError);
   }
 }
@@ -58493,18 +58580,18 @@ function createSendMessageTool(messageStore, fromAgentId) {
     }
   };
 }
-function formatResearchRunDetails(run) {
-  const findings = run.results?.findings ?? [];
-  const citations = run.results?.citations ?? [];
+function formatResearchRunDetails(run2) {
+  const findings = run2.results?.findings ?? [];
+  const citations = run2.results?.citations ?? [];
   return {
-    runId: run.id,
-    status: run.status,
-    query: run.query,
-    summary: run.results?.summary ?? null,
+    runId: run2.id,
+    status: run2.status,
+    query: run2.query,
+    summary: run2.results?.summary ?? null,
     findings,
     citations,
-    sourceCount: run.sources.length,
-    error: run.error ?? null,
+    sourceCount: run2.sources.length,
+    error: run2.error ?? null,
     setup: null
   };
 }
@@ -58629,10 +58716,10 @@ function createResearchTools(options) {
         status: params.status,
         limit
       });
-      const text = runs.length ? runs.map((run) => `- ${run.id} [${run.status}] ${run.query}`).join("\n") : "No research runs found.";
+      const text = runs.length ? runs.map((run2) => `- ${run2.id} [${run2.status}] ${run2.query}`).join("\n") : "No research runs found.";
       return {
         content: [{ type: "text", text }],
-        details: { runs: runs.map((run) => formatResearchRunDetails(run)) }
+        details: { runs: runs.map((run2) => formatResearchRunDetails(run2)) }
       };
     }
   };
@@ -58642,16 +58729,16 @@ function createResearchTools(options) {
     description: "Get one research run with structured findings and citations.",
     parameters: researchGetParams,
     execute: async (_id, params) => {
-      const run = options.store.getResearchStore().getRun(params.id);
-      if (!run) {
+      const run2 = options.store.getResearchStore().getRun(params.id);
+      if (!run2) {
         return {
           content: [{ type: "text", text: `Research run ${params.id} not found.` }],
           details: { runId: params.id, status: "missing", summary: null, findings: [], citations: [], error: "not found", setup: null }
         };
       }
-      const details = formatResearchRunDetails(run);
+      const details = formatResearchRunDetails(run2);
       return {
-        content: [{ type: "text", text: `Research run ${run.id} is ${run.status}.` }],
+        content: [{ type: "text", text: `Research run ${run2.id} is ${run2.status}.` }],
         details
       };
     }
@@ -58667,8 +58754,8 @@ function createResearchTools(options) {
         return researchUnavailable("provider-unavailable", "Research orchestrator is unavailable because research providers are not configured.");
       }
       const cancelled = orchestrator.cancelRun(params.id);
-      const run = options.store.getResearchStore().getRun(params.id);
-      if (!run) {
+      const run2 = options.store.getResearchStore().getRun(params.id);
+      if (!run2) {
         return {
           content: [{ type: "text", text: `Research run ${params.id} not found.` }],
           details: { runId: params.id, status: "missing", summary: null, findings: [], citations: [], error: "not found", setup: null }
@@ -58676,7 +58763,7 @@ function createResearchTools(options) {
       }
       return {
         content: [{ type: "text", text: cancelled ? `Cancellation requested for ${params.id}.` : `Run ${params.id} is not active.` }],
-        details: formatResearchRunDetails(run)
+        details: formatResearchRunDetails(run2)
       };
     }
   };
@@ -59099,9 +59186,18 @@ function normalizeAgentSkills(metadataSkills) {
         name = namedEntry.trim();
       }
     }
-    if (name && name.length > 0 && !seen.has(name)) {
-      seen.add(name);
-      result.push(name);
+    if (name && name.length > 0) {
+      if (name.includes("::")) {
+        const idPath = name.split("::").pop();
+        const parts = idPath.replace(/\\/g, "/").split("/").filter(Boolean);
+        if (parts.length >= 2) {
+          name = parts.slice(-2).join("/");
+        }
+      }
+      if (!seen.has(name)) {
+        seen.add(name);
+        result.push(name);
+      }
     }
   }
   return result;
@@ -69724,20 +69820,26 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         if (from !== "in-review" && from !== "done") {
           return task;
         }
-        const hasMergeEvidence = Boolean(task.mergeDetails) || (task.mergeRetries ?? 0) > 0 || (task.verificationFailureCount ?? 0) > 0 || task.status === "merging" || task.status === "merging-pr";
+        const hasMergeEvidence = Boolean(task.mergeDetails) || (task.mergeRetries ?? 0) > 0 || (task.verificationFailureCount ?? 0) > 0 || task.status === "merging" || task.status === "merging-pr" || task.status === "merging-fix";
         if (!hasMergeEvidence) {
           return task;
         }
         return this.cleanupMergeStateForReverification(
           task,
-          `Task returned to in-progress from ${from} column \u2014 resetting verification steps and merge state for re-verification`
+          `Task returned to in-progress from ${from} column \u2014 resetting verification steps and merge state for re-verification`,
+          {
+            // Keep deterministic merge-verification bounce budget across remediation
+            // cycles. Status may be cleared by intermediate paths, so the counter is
+            // the canonical signal once a bounce has started.
+            preserveVerificationFailureCount: (task.verificationFailureCount ?? 0) > 0
+          }
         );
       }
-      async cleanupMergeStateForReverification(task, logMessage) {
+      async cleanupMergeStateForReverification(task, logMessage, options) {
         await this.store.updateTask(task.id, {
           mergeDetails: null,
           mergeRetries: 0,
-          verificationFailureCount: 0,
+          verificationFailureCount: options?.preserveVerificationFailureCount ? task.verificationFailureCount ?? 0 : 0,
           workflowStepResults: []
         });
         const refreshedTask = await this.store.getTask(task.id);
@@ -70332,7 +70434,7 @@ The tool prevents your session from being killed by the inactivity watchdog duri
         };
         const audit = createRunAuditor(this.store, engineRunContext);
         const activeColumns = /* @__PURE__ */ new Set(["in-progress", "in-review", "done"]);
-        const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr"]);
+        const activeMergeStatuses = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
         const isActiveTask = activeColumns.has(task.column) || activeMergeStatuses.has(task.status ?? "");
         if (!isActiveTask) {
           const tasksDir = join36(this.store.getFusionDir(), "tasks");
@@ -70671,7 +70773,9 @@ The tool prevents your session from being killed by the inactivity watchdog duri
                           `${failedType} command \`${failedCommand}\` failed (exit ${failedResult.exitCode}):
 ${summary}`,
                           `Verification (${failedType})`,
-                          `Deterministic verification failed (${failedType})`
+                          `Deterministic verification failed (${failedType})`,
+                          true,
+                          true
                         );
                         return;
                       }
@@ -70717,7 +70821,9 @@ ${summary}`,
                           `${failedType} command \`${failedCommand}\` failed (exit ${failedResult.exitCode}) after ${maxFixRetries} fix attempts:
 ${summary}`,
                           `Verification (${failedType})`,
-                          `Deterministic verification failed after ${maxFixRetries} fix attempts`
+                          `Deterministic verification failed after ${maxFixRetries} fix attempts`,
+                          true,
+                          true
                         );
                         return;
                       }
@@ -72406,7 +72512,7 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
        * Injects failure feedback into PROMPT.md, resets steps, clears session,
        * and schedules a move to todo → in-progress after the executing guard clears.
        */
-      async sendTaskBackForFix(task, worktreePath, failureFeedback, stepName, reason, preserveResumeState = true) {
+      async sendTaskBackForFix(task, worktreePath, failureFeedback, stepName, reason, preserveResumeState = true, mergeVerificationFailure = false) {
         const taskId = task.id;
         this.clearCompletedTaskWatchdog(taskId);
         await this.store.addTaskComment(
@@ -72425,7 +72531,7 @@ Please fix the issues so the verification can pass on the next attempt.`,
         const updatedTask = await this.store.getTask(taskId);
         await this.reopenLastStepForRevision(taskId, updatedTask);
         await this.store.updateTask(taskId, {
-          status: null,
+          status: mergeVerificationFailure ? "merging-fix" : null,
           error: null,
           sessionFile: null,
           workflowStepRetries: 0
@@ -76001,17 +76107,17 @@ Assertions: ${assertions.map((a) => a.title).join(", ")}`,
             validationTaskId = validationTask.id;
             await this.taskStore.updateTask(validationTaskId, { status: "mission-validation" });
             loopLog.log(`Created validation board task ${validationTaskId} for feature ${feature.id}`);
-            const run = this.missionStore.startValidatorRun(feature.id, "task_completion", validationTaskId);
-            loopLog.log(`Started validator run ${run.id} for feature ${feature.id}`);
-            const result = await this.runValidation(feature, assertions, run);
+            const run2 = this.missionStore.startValidatorRun(feature.id, "task_completion", validationTaskId);
+            loopLog.log(`Started validator run ${run2.id} for feature ${feature.id}`);
+            const result = await this.runValidation(feature, assertions, run2);
             if (result.status === "pass") {
-              await this.handleValidationPass(feature.id, run.id, result.summary, validationTaskId);
+              await this.handleValidationPass(feature.id, run2.id, result.summary, validationTaskId);
             } else if (result.status === "fail") {
-              await this.handleValidationFail(feature.id, run.id, result, validationTaskId);
+              await this.handleValidationFail(feature.id, run2.id, result, validationTaskId);
             } else if (result.status === "blocked") {
-              await this.handleValidationBlocked(feature.id, run.id, result.blockedReason, validationTaskId);
+              await this.handleValidationBlocked(feature.id, run2.id, result.blockedReason, validationTaskId);
             } else if (result.status === "error") {
-              await this.handleValidationError(feature.id, run.id, result.summary, validationTaskId);
+              await this.handleValidationError(feature.id, run2.id, result.summary, validationTaskId);
             }
           } finally {
             this.activeValidations.delete(feature.id);
@@ -76746,7 +76852,7 @@ Rules:
         const tasksFailed = outcomes.filter((outcome) => outcome.outcome !== "completed").length;
         const durations = outcomes.map((outcome) => outcome.durationMs).filter((duration) => typeof duration === "number" && Number.isFinite(duration));
         const avgDurationMs = durations.length > 0 ? Math.round(durations.reduce((sum, duration) => sum + duration, 0) / durations.length) : performanceSummary?.avgDurationMs ?? 0;
-        const runErrors = recentRuns.map((run) => this.extractRunError(run)).filter((value) => Boolean(value));
+        const runErrors = recentRuns.map((run2) => this.extractRunError(run2)).filter((value) => Boolean(value));
         const mergedErrors = [
           ...performanceSummary?.commonErrors ?? [],
           ...outcomes.filter((outcome) => outcome.outcome !== "completed").map((outcome) => `${outcome.outcome}: ${outcome.taskId}`),
@@ -76760,11 +76866,11 @@ Rules:
           commonErrors
         };
       }
-      extractRunError(run) {
-        if (typeof run.stderrExcerpt === "string" && run.stderrExcerpt.trim()) {
-          return run.stderrExcerpt.trim().split("\n")[0] ?? null;
+      extractRunError(run2) {
+        if (typeof run2.stderrExcerpt === "string" && run2.stderrExcerpt.trim()) {
+          return run2.stderrExcerpt.trim().split("\n")[0] ?? null;
         }
-        const resultError = run.resultJson && typeof run.resultJson.error === "string" ? run.resultJson.error.trim() : "";
+        const resultError = run2.resultJson && typeof run2.resultJson.error === "string" ? run2.resultJson.error.trim() : "";
         if (resultError) {
           return resultError;
         }
@@ -76772,8 +76878,8 @@ Rules:
       }
       extractTaskIdsFromRuns(runs) {
         const ids = /* @__PURE__ */ new Set();
-        for (const run of runs) {
-          const taskId = run.contextSnapshot?.taskId;
+        for (const run2 of runs) {
+          const taskId = run2.contextSnapshot?.taskId;
           if (typeof taskId === "string" && taskId.trim()) {
             ids.add(taskId.trim());
           }
@@ -77309,9 +77415,9 @@ not loop on the same plan across heartbeats without recording why.`;
           const msg = activeRunCheckErr instanceof Error ? activeRunCheckErr.message : String(activeRunCheckErr);
           heartbeatLog.warn(`Failed to check for existing active run for ${agentId}: ${msg} \u2014 continuing with new run`);
         }
-        const run = await this.store.startHeartbeatRun(agentId);
+        const run2 = await this.store.startHeartbeatRun(agentId);
         const enrichedRun = {
-          ...run,
+          ...run2,
           invocationSource: options?.source ?? "on_demand",
           triggerDetail: options?.triggerDetail ?? "manual",
           contextSnapshot: options?.contextSnapshot,
@@ -77333,14 +77439,14 @@ not loop on the same plan across heartbeats without recording why.`;
        * @param result - Execution results
        */
       async completeRun(agentId, runId, result) {
-        const run = await this.store.getRunDetail(agentId, runId);
-        if (!run) return;
+        const run2 = await this.store.getRunDetail(agentId, runId);
+        if (!run2) return;
         const tracked = this.trackedAgents.get(agentId);
         let completionResult = result;
         const createdTasks = this.runCreatedTasks.get(agentId);
         const enrichedResultJson = createdTasks?.length ? { ...completionResult.resultJson, tasksCreated: createdTasks } : completionResult.resultJson;
         const completedRun = {
-          ...run,
+          ...run2,
           endedAt: (/* @__PURE__ */ new Date()).toISOString(),
           status: completionResult.status,
           exitCode: completionResult.exitCode,
@@ -77585,18 +77691,18 @@ not loop on the same plan across heartbeats without recording why.`;
             ...effectiveTriggeringCommentIds?.length ? { triggeringCommentIds: effectiveTriggeringCommentIds } : {},
             ...effectiveTriggeringCommentType ? { triggeringCommentType: effectiveTriggeringCommentType } : {}
           };
-          const run = await this.startRun(agentId, {
+          const run2 = await this.startRun(agentId, {
             source,
             triggerDetail,
             contextSnapshot: Object.keys(runContextSnapshot).length > 0 ? runContextSnapshot : void 0
           });
           const runContext = {
-            runId: run.id,
+            runId: run2.id,
             agentId,
             source
           };
           const engineRunContext = {
-            runId: run.id,
+            runId: run2.id,
             agentId,
             source,
             phase: "heartbeat"
@@ -77618,21 +77724,21 @@ not loop on the same plan across heartbeats without recording why.`;
               const budgetStatus = await this.store.getBudgetStatus(agentId);
               if (budgetStatus.isOverBudget) {
                 heartbeatLog.log(`Agent ${agentId} budget exhausted \u2014 heartbeat skipped`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "budget_exhausted", budgetStatus },
                   skipStateTransition: true
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
               if (budgetStatus.isOverThreshold && source === "timer") {
                 heartbeatLog.log(`Agent ${agentId} over budget threshold (${budgetStatus.usagePercent}%) \u2014 timer heartbeat skipped`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "budget_threshold_exceeded", budgetStatus },
                   skipStateTransition: true
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
             } catch (budgetErr) {
               heartbeatLog.warn(`Agent ${agentId} budget status check failed: ${budgetErr instanceof Error ? budgetErr.message : String(budgetErr)} \u2014 proceeding without budget check`);
@@ -77641,21 +77747,21 @@ not loop on the same plan across heartbeats without recording why.`;
               const settings = await taskStore.getSettings();
               if (settings.globalPause) {
                 heartbeatLog.log(`Agent ${agentId} heartbeat skipped \u2014 global pause active (source=${source})`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "global_pause", source },
                   skipStateTransition: true
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
               if (settings.enginePaused && source === "timer") {
                 heartbeatLog.log(`Agent ${agentId} timer heartbeat skipped \u2014 engine paused (soft pause)`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "engine_paused", source },
                   skipStateTransition: true
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
             } catch (pauseErr) {
               heartbeatLog.warn(`Pause status check failed for ${agentId}: ${pauseErr instanceof Error ? pauseErr.message : String(pauseErr)} \u2014 proceeding`);
@@ -77663,11 +77769,11 @@ not loop on the same plan across heartbeats without recording why.`;
             const agent = preloadedAgent ?? await this.store.getAgent(agentId);
             if (!agent) {
               heartbeatLog.warn(`Agent ${agentId} not found \u2014 completing run as failed`);
-              await this.completeRun(agentId, run.id, {
+              await this.completeRun(agentId, run2.id, {
                 status: "failed",
                 stderrExcerpt: `Agent ${agentId} not found`
               });
-              return await this.store.getRunDetail(agentId, run.id);
+              return await this.store.getRunDetail(agentId, run2.id);
             }
             const agentHasIdentity = hasAgentIdentity(agent);
             const isAgentEphemeral = isEphemeralAgent(agent);
@@ -77696,11 +77802,11 @@ not loop on the same plan across heartbeats without recording why.`;
                 }
               }
             }
-            if (taskId && run.contextSnapshot?.taskId !== taskId) {
+            if (taskId && run2.contextSnapshot?.taskId !== taskId) {
               const updatedRun = {
-                ...run,
+                ...run2,
                 contextSnapshot: {
-                  ...run.contextSnapshot ?? {},
+                  ...run2.contextSnapshot ?? {},
                   taskId
                 }
               };
@@ -77710,11 +77816,11 @@ not loop on the same plan across heartbeats without recording why.`;
             if (!taskId) {
               if (!canRunNoTaskHeartbeat) {
                 heartbeatLog.log(`Agent ${agentId} has no task assignment \u2014 graceful exit`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "no_assignment" }
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
               heartbeatLog.log(`Agent ${agentId} has no task but has identity \u2014 running no-task heartbeat`);
             }
@@ -77723,12 +77829,12 @@ not loop on the same plan across heartbeats without recording why.`;
               const validStates = ["active", "running", "idle"];
               if (!validStates.includes(agent.state)) {
                 heartbeatLog.log(`Agent ${agentId} state is "${agent.state}" \u2014 graceful exit`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "invalid_state", state: agent.state },
                   skipStateTransition: true
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
             }
             let taskDetail;
@@ -77738,11 +77844,11 @@ not loop on the same plan across heartbeats without recording why.`;
                 taskDetail = await taskStore.getTask(resolvedTaskId2);
               } catch (taskDetailErr) {
                 heartbeatLog.warn(`Task ${resolvedTaskId2} fetch failed: ${taskDetailErr instanceof Error ? taskDetailErr.message : String(taskDetailErr)} \u2014 graceful exit`);
-                await this.completeRun(agentId, run.id, {
+                await this.completeRun(agentId, run2.id, {
                   status: "completed",
                   resultJson: { reason: "task_not_found", taskId: resolvedTaskId2 }
                 });
-                return await this.store.getRunDetail(agentId, run.id);
+                return await this.store.getRunDetail(agentId, run2.id);
               }
               if (taskDetail.column === "done" || taskDetail.column === "archived") {
                 if (agent.taskId === resolvedTaskId2) {
@@ -77760,21 +77866,21 @@ not loop on the same plan across heartbeats without recording why.`;
                   taskDetail = void 0;
                   isNoTaskRun = true;
                   if (!canRunNoTaskHeartbeat) {
-                    await this.completeRun(agentId, run.id, {
+                    await this.completeRun(agentId, run2.id, {
                       status: "completed",
                       resultJson: { reason: "no_assignment" }
                     });
-                    return await this.store.getRunDetail(agentId, run.id);
+                    return await this.store.getRunDetail(agentId, run2.id);
                   }
                 } else {
                   heartbeatLog.log(
                     `Heartbeat for ${agentId} targeted terminal task ${resolvedTaskId2} (${taskDetail.column}) \u2014 graceful exit`
                   );
-                  await this.completeRun(agentId, run.id, {
+                  await this.completeRun(agentId, run2.id, {
                     status: "completed",
                     resultJson: { reason: "terminal_task", taskId: resolvedTaskId2, column: taskDetail.column }
                   });
-                  return await this.store.getRunDetail(agentId, run.id);
+                  return await this.store.getRunDetail(agentId, run2.id);
                 }
               }
               if (isNoTaskRun) {
@@ -77783,17 +77889,17 @@ not loop on the same plan across heartbeats without recording why.`;
                 const liveTaskDetail = taskDetail;
                 if (!liveTaskDetail) {
                   heartbeatLog.warn(`Task ${resolvedTaskId2} lost detail after terminal-assignment handling \u2014 graceful exit`);
-                  await this.completeRun(agentId, run.id, {
+                  await this.completeRun(agentId, run2.id, {
                     status: "completed",
                     resultJson: { reason: "task_not_found", taskId: resolvedTaskId2 }
                   });
-                  return await this.store.getRunDetail(agentId, run.id);
+                  return await this.store.getRunDetail(agentId, run2.id);
                 }
                 if (liveTaskDetail.checkedOutBy && liveTaskDetail.checkedOutBy !== agentId) {
                   heartbeatLog.warn(
                     `Agent ${agentId} does not hold checkout for ${resolvedTaskId2} (held by ${liveTaskDetail.checkedOutBy}) \u2014 graceful exit`
                   );
-                  await this.completeRun(agentId, run.id, {
+                  await this.completeRun(agentId, run2.id, {
                     status: "completed",
                     resultJson: {
                       reason: "checkout_conflict",
@@ -77801,7 +77907,7 @@ not loop on the same plan across heartbeats without recording why.`;
                       checkedOutBy: liveTaskDetail.checkedOutBy
                     }
                   });
-                  return await this.store.getRunDetail(agentId, run.id);
+                  return await this.store.getRunDetail(agentId, run2.id);
                 }
                 const blockedBy = typeof liveTaskDetail.blockedBy === "string" ? liveTaskDetail.blockedBy.trim() : "";
                 const isBlockedTask = liveTaskDetail.status === "queued" && blockedBy.length > 0;
@@ -77820,22 +77926,22 @@ not loop on the same plan across heartbeats without recording why.`;
                   };
                   const previousBlockedState = await this.store.getLastBlockedState(agentId);
                   if (previousBlockedState && isBlockedStateDuplicate(currentBlockedState, previousBlockedState)) {
-                    await this.completeRun(agentId, run.id, {
+                    await this.completeRun(agentId, run2.id, {
                       status: "completed",
                       resultJson: { reason: "blocked_duplicate", taskId: resolvedTaskId2, blockedBy }
                     });
-                    return await this.store.getRunDetail(agentId, run.id);
+                    return await this.store.getRunDetail(agentId, run2.id);
                   }
                   const blockedMessage = `Task is blocked by ${blockedBy}; waiting for dependency/context changes before retrying.`;
                   await taskStore.addComment(resolvedTaskId2, blockedMessage, "agent", void 0, runContext);
                   await audit.database({ type: "task:comment:add", target: resolvedTaskId2, metadata: { blockedBy } });
                   await this.store.setLastBlockedState(agentId, currentBlockedState);
                   heartbeatLog.log(`Task ${resolvedTaskId2} is blocked by ${blockedBy} \u2014 recorded blocked state`);
-                  await this.completeRun(agentId, run.id, {
+                  await this.completeRun(agentId, run2.id, {
                     status: "completed",
                     resultJson: { reason: "blocked", taskId: resolvedTaskId2, blockedBy }
                   });
-                  return await this.store.getRunDetail(agentId, run.id);
+                  return await this.store.getRunDetail(agentId, run2.id);
                 }
               }
             }
@@ -77930,7 +78036,7 @@ not loop on the same plan across heartbeats without recording why.`;
             heartbeatTools.push(heartbeatDoneTool);
             if (isNoTaskRun) {
               agentLogger = new AgentLogger({
-                appendLog: (entry) => this.store.appendRunLog(agentId, run.id, entry),
+                appendLog: (entry) => this.store.appendRunLog(agentId, run2.id, entry),
                 agent: agent.role,
                 persistAgentToolOutput: memorySettings?.persistAgentToolOutput
               });
@@ -77939,7 +78045,7 @@ not loop on the same plan across heartbeats without recording why.`;
                 store: taskStore,
                 taskId,
                 agent: agent.role,
-                appendLog: (entry) => this.store.appendRunLog(agentId, run.id, entry),
+                appendLog: (entry) => this.store.appendRunLog(agentId, run2.id, entry),
                 persistAgentToolOutput: memorySettings?.persistAgentToolOutput
               });
             }
@@ -77973,7 +78079,7 @@ not loop on the same plan across heartbeats without recording why.`;
               // Skill selection: use waking agent's skills (heartbeat has no role fallback)
               ...skillContext.skillSelectionContext ? { skillSelection: skillContext.skillSelectionContext } : {}
             });
-            this.trackAgent(agentId, { dispose: () => session.dispose() }, run.id);
+            this.trackAgent(agentId, { dispose: () => session.dispose() }, run2.id);
             try {
               let pendingMessages = [];
               let executionPrompt;
@@ -78137,15 +78243,15 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
               }
               try {
                 const runWithPrompts = {
-                  ...run,
+                  ...run2,
                   systemPrompt: truncatePrompt(systemPrompt, 1e5),
                   executionPrompt: truncatePrompt(executionPrompt, 1e5),
                   heartbeatProcedureSource: customProcedure ? "custom" : "default"
                 };
                 await this.store.saveRun(runWithPrompts);
-                Object.assign(run, { systemPrompt: runWithPrompts.systemPrompt, executionPrompt: runWithPrompts.executionPrompt, heartbeatProcedureSource: runWithPrompts.heartbeatProcedureSource });
+                Object.assign(run2, { systemPrompt: runWithPrompts.systemPrompt, executionPrompt: runWithPrompts.executionPrompt, heartbeatProcedureSource: runWithPrompts.heartbeatProcedureSource });
               } catch (promptPersistErr) {
-                heartbeatLog.warn(`Failed to persist prompts for ${agentId}/${run.id}: ${promptPersistErr instanceof Error ? promptPersistErr.message : String(promptPersistErr)}`);
+                heartbeatLog.warn(`Failed to persist prompts for ${agentId}/${run2.id}: ${promptPersistErr instanceof Error ? promptPersistErr.message : String(promptPersistErr)}`);
               }
               await promptWithFallback(session, executionPrompt);
               let usageInput = 0;
@@ -78189,7 +78295,7 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
                 completionResultJson.priority = inboxSelection.priority;
                 completionResultJson.taskId = taskId;
               }
-              await this.completeRun(agentId, run.id, {
+              await this.completeRun(agentId, run2.id, {
                 status: "completed",
                 usageJson: { inputTokens: usageInput, outputTokens: usageOutput, cachedTokens: usageCached },
                 resultJson: completionResultJson,
@@ -78200,7 +78306,7 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
               const errorDetail = formatError(err).detail;
               heartbeatLog.error(`Heartbeat execution failed for ${agentId}: ${errorDetail}`);
               await flushAgentLogger();
-              await this.completeRun(agentId, run.id, {
+              await this.completeRun(agentId, run2.id, {
                 status: "failed",
                 stderrExcerpt: errorDetail,
                 stdoutExcerpt: stdoutExcerpt || void 0
@@ -78219,22 +78325,22 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
                 heartbeatLog.warn(`session.dispose() failed for ${agentId}: ${errorMessage}`);
               }
             }
-            return await this.store.getRunDetail(agentId, run.id);
+            return await this.store.getRunDetail(agentId, run2.id);
           } catch (err) {
             const errorDetail = formatError(err).detail;
             const errorMessage = err instanceof Error ? err.message : String(err);
             heartbeatLog.error(`Heartbeat execution error for ${agentId}: ${errorDetail}`);
             await flushAgentLogger();
             try {
-              await this.completeRun(agentId, run.id, {
+              await this.completeRun(agentId, run2.id, {
                 status: "failed",
                 stderrExcerpt: errorDetail
               });
             } catch (completeRunErr) {
               const completeRunErrMsg = completeRunErr instanceof Error ? completeRunErr.message : String(completeRunErr);
-              heartbeatLog.error(`completeRun failed for ${agentId}/${run.id}: ${completeRunErrMsg} \u2014 attempting safety-net completion`);
+              heartbeatLog.error(`completeRun failed for ${agentId}/${run2.id}: ${completeRunErrMsg} \u2014 attempting safety-net completion`);
               try {
-                const runDetail = await this.store.getRunDetail(agentId, run.id);
+                const runDetail = await this.store.getRunDetail(agentId, run2.id);
                 if (runDetail && runDetail.status !== "completed" && runDetail.status !== "failed" && runDetail.status !== "terminated") {
                   await this.store.saveRun({
                     ...runDetail,
@@ -78242,16 +78348,16 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
                     status: "failed",
                     stderrExcerpt: `Heartbeat execution failed: ${errorMessage}. Run completion also failed: ${completeRunErrMsg}`
                   });
-                  await this.store.endHeartbeatRun(run.id, "terminated");
+                  await this.store.endHeartbeatRun(run2.id, "terminated");
                   this.clearRunState(agentId);
-                  heartbeatLog.log(`Safety-net run completion for ${agentId}/${run.id} \u2014 run terminated`);
+                  heartbeatLog.log(`Safety-net run completion for ${agentId}/${run2.id} \u2014 run terminated`);
                 }
               } catch (safetyNetErr) {
                 const safetyNetErrMsg = safetyNetErr instanceof Error ? safetyNetErr.message : String(safetyNetErr);
-                heartbeatLog.error(`Safety-net run completion also failed for ${agentId}/${run.id}: ${safetyNetErrMsg} \u2014 run may be stuck permanently`);
+                heartbeatLog.error(`Safety-net run completion also failed for ${agentId}/${run2.id}: ${safetyNetErrMsg} \u2014 run may be stuck permanently`);
               }
             }
-            return await this.store.getRunDetail(agentId, run.id);
+            return await this.store.getRunDetail(agentId, run2.id);
           }
         });
       }
@@ -79988,7 +80094,7 @@ var init_routine_runner = __esm({
         return Boolean(routine.steps && routine.steps.length > 0 || routine.command?.trim());
       }
       async executeAgentRoutine(routine, triggerType, context) {
-        const run = await this.options.heartbeatMonitor.executeHeartbeat({
+        const run2 = await this.options.heartbeatMonitor.executeHeartbeat({
           agentId: routine.agentId,
           source: "routine",
           triggerDetail: `routine:${routine.id}:${triggerType}`,
@@ -79999,8 +80105,8 @@ var init_routine_runner = __esm({
             ...context
           }
         });
-        if (run.status === "failed" || run.status === "terminated") {
-          const error = run.stderrExcerpt || `Run ${run.status}`;
+        if (run2.status === "failed" || run2.status === "terminated") {
+          const error = run2.stderrExcerpt || `Run ${run2.status}`;
           return {
             success: false,
             output: error,
@@ -80011,7 +80117,7 @@ var init_routine_runner = __esm({
         }
         return {
           success: true,
-          output: run.resultJson ? JSON.stringify(run.resultJson) : "Routine completed successfully",
+          output: run2.resultJson ? JSON.stringify(run2.resultJson) : "Routine completed successfully",
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           completedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -80794,14 +80900,15 @@ var init_self_healing = __esm({
     execAsync7 = promisify9(exec9);
     APPROVED_TRIAGE_RECOVERY_GRACE_MS = 6e4;
     ORPHANED_EXECUTION_RECOVERY_GRACE_MS = 6e4;
-    ACTIVE_MERGE_STATUSES = /* @__PURE__ */ new Set(["merging", "merging-pr"]);
+    ACTIVE_MERGE_STATUSES = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix"]);
     NON_TERMINAL_STEP_STATUSES2 = /* @__PURE__ */ new Set(["pending", "in-progress"]);
     GHOST_REVIEW_PRESERVED_STATUSES = /* @__PURE__ */ new Set([
       "failed",
       "awaiting-user-review",
       "awaiting-approval",
       "merging",
-      "merging-pr"
+      "merging-pr",
+      "merging-fix"
     ]);
     ORPHANED_WITH_WORKTREE_GRACE_MS = 3e5;
     MAX_TASK_DONE_RETRIES = 3;
@@ -81524,7 +81631,7 @@ var init_self_healing = __esm({
        *
        * Preserved statuses (skipped):
        * - `awaiting-user-review`, `awaiting-approval`: explicit human handoff
-       * - `merging`, `merging-pr`: handled by `recoverInterruptedMergingTasks`
+       * - `merging`, `merging-pr`, `merging-fix`: handled by `recoverInterruptedMergingTasks`
        *
        * Rate-limiting comes from the `updatedAt >= taskStuckTimeoutMs` gate —
        * each kick refreshes `updatedAt`, so a task that re-enters review and gets
@@ -87140,7 +87247,7 @@ ${detail}`
                     "agent"
                   );
                   await store.updateTask(taskId, {
-                    status: null,
+                    status: "merging-fix",
                     mergeRetries: 0,
                     error: null,
                     verificationFailureCount: nextBounces
@@ -87148,10 +87255,10 @@ ${detail}`
                   await store.moveTask(taskId, "in-progress");
                   await store.logEntry(
                     taskId,
-                    `Deterministic ${failedKind} verification failed (${nextBounces}/${cap}) \u2014 moved back to in-progress for remediation`
+                    `Deterministic ${failedKind} verification failed (${nextBounces}/${cap}) \u2014 moved back to in-progress with status=merging-fix for remediation`
                   );
                   runtimeLog.log(
-                    `Auto-merge: ${taskId} deterministic ${failedKind} verification failed (${nextBounces}/${cap}) \u2014 moved to in-progress`
+                    `Auto-merge: ${taskId} deterministic ${failedKind} verification failed (${nextBounces}/${cap}) \u2014 moved to in-progress with status=merging-fix`
                   );
                 } catch {
                   runtimeLog.error(
@@ -94297,9 +94404,22 @@ function registerTaskWorkflowRoutes(ctx, deps) {
       const { store: scopedStore } = await getProjectContext3(req);
       const task = await scopedStore.getTask(req.params.id);
       const retrySpecification = task.column === "triage" && (task.status === "failed" || task.status === "planning" || task.status === "needs-replan" || (task.stuckKillCount ?? 0) > 0);
+      const isInReviewRetry = task.column === "in-review" && (task.status === "failed" || task.status === "stuck-killed");
       if (task.status !== "failed" && task.status !== "stuck-killed" && !retrySpecification) {
         throw badRequest(`Task is not in a retryable state (current status: ${task.status || "none"})`);
       }
+      if (isInReviewRetry) {
+        await scopedStore.updateTask(req.params.id, {
+          status: null,
+          error: null,
+          stuckKillCount: 0,
+          mergeRetries: 0
+        });
+        await scopedStore.logEntry(req.params.id, "Retry requested from dashboard (in-review retry, mergeRetries reset)");
+        const updated2 = await scopedStore.getTask(req.params.id);
+        res.json(updated2);
+        return;
+      }
       await scopedStore.updateTask(req.params.id, {
         status: retrySpecification ? "needs-replan" : null,
         error: null,
@@ -94722,8 +94842,12 @@ function registerTaskWorkflowRoutes(ctx, deps) {
   router.post("/tasks/:id/pause", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext3(req);
-      const task = await scopedStore.pauseTask(req.params.id, true);
-      res.json(task);
+      const task = await scopedStore.getTask(req.params.id);
+      if (task.assignedAgentId) {
+        throw conflict(`Cannot manually pause/unpause task assigned to agent ${task.assignedAgentId}. Use agent pause controls instead.`);
+      }
+      const updated = await scopedStore.pauseTask(req.params.id, true);
+      res.json(updated);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -94734,8 +94858,12 @@ function registerTaskWorkflowRoutes(ctx, deps) {
   router.post("/tasks/:id/unpause", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext3(req);
-      const task = await scopedStore.pauseTask(req.params.id, false);
-      res.json(task);
+      const task = await scopedStore.getTask(req.params.id);
+      if (task.assignedAgentId) {
+        throw conflict(`Cannot manually pause/unpause task assigned to agent ${task.assignedAgentId}. Use agent pause controls instead.`);
+      }
+      const updated = await scopedStore.pauseTask(req.params.id, false);
+      res.json(updated);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -111900,8 +112028,8 @@ function auto(tasks, concurrency, callback) {
       return callback(null, results);
     }
     while (readyTasks.length && runningTasks < concurrency) {
-      var run = readyTasks.shift();
-      run();
+      var run2 = readyTasks.shift();
+      run2();
     }
   }
   function addListener(taskName, fn) {
@@ -136929,7 +137057,7 @@ var init_register_project_routes = __esm({
     } = fsPromises);
     registerProjectRoutes = (ctx) => {
       const { router, options, runtimeLogger, prioritizeProjectsForCurrentDirectory, rethrowAsApiError: rethrowAsApiError8 } = ctx;
-      async function withCentralCore(run, onError) {
+      async function withCentralCore(run2, onError) {
         const sharedCentral = options?.centralCore;
         const shouldClose = !sharedCentral;
         const central = sharedCentral ?? new (await Promise.resolve().then(() => (init_src(), src_exports))).CentralCore();
@@ -136937,7 +137065,7 @@ var init_register_project_routes = __esm({
           if (!sharedCentral || typeof central.isInitialized === "function" && !central.isInitialized()) {
             await central.init();
           }
-          return await run(central);
+          return await run2(central);
         } catch (error) {
           if (onError) {
             return await onError(error);
@@ -137674,6 +137802,32 @@ function sanitizeExtraClis(input) {
   }
   return input;
 }
+function toManagedDockerNodeInfo(managedNode, linkedNode) {
+  return {
+    ...managedNode,
+    hostConfig: {
+      type: managedNode.hostConfig.host || managedNode.hostConfig.context ? "remote" : "local",
+      host: managedNode.hostConfig.host,
+      context: managedNode.hostConfig.context,
+      tlsOptions: {
+        tlsVerify: managedNode.hostConfig.tlsVerify,
+        tlsCaPath: managedNode.hostConfig.tlsCaPath,
+        tlsCertPath: managedNode.hostConfig.tlsCertPath,
+        tlsKeyPath: managedNode.hostConfig.tlsKeyPath
+      }
+    },
+    volumeMounts: managedNode.volumeMounts.map((mount) => ({
+      hostPath: mount.hostPath,
+      containerPath: mount.containerPath,
+      readOnly: mount.mode === "ro" ? true : void 0
+    })),
+    resourceSizing: {
+      cpuLimit: managedNode.resourceSizing?.cpus !== void 0 ? String(managedNode.resourceSizing.cpus) : void 0,
+      memoryLimit: managedNode.resourceSizing?.memoryMB !== void 0 ? `${managedNode.resourceSizing.memoryMB}MB` : void 0
+    },
+    linkedNode: linkedNode ?? void 0
+  };
+}
 var VALID_EXTRA_CLIS, registerDockerNodeRoutes;
 var init_register_docker_node_routes = __esm({
   "../dashboard/src/routes/register-docker-node-routes.ts"() {
@@ -137722,6 +137876,126 @@ var init_register_docker_node_routes = __esm({
           res.json({ available: false, error: message });
         }
       });
+      router.get("/docker/nodes", async (_req, res) => {
+        try {
+          const { CentralCore: CentralCore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+          const central = new CentralCore2();
+          await central.init();
+          try {
+            const nodes = await central.listManagedDockerNodes();
+            const enriched = await Promise.all(nodes.map(async (managedNode) => {
+              const linkedNode = managedNode.nodeId ? await central.getNode(managedNode.nodeId) : void 0;
+              return toManagedDockerNodeInfo(managedNode, linkedNode);
+            }));
+            enriched.sort((a, b) => (a.name ?? "").localeCompare(b.name ?? ""));
+            res.json(enriched);
+          } finally {
+            await central.close();
+          }
+        } catch (error) {
+          if (error instanceof ApiError) {
+            throw error;
+          }
+          rethrowAsApiError8(error);
+        }
+      });
+      router.get("/docker/nodes/:managedId/container-status", async (req, res) => {
+        try {
+          const { CentralCore: CentralCore2, DockerClientService: DockerClientService2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+          const central = new CentralCore2();
+          await central.init();
+          try {
+            const managedNode = await central.getManagedDockerNode(req.params.managedId);
+            if (!managedNode) {
+              throw notFound("Managed Docker node not found");
+            }
+            if (!managedNode.containerId) {
+              throw badRequest(`Node has no container yet (status: ${managedNode.status})`);
+            }
+            try {
+              const dockerService = new DockerClientService2(managedNode.hostConfig);
+              const info = await dockerService.getContainerInfo(managedNode.containerId, managedNode.hostConfig);
+              if (!info) {
+                throw notFound("Container not found");
+              }
+              res.json({
+                running: info.state.running,
+                status: info.status,
+                startedAt: info.state.startedAt,
+                finishedAt: info.state.finishedAt,
+                exitCode: info.state.exitCode,
+                error: info.state.error,
+                ports: info.ports
+              });
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              res.status(503).json({ error: `Docker unreachable: ${message}` });
+            }
+          } finally {
+            await central.close();
+          }
+        } catch (error) {
+          if (error instanceof ApiError) {
+            throw error;
+          }
+          rethrowAsApiError8(error);
+        }
+      });
+      router.get("/docker/nodes/:managedId/logs", async (req, res) => {
+        try {
+          const { CentralCore: CentralCore2, DockerClientService: DockerClientService2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+          const central = new CentralCore2();
+          await central.init();
+          try {
+            const managedNode = await central.getManagedDockerNode(req.params.managedId);
+            if (!managedNode) {
+              throw notFound("Managed Docker node not found");
+            }
+            if (!managedNode.containerId) {
+              throw badRequest(`Node has no container yet (status: ${managedNode.status})`);
+            }
+            const tailValue = Number(req.query.tail ?? 100);
+            const tail = Number.isFinite(tailValue) ? Math.max(1, Math.min(1e3, Math.floor(tailValue))) : 100;
+            try {
+              const dockerService = new DockerClientService2(managedNode.hostConfig);
+              const logs = await dockerService.getContainerLogs(managedNode.containerId, managedNode.hostConfig, { tail });
+              res.json({ logs });
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              res.status(503).json({ error: `Docker unreachable: ${message}` });
+            }
+          } finally {
+            await central.close();
+          }
+        } catch (error) {
+          if (error instanceof ApiError) {
+            throw error;
+          }
+          rethrowAsApiError8(error);
+        }
+      });
+      router.get("/docker/nodes/:managedId", async (req, res) => {
+        try {
+          const { CentralCore: CentralCore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+          const central = new CentralCore2();
+          await central.init();
+          try {
+            const node = await central.getManagedDockerNode(req.params.managedId);
+            if (!node) {
+              throw notFound("Managed Docker node not found");
+            }
+            const linkedNode = node.nodeId ? await central.getNode(node.nodeId) : void 0;
+            res.json(toManagedDockerNodeInfo(node, linkedNode));
+          } finally {
+            await central.close();
+          }
+        } catch (error) {
+          if (error instanceof ApiError) {
+            throw error;
+          }
+          rethrowAsApiError8(error);
+        }
+      });
       router.get("/docker-nodes", async (_req, res) => {
         try {
           const { CentralCore: CentralCore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -139578,6 +139852,7 @@ function registerAgentRuntimeRoutes(ctx, deps) {
     hasHeartbeatExecutor,
     heartbeatMonitor,
     isHeartbeatMonitorForProject,
+    resolveHeartbeatMonitor,
     runExcerptToAgentLogs: runExcerptToAgentLogs2,
     parseRunAuditFilters: parseRunAuditFilters2,
     normalizeRunAuditEvent: normalizeRunAuditEvent2,
@@ -139873,6 +140148,33 @@ function registerAgentRuntimeRoutes(ctx, deps) {
               }
             }
           }
+          if (nextState === "paused") {
+            const assignedTasks = await scopedStore.getTasksByAssignedAgent(agentId, { excludeArchived: true });
+            const toPause = assignedTasks.filter((task) => task.paused !== true);
+            const results = await Promise.allSettled(
+              toPause.map((task) => scopedStore.pauseTask(task.id, true, void 0, { pausedByAgentId: agentId }))
+            );
+            results.forEach((result, index2) => {
+              if (result.status === "rejected") {
+                console.error(`[agent-state] failed to pause assigned task ${toPause[index2]?.id} for ${agentId}:`, result.reason);
+              }
+            });
+          }
+          if (nextState === "active" || nextState === "terminated") {
+            const pausedTasks = await scopedStore.getTasksByAssignedAgent(agentId, {
+              pausedOnly: true,
+              excludeArchived: true
+            });
+            const toUnpause = pausedTasks.filter((task) => task.pausedByAgentId === agentId);
+            const results = await Promise.allSettled(
+              toUnpause.map((task) => scopedStore.pauseTask(task.id, false))
+            );
+            results.forEach((result, index2) => {
+              if (result.status === "rejected") {
+                console.error(`[agent-state] failed to unpause assigned task ${toUnpause[index2]?.id} for ${agentId}:`, result.reason);
+              }
+            });
+          }
           const isHeartbeatEnabled = currentAgent.runtimeConfig?.enabled !== false;
           if (nextState === "active" && isHeartbeatEnabled && projectHeartbeatMonitor) {
             await projectHeartbeatMonitor.executeHeartbeat({
@@ -140140,19 +140442,22 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
       const event = await agentStore.recordHeartbeat(req.params.id, status);
-      let run;
-      if (triggerExecution && hasHeartbeatExecutor && heartbeatMonitor && isHeartbeatMonitorForProject(scopedStore)) {
-        run = await heartbeatMonitor.executeHeartbeat({
-          agentId: req.params.id,
-          source: "on_demand",
-          triggerDetail: "Triggered from heartbeat",
-          contextSnapshot: {
-            wakeReason: "on_demand",
-            triggerDetail: "Triggered from heartbeat"
-          }
-        });
+      let run2;
+      if (triggerExecution && hasHeartbeatExecutor && heartbeatMonitor) {
+        const resolvedMonitor = isHeartbeatMonitorForProject(scopedStore) ? heartbeatMonitor : resolveHeartbeatMonitor(scopedStore);
+        if (resolvedMonitor) {
+          run2 = await resolvedMonitor.executeHeartbeat({
+            agentId: req.params.id,
+            source: "on_demand",
+            triggerDetail: "Triggered from heartbeat",
+            contextSnapshot: {
+              wakeReason: "on_demand",
+              triggerDetail: "Triggered from heartbeat"
+            }
+          });
+        }
       }
-      res.json(run ? { event, run } : event);
+      res.json(run2 ? { event, run: run2 } : event);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -140230,8 +140535,9 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       }
       if (hasHeartbeatExecutor && heartbeatMonitor) {
         const { store: scopedStore } = await getProjectContext3(req);
-        if (!isHeartbeatMonitorForProject(scopedStore)) {
-          throw new ApiError(400, "Agent execution is only available for the server's primary project. The heartbeat monitor is not bound to this project.");
+        const resolvedMonitor = isHeartbeatMonitorForProject(scopedStore) ? heartbeatMonitor : resolveHeartbeatMonitor(scopedStore);
+        if (!resolvedMonitor) {
+          throw new ApiError(400, "No heartbeat executor available for this project.");
         }
         const { AgentStore: AgentStoreClass } = await Promise.resolve().then(() => (init_src(), src_exports));
         const agentStore = new AgentStoreClass({ rootDir: scopedStore.getFusionDir() });
@@ -140244,7 +140550,7 @@ function registerAgentRuntimeRoutes(ctx, deps) {
         if (activeRun) {
           throw new ApiError(409, "Agent already has an active run", { runId: activeRun.id });
         }
-        const run = await heartbeatMonitor.executeHeartbeat({
+        const run2 = await resolvedMonitor.executeHeartbeat({
           agentId: req.params.id,
           source: invocationSource,
           triggerDetail: trigger,
@@ -140253,7 +140559,7 @@ function registerAgentRuntimeRoutes(ctx, deps) {
           triggeringCommentType: normalizedTriggeringCommentType,
           contextSnapshot
         });
-        res.status(201).json(run);
+        res.status(201).json(run2);
       } else {
         const { store: scopedStore } = await getProjectContext3(req);
         const { AgentStore: AgentStore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -140267,12 +140573,12 @@ function registerAgentRuntimeRoutes(ctx, deps) {
         if (activeRun) {
           throw new ApiError(409, "Agent already has an active run", { runId: activeRun.id });
         }
-        const run = await agentStore.startHeartbeatRun(req.params.id);
-        run.invocationSource = invocationSource;
-        run.triggerDetail = trigger;
-        run.contextSnapshot = contextSnapshot;
-        await agentStore.saveRun(run);
-        res.status(201).json(run);
+        const run2 = await agentStore.startHeartbeatRun(req.params.id);
+        run2.invocationSource = invocationSource;
+        run2.triggerDetail = trigger;
+        run2.contextSnapshot = contextSnapshot;
+        await agentStore.saveRun(run2);
+        res.status(201).json(run2);
       }
     } catch (err) {
       if (err instanceof ApiError) {
@@ -140300,8 +140606,26 @@ function registerAgentRuntimeRoutes(ctx, deps) {
         res.status(200).json({ ok: true, message: "No active run" });
         return;
       }
-      if (hasHeartbeatExecutor && heartbeatMonitor && isHeartbeatMonitorForProject(scopedStore)) {
-        await heartbeatMonitor.stopRun(req.params.id);
+      if (hasHeartbeatExecutor && heartbeatMonitor) {
+        const resolvedMonitor = isHeartbeatMonitorForProject(scopedStore) ? heartbeatMonitor : resolveHeartbeatMonitor(scopedStore);
+        if (resolvedMonitor) {
+          await resolvedMonitor.stopRun(req.params.id);
+        } else {
+          const existingRun = await agentStore.getRunDetail(req.params.id, activeRun.id);
+          if (existingRun) {
+            await agentStore.saveRun({
+              ...existingRun,
+              endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              status: "terminated",
+              stderrExcerpt: existingRun.stderrExcerpt ?? "Run stopped by user"
+            });
+          }
+          await agentStore.endHeartbeatRun(activeRun.id, "terminated");
+          try {
+            await agentStore.updateAgentState(req.params.id, "active");
+          } catch {
+          }
+        }
       } else {
         const existingRun = await agentStore.getRunDetail(req.params.id, activeRun.id);
         if (existingRun) {
@@ -140335,11 +140659,11 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       const { AgentStore: AgentStore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
-      const run = await agentStore.getRunDetail(req.params.id, req.params.runId);
-      if (!run) {
+      const run2 = await agentStore.getRunDetail(req.params.id, req.params.runId);
+      if (!run2) {
         throw notFound("Run not found");
       }
-      res.json(run);
+      res.json(run2);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -140357,8 +140681,8 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       const { AgentStore: AgentStore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
-      const run = await agentStore.getRunDetail(req.params.id, req.params.runId);
-      if (!run) {
+      const run2 = await agentStore.getRunDetail(req.params.id, req.params.runId);
+      if (!run2) {
         throw notFound("Run not found");
       }
       const runLogs = await agentStore.getRunLogs(req.params.id, req.params.runId);
@@ -140366,17 +140690,17 @@ function registerAgentRuntimeRoutes(ctx, deps) {
         res.json(runLogs);
         return;
       }
-      const taskId = run.contextSnapshot?.taskId;
+      const taskId = run2.contextSnapshot?.taskId;
       if (!taskId) {
-        res.json(runExcerptToAgentLogs2(run));
+        res.json(runExcerptToAgentLogs2(run2));
         return;
       }
       const logs = await scopedStore.getAgentLogsByTimeRange(
         taskId,
-        run.startedAt,
-        run.endedAt
+        run2.startedAt,
+        run2.endedAt
       );
-      res.json(logs.length > 0 ? logs : runExcerptToAgentLogs2(run));
+      res.json(logs.length > 0 ? logs : runExcerptToAgentLogs2(run2));
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -140394,8 +140718,8 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       const { AgentStore: AgentStore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
-      const run = await agentStore.getRunDetail(req.params.id, req.params.runId);
-      if (!run) {
+      const run2 = await agentStore.getRunDetail(req.params.id, req.params.runId);
+      if (!run2) {
         throw notFound("Run not found");
       }
       const mutations = await scopedStore.getMutationsForRun(req.params.runId);
@@ -140421,8 +140745,8 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       if (!runId || runId.trim().length === 0) {
         throw badRequest("runId is required");
       }
-      const run = await agentStore.getRunDetail(req.params.id, req.params.runId);
-      if (!run) {
+      const run2 = await agentStore.getRunDetail(req.params.id, req.params.runId);
+      if (!run2) {
         throw notFound("Run not found");
       }
       const filters = parseRunAuditFilters2(req.query);
@@ -140476,8 +140800,8 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       if (!runId || runId.trim().length === 0) {
         throw badRequest("runId is required");
       }
-      const run = await agentStore.getRunDetail(req.params.id, req.params.runId);
-      if (!run) {
+      const run2 = await agentStore.getRunDetail(req.params.id, req.params.runId);
+      if (!run2) {
         throw notFound("Run not found");
       }
       const filters = parseRunAuditFilters2(req.query);
@@ -140492,7 +140816,7 @@ function registerAgentRuntimeRoutes(ctx, deps) {
         }
         return true;
       })();
-      const auditTaskId = filters.taskId ?? run.contextSnapshot?.taskId ?? void 0;
+      const auditTaskId = filters.taskId ?? run2.contextSnapshot?.taskId ?? void 0;
       const auditEvents = scopedStore.getRunAuditEvents({
         runId: req.params.runId,
         taskId: auditTaskId,
@@ -140520,13 +140844,13 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       for (const event of auditEvents) {
         timelineEntries.push(auditEventToTimelineEntry2(event));
       }
-      if (includeLogs && run.startedAt) {
+      if (includeLogs && run2.startedAt) {
         const taskId = auditTaskId;
         if (taskId) {
           const logs = await scopedStore.getAgentLogsByTimeRange(
             taskId,
-            run.startedAt,
-            run.endedAt
+            run2.startedAt,
+            run2.endedAt
           );
           for (const log19 of logs) {
             timelineEntries.push(logEntryToTimelineEntry2(log19));
@@ -140536,11 +140860,11 @@ function registerAgentRuntimeRoutes(ctx, deps) {
       timelineEntries.sort(compareTimelineEntries2);
       const response = {
         run: {
-          id: run.id,
-          agentId: run.agentId,
-          startedAt: run.startedAt,
-          endedAt: run.endedAt ?? void 0,
-          status: run.status,
+          id: run2.id,
+          agentId: run2.agentId,
+          startedAt: run2.startedAt,
+          endedAt: run2.endedAt ?? void 0,
+          status: run2.status,
           taskId: auditTaskId ?? void 0
         },
         auditByDomain,
@@ -140548,8 +140872,8 @@ function registerAgentRuntimeRoutes(ctx, deps) {
           auditEvents: normalizedAuditEvents.length,
           logEntries: includeLogs && auditTaskId ? (await scopedStore.getAgentLogsByTimeRange(
             auditTaskId,
-            run.startedAt,
-            run.endedAt
+            run2.startedAt,
+            run2.endedAt
           )).length : 0
         },
         timeline: timelineEntries
@@ -144457,96 +144781,70 @@ var init_claude_cli_probe = __esm({
   }
 });
 
-// ../dashboard/src/droid-cli-probe.ts
+// ../../plugins/fusion-plugin-droid-runtime/dist/probe.js
 import { spawn as spawn13 } from "node:child_process";
-async function probeDroidCli(options = {}) {
-  const startedAt = Date.now();
-  const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS2;
-  const binaryPath = await tryResolveBinaryPath4("droid");
-  return new Promise((resolvePromise) => {
-    const finish = (result) => {
-      resolvePromise({ ...result, probeDurationMs: Date.now() - startedAt });
-    };
-    let settled = false;
-    const child = spawn13(binaryPath ?? "droid", ["--version"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
+async function run(binary, args, timeoutMs = 2e3) {
+  return new Promise((resolve44) => {
+    const child = spawn13(binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
     const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
       try {
         child.kill("SIGKILL");
       } catch {
       }
-      finish({
-        available: false,
-        binaryPath,
-        reason: `Probe timed out after ${timeoutMs}ms`
-      });
+      resolve44({ code: 124, stdout, stderr });
     }, timeoutMs);
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString("utf-8");
+    child.stdout?.on("data", (c) => {
+      stdout += c.toString("utf-8");
     });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString("utf-8");
+    child.stderr?.on("data", (c) => {
+      stderr += c.toString("utf-8");
     });
-    child.on("error", (err) => {
-      if (settled) return;
-      settled = true;
+    child.on("error", () => {
       clearTimeout(timer);
-      const isNotFound = err.code === "ENOENT";
-      finish({
-        available: false,
-        binaryPath,
-        reason: isNotFound ? "`droid` not found on PATH" : err.message
-      });
+      resolve44({ code: 127, stdout, stderr });
     });
     child.on("close", (code) => {
-      if (settled) return;
-      settled = true;
       clearTimeout(timer);
-      if (code === 0) {
-        finish({
-          available: true,
-          version: stdout.trim() || void 0,
-          binaryPath
-        });
-      } else {
-        finish({
-          available: false,
-          binaryPath,
-          reason: stderr.trim() || `droid --version exited with code ${String(code)}`
-        });
-      }
+      resolve44({ code, stdout, stderr });
     });
   });
 }
-async function tryResolveBinaryPath4(binary) {
-  return new Promise((resolvePromise) => {
-    const which = process.platform === "win32" ? "where" : "which";
-    const child = spawn13(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
-    let out = "";
-    child.stdout?.on("data", (chunk) => {
-      out += chunk.toString("utf-8");
-    });
-    child.on("error", () => resolvePromise(void 0));
-    child.on("close", (code) => {
-      if (code === 0) {
-        const first = out.trim().split(/\r?\n/)[0];
-        resolvePromise(first?.length ? first : void 0);
-      } else {
-        resolvePromise(void 0);
-      }
-    });
-  });
+async function probeDroidBinary(options) {
+  const startedAt = Date.now();
+  const binaryPath = options?.binaryPath?.trim() || "droid";
+  const timeoutMs = options?.timeoutMs ?? 2e3;
+  const versionRun = await run(binaryPath, ["--version"], timeoutMs);
+  if (versionRun.code !== 0) {
+    return {
+      available: false,
+      binaryPath,
+      reason: versionRun.code === 124 ? `Probe timed out after ${timeoutMs}ms` : "`droid` not found on PATH",
+      probeDurationMs: Date.now() - startedAt
+    };
+  }
+  return {
+    available: true,
+    binaryPath,
+    version: versionRun.stdout.trim() || void 0,
+    probeDurationMs: Date.now() - startedAt
+  };
+}
+var init_probe3 = __esm({
+  "../../plugins/fusion-plugin-droid-runtime/dist/probe.js"() {
+    "use strict";
+  }
+});
+
+// ../dashboard/src/droid-cli-probe.ts
+async function probeDroidCli(options = {}) {
+  return probeDroidBinary({ timeoutMs: options.timeoutMs });
 }
-var PROBE_TIMEOUT_MS2;
 var init_droid_cli_probe = __esm({
   "../dashboard/src/droid-cli-probe.ts"() {
     "use strict";
-    PROBE_TIMEOUT_MS2 = 2e3;
+    init_probe3();
   }
 });
 
@@ -148050,24 +148348,24 @@ function createMissionRouter(store, missionAutopilot, aiSessionStore, missionExe
       const validationRounds = [];
       for (const feature of allFeatures) {
         const runs = missionStore.getValidatorRunsByFeature(feature.id);
-        for (const run of runs) {
+        for (const run2 of runs) {
           let failedAssertionIds = [];
-          if (run.status === "failed") {
-            failedAssertionIds = missionStore.getFailuresForRun(run.id).map((failure) => failure.assertionId);
-            failedAssertionIdsByRunId.set(run.id, failedAssertionIds);
+          if (run2.status === "failed") {
+            failedAssertionIds = missionStore.getFailuresForRun(run2.id).map((failure) => failure.assertionId);
+            failedAssertionIdsByRunId.set(run2.id, failedAssertionIds);
           }
           validationRounds.push({
-            roundId: run.id,
-            featureId: run.featureId,
+            roundId: run2.id,
+            featureId: run2.featureId,
             featureTitle: feature.title,
-            validatorStatus: run.status,
-            implementationAttempt: run.implementationAttempt,
-            validatorAttempt: run.validatorAttempt,
+            validatorStatus: run2.status,
+            implementationAttempt: run2.implementationAttempt,
+            validatorAttempt: run2.validatorAttempt,
             failedAssertionIds,
-            generatedFixFeatureIds: generatedFixFeatureIdsByRunId.get(run.id) ?? [],
-            blockedReason: run.blockedReason,
-            startedAt: run.startedAt,
-            completedAt: run.completedAt
+            generatedFixFeatureIds: generatedFixFeatureIdsByRunId.get(run2.id) ?? [],
+            blockedReason: run2.blockedReason,
+            startedAt: run2.startedAt,
+            completedAt: run2.completedAt
           });
         }
       }
@@ -148130,15 +148428,15 @@ function createMissionRouter(store, missionAutopilot, aiSessionStore, missionExe
       missionStore.updateFeature(featureId, {
         loopState: "validating"
       });
-      const run = missionStore.startValidatorRun(featureId, "manual");
+      const run2 = missionStore.startValidatorRun(featureId, "manual");
       res.status(202).json({
-        runId: run.id,
-        featureId: run.featureId,
-        status: run.status,
-        triggerType: run.triggerType,
-        implementationAttempt: run.implementationAttempt,
-        validatorAttempt: run.validatorAttempt,
-        startedAt: run.startedAt
+        runId: run2.id,
+        featureId: run2.featureId,
+        status: run2.status,
+        triggerType: run2.triggerType,
+        implementationAttempt: run2.implementationAttempt,
+        validatorAttempt: run2.validatorAttempt,
+        startedAt: run2.startedAt
       });
     })
   );
@@ -148188,13 +148486,13 @@ function createMissionRouter(store, missionAutopilot, aiSessionStore, missionExe
       if (!runId || typeof runId !== "string") {
         throw badRequest("Run ID is required");
       }
-      const run = missionStore.getValidatorRun(runId);
-      if (!run) {
+      const run2 = missionStore.getValidatorRun(runId);
+      if (!run2) {
         throw notFound("Validator run not found");
       }
       const failures = missionStore.getFailuresForRun(runId);
       res.json({
-        ...run,
+        ...run2,
         failures
       });
     })
@@ -150353,7 +150651,7 @@ function createInsightsRouter(store) {
       if (!taskStore) throw new ApiError(500, "Store context not available");
       const rootDir = taskStore.getRootDir();
       const controller = new AbortController();
-      const run = await executeInsightRunLifecycle({
+      const run2 = await executeInsightRunLifecycle({
         store: insightStore,
         projectId,
         input: {
@@ -150364,19 +150662,19 @@ function createInsightsRouter(store) {
         timeoutMs: typeof req.body.timeoutMs === "number" ? req.body.timeoutMs : 12e4,
         maxAttempts: 2,
         retryDelayMs: 250,
-        executeAttempt: async ({ run: run2, signal }) => {
-          activeRunControllers.set(run2.id, controller);
+        executeAttempt: async ({ run: run3, signal }) => {
+          activeRunControllers.set(run3.id, controller);
           return executeInsightAttempt({
             rootDir,
             projectId,
-            runId: run2.id,
+            runId: run3.id,
             signal,
             insightStore
           });
         }
       });
-      activeRunControllers.delete(run.id);
-      res.status(201).json(run);
+      activeRunControllers.delete(run2.id);
+      res.status(201).json(run2);
     } catch (error) {
       if (error instanceof InsightLifecycleError && error.code === "active_run_conflict") {
         throw new ApiError(409, error.message);
@@ -150426,11 +150724,11 @@ function createInsightsRouter(store) {
     try {
       const id = String(req.params.id);
       const store2 = getInsightStore();
-      const run = store2.getRun(id);
-      if (!run) {
+      const run2 = store2.getRun(id);
+      if (!run2) {
         throw notFound(`Run not found: ${id}`);
       }
-      res.json(run);
+      res.json(run2);
     } catch (error) {
       rethrowAsApiError5(error, "Failed to get run");
     }
@@ -150439,8 +150737,8 @@ function createInsightsRouter(store) {
     try {
       const id = String(req.params.id);
       const store2 = getInsightStore();
-      const run = store2.getRun(id);
-      if (!run) throw notFound(`Run not found: ${id}`);
+      const run2 = store2.getRun(id);
+      if (!run2) throw notFound(`Run not found: ${id}`);
       res.json({ events: store2.listRunEvents(id) });
     } catch (error) {
       rethrowAsApiError5(error, "Failed to list run events");
@@ -150450,34 +150748,34 @@ function createInsightsRouter(store) {
     try {
       const id = String(req.params.id);
       const store2 = getInsightStore();
-      const run = store2.getRun(id);
-      if (!run) throw notFound(`Run not found: ${id}`);
-      if (!["pending", "running"].includes(run.status)) {
+      const run2 = store2.getRun(id);
+      if (!run2) throw notFound(`Run not found: ${id}`);
+      if (!["pending", "running"].includes(run2.status)) {
         throw new ApiError(409, `Run ${id} is already terminal`);
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      store2.appendRunEvent(id, { type: "cancel_requested", status: run.status, message: "Cancellation requested" });
+      store2.appendRunEvent(id, { type: "cancel_requested", status: run2.status, message: "Cancellation requested" });
       const updated = store2.updateRun(id, {
-        lifecycle: { ...run.lifecycle, cancellationRequestedAt: now }
+        lifecycle: { ...run2.lifecycle, cancellationRequestedAt: now }
       });
-      if (run.status === "pending") {
+      if (run2.status === "pending") {
         const cancelled = store2.updateRun(id, {
           status: "cancelled",
           error: "Cancelled before execution started",
           cancelledAt: now,
           lifecycle: {
-            ...updated?.lifecycle ?? run.lifecycle,
+            ...updated?.lifecycle ?? run2.lifecycle,
             terminalReason: "cancelled",
             terminalCause: "cancel_requested",
             failureClass: "cancelled",
             retryable: false
           }
         });
-        res.json(cancelled ?? updated ?? run);
+        res.json(cancelled ?? updated ?? run2);
         return;
       }
       activeRunControllers.get(id)?.abort(new DOMException("Run cancelled", "AbortError"));
-      res.json(updated ?? run);
+      res.json(updated ?? run2);
     } catch (error) {
       rethrowAsApiError5(error, "Failed to cancel run");
     }
@@ -150498,26 +150796,26 @@ function createInsightsRouter(store) {
       if (!taskStore) throw new ApiError(500, "Store context not available");
       const rootDir = taskStore.getRootDir();
       const controller = new AbortController();
-      const { run } = await retryInsightRunLifecycle({
+      const { run: run2 } = await retryInsightRunLifecycle({
         store: store2,
         runId: id,
         timeoutMs: typeof req.body?.timeoutMs === "number" ? req.body.timeoutMs : 12e4,
         maxAttempts: 2,
         retryDelayMs: 250,
         signal: controller.signal,
-        executeAttempt: async ({ run: run2, signal }) => {
-          activeRunControllers.set(run2.id, controller);
+        executeAttempt: async ({ run: run3, signal }) => {
+          activeRunControllers.set(run3.id, controller);
           return executeInsightAttempt({
             rootDir,
             projectId: existing.projectId,
-            runId: run2.id,
+            runId: run3.id,
             signal,
             insightStore: store2
           });
         }
       });
-      activeRunControllers.delete(run.id);
-      res.status(201).json(run);
+      activeRunControllers.delete(run2.id);
+      res.status(201).json(run2);
     } catch (error) {
       if (error instanceof InsightLifecycleError && error.code === "not_retryable") {
         throw new ApiError(409, error.message);
@@ -150658,32 +150956,33 @@ import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 function rethrowAsApiError6(error, fallback2 = "Internal server error") {
   if (error instanceof ApiError) throw error;
   if (error instanceof ResearchLifecycleError) {
-    const status = error.code === "invalid_transition" || error.code === "active_run_conflict" ? 409 : 400;
-    throw new ApiError(status, error.message, { code: error.code.toUpperCase() });
+    const status = error.code === "invalid_transition" || error.code === "active_run_conflict" || error.code === "not_retryable" ? 409 : 400;
+    const mappedCode = error.code === "not_retryable" ? "NON_RETRYABLE_PROVIDER_ERROR" : "INVALID_TRANSITION";
+    throw new ApiError(status, error.message, { code: mappedCode, retryable: false });
   }
-  if (error instanceof Error) throw new ApiError(500, error.message);
-  throw new ApiError(500, fallback2);
+  if (error instanceof Error) throw new ApiError(500, error.message, { code: "INTERNAL_ERROR" });
+  throw new ApiError(500, fallback2, { code: "INTERNAL_ERROR" });
 }
 function getProjectId2(req) {
   if (typeof req.query.projectId === "string" && req.query.projectId.trim()) return req.query.projectId;
   if (req.body && typeof req.body === "object" && typeof req.body.projectId === "string" && req.body.projectId.trim()) return req.body.projectId;
   return void 0;
 }
-function toRunListItem(run) {
+function toRunListItem(run2) {
   return {
-    id: run.id,
-    query: run.query,
-    title: run.topic || run.query,
-    status: run.status,
-    summary: run.results?.summary,
-    createdAt: run.createdAt,
-    updatedAt: run.updatedAt
+    id: run2.id,
+    query: run2.query,
+    title: run2.topic || run2.query,
+    status: run2.status,
+    summary: run2.results?.summary,
+    createdAt: run2.createdAt,
+    updatedAt: run2.updatedAt
   };
 }
-function toRunDetail(run) {
+function toRunDetail(run2) {
   return {
-    ...run,
-    title: run.topic || run.query
+    ...run2,
+    title: run2.topic || run2.query
   };
 }
 function getFindingId(finding, index2) {
@@ -150691,8 +150990,8 @@ function getFindingId(finding, index2) {
   const explicitId = typeof maybeFinding.id === "string" ? maybeFinding.id.trim() : "";
   return explicitId || `finding-${index2 + 1}`;
 }
-function getFindingById(run, findingId) {
-  const findings = run.results?.findings ?? [];
+function getFindingById(run2, findingId) {
+  const findings = run2.results?.findings ?? [];
   for (const [index2, finding] of findings.entries()) {
     if (getFindingId(finding, index2) === findingId) {
       return { finding, findingId };
@@ -150700,24 +150999,24 @@ function getFindingById(run, findingId) {
   }
   return null;
 }
-function buildFindingTaskSummary(run, finding) {
+function buildFindingTaskSummary(run2, finding) {
   const heading = finding.heading?.trim() || "Research finding";
   const content = finding.content?.trim() || "";
   const firstSentence = content.split(/(?<=[.!?])\s+/)[0]?.trim() || content;
-  const scope = run.topic || run.query;
+  const scope = run2.topic || run2.query;
   return `${heading} \u2014 ${firstSentence || "Review cited research details."}
 
 Context: ${scope}`;
 }
-function buildFindingMarkdown(run, findingId, finding) {
+function buildFindingMarkdown(run2, findingId, finding) {
   const citations = (finding.sources ?? []).map((source) => `- ${source}`).join("\n");
-  const runSummary = run.results?.summary?.trim();
+  const runSummary = run2.results?.summary?.trim();
   return [
     `# Research Finding`,
     ``,
-    `- Run ID: ${run.id}`,
+    `- Run ID: ${run2.id}`,
     `- Finding ID: ${findingId}`,
-    `- Query: ${run.query}`,
+    `- Query: ${run2.query}`,
     ``,
     `## ${finding.heading || "Finding"}`,
     finding.content || "",
@@ -150788,7 +151087,7 @@ function createResearchRouter(store) {
       if (typeof req.body?.query !== "string" || !req.body.query.trim()) {
         throw badRequest("query is required");
       }
-      const run = getStore4().createRun({
+      const run2 = getStore4().createRun({
         query: req.body.query,
         topic: req.body.query,
         providerConfig: {
@@ -150801,55 +151100,85 @@ function createResearchRouter(store) {
           depth: req.body.depth
         }
       });
-      res.status(201).json({ run: toRunDetail(run), availability: DEFAULT_AVAILABILITY });
+      res.status(201).json({ run: toRunDetail(run2), availability: DEFAULT_AVAILABILITY });
     } catch (error) {
       rethrowAsApiError6(error, "Failed to create research run");
     }
   });
   router.get("/runs/:id", (req, res) => {
     try {
-      const run = getStore4().getRun(req.params.id);
-      if (!run) throw notFound(`Run not found: ${req.params.id}`);
-      res.json({ run: toRunDetail(run), availability: DEFAULT_AVAILABILITY });
+      const run2 = getStore4().getRun(req.params.id);
+      if (!run2) throw notFound(`Run not found: ${req.params.id}`);
+      res.json({ run: toRunDetail(run2), availability: DEFAULT_AVAILABILITY });
     } catch (error) {
       rethrowAsApiError6(error, "Failed to get research run");
     }
   });
   router.post("/runs/:id/cancel", (req, res) => {
     try {
-      const run = getStore4().requestCancellation(req.params.id);
-      res.json({ run: toRunDetail(run) });
+      const existing = getStore4().getRun(req.params.id);
+      if (!existing) throw notFound(`Run not found: ${req.params.id}`);
+      if (["completed", "failed", "cancelled", "timed_out", "retry_exhausted"].includes(existing.status)) {
+        res.status(409).json({
+          error: `Run ${req.params.id} cannot be cancelled from status ${existing.status}`,
+          details: { code: "INVALID_TRANSITION", retryable: false }
+        });
+        return;
+      }
+      const run2 = getStore4().requestCancellation(req.params.id);
+      res.json({ run: toRunDetail(run2) });
     } catch (error) {
       rethrowAsApiError6(error, "Failed to cancel research run");
     }
   });
   router.post("/runs/:id/retry", (req, res) => {
     try {
+      const existing = getStore4().getRun(req.params.id);
+      if (!existing) throw notFound(`Run not found: ${req.params.id}`);
       const retryRun = getStore4().createRetryRun(req.params.id);
       res.json({ run: toRunDetail(retryRun) });
     } catch (error) {
+      if (error instanceof ResearchLifecycleError && error.code === "not_retryable") {
+        const run2 = getStore4().getRun(req.params.id);
+        const exhausted = run2?.status === "retry_exhausted" || run2?.lifecycle?.errorCode === "RETRY_EXHAUSTED";
+        res.status(409).json({
+          error: error.message,
+          details: {
+            code: exhausted ? "RETRY_EXHAUSTED" : "NON_RETRYABLE_PROVIDER_ERROR",
+            retryable: false
+          }
+        });
+        return;
+      }
+      if (error instanceof ResearchLifecycleError && error.code === "invalid_transition") {
+        res.status(409).json({
+          error: error.message,
+          details: { code: "INVALID_TRANSITION", retryable: false }
+        });
+        return;
+      }
       rethrowAsApiError6(error, "Failed to retry research run");
     }
   });
   router.get("/runs/:id/export", (req, res) => {
     try {
-      const run = getStore4().getRun(req.params.id);
-      if (!run) throw notFound(`Run not found: ${req.params.id}`);
+      const run2 = getStore4().getRun(req.params.id);
+      if (!run2) throw notFound(`Run not found: ${req.params.id}`);
       const format = String(req.query.format ?? "markdown");
       if (format === "json") {
-        res.json({ format, filename: `${run.id}.json`, content: JSON.stringify(run, null, 2) });
+        res.json({ format, filename: `${run2.id}.json`, content: JSON.stringify(run2, null, 2) });
         return;
       }
       if (format === "html") {
-        const html = `<h1>${run.topic || run.query}</h1><p>${run.results?.summary ?? ""}</p>`;
-        res.json({ format, filename: `${run.id}.html`, content: html });
+        const html = `<h1>${run2.topic || run2.query}</h1><p>${run2.results?.summary ?? ""}</p>`;
+        res.json({ format, filename: `${run2.id}.html`, content: html });
         return;
       }
       if (format !== "markdown") throw badRequest(`Unsupported format: ${format}`);
-      const markdown = `# ${run.topic || run.query}
+      const markdown = `# ${run2.topic || run2.query}
 
-${run.results?.summary ?? ""}`;
-      res.json({ format: "markdown", filename: `${run.id}.md`, content: markdown });
+${run2.results?.summary ?? ""}`;
+      res.json({ format: "markdown", filename: `${run2.id}.md`, content: markdown });
     } catch (error) {
       rethrowAsApiError6(error, "Failed to export research run");
     }
@@ -150858,9 +151187,9 @@ ${run.results?.summary ?? ""}`;
     try {
       const scopedStore = requestContext.getStore();
       if (!scopedStore) throw new ApiError(500, "Task store context unavailable");
-      const run = getStore4().getRun(req.params.runId);
-      if (!run) throw notFound(`Run not found: ${req.params.runId}`);
-      const found = getFindingById(run, req.params.findingId);
+      const run2 = getStore4().getRun(req.params.runId);
+      if (!run2) throw notFound(`Run not found: ${req.params.runId}`);
+      const found = getFindingById(run2, req.params.findingId);
       if (!found) throw notFound(`Finding not found: ${req.params.findingId}`);
       let documentKey;
       try {
@@ -150868,8 +151197,8 @@ ${run.results?.summary ?? ""}`;
       } catch {
         throw badRequest("Invalid run id for research document key");
       }
-      const title = typeof req.body?.title === "string" && req.body.title.trim() ? req.body.title.trim() : `Research: ${found.finding.heading || run.topic || run.query}`;
-      const description = typeof req.body?.description === "string" && req.body.description.trim() ? req.body.description.trim() : buildFindingTaskSummary(run, found.finding);
+      const title = typeof req.body?.title === "string" && req.body.title.trim() ? req.body.title.trim() : `Research: ${found.finding.heading || run2.topic || run2.query}`;
+      const description = typeof req.body?.description === "string" && req.body.description.trim() ? req.body.description.trim() : buildFindingTaskSummary(run2, found.finding);
       const priority = req.body?.priority;
       if (priority !== void 0 && !["low", "normal", "high", "urgent"].includes(priority)) {
         throw badRequest("priority must be one of: low, normal, high, urgent");
@@ -150881,9 +151210,9 @@ ${run.results?.summary ?? ""}`;
         priority,
         source: {
           sourceType: "research",
-          sourceRunId: run.id,
+          sourceRunId: run2.id,
           sourceMetadata: {
-            runId: run.id,
+            runId: run2.id,
             findingId: found.findingId,
             findingLabel: found.finding.heading,
             documentKey
@@ -150891,13 +151220,13 @@ ${run.results?.summary ?? ""}`;
         }
       };
       const task = await scopedStore.createTask(taskInput);
-      const markdown = buildFindingMarkdown(run, found.findingId, found.finding);
+      const markdown = buildFindingMarkdown(run2, found.findingId, found.finding);
       await scopedStore.upsertTaskDocument(task.id, {
         key: documentKey,
         content: markdown,
         author: "research",
         metadata: {
-          runId: run.id,
+          runId: run2.id,
           findingId: found.findingId,
           findingLabel: found.finding.heading
         }
@@ -150905,7 +151234,7 @@ ${run.results?.summary ?? ""}`;
       if (typeof scopedStore.appendAgentLog === "function") {
         await scopedStore.appendAgentLog(
           task.id,
-          `Task created from research finding ${found.findingId} in run ${run.id}`,
+          `Task created from research finding ${found.findingId} in run ${run2.id}`,
           "text",
           "research-task-integration",
           "executor"
@@ -150913,7 +151242,7 @@ ${run.results?.summary ?? ""}`;
       }
       let attachmentFilename;
       if (attachExport) {
-        const filename = `${run.id}-${found.findingId}.md`;
+        const filename = `${run2.id}-${found.findingId}.md`;
         const existing = await scopedStore.getTask(task.id);
         if (!existing.attachments?.some((attachment) => attachment.originalName === filename)) {
           attachmentFilename = await addFindingAttachment(scopedStore, task.id, filename, markdown);
@@ -150934,9 +151263,9 @@ ${run.results?.summary ?? ""}`;
     try {
       const scopedStore = requestContext.getStore();
       if (!scopedStore) throw new ApiError(500, "Task store context unavailable");
-      const run = getStore4().getRun(req.params.runId);
-      if (!run) throw notFound(`Run not found: ${req.params.runId}`);
-      const found = getFindingById(run, req.params.findingId);
+      const run2 = getStore4().getRun(req.params.runId);
+      if (!run2) throw notFound(`Run not found: ${req.params.runId}`);
+      const found = getFindingById(run2, req.params.findingId);
       if (!found) throw notFound(`Finding not found: ${req.params.findingId}`);
       const task = await scopedStore.getTask(req.params.taskId);
       if (!task) throw notFound(`Task not found: ${req.params.taskId}`);
@@ -150947,13 +151276,13 @@ ${run.results?.summary ?? ""}`;
       } catch {
         throw badRequest("Invalid run id for research document key");
       }
-      const markdown = buildFindingMarkdown(run, found.findingId, found.finding);
+      const markdown = buildFindingMarkdown(run2, found.findingId, found.finding);
       const document2 = await scopedStore.upsertTaskDocument(task.id, {
         key: documentKey,
         content: markdown,
         author: "research",
         metadata: {
-          runId: run.id,
+          runId: run2.id,
           findingId: found.findingId,
           findingLabel: found.finding.heading
         }
@@ -150961,7 +151290,7 @@ ${run.results?.summary ?? ""}`;
       const attachExport = validateAttachExport(req.body?.attachExport);
       let attachmentFilename;
       if (attachExport) {
-        const filename = `${run.id}-${found.findingId}.md`;
+        const filename = `${run2.id}-${found.findingId}.md`;
         if (!task.attachments?.some((attachment) => attachment.originalName === filename)) {
           attachmentFilename = await addFindingAttachment(scopedStore, task.id, filename, markdown);
         }
@@ -150969,7 +151298,7 @@ ${run.results?.summary ?? ""}`;
       if (typeof scopedStore.appendAgentLog === "function") {
         await scopedStore.appendAgentLog(
           task.id,
-          `Task enriched from research finding ${found.findingId} in run ${run.id}`,
+          `Task enriched from research finding ${found.findingId} in run ${run2.id}`,
           "text",
           "research-task-integration",
           "executor"
@@ -151046,9 +151375,9 @@ ${run.results?.summary ?? ""}`;
       const status = req.body?.status;
       if (!status || !RESEARCH_RUN_STATUSES.includes(status)) throw badRequest(`Invalid status: ${String(status)}`);
       getStore4().updateStatus(req.params.id, status, req.body?.extra);
-      const run = getStore4().getRun(req.params.id);
-      if (!run) throw notFound(`Run not found: ${req.params.id}`);
-      res.json(run);
+      const run2 = getStore4().getRun(req.params.id);
+      if (!run2) throw notFound(`Run not found: ${req.params.id}`);
+      res.json(run2);
     } catch (error) {
       rethrowAsApiError6(error, "Failed to update research status");
     }
@@ -151107,7 +151436,8 @@ var init_research_routes = __esm({
     DEFAULT_AVAILABILITY = {
       available: true,
       supportedProviders: ["web-search", "page-fetch", "github", "local-docs", "llm-synthesis"],
-      supportedExportFormats: ["markdown", "json", "html"]
+      supportedExportFormats: ["markdown", "json", "html"],
+      setupInstructions: "If research fails to start, check Settings \u2192 Models and Authentication for provider enablement and credentials."
     };
   }
 });
@@ -153027,32 +153357,32 @@ function logEntryToTimelineEntry(entry) {
     log: entry
   };
 }
-function runExcerptToAgentLogs(run) {
+function runExcerptToAgentLogs(run2) {
   const entries = [];
-  const taskId = typeof run.contextSnapshot?.taskId === "string" ? run.contextSnapshot.taskId : "agent-run";
-  if (run.stdoutExcerpt?.trim()) {
+  const taskId = typeof run2.contextSnapshot?.taskId === "string" ? run2.contextSnapshot.taskId : "agent-run";
+  if (run2.stdoutExcerpt?.trim()) {
     entries.push({
-      timestamp: run.endedAt ?? run.startedAt,
+      timestamp: run2.endedAt ?? run2.startedAt,
       taskId,
       type: "text",
-      text: run.stdoutExcerpt
+      text: run2.stdoutExcerpt
     });
   }
-  if (run.stderrExcerpt?.trim()) {
+  if (run2.stderrExcerpt?.trim()) {
     entries.push({
-      timestamp: run.endedAt ?? run.startedAt,
+      timestamp: run2.endedAt ?? run2.startedAt,
       taskId,
       type: "tool_error",
       text: "stderr",
-      detail: run.stderrExcerpt
+      detail: run2.stderrExcerpt
     });
   }
-  if (run.resultJson && Object.keys(run.resultJson).length > 0 && entries.length === 0) {
+  if (run2.resultJson && Object.keys(run2.resultJson).length > 0 && entries.length === 0) {
     entries.push({
-      timestamp: run.endedAt ?? run.startedAt,
+      timestamp: run2.endedAt ?? run2.startedAt,
       taskId,
       type: "text",
-      text: JSON.stringify(run.resultJson, null, 2)
+      text: JSON.stringify(run2.resultJson, null, 2)
     });
   }
   return entries;
@@ -153183,11 +153513,26 @@ function createApiRoutes(store, options) {
       return true;
     }
   }
+  function resolveHeartbeatMonitor(scopedStore) {
+    const engineManager = options?.engineManager;
+    if (!engineManager) return void 0;
+    try {
+      const storeRoot = resolve27(scopedStore.getRootDir());
+      for (const engine of engineManager.getAllEngines().values()) {
+        if (resolve27(engine.getWorkingDirectory()) === storeRoot) {
+          return engine.getHeartbeatMonitor() ?? void 0;
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
   const triggerCommentWakeForAssignedAgent = async (scopedStore, task, wake) => {
     if (!hasHeartbeatExecutor || !heartbeatMonitor || !task.assignedAgentId) {
       return;
     }
-    if (!isHeartbeatMonitorForProject(scopedStore)) {
+    const resolvedMonitor = isHeartbeatMonitorForProject(scopedStore) ? heartbeatMonitor : resolveHeartbeatMonitor(scopedStore);
+    if (!resolvedMonitor) {
       return;
     }
     const { AgentStore: AgentStore2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -153213,7 +153558,7 @@ function createApiRoutes(store, options) {
       ...triggeringCommentIds?.length ? { triggeringCommentIds } : {},
       triggeringCommentType: wake.triggeringCommentType
     };
-    await heartbeatMonitor.executeHeartbeat({
+    await resolvedMonitor.executeHeartbeat({
       agentId: assignedAgent.id,
       source: "on_demand",
       triggerDetail: wake.triggerDetail,
@@ -154643,6 +154988,7 @@ Description: ${step.description}`
     hasHeartbeatExecutor,
     heartbeatMonitor,
     isHeartbeatMonitorForProject,
+    resolveHeartbeatMonitor,
     runExcerptToAgentLogs,
     parseRunAuditFilters,
     normalizeRunAuditEvent,
@@ -155979,39 +156325,39 @@ data: ${JSON.stringify(stripTaskEventHeavyFields(result))}
 
 `);
     };
-    const onResearchRunCreated = (run) => {
+    const onResearchRunCreated = (run2) => {
       send(`event: research:run:created
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
-    const onResearchRunUpdated = (run) => {
+    const onResearchRunUpdated = (run2) => {
       send(`event: research:run:updated
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
-    const onResearchRunCompleted = (run) => {
+    const onResearchRunCompleted = (run2) => {
       send(`event: research:run:completed
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
-    const onResearchRunFailed = (run) => {
+    const onResearchRunFailed = (run2) => {
       send(`event: research:run:failed
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
-    const onResearchRunCancelled = (run) => {
+    const onResearchRunCancelled = (run2) => {
       send(`event: research:run:cancelled
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
-    const onResearchRunTimedOut = (run) => {
+    const onResearchRunTimedOut = (run2) => {
       send(`event: research:run:timed_out
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
@@ -156141,15 +156487,15 @@ data: ${JSON.stringify(data)}
 
 `);
     };
-    const onValidatorRunStarted = (run) => {
+    const onValidatorRunStarted = (run2) => {
       send(`event: validator-run:started
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
-    const onValidatorRunCompleted = (run) => {
+    const onValidatorRunCompleted = (run2) => {
       send(`event: validator-run:completed
-data: ${JSON.stringify(run)}
+data: ${JSON.stringify(run2)}
 
 `);
     };
@@ -161973,7 +162319,8 @@ function createSkillsAdapter(options) {
       }
       const discoveredSkills = [];
       for (const resource of skillResources) {
-        const skillRelativePath = "skills/" + relative13(resource.metadata.baseDir ?? "", resource.path);
+        const relPath = relative13(resource.metadata.baseDir ?? "", resource.path).replaceAll("\\", "/");
+        const skillRelativePath = relPath.startsWith("skills/") ? relPath : `skills/${relPath}`;
         const skillId = computeSkillId(resource.metadata.source, skillRelativePath);
         const skillName = extractSkillName(skillRelativePath, resource.metadata.source);
         discoveredSkills.push({
@@ -165200,22 +165547,22 @@ function runStatusColor(status) {
       return "gray";
   }
 }
-function getRunLogLines(run) {
-  if (Array.isArray(run.logs) && run.logs.length > 0) return run.logs;
+function getRunLogLines(run2) {
+  if (Array.isArray(run2.logs) && run2.logs.length > 0) return run2.logs;
   const lines = [];
-  if (run.triggerDetail) lines.push(`trigger: ${run.triggerDetail}`);
-  if (run.invocationSource) lines.push(`source: ${run.invocationSource}`);
-  if (run.stdoutExcerpt) {
+  if (run2.triggerDetail) lines.push(`trigger: ${run2.triggerDetail}`);
+  if (run2.invocationSource) lines.push(`source: ${run2.invocationSource}`);
+  if (run2.stdoutExcerpt) {
     lines.push("stdout:");
-    lines.push(...run.stdoutExcerpt.split(/\r?\n/).filter((line) => line.length > 0));
+    lines.push(...run2.stdoutExcerpt.split(/\r?\n/).filter((line) => line.length > 0));
   }
-  if (run.stderrExcerpt) {
+  if (run2.stderrExcerpt) {
     lines.push("stderr:");
-    lines.push(...run.stderrExcerpt.split(/\r?\n/).filter((line) => line.length > 0));
+    lines.push(...run2.stderrExcerpt.split(/\r?\n/).filter((line) => line.length > 0));
   }
-  if (run.resultJson) {
+  if (run2.resultJson) {
     lines.push("result:");
-    lines.push(JSON.stringify(run.resultJson));
+    lines.push(JSON.stringify(run2.resultJson));
   }
   return lines.length > 0 ? lines : ["No logs captured for this run."];
 }
@@ -165470,12 +165817,12 @@ function AgentsView({ state }) {
                 recentRuns.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
                   /* @__PURE__ */ jsx(Box, { height: 1 }),
                   /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Run history (latest first):" }),
-                  recentRuns.slice(0, 5).map((run, i) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, marginLeft: 1, children: [
+                  recentRuns.slice(0, 5).map((run2, i) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, marginLeft: 1, children: [
                     /* @__PURE__ */ jsx(Text, { color: detailFocused && i === selectedRunIndex ? "white" : "gray", children: detailFocused && i === selectedRunIndex ? "\u25B6" : " " }),
-                    /* @__PURE__ */ jsx(Text, { color: runStatusColor(run.status), children: formatRunStatusLabel(run.status) }),
-                    /* @__PURE__ */ jsx(Text, { dimColor: true, children: run.startedAt.slice(11, 19) }),
-                    run.triggerDetail && /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "truncate-end", children: run.triggerDetail })
-                  ] }, run.id)),
+                    /* @__PURE__ */ jsx(Text, { color: runStatusColor(run2.status), children: formatRunStatusLabel(run2.status) }),
+                    /* @__PURE__ */ jsx(Text, { dimColor: true, children: run2.startedAt.slice(11, 19) }),
+                    run2.triggerDetail && /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "truncate-end", children: run2.triggerDetail })
+                  ] }, run2.id)),
                   /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[Enter] open logs" })
                 ] })
               ] })
@@ -176354,12 +176701,27 @@ async function getStore3(projectName) {
   await store.init();
   return store;
 }
+function hasProviderCredentials(settings, providerId) {
+  if (!providerId) return false;
+  if (providerId === "searxng") return Boolean(settings.researchSearxngUrl);
+  if (providerId === "brave") return Boolean(settings.researchBraveApiKey);
+  if (providerId === "google") return Boolean(settings.researchGoogleSearchApiKey && settings.researchGoogleSearchCx);
+  if (providerId === "tavily") return Boolean(settings.researchTavilyApiKey);
+  return false;
+}
 async function getResearchRuntime(store) {
   const settings = await store.getSettings();
   const resolved = resolveResearchSettings(settings);
   if (!resolved.enabled) {
     throw new Error("feature-disabled: Research is disabled in settings.");
   }
+  const configuredProvider = resolved.searchProvider ?? settings.researchWebSearchProvider;
+  if (!configuredProvider) {
+    throw new Error("provider-unavailable: Research providers are not configured. Add provider credentials in settings.");
+  }
+  if (!hasProviderCredentials(settings, configuredProvider)) {
+    throw new Error(`missing-credentials: ${configuredProvider} credentials are missing. Configure Authentication and Research defaults in settings.`);
+  }
   const registry = new ResearchProviderRegistry(settings, process.cwd());
   const availableProviderTypes = registry.getAvailableProviders();
   if (availableProviderTypes.length === 0) {
@@ -176375,17 +176737,17 @@ async function getResearchRuntime(store) {
   });
   return { orchestrator, settings, resolved, availableProviderTypes };
 }
-function printRun(run) {
-  console.log(`Run:       ${run.id}`);
-  console.log(`Status:    ${run.status}`);
-  console.log(`Query:     ${run.query}`);
-  console.log(`Created:   ${run.createdAt}`);
-  console.log(`Updated:   ${run.updatedAt}`);
-  if (run.startedAt) console.log(`Started:   ${run.startedAt}`);
-  if (run.completedAt) console.log(`Completed: ${run.completedAt}`);
-  if (run.cancelledAt) console.log(`Cancelled: ${run.cancelledAt}`);
-  if (run.results?.summary) console.log(`Summary:   ${run.results.summary}`);
-  if (run.error) console.log(`Error:     ${run.error}`);
+function printRun(run2) {
+  console.log(`Run:       ${run2.id}`);
+  console.log(`Status:    ${run2.status}`);
+  console.log(`Query:     ${run2.query}`);
+  console.log(`Created:   ${run2.createdAt}`);
+  console.log(`Updated:   ${run2.updatedAt}`);
+  if (run2.startedAt) console.log(`Started:   ${run2.startedAt}`);
+  if (run2.completedAt) console.log(`Completed: ${run2.completedAt}`);
+  if (run2.cancelledAt) console.log(`Cancelled: ${run2.cancelledAt}`);
+  if (run2.results?.summary) console.log(`Summary:   ${run2.results.summary}`);
+  if (run2.error) console.log(`Error:     ${run2.error}`);
 }
 function jsonOut(payload) {
   console.log(JSON.stringify(payload, null, 2));
@@ -176408,12 +176770,12 @@ async function runResearchCreate(options) {
     });
     const runPromise = orchestrator.startRun(runId, options.query);
     if (!options.waitForCompletion) {
-      const run = store.getResearchStore().getRun(runId);
+      const run2 = store.getResearchStore().getRun(runId);
       if (options.json) {
-        jsonOut(run);
+        jsonOut(run2);
       } else {
         console.log(`Created research run ${runId}.`);
-        if (run) printRun(run);
+        if (run2) printRun(run2);
       }
       return;
     }
@@ -176461,8 +176823,8 @@ async function runResearchList(options = {}) {
       console.log("No research runs found.");
       return;
     }
-    for (const run of runs) {
-      console.log(`${run.id}  [${run.status}]  ${run.query}`);
+    for (const run2 of runs) {
+      console.log(`${run2.id}  [${run2.status}]  ${run2.query}`);
     }
   } catch (error) {
     handleError(error);
@@ -176471,46 +176833,46 @@ async function runResearchList(options = {}) {
 async function runResearchShow(runId, options = {}) {
   try {
     const store = await getStore3(options.projectName);
-    const run = store.getResearchStore().getRun(runId);
-    if (!run) throw new Error(`Research run not found: ${runId}`);
+    const run2 = store.getResearchStore().getRun(runId);
+    if (!run2) throw new Error(`Research run not found: ${runId}`);
     if (options.json) {
-      jsonOut(run);
+      jsonOut(run2);
       return;
     }
-    printRun(run);
+    printRun(run2);
   } catch (error) {
     handleError(error);
   }
 }
-function renderMarkdown(run) {
-  const citations = run.results?.citations?.length ? `
+function renderMarkdown(run2) {
+  const citations = run2.results?.citations?.length ? `
 ## Citations
-${run.results.citations.map((citation) => `- ${citation}`).join("\n")}` : "";
-  return `# ${run.topic || run.query}
+${run2.results.citations.map((citation) => `- ${citation}`).join("\n")}` : "";
+  return `# ${run2.topic || run2.query}
 
 ## Summary
-${run.results?.summary ?? ""}${citations}
+${run2.results?.summary ?? ""}${citations}
 `;
 }
 async function runResearchExport(options) {
   try {
     const store = await getStore3(options.projectName);
-    const run = store.getResearchStore().getRun(options.runId);
-    if (!run) throw new Error(`Research run not found: ${options.runId}`);
+    const run2 = store.getResearchStore().getRun(options.runId);
+    if (!run2) throw new Error(`Research run not found: ${options.runId}`);
     const format = options.format ?? "markdown";
     if (!RESEARCH_EXPORT_FORMATS.includes(format)) {
       throw new Error(`Unsupported export format: ${format}`);
     }
-    const content = format === "json" ? JSON.stringify(run, null, 2) : renderMarkdown(run);
+    const content = format === "json" ? JSON.stringify(run2, null, 2) : renderMarkdown(run2);
     const ext = format === "json" ? "json" : "md";
-    const outputPath = options.output ? resolve42(options.output) : join69(process.cwd(), `research-${run.id.toLowerCase()}.${ext}`);
+    const outputPath = options.output ? resolve42(options.output) : join69(process.cwd(), `research-${run2.id.toLowerCase()}.${ext}`);
     await writeFile19(outputPath, content, "utf8");
-    store.getResearchStore().createExport(run.id, format, content);
+    store.getResearchStore().createExport(run2.id, format, content);
     if (options.json) {
-      jsonOut({ runId: run.id, format, outputPath, bytes: Buffer.byteLength(content, "utf8") });
+      jsonOut({ runId: run2.id, format, outputPath, bytes: Buffer.byteLength(content, "utf8") });
       return;
     }
-    console.log(`Exported ${run.id} (${format}) to ${outputPath}`);
+    console.log(`Exported ${run2.id} (${format}) to ${outputPath}`);
   } catch (error) {
     handleError(error);
   }
@@ -176518,16 +176880,19 @@ async function runResearchExport(options) {
 async function runResearchCancel(runId, options = {}) {
   try {
     const store = await getStore3(options.projectName);
-    const run = store.getResearchStore().getRun(runId);
-    if (!run) throw new Error(`Research run not found: ${runId}`);
+    const run2 = store.getResearchStore().getRun(runId);
+    if (!run2) throw new Error(`Research run not found: ${runId}`);
+    if (!["queued", "running", "cancelling", "retry_waiting"].includes(run2.status)) {
+      throw new Error(`invalid-transition: Run ${runId} cannot be cancelled from status ${run2.status}.`);
+    }
     const { orchestrator } = await getResearchRuntime(store);
     const cancelled = orchestrator.cancelRun(runId);
     if (options.json) {
-      jsonOut({ cancelled, run });
+      jsonOut({ cancelled, run: run2 });
       return;
     }
     console.log(cancelled ? `Cancellation requested for ${runId}.` : `Run ${runId} is not active.`);
-    printRun(run);
+    printRun(run2);
   } catch (error) {
     handleError(error);
   }
@@ -176537,15 +176902,21 @@ async function runResearchRetry(runId, options = {}) {
     const store = await getStore3(options.projectName);
     const existing = store.getResearchStore().getRun(runId);
     if (!existing) throw new Error(`Research run not found: ${runId}`);
+    if (existing.status === "retry_exhausted" || existing.lifecycle?.errorCode === "RETRY_EXHAUSTED") {
+      throw new Error(`retry-exhausted: Run ${runId} has exhausted retry attempts.`);
+    }
+    if (existing.lifecycle?.retryable === false) {
+      throw new Error(`non-retryable-provider-error: Run ${runId} is marked non-retryable.`);
+    }
     const { orchestrator } = await getResearchRuntime(store);
     const newRunId = orchestrator.retryRun(runId);
-    const run = store.getResearchStore().getRun(newRunId);
+    const run2 = store.getResearchStore().getRun(newRunId);
     if (options.json) {
-      jsonOut({ retryOf: runId, run });
+      jsonOut({ retryOf: runId, run: run2 });
       return;
     }
     console.log(`Created retry run ${newRunId} from ${runId}.`);
-    if (run) printRun(run);
+    if (run2) printRun(run2);
   } catch (error) {
     handleError(error);
   }