brainclaw 0.28.0 → 1.5.3

package/dist/core/agentruns.js

@@ -0,0 +1,424 @@
+/**
+ * AgentRun lifecycle — concrete execution attempts for an Assignment.
+ *
+ * Assignment stays the business coordination object.
+ * AgentRun tracks one concrete launch / pickup / retry attempt.
+ *
+ * @module
+ */
+import fs from 'node:fs';
+import { AgentRunSchema } from './schema.js';
+import { resolveEntityDir } from './io.js';
+import { mutate } from './mutation-pipeline.js';
+import { nowISO, generateIdWithLabel } from './ids.js';
+import { JsonStore } from './json-store.js';
+import { appendAuditEntry } from './audit.js';
+import { appendEvent } from './event-log.js';
+import { createRuntimeEvent } from './events.js';
+function agentRunsDir(cwd, mode = 'read') {
+    return resolveEntityDir('runs', cwd, mode);
+}
+function ensureAgentRunsDir(cwd) {
+    const dir = agentRunsDir(cwd, 'write');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function agentRunStore(cwd) {
+    return new JsonStore({
+        dirPath: agentRunsDir(cwd, 'read'),
+        documentType: 'agent_run',
+        getId: (run) => run.id,
+        sort: (a, b) => {
+            const byAssignment = a.assignment_id.localeCompare(b.assignment_id);
+            if (byAssignment !== 0)
+                return byAssignment;
+            return a.created_at.localeCompare(b.created_at);
+        },
+    });
+}
+export function saveAgentRun(run, cwd) {
+    mutate({ cwd }, () => {
+        ensureAgentRunsDir(cwd);
+        const store = new JsonStore({
+            dirPath: agentRunsDir(cwd, 'write'),
+            documentType: 'agent_run',
+            getId: (item) => item.id,
+            sort: (a, b) => a.created_at.localeCompare(b.created_at),
+        });
+        store.save(AgentRunSchema.parse(run));
+    });
+}
+export function loadAgentRun(id, cwd) {
+    try {
+        return agentRunStore(cwd).load(id);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function listAgentRuns(cwd, filter) {
+    let runs = agentRunStore(cwd).list();
+    if (filter?.status)
+        runs = runs.filter((run) => run.status === filter.status);
+    if (filter?.agent)
+        runs = runs.filter((run) => run.agent === filter.agent);
+    if (filter?.assignment_id)
+        runs = runs.filter((run) => run.assignment_id === filter.assignment_id);
+    if (filter?.claim_id)
+        runs = runs.filter((run) => run.claim_id === filter.claim_id);
+    if (filter?.plan_id)
+        runs = runs.filter((run) => run.plan_id === filter.plan_id);
+    if (filter?.sequence_id)
+        runs = runs.filter((run) => run.sequence_id === filter.sequence_id);
+    if (filter?.transport)
+        runs = runs.filter((run) => run.transport === filter.transport);
+    return runs;
+}
+export function generateAgentRunId(cwd) {
+    return generateIdWithLabel('runs', cwd);
+}
+function nextAttemptIndex(assignmentId, cwd) {
+    const existing = listAgentRuns(cwd, { assignment_id: assignmentId });
+    if (existing.length === 0)
+        return 1;
+    return Math.max(...existing.map((run) => run.attempt_index)) + 1;
+}
+export function findLatestAgentRunForAssignment(assignmentId, cwd) {
+    const runs = listAgentRuns(cwd, { assignment_id: assignmentId });
+    if (runs.length === 0)
+        return undefined;
+    return [...runs].sort((left, right) => {
+        if (left.attempt_index !== right.attempt_index)
+            return right.attempt_index - left.attempt_index;
+        return right.created_at.localeCompare(left.created_at);
+    })[0];
+}
+const VALID_TRANSITIONS = new Map([
+    ['created', new Set(['launching', 'waiting_input', 'running', 'cancelled', 'interrupted'])],
+    ['launching', new Set(['waiting_input', 'running', 'failed', 'cancelled', 'timed_out', 'interrupted'])],
+    ['waiting_input', new Set(['launching', 'running', 'blocked', 'cancelled', 'timed_out', 'interrupted'])],
+    ['running', new Set(['blocked', 'completed', 'failed', 'cancelled', 'timed_out', 'interrupted'])],
+    ['blocked', new Set(['running', 'cancelled', 'timed_out', 'interrupted'])],
+    ['completed', new Set()],
+    ['failed', new Set()],
+    ['cancelled', new Set()],
+    ['timed_out', new Set()],
+    ['interrupted', new Set()],
+]);
+export function createAgentRun(options, cwd) {
+    const generated = options.id ? undefined : generateAgentRunId(cwd);
+    const now = nowISO();
+    const run = AgentRunSchema.parse({
+        schema_version: 1,
+        id: options.id ?? generated.id,
+        short_label: options.short_label ?? generated.short_label,
+        assignment_id: options.assignment_id,
+        claim_id: options.claim_id,
+        message_id: options.message_id,
+        plan_id: options.plan_id,
+        sequence_id: options.sequence_id,
+        retry_of_run_id: options.retry_of_run_id,
+        attempt_index: options.attempt_index ?? nextAttemptIndex(options.assignment_id, cwd),
+        agent: options.agent,
+        agent_id: options.agent_id,
+        session_id: options.session_id,
+        transport: options.transport,
+        status: options.status ?? 'created',
+        status_reason: options.status_reason,
+        scope: options.scope,
+        description: options.description,
+        worktree_path: options.worktree_path,
+        command: options.command,
+        shell: options.shell,
+        pid: options.pid,
+        provider_run_id: options.provider_run_id,
+        created_at: now,
+        updated_at: now,
+        last_event_at: now,
+        ...(options.status === 'launching' ? { launched_at: now } : {}),
+        ...(options.status === 'running' ? { started_at: now, launched_at: now } : {}),
+        ...(options.status === 'waiting_input' ? { launched_at: now } : {}),
+        artifacts: [],
+        tags: options.tags ?? [],
+    });
+    saveAgentRun(run, cwd);
+    emitAgentRunEvent(run, 'run_created', options.agent, cwd);
+    if (run.status !== 'created') {
+        emitAgentRunEvent(run, `run_${run.status}`, options.agent, cwd);
+    }
+    appendAuditEntry({
+        actor: options.agent,
+        actor_id: options.agent_id,
+        action: 'create',
+        item_id: run.id,
+        item_type: 'agent_run',
+        after: { assignment_id: run.assignment_id, status: run.status, transport: run.transport },
+        scope: run.scope,
+        session_id: run.session_id,
+    }, cwd);
+    return run;
+}
+export function transitionAgentRun(id, newStatus, options = {}, cwd) {
+    const run = loadAgentRun(id, cwd);
+    if (!run)
+        throw new Error(`AgentRun not found: ${id}`);
+    if (run.status === newStatus) {
+        const now = nowISO();
+        run.updated_at = now;
+        run.last_event_at = now;
+        if (options.session_id)
+            run.session_id = options.session_id;
+        if (options.status_reason)
+            run.status_reason = options.status_reason;
+        if (options.pid)
+            run.pid = options.pid;
+        if (options.provider_run_id)
+            run.provider_run_id = options.provider_run_id;
+        if (options.artifacts?.length)
+            run.artifacts = [...run.artifacts, ...options.artifacts];
+        saveAgentRun(run, cwd);
+        return { run, previous_status: newStatus, idempotent: true };
+    }
+    const allowed = VALID_TRANSITIONS.get(run.status);
+    if (!allowed?.has(newStatus)) {
+        throw new Error(`Invalid AgentRun transition: ${run.status} -> ${newStatus}`);
+    }
+    const previous_status = run.status;
+    const now = nowISO();
+    run.status = newStatus;
+    run.updated_at = now;
+    run.last_event_at = now;
+    if (options.session_id)
+        run.session_id = options.session_id;
+    if (options.status_reason)
+        run.status_reason = options.status_reason;
+    if (options.error_message)
+        run.error_message = options.error_message;
+    if (options.artifacts?.length)
+        run.artifacts = [...run.artifacts, ...options.artifacts];
+    if (options.pid)
+        run.pid = options.pid;
+    if (options.provider_run_id)
+        run.provider_run_id = options.provider_run_id;
+    switch (newStatus) {
+        case 'launching':
+            run.launched_at = now;
+            break;
+        case 'waiting_input':
+            run.launched_at ??= now;
+            break;
+        case 'running':
+            run.launched_at ??= now;
+            run.started_at = now;
+            break;
+        case 'blocked':
+            run.blocked_at = now;
+            break;
+        case 'completed':
+            run.completed_at = now;
+            break;
+        case 'failed':
+            run.failed_at = now;
+            break;
+        case 'cancelled':
+            run.cancelled_at = now;
+            break;
+        case 'timed_out':
+            run.timed_out_at = now;
+            break;
+        case 'interrupted':
+            run.interrupted_at = now;
+            break;
+    }
+    saveAgentRun(run, cwd);
+    emitAgentRunEvent(run, `run_${newStatus}`, options.actor, cwd);
+    appendAuditEntry({
+        actor: options.actor ?? run.agent,
+        actor_id: options.actor_id,
+        action: 'update',
+        item_id: run.id,
+        item_type: 'agent_run',
+        before: { status: previous_status },
+        after: { status: newStatus, reason: options.status_reason },
+        scope: run.scope,
+        session_id: options.session_id,
+    }, cwd);
+    return { run, previous_status };
+}
+export function recordAgentRunProgress(id, options = {}, cwd) {
+    const run = loadAgentRun(id, cwd);
+    if (!run)
+        throw new Error(`AgentRun not found: ${id}`);
+    if (run.status === 'created' || run.status === 'launching' || run.status === 'waiting_input' || run.status === 'blocked') {
+        transitionAgentRun(id, 'running', {
+            actor: options.actor,
+            actor_id: options.actor_id,
+            session_id: options.session_id,
+            status_reason: options.message,
+            artifacts: options.artifacts,
+        }, cwd);
+        return loadAgentRun(id, cwd);
+    }
+    if (run.status !== 'running') {
+        throw new Error(`Cannot record progress: run ${id} is ${run.status}, expected running`);
+    }
+    const now = nowISO();
+    run.updated_at = now;
+    run.last_event_at = now;
+    if (options.session_id)
+        run.session_id = options.session_id;
+    if (options.message)
+        run.status_reason = options.message;
+    if (options.artifacts?.length)
+        run.artifacts = [...run.artifacts, ...options.artifacts];
+    saveAgentRun(run, cwd);
+    emitAgentRunEvent(run, 'run_running', options.actor, cwd);
+    return run;
+}
+/** Check if a run transition is allowed before attempting it (best-effort sync). */
+function canTransitionRun(run, target) {
+    if (run.status === target)
+        return true; // idempotent
+    const allowed = VALID_TRANSITIONS.get(run.status);
+    return !!allowed?.has(target);
+}
+export function syncAgentRunFromAssignmentTransition(assignment, newStatus, options = {}, cwd) {
+    const run = findLatestAgentRunForAssignment(assignment.id, cwd);
+    if (!run)
+        return;
+    switch (newStatus) {
+        case 'accepted': {
+            const now = nowISO();
+            run.updated_at = now;
+            run.last_event_at = now;
+            if (options.session_id)
+                run.session_id = options.session_id;
+            if (options.status_reason)
+                run.status_reason = options.status_reason;
+            saveAgentRun(run, cwd);
+            return;
+        }
+        case 'started':
+            if (!canTransitionRun(run, 'running'))
+                return;
+            transitionAgentRun(run.id, 'running', {
+                actor: options.actor,
+                actor_id: options.actor_id,
+                session_id: options.session_id,
+                status_reason: options.status_reason,
+            }, cwd);
+            return;
+        case 'completed':
+            if (!canTransitionRun(run, 'completed'))
+                return;
+            transitionAgentRun(run.id, 'completed', {
+                actor: options.actor,
+                actor_id: options.actor_id,
+                session_id: options.session_id,
+                status_reason: options.status_reason,
+                artifacts: options.artifacts,
+            }, cwd);
+            return;
+        case 'failed':
+            if (!canTransitionRun(run, 'failed'))
+                return;
+            transitionAgentRun(run.id, 'failed', {
+                actor: options.actor,
+                actor_id: options.actor_id,
+                session_id: options.session_id,
+                status_reason: options.status_reason,
+                artifacts: options.artifacts,
+                error_message: options.error_message,
+            }, cwd);
+            return;
+        case 'blocked':
+            if (!canTransitionRun(run, 'blocked'))
+                return;
+            transitionAgentRun(run.id, 'blocked', {
+                actor: options.actor,
+                actor_id: options.actor_id,
+                session_id: options.session_id,
+                status_reason: options.status_reason,
+            }, cwd);
+            return;
+        case 'timed_out':
+            if (!canTransitionRun(run, 'timed_out'))
+                return;
+            transitionAgentRun(run.id, 'timed_out', {
+                actor: options.actor,
+                actor_id: options.actor_id,
+                session_id: options.session_id,
+                status_reason: options.status_reason,
+            }, cwd);
+            return;
+        case 'expired':
+        case 'rerouted':
+            if (!canTransitionRun(run, 'interrupted'))
+                return;
+            transitionAgentRun(run.id, 'interrupted', {
+                actor: options.actor,
+                actor_id: options.actor_id,
+                session_id: options.session_id,
+                status_reason: options.status_reason ?? `${newStatus} via assignment lifecycle`,
+            }, cwd);
+            return;
+        case 'retrying':
+            if (!['completed', 'failed', 'cancelled', 'timed_out', 'interrupted'].includes(run.status)) {
+                if (!canTransitionRun(run, 'interrupted'))
+                    return;
+                transitionAgentRun(run.id, 'interrupted', {
+                    actor: options.actor,
+                    actor_id: options.actor_id,
+                    session_id: options.session_id,
+                    status_reason: options.status_reason ?? 'Retry requested at assignment level',
+                }, cwd);
+            }
+            return;
+        default:
+            return;
+    }
+}
+function emitAgentRunEvent(run, action, actor, cwd) {
+    const text = `${run.description} [${run.status}/${run.transport}]${run.status_reason ? ` — ${run.status_reason}` : ''}`;
+    appendEvent({
+        ts: nowISO(),
+        agent: actor ?? run.agent,
+        agent_id: run.agent_id,
+        action,
+        item_type: 'agent_run',
+        item_id: run.id,
+        summary: `${run.status}: ${run.description.slice(0, 80)}`,
+    }, cwd);
+    try {
+        createRuntimeEvent({
+            agent: actor ?? run.agent,
+            agent_id: run.agent_id,
+            session_id: run.session_id,
+            event_type: action,
+            text,
+            tags: ['agent-runtime', 'run'],
+            assignment_id: run.assignment_id,
+            run_id: run.id,
+            claim_id: run.claim_id,
+            message_id: run.message_id,
+            plan_id: run.plan_id,
+            sequence_id: run.sequence_id,
+            scope: run.scope,
+            transport: run.transport,
+            status: run.status,
+            status_reason: run.status_reason,
+            related_paths: [run.scope],
+            metadata: {
+                attempt_index: run.attempt_index,
+                retry_of_run_id: run.retry_of_run_id,
+                provider_run_id: run.provider_run_id,
+                protocol: 'brainclaw.agent_runtime.v0',
+            },
+        }, cwd);
+    }
+    catch {
+        /* best-effort: runtime event emission should not break run lifecycle */
+    }
+}
+//# sourceMappingURL=agentruns.js.map

package/dist/core/ai-agent-detection.js

@@ -32,17 +32,19 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
         };
     }
     // Claude Code — tested BEFORE Copilot because both can be present in VS Code.
-    // CLAUDE_CODE_VERSION is set by Claude Code CLI; CLAUDECODE is set by the VS Code extension.
-    if (env.CLAUDE_CODE_VERSION || env.CLAUDECODE || env.ANTHROPIC_AI_PRODUCT === 'claude-code') {
+    // CLAUDE_CODE_VERSION is set by Claude Code CLI; CLAUDECODE is set by the VS Code extension;
+    // CLAUDE_AGENT_SDK_VERSION is set on remote/SSH; CLAUDE_CODE_ENTRYPOINT indicates launch source.
+    if (env.CLAUDE_CODE_VERSION || env.CLAUDECODE || env.CLAUDE_AGENT_SDK_VERSION || env.CLAUDE_CODE_ENTRYPOINT || env.ANTHROPIC_AI_PRODUCT === 'claude-code') {
+        const source = env.CLAUDE_CODE_VERSION ? 'CLAUDE_CODE_VERSION env var'
+            : env.CLAUDECODE ? 'CLAUDECODE env var'
+                : env.CLAUDE_AGENT_SDK_VERSION ? 'CLAUDE_AGENT_SDK_VERSION env var'
+                    : env.CLAUDE_CODE_ENTRYPOINT ? 'CLAUDE_CODE_ENTRYPOINT env var'
+                        : 'ANTHROPIC_AI_PRODUCT env var';
         return {
             name: 'claude-code',
             kind: 'agent',
             trust_level: 'trusted',
-            detection_source: env.CLAUDE_CODE_VERSION
-                ? 'CLAUDE_CODE_VERSION env var'
-                : env.CLAUDECODE
-                    ? 'CLAUDECODE env var'
-                    : 'ANTHROPIC_AI_PRODUCT env var',
+            detection_source: source,
         };
     }
     // Cursor IDE
@@ -86,13 +88,20 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: env.GITHUB_COPILOT_PRODUCT ? 'GITHUB_COPILOT_PRODUCT env var' : 'GITHUB_COPILOT_TOKEN env var',
         };
     }
-    // OpenAI Codex CLI (~/.codex/ presence)
-    if (fs.existsSync(path.join(homeDir, '.codex'))) {
+    // OpenAI Codex CLI — detect via active runtime env vars, not ~/.codex directory
+    // (the directory persists after install and causes permanent false positives).
+    // Real Codex env vars observed: CODEX_THREAD_ID, CODEX_CI, CODEX_INTERNAL_ORIGINATOR_OVERRIDE.
+    if (env.CODEX_THREAD_ID || env.CODEX_CI || env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE || env.CODEX_AGENT || env.CODEX_SESSION_ID) {
+        const source = env.CODEX_THREAD_ID ? 'CODEX_THREAD_ID env var'
+            : env.CODEX_CI ? 'CODEX_CI env var'
+                : env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE ? 'CODEX_INTERNAL_ORIGINATOR_OVERRIDE env var'
+                    : env.CODEX_AGENT ? 'CODEX_AGENT env var'
+                        : 'CODEX_SESSION_ID env var';
         return {
             name: 'codex',
             kind: 'agent',
             trust_level: 'trusted',
-            detection_source: '~/.codex directory',
+            detection_source: source,
         };
     }
     // OpenCode
@@ -140,6 +149,18 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
             detection_source: env.OPENCLAW_SESSION_ID || env.OPENCLAW_AGENT ? 'OPENCLAW_* env var' : '~/.openclaw directory',
         };
     }
+    // Mistral Vibe — no dedicated session env var documented (per pln#489 research).
+    // Detect via the user-level config dir (~/.vibe/) which Mistral creates on first
+    // run, or via VIBE_HOME override. Tested last so other agents with dedicated
+    // session env vars take precedence.
+    if (env.VIBE_HOME || fs.existsSync(path.join(homeDir, '.vibe'))) {
+        return {
+            name: 'mistral-vibe',
+            kind: 'agent',
+            trust_level: 'trusted',
+            detection_source: env.VIBE_HOME ? 'VIBE_HOME env var' : '~/.vibe directory',
+        };
+    }
     return undefined;
 }
 /**

package/dist/core/archival.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveEntityDir } from './io.js';
+import { logger } from './logger.js';
+/** Default age threshold: items older than 30 days are eligible for archival. */
+const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Archive done plans and closed handoffs older than maxAgeMs to JSONL cold storage.
+ * Each entity type gets its own archive file (e.g. coordination/plans/archive.jsonl).
+ * Archived items are appended as one JSON line per item, then the source file is deleted.
+ * This is lossless — all data is preserved in the archive.
+ */
+export function archiveStalePlansAndHandoffs(cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+    const results = [];
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    results.push(archiveEntity('plans', cutoff, (item) => {
+        return item.status === 'done' || item.status === 'dropped';
+    }, cwd));
+    results.push(archiveEntity('handoffs', cutoff, (item) => {
+        return item.status === 'closed';
+    }, cwd));
+    return results.filter(r => r.archived > 0);
+}
+function archiveEntity(entity, cutoffDate, isEligible, cwd) {
+    const dir = resolveEntityDir(entity, cwd ?? process.cwd(), 'read');
+    const archivePath = path.join(dir, 'archive.jsonl');
+    if (!fs.existsSync(dir)) {
+        return { archived: 0, entity, archivePath };
+    }
+    let archived = 0;
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json') && f !== 'archive.json');
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const item = JSON.parse(content);
+            // Check eligibility: correct status AND older than cutoff
+            const createdAt = (item.completed_at ?? item.updated_at ?? item.created_at);
+            if (!isEligible(item))
+                continue;
+            if (createdAt && createdAt > cutoffDate)
+                continue;
+            // Append to archive JSONL
+            fs.mkdirSync(path.dirname(archivePath), { recursive: true });
+            fs.appendFileSync(archivePath, JSON.stringify(item) + '\n', 'utf-8');
+            // Delete source file
+            fs.unlinkSync(filePath);
+            archived++;
+        }
+        catch (err) {
+            logger.debug(`Failed to archive ${entity}/${file}:`, err);
+        }
+    }
+    return { archived, entity, archivePath };
+}
+/**
+ * Read archived items from a JSONL archive file.
+ * Useful for search/audit across archived entities.
+ */
+export function readArchive(entity, cwd) {
+    const dir = resolveEntityDir(entity, cwd ?? process.cwd(), 'read');
+    const archivePath = path.join(dir, 'archive.jsonl');
+    if (!fs.existsSync(archivePath))
+        return [];
+    const lines = fs.readFileSync(archivePath, 'utf-8').split('\n').filter(Boolean);
+    const items = [];
+    for (const line of lines) {
+        try {
+            items.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    return items;
+}
+//# sourceMappingURL=archival.js.map

package/dist/core/assignment-sweeper.js

@@ -0,0 +1,82 @@
+/**
+ * Assignment timeout sweeper — detects stuck/expired assignments.
+ *
+ * Runs opportunistically (no daemon): integrated into dispatch().
+ * Future: integrate into session_start() and expose as CLI `brainclaw sweep`.
+ *
+ * @module
+ */
+import { listAssignments, transitionAssignment } from './assignments.js';
+// ── Sweeper ──────────────────────────────────────────────────
+/**
+ * Scan all active assignments and timeout those past their TTL.
+ *
+ * - `started` assignments with no heartbeat within `heartbeat_ttl_ms` → `timed_out`
+ * - `offered` assignments not accepted within `acceptance_ttl_ms` → `expired`
+ *
+ * @param cwd - Project root
+ * @param options.nowMs - Override current time for testing
+ * @param options.actor - Actor name for audit trail (default: 'sweeper')
+ */
+export function sweepAssignments(cwd, options) {
+    const now = options?.nowMs ?? Date.now();
+    const actor = options?.actor ?? 'sweeper';
+    const result = { timed_out: [], expired: [] };
+    const all = listAssignments(cwd);
+    for (const assignment of all) {
+        // Check started assignments for heartbeat timeout
+        if (assignment.status === 'started') {
+            const lastBeat = assignment.last_heartbeat_at ?? assignment.started_at;
+            if (!lastBeat)
+                continue;
+            const ageMs = now - new Date(lastBeat).getTime();
+            if (ageMs > assignment.heartbeat_ttl_ms) {
+                try {
+                    transitionAssignment(assignment.id, 'timed_out', {
+                        status_reason: `No heartbeat for ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.heartbeat_ttl_ms / 60_000)}min)`,
+                        actor,
+                    }, cwd);
+                    result.timed_out.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
+                }
+                catch { /* skip: transition may fail if status changed concurrently */ }
+            }
+        }
+        // Check accepted assignments that never started (accepted but worker died before starting)
+        if (assignment.status === 'accepted') {
+            const acceptedAt = assignment.accepted_at ?? assignment.last_heartbeat_at;
+            if (!acceptedAt)
+                continue;
+            const ageMs = now - new Date(acceptedAt).getTime();
+            // Use acceptance_ttl for accepted→timed_out (same window: agent should start quickly after accepting)
+            if (ageMs > assignment.acceptance_ttl_ms) {
+                try {
+                    transitionAssignment(assignment.id, 'timed_out', {
+                        status_reason: `Accepted but not started within ${Math.round(ageMs / 60_000)} minutes`,
+                        actor,
+                    }, cwd);
+                    result.timed_out.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
+                }
+                catch { /* skip */ }
+            }
+        }
+        // Check offered assignments for acceptance timeout
+        if (assignment.status === 'offered') {
+            const offeredAt = assignment.offered_at;
+            if (!offeredAt)
+                continue;
+            const ageMs = now - new Date(offeredAt).getTime();
+            if (ageMs > assignment.acceptance_ttl_ms) {
+                try {
+                    transitionAssignment(assignment.id, 'expired', {
+                        status_reason: `Not accepted within ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.acceptance_ttl_ms / 60_000)}min)`,
+                        actor,
+                    }, cwd);
+                    result.expired.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=assignment-sweeper.js.map