chatccc 0.2.270 → 0.2.272

package/dist/src/agent-team/application/task-execution-service.js

@@ -1,17 +1,22 @@
 import { randomUUID } from "node:crypto";
-import { isActiveTaskRun } from "../domain/task-run.js";
+import { isActiveTaskRun, } from "../domain/task-run.js";
 import { BoardStoreError } from "../repositories/board-repository.js";
 import { beginSafeMaintenanceTrackedWork, isSafeMaintenanceAdmissionClosed, } from "../../safe-maintenance.js";
 export class TaskExecutionService {
     options;
     now;
     idFactory;
+    stopTimeoutMs;
+    staleAfterMs;
     projectOperations = new Map();
     executions = new Map();
+    pendingReconciliationProjects = new Set();
     constructor(options) {
         this.options = options;
         this.now = options.now ?? (() => new Date());
         this.idFactory = options.idFactory ?? randomUUID;
+        this.stopTimeoutMs = options.stopTimeoutMs ?? 30_000;
+        this.staleAfterMs = options.staleAfterMs ?? 5 * 60_000;
     }
     async listRuns(projectId) {
         const runs = await this.options.repository.listByProject(projectId);
@@ -22,85 +27,101 @@ export class TaskExecutionService {
         if (!run || run.projectId !== projectId) {
             throw new BoardStoreError("task_run_not_found", "找不到这次任务执行记录", 404);
         }
-        if (!isActiveTaskRun(run) || !this.options.runtime.getTranscript)
+        if (!isActiveTaskRun(run) || !this.options.runtime.getSnapshot)
             return run;
-        const live = await this.options.runtime.getTranscript(run.sessionId).catch(() => []);
-        return live.length ? { ...run, transcript: mergeTranscript(run.transcript, live) } : run;
+        const snapshot = await this.options.runtime.getSnapshot(run.sessionId).catch(() => null);
+        return snapshot?.transcript.length
+            ? { ...run, transcript: combineTranscript(run.transcript, snapshot.transcript) }
+            : run;
     }
     async startTask(projectId, taskId, expectedRevision) {
         if (isSafeMaintenanceAdmissionClosed()) {
             throw new BoardStoreError("safe_maintenance_draining", "ChatCCC 正在等待安全维护，暂不接受新的 Agent Team 任务。", 409);
         }
-        const release = beginSafeMaintenanceTrackedWork("agent-team-task-start");
-        return this.exclusive(projectId, async () => {
-            let board = await this.options.boardService.getBoard(projectId);
-            const active = (await this.options.repository.listByProject(projectId)).find(isActiveTaskRun);
-            if (active) {
-                if (active.taskId === taskId)
-                    return { board, run: active };
-                throw new BoardStoreError("task_run_busy", "该项目已有任务正在由主 Agent 执行", 409);
-            }
-            if (board.revision !== expectedRevision) {
-                throw new BoardStoreError("revision_conflict", `Board changed in another page (expected revision ${expectedRevision}, current ${board.revision})`, 409);
-            }
-            const task = board.tasks.find((candidate) => candidate.id === taskId && !candidate.deletedAt);
-            if (!task)
-                throw new BoardStoreError("not_found", `Task not found: ${taskId}`, 404);
-            const binding = await this.options.getBinding(projectId);
-            if (!binding || binding.status !== "ready" || !binding.chatId || !binding.sessionId) {
-                throw new BoardStoreError("main_agent_unavailable", "请先为项目设置可用的主 Agent", 409);
-            }
-            if (this.options.runtime.isSessionRunning(binding.sessionId)) {
-                throw new BoardStoreError("task_run_busy", "主 Agent 正在处理其他消息，请稍后再试", 409);
-            }
-            const priorRuns = await this.options.repository.listByProject(projectId);
-            const timestamp = this.now().toISOString();
-            let run = {
-                schemaVersion: 1,
-                runId: this.idFactory(),
-                projectId,
-                taskId,
-                taskTitle: task.title,
-                taskDescription: task.description,
-                attempt: priorRuns.filter((candidate) => candidate.taskId === taskId).length + 1,
-                state: "queued",
-                agentId: binding.agentId,
-                chatId: binding.chatId,
-                sessionId: binding.sessionId,
-                createdAt: timestamp,
-                updatedAt: timestamp,
-            };
-            run = {
-                ...run,
-                transcript: [{ type: "prompt", at: timestamp, text: taskPrompt(run) }],
-            };
-            await this.options.repository.save(run);
-            try {
-                if (task.columnId !== "doing") {
-                    const doingCount = board.tasks.filter((candidate) => !candidate.deletedAt && candidate.columnId === "doing").length;
-                    board = await this.options.boardService.moveTask(projectId, taskId, {
-                        expectedRevision: board.revision,
-                        columnId: "doing",
-                        index: doingCount,
-                    });
+        const release = beginSafeMaintenanceTrackedWork("agent-team-task-run");
+        let releaseOwnedByExecution = false;
+        try {
+            const result = await this.exclusive(projectId, async () => {
+                let board = await this.options.boardService.getBoard(projectId);
+                const active = (await this.options.repository.listByProject(projectId)).find(isActiveTaskRun);
+                if (active) {
+                    if (active.taskId === taskId)
+                        return { board, run: active };
+                    throw new BoardStoreError("task_run_busy", "该项目已有任务正在由主 Agent 执行", 409);
                 }
-            }
-            catch (err) {
-                run = await this.finishRun(run, "failed", { error: err.message });
-                throw err;
-            }
-            const startedAt = this.now().toISOString();
-            run = { ...run, state: "running", startedAt, updatedAt: startedAt };
-            await this.options.repository.save(run);
-            const execution = this.execute(run).finally(() => {
-                this.executions.delete(run.runId);
-            });
-            this.executions.set(run.runId, execution);
-            void execution.catch((err) => {
-                console.error(`[Agent Team] Task run ${run.runId} failed to persist its terminal state: ${err.message}`);
+                if (board.revision !== expectedRevision) {
+                    throw new BoardStoreError("revision_conflict", `Board changed in another page (expected revision ${expectedRevision}, current ${board.revision})`, 409);
+                }
+                const task = board.tasks.find((candidate) => candidate.id === taskId && !candidate.deletedAt);
+                if (!task)
+                    throw new BoardStoreError("not_found", `Task not found: ${taskId}`, 404);
+                const binding = await this.options.getBinding(projectId);
+                if (!binding || binding.status !== "ready" || !binding.chatId || !binding.sessionId) {
+                    throw new BoardStoreError("main_agent_unavailable", "请先为项目设置可用的主 Agent", 409);
+                }
+                if (this.options.runtime.isSessionRunning(binding.sessionId)) {
+                    throw new BoardStoreError("task_run_busy", "主 Agent 正在处理其他消息，请稍后再试", 409);
+                }
+                const priorRuns = await this.options.repository.listByProject(projectId);
+                const timestamp = this.now().toISOString();
+                const runId = this.idFactory();
+                let run = {
+                    schemaVersion: 1,
+                    runId,
+                    projectId,
+                    taskId,
+                    taskTitle: task.title,
+                    taskDescription: task.description,
+                    attempt: priorRuns.filter((candidate) => candidate.taskId === taskId).length + 1,
+                    state: "queued",
+                    agentId: binding.agentId,
+                    chatId: binding.chatId,
+                    sessionId: binding.sessionId,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                    traceId: `agent-team-${runId}`,
+                    lastProgressAt: timestamp,
+                };
+                run = {
+                    ...run,
+                    transcript: [{ type: "prompt", at: timestamp, text: taskPrompt(run) }],
+                };
+                await this.options.repository.save(run);
+                try {
+                    if (task.columnId !== "doing") {
+                        const doingCount = board.tasks.filter((candidate) => !candidate.deletedAt && candidate.columnId === "doing").length;
+                        board = await this.options.boardService.moveTask(projectId, taskId, {
+                            expectedRevision: board.revision,
+                            columnId: "doing",
+                            index: doingCount,
+                        });
+                    }
+                }
+                catch (err) {
+                    run = await this.finishRun(run, "failed", { error: err.message });
+                    throw err;
+                }
+                const startedAt = this.now().toISOString();
+                run = { ...run, state: "running", startedAt, updatedAt: startedAt };
+                await this.options.repository.save(run);
+                logTaskRunEvent("started", run);
+                const execution = this.execute(run).finally(() => {
+                    this.executions.delete(run.runId);
+                    release();
+                });
+                releaseOwnedByExecution = true;
+                this.executions.set(run.runId, execution);
+                void execution.catch((err) => {
+                    console.error(`[Agent Team] Task run ${run.runId} failed to persist its terminal state: ${err.message}`);
+                });
+                return { board, run };
             });
-            return { board, run };
-        }).finally(release);
+            return result;
+        }
+        finally {
+            if (!releaseOwnedByExecution)
+                release();
+        }
     }
     async stopRun(projectId, runId) {
         return this.exclusive(projectId, async () => {
@@ -110,11 +131,19 @@ export class TaskExecutionService {
             if (!isActiveTaskRun(run))
                 return run;
             const now = this.now().toISOString();
-            const updated = { ...run, stopRequestedAt: run.stopRequestedAt ?? now, updatedAt: now };
+            const updated = {
+                ...run,
+                stopRequestedAt: run.stopRequestedAt ?? now,
+                stopDeadlineAt: run.stopDeadlineAt ?? new Date(Date.parse(now) + this.stopTimeoutMs).toISOString(),
+                updatedAt: now,
+            };
             await this.options.repository.save(updated);
             const stopped = this.options.runtime.stop(run.sessionId);
             if (!stopped && !this.options.runtime.isSessionRunning(run.sessionId)) {
-                return this.finishRun(updated, "interrupted", { error: "Task process was no longer running" });
+                return this.finishRun(updated, "interrupted", {
+                    error: "Task process was no longer running",
+                    failureCode: "process_missing",
+                });
             }
             return updated;
         });
@@ -130,35 +159,104 @@ export class TaskExecutionService {
     }
     async recoverInterruptedRuns() {
         const active = await this.options.repository.listActive();
-        await Promise.all(active.map((run) => this.finishRun(run, "interrupted", {
-            error: "ChatCCC restarted while this task was running",
-        })));
+        await Promise.all(active.map(async (run) => {
+            const snapshot = await this.readSnapshot(run);
+            await this.finishRun(run, "interrupted", {
+                error: "ChatCCC restarted while this task was running",
+                failureCode: "chatccc_restart",
+                transcript: snapshot?.transcript,
+            });
+        }));
+        const workspaces = await this.options.boardService.listWorkspaces().catch(() => []);
+        await Promise.all(workspaces.map((workspace) => this.reconcileProject(workspace.boardId)));
+        return active.length;
+    }
+    /** Persist live execution state and enforce stop deadlines. Safe to call repeatedly from a timer. */
+    async checkpointActiveRuns() {
+        const active = await this.options.repository.listActive();
+        await Promise.all(active.map((run) => this.exclusive(run.projectId, () => this.checkpointRun(run.runId))));
+        const pending = [...this.pendingReconciliationProjects];
+        await Promise.all(pending.map((projectId) => this.reconcileProject(projectId)));
         return active.length;
     }
+    async reconcileProject(projectId) {
+        return this.exclusive(projectId, async () => {
+            const runs = await this.options.repository.listByProject(projectId);
+            const latestByTask = new Map();
+            for (const run of runs) {
+                if (!latestByTask.has(run.taskId))
+                    latestByTask.set(run.taskId, run);
+            }
+            let reconciled = 0;
+            let failed = false;
+            for (const run of latestByTask.values()) {
+                // Only repair a transition that this service previously recorded as partial.
+                // A user may intentionally move an already-synced card after completion.
+                if (isActiveTaskRun(run) || run.boardSyncPending !== true)
+                    continue;
+                try {
+                    await this.moveFinishedTask(run);
+                    const now = this.now().toISOString();
+                    await this.options.repository.save({
+                        ...run,
+                        boardSyncPending: false,
+                        reconciledAt: now,
+                        updatedAt: now,
+                        syncError: undefined,
+                    });
+                    reconciled++;
+                }
+                catch (err) {
+                    await this.options.repository.save({
+                        ...run,
+                        boardSyncPending: true,
+                        syncError: err.message,
+                    });
+                    this.pendingReconciliationProjects.add(projectId);
+                    logTaskRunEvent("board_sync_failed", run, { error: err.message });
+                    failed = true;
+                    continue;
+                }
+            }
+            if (!failed)
+                this.pendingReconciliationProjects.delete(projectId);
+            return reconciled;
+        });
+    }
     async execute(run) {
         try {
             const result = await this.options.runtime.run({
                 sessionId: run.sessionId,
                 chatId: run.chatId,
                 agentId: run.agentId,
-                traceId: `agent-team-${run.runId}`,
+                traceId: run.traceId ?? `agent-team-${run.runId}`,
                 prompt: taskPrompt(run),
             });
             if (result.outcome === "done") {
                 return this.finishRun(run, "succeeded", { result: result.result, transcript: result.transcript, moveTask: true });
             }
             if (result.outcome === "stopped") {
-                return this.finishRun(run, "canceled", { error: result.error, transcript: result.transcript, moveTask: true });
+                return this.finishRun(run, "canceled", {
+                    error: result.error,
+                    failureCode: "user_stopped",
+                    transcript: result.transcript,
+                    moveTask: true,
+                });
             }
             return this.finishRun(run, "failed", {
                 error: result.error || (result.outcome === "auto_ended" ? "Agent response timed out" : "Agent execution failed"),
+                failureCode: result.outcome === "auto_ended" ? "agent_timeout" : "agent_error",
                 result: result.result,
                 transcript: result.transcript,
                 moveTask: true,
             });
         }
         catch (err) {
-            return this.finishRun(run, "failed", { error: err.message, moveTask: true });
+            return this.finishRun(run, "failed", {
+                error: err.message,
+                failureCode: "agent_error",
+                moveTask: true,
+            });
         }
     }
     async finishRun(run, state, details = {}) {
@@ -171,35 +269,109 @@ export class TaskExecutionService {
             state,
             updatedAt: now,
             finishedAt: now,
-            ...(details.transcript?.length ? { transcript: mergeTranscript(latest.transcript, details.transcript) } : {}),
+            stalledAt: undefined,
+            lastProgressAt: latestTranscriptAt(details.transcript) ?? latest.lastProgressAt ?? now,
+            ...(details.transcript?.length ? { transcript: combineTranscript(latest.transcript, details.transcript) } : {}),
             ...(details.result ? { result: details.result } : {}),
             ...(details.error ? { error: details.error } : {}),
+            ...(details.failureCode ? { failureCode: details.failureCode } : {}),
+            ...(details.moveTask !== false ? { boardSyncPending: true } : {}),
         };
         await this.options.repository.save(updated);
+        logTaskRunEvent("finished", updated);
         if (details.moveTask !== false) {
-            await this.moveFinishedTask(updated).catch(async (err) => {
+            try {
+                await this.moveFinishedTask(updated);
+                const reconciledAt = this.now().toISOString();
                 await this.options.repository.save({
                     ...updated,
-                    error: updated.error || `Task completed but board update failed: ${err.message}`,
+                    boardSyncPending: false,
+                    reconciledAt,
+                    updatedAt: reconciledAt,
+                    syncError: undefined,
                 });
-            });
+            }
+            catch (err) {
+                await this.options.repository.save({
+                    ...updated,
+                    boardSyncPending: true,
+                    syncError: err.message,
+                });
+                this.pendingReconciliationProjects.add(run.projectId);
+                logTaskRunEvent("board_sync_failed", updated, { error: err.message });
+            }
         }
         return await this.options.repository.get(run.runId) ?? updated;
     }
     async moveFinishedTask(run) {
-        const board = await this.options.boardService.getBoard(run.projectId);
-        const task = board.tasks.find((candidate) => candidate.id === run.taskId && !candidate.deletedAt);
-        if (!task)
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const board = await this.options.boardService.getBoard(run.projectId);
+            const task = board.tasks.find((candidate) => candidate.id === run.taskId && !candidate.deletedAt);
+            if (!task)
+                return;
+            const target = run.state === "succeeded" ? "done" : "on_hold";
+            if (task.columnId === target)
+                return;
+            const targetCount = board.tasks.filter((candidate) => !candidate.deletedAt && candidate.columnId === target).length;
+            try {
+                await this.options.boardService.moveTask(run.projectId, run.taskId, {
+                    expectedRevision: board.revision,
+                    columnId: target,
+                    index: targetCount,
+                });
+                return;
+            }
+            catch (err) {
+                if (!(err instanceof BoardStoreError) || err.code !== "revision_conflict" || attempt === 2)
+                    throw err;
+            }
+        }
+    }
+    async checkpointRun(runId) {
+        const run = await this.options.repository.get(runId);
+        if (!run || !isActiveTaskRun(run))
             return;
-        const target = run.state === "succeeded" ? "done" : "on_hold";
-        if (task.columnId === target)
+        const now = this.now();
+        const snapshot = await this.readSnapshot(run);
+        const transcript = snapshot?.transcript.length
+            ? combineTranscript(run.transcript, snapshot.transcript)
+            : run.transcript;
+        const snapshotProgressAt = latestIso(validIso(snapshot?.updatedAt), run.lastProgressAt ?? run.startedAt ?? run.createdAt);
+        const madeProgress = snapshotProgressAt > (run.lastProgressAt ?? "");
+        const stalled = now.getTime() - Date.parse(snapshotProgressAt) >= this.staleAfterMs;
+        const updated = {
+            ...run,
+            transcript,
+            lastProgressAt: snapshotProgressAt,
+            updatedAt: madeProgress ? now.toISOString() : run.updatedAt,
+            stalledAt: stalled ? (run.stalledAt ?? now.toISOString()) : undefined,
+        };
+        if (JSON.stringify(updated) !== JSON.stringify(run))
+            await this.options.repository.save(updated);
+        if (updated.stopDeadlineAt && Date.parse(updated.stopDeadlineAt) <= now.getTime()) {
+            this.options.runtime.stop(updated.sessionId);
+            await this.finishRun(updated, "canceled", {
+                error: "Agent did not stop before the requested deadline",
+                failureCode: "stop_timeout",
+                transcript: snapshot?.transcript,
+                moveTask: true,
+            });
             return;
-        const targetCount = board.tasks.filter((candidate) => !candidate.deletedAt && candidate.columnId === target).length;
-        await this.options.boardService.moveTask(run.projectId, run.taskId, {
-            expectedRevision: board.revision,
-            columnId: target,
-            index: targetCount,
-        });
+        }
+        const board = await this.options.boardService.getBoard(updated.projectId);
+        const taskExists = board.tasks.some((task) => task.id === updated.taskId && !task.deletedAt);
+        if (!taskExists) {
+            this.options.runtime.stop(updated.sessionId);
+            await this.finishRun(updated, "canceled", {
+                error: "Task was deleted while the Agent was running",
+                failureCode: "task_deleted",
+                transcript: snapshot?.transcript,
+                moveTask: false,
+            });
+        }
+    }
+    async readSnapshot(run) {
+        return this.options.runtime.getSnapshot?.(run.sessionId).catch(() => null) ?? null;
     }
     async exclusive(projectId, operation) {
         const previous = this.projectOperations.get(projectId) ?? Promise.resolve();
@@ -217,8 +389,69 @@ export class TaskExecutionService {
         }
     }
 }
-function mergeTranscript(existing, appended) {
-    return [...(existing ?? []), ...appended];
+function combineTranscript(existing, live) {
+    const prompts = (existing ?? []).filter((entry) => entry.type === "prompt");
+    return compactTranscript([...prompts, ...live]);
+}
+const MAX_TRANSCRIPT_ENTRIES = 2_000;
+const MAX_TRANSCRIPT_CHARS = 2_000_000;
+const MAX_TRANSCRIPT_FIELD_CHARS = 100_000;
+function compactTranscript(entries) {
+    const prompt = entries.find((entry) => entry.type === "prompt");
+    const tail = entries.filter((entry) => entry !== prompt).slice(-(MAX_TRANSCRIPT_ENTRIES - (prompt ? 1 : 0)));
+    const kept = [...(prompt ? [prompt] : []), ...tail].map((entry) => {
+        const compacted = { ...entry };
+        for (const field of ["text", "input", "output"]) {
+            const value = compacted[field];
+            if (value && value.length > MAX_TRANSCRIPT_FIELD_CHARS) {
+                compacted[field] = `${value.slice(0, MAX_TRANSCRIPT_FIELD_CHARS)}\n…（内容已截断）`;
+            }
+        }
+        return compacted;
+    });
+    let remaining = MAX_TRANSCRIPT_CHARS;
+    const result = [];
+    for (let index = kept.length - 1; index >= 0; index--) {
+        const entry = kept[index];
+        const size = JSON.stringify(entry).length;
+        if (size > remaining && result.length)
+            break;
+        result.unshift(entry);
+        remaining -= size;
+    }
+    return result;
+}
+function validIso(value) {
+    if (!value || !Number.isFinite(Date.parse(value)))
+        return null;
+    return new Date(value).toISOString();
+}
+function latestIso(first, second) {
+    if (!first)
+        return second;
+    return Date.parse(first) >= Date.parse(second) ? first : second;
+}
+function latestTranscriptAt(entries) {
+    if (!entries?.length)
+        return null;
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const at = validIso(entries[index]?.at);
+        if (at)
+            return at;
+    }
+    return null;
+}
+function logTaskRunEvent(event, run, details = {}) {
+    console.log(`[Agent Team] ${JSON.stringify({
+        event,
+        projectId: run.projectId,
+        taskId: run.taskId,
+        runId: run.runId,
+        traceId: run.traceId,
+        state: run.state,
+        attempt: run.attempt,
+        ...details,
+    })}`);
 }
 function withoutTranscript(run) {
     const { transcript: _transcript, ...summary } = run;

package/dist/src/agent-team/domain/task-run.js

@@ -22,10 +22,23 @@ export function parseTaskRun(value) {
     }
     if (!isAgentTool(run.agentId))
         throw new Error("Invalid task run Agent");
-    for (const field of ["startedAt", "stopRequestedAt", "finishedAt", "result", "error"]) {
+    for (const field of [
+        "traceId", "startedAt", "stopRequestedAt", "stopDeadlineAt", "finishedAt", "lastProgressAt",
+        "stalledAt", "result", "error", "reconciledAt", "syncError",
+    ]) {
         if (run[field] !== undefined && typeof run[field] !== "string")
             throw new Error(`Invalid task run ${field}`);
     }
+    const failureCodes = [
+        "agent_error", "agent_timeout", "user_stopped", "stop_timeout", "process_missing",
+        "chatccc_restart", "task_deleted",
+    ];
+    if (run.failureCode !== undefined && !failureCodes.includes(run.failureCode)) {
+        throw new Error("Invalid task run failureCode");
+    }
+    if (run.boardSyncPending !== undefined && typeof run.boardSyncPending !== "boolean") {
+        throw new Error("Invalid task run boardSyncPending");
+    }
     if (run.transcript !== undefined && (!Array.isArray(run.transcript) || !run.transcript.every(isExecutionTranscriptEntry))) {
         throw new Error("Invalid task run transcript");
     }

package/dist/src/agent-team/infrastructure/task-execution-runtime.js

@@ -16,8 +16,13 @@ export function createTaskExecutionRuntime(platform) {
                 ...(stream?.terminalError?.message ? { error: stream.terminalError.message } : {}),
             };
         },
-        async getTranscript(sessionId) {
-            return (await readStreamState(sessionId))?.transcript ?? [];
+        async getSnapshot(sessionId) {
+            const state = await readStreamState(sessionId);
+            return {
+                transcript: state?.transcript ?? [],
+                ...(state?.updatedAt ? { updatedAt: new Date(state.updatedAt).toISOString() } : {}),
+                ...(state?.status ? { status: state.status } : {}),
+            };
         },
         stop: stopSession,
         isSessionRunning,

package/dist/src/agent-team/main-agent-bootstrap.js

@@ -6,8 +6,13 @@ import { createTaskExecutionRuntime } from "./infrastructure/task-execution-runt
 import { feishuP2pContactStore } from "./repositories/feishu-p2p-contact-store.js";
 import { JsonMainAgentBindingRepository } from "./repositories/main-agent-binding-repository.js";
 import { JsonTaskRunRepository } from "./repositories/json-task-run-repository.js";
+const TASK_RUN_CHECKPOINT_INTERVAL_MS = 3_000;
+let taskRunMonitor = null;
+let taskRunMonitorBusy = false;
+let taskRunMonitorGeneration = 0;
 /** Wire runtime dependencies only from index.ts, keeping the standalone Web UI import side-effect free. */
 export function configureAgentTeamMainAgent(platform) {
+    const monitorGeneration = ++taskRunMonitorGeneration;
     const bindingRepository = new JsonMainAgentBindingRepository();
     const mainAgentService = new MainAgentService({
         boardService: defaultAgentTeamBoardService,
@@ -24,7 +29,25 @@ export function configureAgentTeamMainAgent(platform) {
     });
     setDefaultAgentTeamMainAgentService(mainAgentService);
     setDefaultAgentTeamTaskExecutionService(taskExecutionService);
-    void taskExecutionService.recoverInterruptedRuns().catch((err) => {
+    if (taskRunMonitor)
+        clearInterval(taskRunMonitor);
+    void taskExecutionService.recoverInterruptedRuns()
+        .catch((err) => {
         console.error(`[Agent Team] Failed to recover interrupted task runs: ${err.message}`);
+    })
+        .finally(() => {
+        if (monitorGeneration !== taskRunMonitorGeneration)
+            return;
+        taskRunMonitor = setInterval(() => {
+            if (taskRunMonitorBusy)
+                return;
+            taskRunMonitorBusy = true;
+            void taskExecutionService.checkpointActiveRuns()
+                .catch((err) => {
+                console.error(`[Agent Team] Failed to checkpoint task runs: ${err.message}`);
+            })
+                .finally(() => { taskRunMonitorBusy = false; });
+        }, TASK_RUN_CHECKPOINT_INTERVAL_MS);
+        taskRunMonitor.unref?.();
     });
 }

package/dist/src/agent-team/repositories/json-task-run-repository.js

@@ -16,8 +16,10 @@ export class JsonTaskRunRepository {
                 return parseTaskRun(JSON.parse(await readFile(this.pathFor(projectId, runId), "utf8")));
             }
             catch (err) {
-                if (err.code !== "ENOENT")
-                    throw err;
+                if (err.code === "ENOENT")
+                    continue;
+                await quarantineCorruptRun(this.pathFor(projectId, runId), err);
+                return null;
             }
         }
         return null;
@@ -41,8 +43,19 @@ export class JsonTaskRunRepository {
         }
         const runs = await Promise.all(entries
             .filter((entry) => entry.endsWith(".json"))
-            .map(async (entry) => parseTaskRun(JSON.parse(await readFile(join(directory, entry), "utf8")))));
-        return runs.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.runId.localeCompare(a.runId));
+            .map(async (entry) => {
+            const path = join(directory, entry);
+            try {
+                return parseTaskRun(JSON.parse(await readFile(path, "utf8")));
+            }
+            catch (err) {
+                await quarantineCorruptRun(path, err);
+                return null;
+            }
+        }));
+        return runs
+            .filter((run) => run !== null)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.runId.localeCompare(a.runId));
     }
     async listActive() {
         const projectIds = await this.projectDirectories();
@@ -96,3 +109,8 @@ async function writeJsonAtomic(path, value) {
         throw err;
     }
 }
+async function quarantineCorruptRun(path, err) {
+    const quarantinePath = `${path}.corrupt-${Date.now()}`;
+    await rename(path, quarantinePath).catch(() => { });
+    console.error(`[Agent Team] Quarantined corrupt task run ${path}: ${err.message}`);
+}