brainclaw 0.29.2 → 1.5.3

package/dist/core/candidates.js

@@ -6,6 +6,39 @@ import { resolveEntityDir } from './io.js';
 import { mutate } from './mutation-pipeline.js';
 import { nowISO, getNextShortLabel } from './ids.js';
 import { JsonStore } from './json-store.js';
+import { refreshLiveCompanions } from '../commands/export.js';
+/**
+ * Return the effective source for a candidate.
+ *
+ * Resolution order:
+ *   1. Explicit `source` field if set to a valid enum value ('auto'|'agent'|'human').
+ *   2. Inferred from `origin` free-text pattern (e.g. 'runtime-note:...' → 'agent',
+ *      'session-end:...' → 'auto', 'mcp:...' / 'cross-project:...' → 'agent').
+ *   3. Default 'human' for legacy items without any provenance.
+ *
+ * This default is only applied in memory — no files are rewritten.
+ */
+export function resolvedSource(candidate) {
+    if (candidate.source)
+        return candidate.source;
+    return inferSourceFromOrigin(candidate.origin);
+}
+/** Infer the enum `source` from a free-text `origin` pattern. */
+export function inferSourceFromOrigin(origin) {
+    if (!origin)
+        return 'human';
+    if (origin.startsWith('session-end:'))
+        return 'auto';
+    if (origin.startsWith('runtime-note:'))
+        return 'agent';
+    if (origin.startsWith('mcp:'))
+        return 'agent';
+    if (origin.startsWith('cross-project:'))
+        return 'agent';
+    // Unknown origin pattern — treat as agent since something explicit was set,
+    // but not matching an auto pattern. Human sources typically have no origin.
+    return 'agent';
+}
 function inboxDir(cwd, mode = 'read') {
     return resolveEntityDir('inbox', cwd ?? process.cwd(), mode);
 }
@@ -39,6 +72,11 @@ export function saveCandidate(candidate, cwd) {
     mutate({ cwd }, () => {
         ensureInboxDirs(cwd);
         candidateStore('pending', cwd).save(CandidateSchema.parse(candidate));
+        // Auto-refresh live companions after candidate changes (non-fatal)
+        try {
+            refreshLiveCompanions(cwd);
+        }
+        catch { /* best-effort */ }
     });
 }
 export function loadCandidate(id, cwd) {
@@ -47,15 +85,36 @@ export function loadCandidate(id, cwd) {
 export function updateCandidate(candidate, cwd) {
     saveCandidate(candidate, cwd);
 }
-export function listCandidates(status, cwd) {
+export function listCandidates(status, cwd, filter) {
     const candidates = candidateStore('pending', cwd).list();
-    return status ? candidates.filter((candidate) => candidate.status === status) : candidates;
+    const byStatus = status ? candidates.filter((candidate) => candidate.status === status) : candidates;
+    return applySourceFilter(byStatus, filter);
+}
+function applySourceFilter(candidates, filter) {
+    if (!filter)
+        return candidates;
+    let result = candidates;
+    if (filter.source !== undefined) {
+        result = result.filter((c) => resolvedSource(c) === filter.source);
+    }
+    if (filter.auto_generated === false) {
+        result = result.filter((c) => resolvedSource(c) !== 'auto');
+    }
+    else if (filter.auto_generated === true) {
+        result = result.filter((c) => resolvedSource(c) === 'auto');
+    }
+    return result;
 }
 export function archiveCandidate(candidate, dest, cwd) {
     mutate({ cwd }, () => {
         ensureInboxDirs(cwd);
         candidateStore(dest, cwd).save(CandidateSchema.parse(candidate));
         candidateStore('pending', cwd).delete(candidate.id);
+        // Auto-refresh live companions after candidate archive (non-fatal)
+        try {
+            refreshLiveCompanions(cwd);
+        }
+        catch { /* best-effort */ }
     });
 }
 export function listArchivedCandidates(dest, cwd) {
@@ -70,6 +129,38 @@ export function deleteArchivedCandidate(id, dest, cwd) {
     }
     return false;
 }
+export function cleanupStaleCandidates(options = {}) {
+    const maxAgeDays = options.maxAgeDays ?? 30;
+    const source = options.source ?? 'auto';
+    const cutoffMs = Date.now() - maxAgeDays * 86_400_000;
+    const candidates = listCandidates('pending', options.cwd).filter((candidate) => {
+        if (resolvedSource(candidate) !== source)
+            return false;
+        return Date.parse(candidate.created_at) <= cutoffMs;
+    });
+    if (options.dryRun || candidates.length === 0) {
+        return {
+            matched: candidates.length,
+            deleted: 0,
+            candidates,
+        };
+    }
+    mutate({ cwd: options.cwd }, () => {
+        const store = candidateStore('pending', options.cwd);
+        for (const candidate of candidates) {
+            store.delete(candidate.id);
+        }
+        try {
+            refreshLiveCompanions(options.cwd);
+        }
+        catch { /* best-effort */ }
+    });
+    return {
+        matched: candidates.length,
+        deleted: candidates.length,
+        candidates,
+    };
+}
 export function addCandidateStar(id, by, cwd) {
     const candidate = loadCandidate(id, cwd);
     if (candidate.status !== 'pending') {

package/dist/core/claims.js

@@ -5,6 +5,26 @@ import { resolveEntityDir } from './io.js';
 import { mutate } from './mutation-pipeline.js';
 import { nowISO } from './ids.js';
 import { JsonStore } from './json-store.js';
+import { loadConfig } from './config.js';
+import { createWorktree } from './worktree.js';
+import { appendAuditEntry } from './audit.js';
+import { refreshLiveCompanions } from '../commands/export.js';
+import { loadSessionById } from './identity.js';
+import { loadState, persistState } from './state.js';
+import { createRuntimeEvent } from './events.js';
+/** Parse duration string like '4h', '30m' to ms. */
+function parseTtl(value) {
+    const match = /^(\d+)([mhd])$/i.exec(value.trim());
+    if (!match)
+        return 4 * 3_600_000;
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (unit === 'm')
+        return amount * 60_000;
+    if (unit === 'h')
+        return amount * 3_600_000;
+    return amount * 86_400_000;
+}
 function claimsDir(cwd, mode = 'read') {
     return resolveEntityDir('claims', cwd ?? process.cwd(), mode);
 }
@@ -32,6 +52,11 @@ export function saveClaim(claim, cwd) {
             sort: (a, b) => a.created_at.localeCompare(b.created_at),
         });
         writeStore.save(ClaimSchema.parse(claim));
+        // Auto-refresh live companions after claim changes (non-fatal)
+        try {
+            refreshLiveCompanions(cwd);
+        }
+        catch { /* best-effort */ }
     });
 }
 export function loadClaim(id, cwd) {
@@ -47,6 +72,96 @@ export function releaseClaim(id, cwd) {
     saveClaim(claim, cwd);
     return claim;
 }
+/**
+ * Release a claim and optionally cascade the status to its linked plan.
+ *
+ * Rules:
+ * - planStatus='done'    → only transition plan if NO OTHER active claims on same plan (last-claim rule).
+ *                          If other active claims exist, warn and leave plan in_progress.
+ * - planStatus='blocked' → always propagate to plan.
+ * - planStatus='todo'/'in_progress' or undefined → no cascade.
+ *
+ * Emits `plan_cascade_to_done` runtime event when auto-transitioning to done.
+ */
+export function releaseClaimWithCascade(id, options = {}) {
+    const { planStatus, cwd } = options;
+    // Release the claim (idempotent: already-released claims are returned as-is)
+    const claim = loadClaim(id, cwd);
+    if (claim.status === 'released') {
+        return { claim, planTransitioned: false };
+    }
+    claim.status = 'released';
+    claim.released_at = nowISO();
+    saveClaim(claim, cwd);
+    appendAuditEntry({
+        actor: claim.agent,
+        actor_id: claim.agent_id,
+        action: 'release_claim',
+        item_id: id,
+        item_type: 'claim',
+        scope: claim.scope,
+        session_id: claim.session_id,
+        host_id: claim.host_id,
+    }, cwd);
+    // No cascade requested or no linked plan
+    if (!planStatus || !claim.plan_id) {
+        return { claim, planTransitioned: false };
+    }
+    const state = loadState(cwd);
+    const plan = state.plan_items.find((item) => item.id === claim.plan_id);
+    if (!plan) {
+        return { claim, planTransitioned: false };
+    }
+    const ts = nowISO();
+    if (planStatus === 'blocked') {
+        // Always propagate blocked status to plan
+        plan.status = 'blocked';
+        plan.updated_at = ts;
+        persistState(state, cwd);
+        return { claim, planTransitioned: true, planId: plan.id, newPlanStatus: 'blocked' };
+    }
+    if (planStatus === 'done') {
+        // Count OTHER active claims on the same plan (current claim already released above)
+        const otherActive = listClaims(cwd).filter((c) => c.status === 'active' && c.plan_id === claim.plan_id && c.id !== id);
+        if (otherActive.length > 0) {
+            const planWarning = `Plan has ${otherActive.length} other active claim(s); staying in_progress`;
+            appendAuditEntry({
+                actor: claim.agent,
+                action: 'update',
+                item_id: plan.id,
+                item_type: 'plan',
+                after: { cascade_blocked: true, reason: planWarning },
+            }, cwd);
+            return {
+                claim,
+                planTransitioned: false,
+                planWarning,
+                planId: plan.id,
+                newPlanStatus: plan.status,
+                otherActiveClaimsCount: otherActive.length,
+            };
+        }
+        // Last active claim released → auto-transition plan to done
+        plan.status = 'done';
+        if (!plan.completed_at)
+            plan.completed_at = ts;
+        plan.updated_at = ts;
+        persistState(state, cwd);
+        createRuntimeEvent({
+            agent: claim.agent,
+            agent_id: claim.agent_id,
+            event_type: 'plan_cascade_to_done',
+            claim_id: id,
+            plan_id: plan.id,
+            session_id: claim.session_id,
+            host_id: claim.host_id,
+            text: `Plan ${plan.id} auto-transitioned to done — last active claim released by ${claim.agent}`,
+        }, cwd);
+        return { claim, planTransitioned: true, planId: plan.id, newPlanStatus: 'done' };
+    }
+    // planStatus='todo', 'in_progress', or other — no cascade
+    return { claim, planTransitioned: false };
+}
 export function generateClaimId() {
     const rand = crypto.randomBytes(4).toString('hex');
     return `clm_${rand}`;
@@ -72,4 +187,308 @@ export function expireStaleActiveClaims(cwd) {
     }
     return count;
 }
+/** Default stale threshold: 24 hours. */
+const DEFAULT_STALE_HOURS = 24;
+/**
+ * Threshold below which a newly created claim is considered "young" and must not be auto-released,
+ * even if it has no session yet (coordinator claims are created before the worker session starts).
+ */
+const YOUNG_CLAIM_THRESHOLD_MS = 30 * 60_000; // 30 minutes
+/**
+ * Assess the liveness of an active claim against session state.
+ *
+ * Decision tree:
+ *  1. Young (< 30 min) → never auto-release — dispatcher may not have sent the worker yet.
+ *  2. Has session_id + session alive → 'live' — long-running work; do NOT release.
+ *  3. Has session_id + adopted_at + session dead → 'orphaned' — crash recovery scenario.
+ *  4. Has session_id + no adopted_at + session dead → 'stale' — direct agent claim, session ended.
+ *  5. No session_id + old → 'never-adopted' — coordinator claim never dispatched.
+ *  6. No session_id + within threshold → 'young'.
+ */
+export function assessClaimLiveness(claim, options = {}) {
+    const nowMs = options.nowMs ?? Date.now();
+    const thresholdMs = (options.thresholdHours ?? DEFAULT_STALE_HOURS) * 3_600_000;
+    const ageMs = nowMs - new Date(claim.created_at).getTime();
+    // 1. Too young to classify — don't release (worker may not have started yet)
+    if (ageMs < YOUNG_CLAIM_THRESHOLD_MS) {
+        return {
+            status: 'young',
+            reason: 'Claim is less than 30 minutes old — too new to classify',
+            ageMs,
+        };
+    }
+    // 2–4. Has a session_id — check session liveness
+    if (claim.session_id) {
+        let sessionAgeMs;
+        let sessionAlive = false;
+        let sessionMissing = false;
+        const sessionTtlMs = options.sessionTtlMs ?? resolveSessionTtlMs(options.cwd);
+        try {
+            const session = loadSessionById(claim.session_id, options.cwd);
+            if (session) {
+                sessionAgeMs = nowMs - new Date(session.last_seen_at).getTime();
+                sessionAlive = sessionAgeMs < sessionTtlMs;
+            }
+            else {
+                // File not found — session either ended cleanly (session-end deletes it)
+                // or the record was deleted externally. Either way, session cannot return.
+                sessionMissing = true;
+            }
+        }
+        catch {
+            // Session file error — treat as dead to avoid hanging claims forever.
+            sessionMissing = true;
+        }
+        if (sessionAlive) {
+            return {
+                status: 'live',
+                reason: `Session ${claim.session_id} is active (last_seen_at within TTL)`,
+                ageMs,
+                sessionAgeMs,
+            };
+        }
+        // Session is dead or not found.
+        if (claim.adopted_at) {
+            // Worker was dispatched and formally adopted the claim — this is a crash.
+            const sessionDesc = sessionMissing
+                ? 'session record cannot be found'
+                : `last seen ${Math.round((sessionAgeMs ?? 0) / 3_600_000)}h ago`;
+            return {
+                status: 'orphaned',
+                reason: `Session ${claim.session_id} was adopted at ${claim.adopted_at} but is now dead (${sessionDesc})`,
+                ageMs,
+                sessionAgeMs,
+            };
+        }
+        // Direct agent claim, no adopted_at, session dead (Phase 4 slice pln#388):
+        // once we have confirmed the session cannot return — either the file is
+        // missing (clean end) or last_seen_at is well past the TTL — mark stale
+        // immediately. The old 24h age threshold forced orphaned claims to hang
+        // around purely because of wall-clock age, even though we already knew
+        // they belonged to a dead session.
+        const sessionConfirmedDead = sessionMissing
+            || (sessionAgeMs !== undefined && sessionAgeMs >= sessionTtlMs + YOUNG_CLAIM_THRESHOLD_MS);
+        if (sessionConfirmedDead) {
+            const reason = sessionMissing
+                ? `Session ${claim.session_id} record is gone (ended cleanly or deleted externally)`
+                : `Session ${claim.session_id} last_seen_at is ${Math.round((sessionAgeMs ?? 0) / 3_600_000)}h past TTL`;
+            return {
+                status: 'stale',
+                reason,
+                ageMs,
+                sessionAgeMs,
+            };
+        }
+        // Session last_seen_at just slipped past TTL — allow a short grace window
+        // in case the session heartbeat catches up (brief disconnect).
+        return {
+            status: 'young',
+            reason: 'Session is briefly past TTL — waiting for heartbeat or confirmed end',
+            ageMs,
+            sessionAgeMs,
+        };
+    }
+    // 5–6. No session_id — coordinator claim that was never dispatched
+    if (ageMs >= thresholdMs) {
+        return {
+            status: 'never-adopted',
+            reason: `No session ever adopted this claim and it is ${Math.round(ageMs / 3_600_000)}h old (threshold: ${options.thresholdHours ?? DEFAULT_STALE_HOURS}h)`,
+            ageMs,
+        };
+    }
+    return {
+        status: 'young',
+        reason: 'Claim has not been adopted by a session yet but is still within the stale threshold',
+        ageMs,
+    };
+}
+/** Resolve session TTL from config, falling back to 4 hours. */
+function resolveSessionTtlMs(cwd) {
+    try {
+        return parseTtl(loadConfig(cwd).implicit_session_ttl ?? '4h');
+    }
+    catch {
+        return 4 * 3_600_000;
+    }
+}
+/**
+ * Check if a claim is stale based on session-aware liveness.
+ * Returns true for 'stale', 'orphaned', and 'never-adopted' statuses.
+ * A claim with a live session is never considered stale regardless of age.
+ */
+export function isClaimStale(claim, thresholdHours, cwd) {
+    if (claim.status !== 'active')
+        return false;
+    const { status } = assessClaimLiveness(claim, { thresholdHours, cwd });
+    return status === 'stale' || status === 'orphaned' || status === 'never-adopted';
+}
+/**
+ * Detect and auto-release stale claims across the store.
+ *
+ * Phase 4 slice pln#388 stp_e2b10ab4: session-aware safety. When a
+ * `currentSessionId` is provided, the sweep skips only claims that
+ * belong to THAT session — prior-session claims from the same agent
+ * are legitimately reclaimable (crash recovery for the same agent on
+ * reconnect). Without `currentSessionId` we fall back to the old
+ * "skip same agent" rule to stay source-compatible.
+ *
+ * Uses claims.auto_release_after from config (default 24h).
+ * Skips claims whose session is still live ('live') or too young to
+ * classify ('young'). Releases 'stale', 'orphaned' (crash recovery),
+ * and 'never-adopted' claims.
+ */
+export function releaseStaleClaimsFromOtherAgents(currentAgent, cwd, currentSessionId) {
+    const config = loadConfig(cwd);
+    const thresholdHours = config.claims?.auto_release_after_hours ?? DEFAULT_STALE_HOURS;
+    const store = claimStore(cwd);
+    const all = store.list();
+    const now = nowISO();
+    const released = [];
+    const warned = [];
+    for (const claim of all) {
+        if (claim.status !== 'active')
+            continue;
+        // Session-aware skip: if the caller names its current session, only that
+        // session's claims are off-limits. Otherwise fall back to the legacy
+        // "skip same agent" rule.
+        if (currentSessionId) {
+            if (claim.session_id === currentSessionId)
+                continue;
+        }
+        else if (claim.agent === currentAgent) {
+            continue;
+        }
+        const { status } = assessClaimLiveness(claim, { thresholdHours, cwd });
+        if (status === 'live' || status === 'young')
+            continue;
+        claim.status = 'released';
+        claim.released_at = now;
+        store.save(claim);
+        released.push(claim);
+    }
+    return { released, warned };
+}
+/**
+ * Create a coordinator-owned claim with worktree isolation.
+ * Encapsulates: generateClaimId + createWorktree + saveClaim + audit.
+ * Used by both bclaw_dispatch and bclaw_coordinate assign/reroute.
+ */
+export function createCoordinatorClaim(options) {
+    // Scope lock is GLOBAL: any active claim on the same scope blocks, regardless of agent.
+    const existingScopeClaim = listClaims(options.cwd).find((claim) => claim.status === 'active' && claim.scope === options.scope);
+    if (existingScopeClaim) {
+        if (existingScopeClaim.agent === options.agent) {
+            // Same agent already has this scope — reuse the claim (backward compat, same-agent multi-call).
+            return {
+                claimId: existingScopeClaim.id,
+                worktreePath: existingScopeClaim.worktree_path,
+                reusedExisting: true,
+            };
+        }
+        // DIFFERENT agent has an active claim on this scope — scope is locked.
+        // Return the existing claim info + a conflict flag so the dispatcher can skip.
+        return {
+            claimId: existingScopeClaim.id,
+            worktreePath: existingScopeClaim.worktree_path,
+            reusedExisting: true,
+            scopeConflict: true,
+            conflictAgent: existingScopeClaim.agent,
+        };
+    }
+    const claimId = generateClaimId();
+    let worktreePath;
+    let worktreeWarning;
+    // Create isolated worktree (matching bclaw_claim MCP handler behavior)
+    const branchSlug = options.scope.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-').slice(0, 48);
+    const worktreeBranch = `feat/${branchSlug}`;
+    try {
+        worktreePath = createWorktree(options.cwd, worktreeBranch, {
+            sessionId: options.sessionId,
+            agent: options.agent,
+            baseRef: options.worktreeBaseRef,
+            resetExistingBranch: options.resetExistingWorktreeBranch,
+        });
+    }
+    catch (err) {
+        worktreeWarning = `Worktree creation failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    saveClaim({
+        id: claimId,
+        agent: options.agent,
+        scope: options.scope,
+        description: options.description,
+        plan_id: options.planId,
+        created_at: nowISO(),
+        status: 'active',
+        worktree_path: worktreePath,
+    }, options.cwd);
+    appendAuditEntry({
+        actor: options.dispatcherAgent,
+        action: 'claim',
+        item_id: claimId,
+        item_type: 'claim',
+        scope: options.scope,
+    }, options.cwd);
+    return { claimId, worktreePath, worktreeWarning, reusedExisting: false };
+}
+// ── Claim lifecycle helpers for multi-instance dispatch ────
+/**
+ * Attach the assignment message ID to a claim (for tracing claim→message→instance).
+ * Called by the dispatcher after sending the inbox message.
+ */
+export function attachAssignmentMessageToClaim(claimId, messageId, cwd) {
+    const claim = loadClaim(claimId, cwd);
+    claim.assignment_message_id = messageId;
+    saveClaim(claim, cwd);
+}
+/** Link a claim to its Assignment entity (Agent SDK runtime protocol). */
+export function linkClaimToAssignment(claimId, assignmentId, cwd) {
+    const claim = loadClaim(claimId, cwd);
+    claim.assignment_id = assignmentId;
+    saveClaim(claim, cwd);
+}
+/**
+ * Adopt a claim from a spawned instance's session.
+ * Sets session_id + adopted_at on the claim. Refuses if the claim is already
+ * adopted by a different live session (prevents race conditions).
+ *
+ * Codex r1 finding (pln#388 stp_aa095668 review): the whole load/decide/save
+ * sequence runs inside a single `mutate` critical section so two reconnecting
+ * workers racing on a dead-session claim cannot both succeed — the second
+ * adopter re-reads the claim under the lock and observes the first
+ * adopter's session_id as live.
+ */
+export function adoptClaimSession(claimId, sessionId, cwd) {
+    return mutate({ cwd }, () => {
+        const claim = loadClaim(claimId, cwd);
+        if (claim.status !== 'active') {
+            return { adopted: false, reason: `Claim ${claimId} is not active (status: ${claim.status})` };
+        }
+        if (claim.session_id && claim.session_id !== sessionId) {
+            // Check if the existing session is still alive — allow re-adoption if dead/stale
+            let isAlive = false;
+            try {
+                const existingSession = loadSessionById(claim.session_id, cwd);
+                if (existingSession) {
+                    let ttlMs = 4 * 3_600_000; // default 4h
+                    try {
+                        ttlMs = parseTtl(loadConfig(cwd).implicit_session_ttl ?? '4h');
+                    }
+                    catch { /* use default */ }
+                    const lastSeen = new Date(existingSession.last_seen_at).getTime();
+                    isAlive = !isNaN(lastSeen) && (Date.now() - lastSeen) < ttlMs;
+                }
+            }
+            catch { /* session file error — treat as dead */ }
+            if (isAlive) {
+                return { adopted: false, reason: `Claim ${claimId} already adopted by live session ${claim.session_id}` };
+            }
+            // Existing session is dead/stale — allow re-adoption
+        }
+        claim.session_id = sessionId;
+        claim.adopted_at = nowISO();
+        saveClaim(claim, cwd);
+        return { adopted: true, reason: 'ok' };
+    });
+}
 //# sourceMappingURL=claims.js.map

package/dist/core/codev-metrics.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { memoryDir } from './io.js';
+function sanitizeForPath(slug) {
+    return slug.replace(/[<>:"/\\|?*]/g, '_');
+}
+export function metricsPath(threadSlug, cwd) {
+    return path.join(memoryDir(cwd), 'coordination', 'ideation', sanitizeForPath(threadSlug), 'metrics.jsonl');
+}
+export function recordResponse(threadSlug, metric, cwd) {
+    const file = metricsPath(threadSlug, cwd);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(metric)}\n`, 'utf8');
+}
+function isMetric(v) {
+    const m = v;
+    return !!m && typeof m.thread_id === 'string' && typeof m.round === 'number' &&
+        typeof m.persona === 'string' && typeof m.agent_name === 'string' &&
+        typeof m.dispatched_at === 'string' && typeof m.responded_at === 'string' &&
+        typeof m.duration_ms === 'number';
+}
+export function loadMetrics(threadSlug, cwd) {
+    try {
+        const data = fs.readFileSync(metricsPath(threadSlug, cwd), 'utf8');
+        const out = [];
+        for (const line of data.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (isMetric(parsed))
+                    out.push(parsed);
+            }
+            catch { }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function computeSummary(entries) {
+    if (!entries.length)
+        return { avg_ms: 0, p95_ms: 0, by_agent: {} };
+    const durations = entries.map((m) => m.duration_ms).sort((a, b) => a - b);
+    const avg_ms = durations.reduce((s, d) => s + d, 0) / durations.length;
+    const p95_ms = durations[Math.ceil(0.95 * durations.length) - 1];
+    const sums = {};
+    for (const m of entries) {
+        const entry = sums[m.agent_name] ?? { sum: 0, count: 0 };
+        entry.sum += m.duration_ms;
+        entry.count += 1;
+        sums[m.agent_name] = entry;
+    }
+    const by_agent = {};
+    for (const [agent, v] of Object.entries(sums))
+        by_agent[agent] = { avg_ms: v.sum / v.count, count: v.count };
+    return { avg_ms, p95_ms, by_agent };
+}
+export function summarizeMetrics(threadSlug, cwd) {
+    return computeSummary(loadMetrics(threadSlug, cwd));
+}
+export function summarizeMetricsByRound(threadSlug, cwd) {
+    const metrics = loadMetrics(threadSlug, cwd);
+    const byRound = {};
+    for (const m of metrics) {
+        (byRound[m.round] ??= []).push(m);
+    }
+    return Object.entries(byRound)
+        .sort(([a], [b]) => Number(a) - Number(b))
+        .map(([round, entries]) => ({
+        round: Number(round),
+        ...computeSummary(entries),
+        count: entries.length,
+    }));
+}
+//# sourceMappingURL=codev-metrics.js.map

package/dist/core/codev-personas.js

@@ -0,0 +1,31 @@
+/**
+ * CoDev persona definitions for multi-perspective ideation.
+ * @module
+ */
+export const CODEV_PERSONAS = {
+    tier1: [
+        { name: 'visionnaire', focus: 'radical possibilities, unconventional approaches, what becomes possible if we remove all constraints' },
+        { name: 'conservateur', focus: 'risks, technical debt, maintainability, what could go wrong and what we will regret' },
+        { name: 'produit', focus: 'user impact, adoption friction, who benefits and how this changes their workflow' },
+        { name: 'avocat_du_diable', focus: 'challenge every assumption, find the weakest argument, stress-test the premise' },
+        { name: 'simplificateur', focus: 'cut complexity ruthlessly, find the 80/20, what is the smallest thing that works' },
+    ],
+    tier2: [
+        { name: 'stratege', focus: 'competitive moat, long-term positioning, what makes this defensible' },
+        { name: 'scenariste', focus: 'what-if scenarios, edge cases, how this plays out under different futures' },
+        { name: 'systemicien', focus: 'second-order effects, feedback loops, unintended consequences across the system' },
+        { name: 'opportuniste', focus: 'quick wins, low-hanging fruit, what can we ship this week that moves the needle' },
+        { name: 'temporaliste', focus: 'past lessons, present constraints, future trajectory — what does the timeline tell us' },
+    ],
+};
+export function listPersonas() {
+    const lines = [];
+    for (const [tier, personas] of Object.entries(CODEV_PERSONAS)) {
+        lines.push(`${tier}:`);
+        for (const p of personas) {
+            lines.push(`  ${p.name} — ${p.focus}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=codev-personas.js.map