wendkeep 0.66.3 → 0.66.5

package/hooks/session-stop.mjs

@@ -8,8 +8,13 @@ import { addUsage, costBreakdown, emptyTokenUsage, normalizeClaudeUsage, normali
 import { buildBrainDigest, buildBrainIndex } from './brain-core.mjs';
 import { activeChangeLink, pruneChangeSentinels } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
-import { updateSessionObservability } from './session-observability.mjs';
+import { materializeSessionObservability } from './session-observability.mjs';
 import { resolveSessionEntry } from './session-identity.mjs';
+import { resolveObservabilityRoots } from './session-observability-lifecycle.mjs';
+import {
+  markObservabilityCheckpoint,
+  readObservabilityStore,
+} from './session-observability-store.mjs';
 import { mutateSessionNote } from './session-note-io.mjs';
 import { applyDerivedSections, provenanceSessions } from './derived-sections.mjs';
 import { buildSessionMemoryEvents, collectLifecycleEvidence } from './memory-handoff.mjs';
@@ -794,7 +799,206 @@ export function shouldAbortStopAfterStaging(causalStop, memoryAttempt) {
   );
 }
 
-export function main({ stageMemory = stageStopMemoryAttempt } = {}) {
+const STOP_OBSERVABILITY_DEADLINE_MS = 45_000;
+
+function stopEntryCausalSnapshot(entry) {
+  const activationId = String(entry?.active_activation_id || '');
+  const activation = entry?.activations?.[activationId] || {};
+  return {
+    activationId,
+    activationEpoch: Number(activation.epoch || entry?.activation_epoch || 0),
+    turnSequence: Number(entry?.last_turn_sequence || activation.last_turn_sequence || 0),
+  };
+}
+
+function expectedStopCausalSnapshot(entry, causalStop, turnSequence) {
+  if (!causalStop) return stopEntryCausalSnapshot(entry);
+  return {
+    activationId: String(causalStop.activationId || ''),
+    activationEpoch: Number(causalStop.activation?.epoch || entry?.activation_epoch || 0),
+    turnSequence: Number(turnSequence || 0),
+  };
+}
+
+function sameStopCausalSnapshot(left, right) {
+  return left.activationId === right.activationId
+    && left.activationEpoch === right.activationEpoch
+    && left.turnSequence === right.turnSequence;
+}
+
+function stopClaudeRoots(entry) {
+  const paths = new Set();
+  const add = (value) => {
+    if (typeof value === 'string' && value.trim()) paths.add(value.trim());
+  };
+  add(entry?.transcript_path);
+  for (const path of entry?.transcript_paths || []) add(path);
+  for (const activation of Object.values(entry?.activations || {})) {
+    add(activation?.transcript_path);
+    for (const path of activation?.transcript_paths || []) add(path);
+  }
+  return { state: 'complete', rootPaths: [...paths], descendantPaths: [], diagnostics: [] };
+}
+
+function materializeStopObservability(request) {
+  return materializeSessionObservability({
+    vaultBase: request.vaultBase,
+    sessionPath: request.sessionPath,
+    transcriptPath: request.transcriptPath,
+    entry: request.entry,
+    canonicalConversationId: request.canonicalConversationId,
+    frontier: request.frontier,
+    signals: request.signals,
+    cache: request.cache,
+    mode: 'live',
+    deadlineAt: request.deadlineAt,
+    now: request.now,
+    allowNone: request.allowNone,
+    readRuntimeFrontier: request.readRuntimeFrontier,
+    withPublicationGuard: request.withPublicationGuard,
+    writeRegistryCheckpoint: request.writeRegistryCheckpoint,
+  });
+}
+
+export async function refreshStopObservability({
+  vaultBase,
+  input,
+  sessionPath,
+  sessionId,
+  entry,
+  causalStop,
+  turnSequence,
+  hookStartedAt,
+  expectedSignalSequence,
+}, {
+  now = Date.now,
+  resolveEntry = resolveSessionEntry,
+  mutateRegistry = mutateSessionRegistry,
+  readStore = readObservabilityStore,
+  resolveRoots = resolveObservabilityRoots,
+  materialize = materializeStopObservability,
+} = {}) {
+  if (causalStop && !causalStop.canPromoteMemory) return false;
+  const deadlineAt = hookStartedAt + STOP_OBSERVABILITY_DEADLINE_MS;
+  if (now() >= deadlineAt) return false;
+
+  const expected = expectedStopCausalSnapshot(entry, causalStop, turnSequence);
+  const fresh = resolveEntry(vaultBase, input, entry?.provider);
+  if (fresh.identity?.state !== 'resolved'
+    || fresh.identity.canonicalConversationId !== sessionId
+    || !fresh.entry?.session_file
+    || fresh.entry.session_file !== entry?.session_file
+    || !sameStopCausalSnapshot(expected, stopEntryCausalSnapshot(fresh.entry))) return false;
+
+  const runtime = readStore(vaultBase, sessionId);
+  const signalSequence = Number(runtime?.observability_signal_sequence || 0);
+  if (expectedSignalSequence !== undefined
+    && signalSequence !== Number(expectedSignalSequence)) return false;
+  if (now() >= deadlineAt) return false;
+
+  const roots = fresh.identity.provider === 'codex'
+    ? resolveRoots(fresh.entry)
+    : stopClaudeRoots(fresh.entry);
+  if (roots?.state !== 'complete' || !roots.rootPaths?.length) return false;
+
+  const frontier = {
+    canonical_session_id: sessionId,
+    activation_id: expected.activationId || 'legacy',
+    activation_epoch: expected.activationEpoch,
+    turn_sequence: expected.turnSequence,
+    signal_sequence: signalSequence,
+    roots_stat_hash: 'pending',
+    graph_cursor: 'pending',
+    source_manifest_hash: 'pending',
+  };
+  const readRuntimeFrontier = (candidateFrontier, guardContext) => {
+    const currentEntry = guardContext?.entry;
+    const current = currentEntry
+      ? { identity: { state: 'resolved', canonicalConversationId: sessionId }, entry: currentEntry }
+      : resolveEntry(vaultBase, input, entry?.provider);
+    if (current.identity?.state !== 'resolved'
+      || current.identity.canonicalConversationId !== sessionId
+      || !current.entry) {
+      return { ...candidateFrontier, canonical_session_id: 'unresolved' };
+    }
+    const currentCausal = stopEntryCausalSnapshot(current.entry);
+    const currentRuntime = readStore(vaultBase, sessionId);
+    return {
+      ...candidateFrontier,
+      activation_id: currentCausal.activationId || 'legacy',
+      activation_epoch: currentCausal.activationEpoch,
+      turn_sequence: currentCausal.turnSequence,
+      signal_sequence: Math.max(
+        Number(currentRuntime?.observability_signal_sequence || 0),
+        Number(current.entry.observability_signal_sequence || 0),
+      ),
+    };
+  };
+  const withPublicationGuard = (_candidateFrontier, publishGuarded) => (
+    mutateRegistry(vaultBase, (registry) => publishGuarded({
+      registry,
+      entry: registry.sessions?.[sessionId] || null,
+    }))
+  );
+  const writeRegistryCheckpoint = ({
+    frontier: checkpointFrontier,
+    state,
+    diagnostics,
+    snapshot,
+  }, guardContext) => {
+    const registry = guardContext?.registry;
+    const current = registry?.sessions?.[sessionId];
+    if (!current) return null;
+    const currentSignal = Number(current.observability_signal_sequence || checkpointFrontier.signal_sequence);
+    registry.sessions[sessionId] = {
+      ...current,
+      observability_signal_sequence: currentSignal,
+      observability_checkpoint_sequence: checkpointFrontier.signal_sequence,
+      observability_dirty: currentSignal > checkpointFrontier.signal_sequence,
+      observability_checkpoint_frontier: checkpointFrontier,
+      subagents_observability_state: state,
+      subagents_diagnostics: diagnostics || [],
+    };
+    return markObservabilityCheckpoint(vaultBase, sessionId, {
+      checkpointSequence: checkpointFrontier.signal_sequence,
+      frontier: checkpointFrontier,
+      sourceManifest: snapshot?.subagents?.sourceManifest,
+      graphCache: snapshot?.subagents?.cache,
+      diagnostics,
+    });
+  };
+
+  const result = await Promise.resolve(materialize({
+    vaultBase,
+    sessionPath,
+    entry: fresh.entry,
+    rootPaths: roots.rootPaths,
+    transcriptPath: roots.rootPaths[0],
+    caller: 'stop',
+    canonicalConversationId: sessionId,
+    activationId: expected.activationId,
+    activationEpoch: expected.activationEpoch,
+    turnSequence: expected.turnSequence,
+    signalSequence,
+    deadlineAt,
+    allowNone: true,
+    frontier,
+    signals: runtime?.signals || [],
+    cache: runtime?.graph_cache || null,
+    now,
+    readRuntimeFrontier,
+    withPublicationGuard,
+    writeRegistryCheckpoint,
+  }));
+  return !['stale', 'conflict', 'degraded', 'missing'].includes(result?.status);
+}
+
+export async function main({
+  stageMemory = stageStopMemoryAttempt,
+  clock = Date.now,
+  refreshObservability = refreshStopObservability,
+} = {}) {
+  const hookStartedAt = clock();
   const input = readHookInput();
   if (input.stop_hook_active) {
     writeHookOutput({});
@@ -961,8 +1165,17 @@ export function main({ stageMemory = stageStopMemoryAttempt } = {}) {
   }
 
   try {
-    updateSessionObservability({
-      vaultBase, sessionPath, transcriptPath, caller: 'stop', canonicalConversationId: sessionId,
+    await refreshObservability({
+      vaultBase,
+      input,
+      sessionPath,
+      sessionId,
+      entry,
+      causalStop,
+      turnSequence: stopTurnSequence,
+      hookStartedAt,
+    }, {
+      now: clock,
     });
   } catch (error) {
     process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
@@ -1062,7 +1275,7 @@ export function main({ stageMemory = stageStopMemoryAttempt } = {}) {
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
-    main();
+    await main();
   } catch (error) {
     process.stderr.write(`[wendkeep] Stop falhou: ${error.message}\n`);
     // Same reasoning as the identity bail: stderr is discarded by Codex. Exit stays 0 —

package/hooks/subagent-stop.mjs

@@ -8,29 +8,283 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { readHookInput, writeHookOutput, getVaultBase, providerMeta } from './obsidian-common.mjs';
-import { updateSessionObservability } from './session-observability.mjs';
+import {
+  getVaultBase,
+  mutateSessionRegistry,
+  providerMeta,
+  readHookInput,
+  writeHookOutput,
+} from './obsidian-common.mjs';
+import { materializeSessionObservability } from './session-observability.mjs';
 import { resolveSessionEntry } from './session-identity.mjs';
+import { readCodexRolloutMeta } from './codex-rollout-meta.mjs';
+import { resolveObservabilityRoots } from './session-observability-lifecycle.mjs';
+import {
+  readObservabilityStore,
+  markObservabilityCheckpoint,
+  recordObservabilitySignal,
+  releaseObservabilityLease,
+  tryAcquireObservabilityLease,
+} from './session-observability-store.mjs';
 
-export function refreshSubagents(vaultBase, input) {
-  const { identity, entry } = resolveSessionEntry(vaultBase, input, providerMeta(input.provider).id);
+const SUBAGENT_COALESCE_MS = 250;
+const SUBAGENT_DEADLINE_MS = 15_000;
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function causalSnapshot(entry) {
+  const activationId = String(entry?.active_activation_id || '');
+  const activation = entry?.activations?.[activationId] || {};
+  return {
+    activationId,
+    activationEpoch: Number(activation.epoch || entry?.activation_epoch || 0),
+    turnSequence: Number(entry?.last_turn_sequence || activation.last_turn_sequence || 0),
+  };
+}
+
+function sameCausalSnapshot(left, right) {
+  return left.activationId === right.activationId
+    && left.activationEpoch === right.activationEpoch
+    && left.turnSequence === right.turnSequence;
+}
+
+function defaultMaterialize(request) {
+  return materializeSessionObservability({
+    vaultBase: request.vaultBase,
+    sessionPath: request.sessionPath,
+    transcriptPath: request.transcriptPath,
+    entry: request.entry,
+    canonicalConversationId: request.canonicalConversationId,
+    frontier: request.frontier,
+    signals: request.signals,
+    cache: request.cache,
+    mode: 'live',
+    deadlineAt: request.deadlineAt,
+    now: request.now,
+    allowNone: request.allowNone,
+    readRuntimeFrontier: request.readRuntimeFrontier,
+    withPublicationGuard: request.withPublicationGuard,
+    writeRegistryCheckpoint: request.writeRegistryCheckpoint,
+  });
+}
+
+function claudeRoots(entry) {
+  const paths = new Set();
+  const add = (value) => {
+    if (typeof value === 'string' && value.trim()) paths.add(value.trim());
+  };
+  add(entry?.transcript_path);
+  for (const path of entry?.transcript_paths || []) add(path);
+  for (const activation of Object.values(entry?.activations || {})) {
+    add(activation?.transcript_path);
+    for (const path of activation?.transcript_paths || []) add(path);
+  }
+  return { state: 'complete', rootPaths: [...paths], descendantPaths: [], diagnostics: [] };
+}
+
+export async function refreshSubagents(vaultBase, input, {
+  now = Date.now,
+  hookStartedAt = now(),
+  sleep = wait,
+  coalesceMs = SUBAGENT_COALESCE_MS,
+  deadlineMs = SUBAGENT_DEADLINE_MS,
+  resolveEntry = resolveSessionEntry,
+  readMeta = readCodexRolloutMeta,
+  mutateRegistry = mutateSessionRegistry,
+  recordSignal = recordObservabilitySignal,
+  readStore = readObservabilityStore,
+  acquireLease = tryAcquireObservabilityLease,
+  releaseLease = releaseObservabilityLease,
+  resolveRoots = resolveObservabilityRoots,
+  materialize = defaultMaterialize,
+} = {}) {
+  const deadlineAt = hookStartedAt + deadlineMs;
+  const provider = providerMeta(input.provider).id;
+  const { identity, entry } = resolveEntry(vaultBase, input, provider);
   if (identity.state !== 'resolved') return false;
-  const transcriptPath = identity.transcriptPath;
+  const childTranscriptPath = identity.transcriptPath;
   const sessionRel = entry?.session_file || '';
   if (!sessionRel) return false;
-  const sessionPath = join(vaultBase, sessionRel);
-  if (!existsSync(sessionPath)) return false;
-  updateSessionObservability({
-    vaultBase, sessionPath, transcriptPath, caller: 'subagent-stop',
-    canonicalConversationId: identity.canonicalConversationId,
+
+  let childParentThreadId = '';
+  if (identity.provider === 'codex') {
+    const childMeta = readMeta(childTranscriptPath);
+    if (!childMeta?.ok || !childMeta.meta?.source?.subagent) return false;
+    if (!childMeta.meta.id || childMeta.meta.id !== identity.transcriptId) return false;
+    if (childMeta.meta.session_id
+      && childMeta.meta.session_id !== identity.canonicalConversationId) return false;
+    childParentThreadId = String(
+      childMeta.meta.parent_thread_id
+      || childMeta.meta.source?.subagent?.thread_spawn?.parent_thread_id
+      || '',
+    );
+  }
+
+  const observed = causalSnapshot(entry);
+  const signal = mutateRegistry(vaultBase, (registry) => {
+    const current = registry.sessions?.[identity.canonicalConversationId];
+    if (!current || current.session_file !== sessionRel
+      || !sameCausalSnapshot(observed, causalSnapshot(current))) return null;
+    const recorded = recordSignal(vaultBase, identity.canonicalConversationId, {
+      rollout_id: identity.transcriptId,
+      transcript_path: childTranscriptPath,
+      parent_thread_id: childParentThreadId,
+      kind: 'started',
+      activation_id: observed.activationId,
+      activation_epoch: observed.activationEpoch,
+      turn_sequence: observed.turnSequence,
+    });
+    if (!recorded?.state) return recorded;
+    registry.sessions[identity.canonicalConversationId] = {
+      ...current,
+      observability_signal_sequence: recorded.sequence,
+      observability_checkpoint_sequence: Number(
+        recorded.state.observability_checkpoint_sequence
+        ?? current.observability_checkpoint_sequence
+        ?? 0,
+      ),
+      observability_dirty: Boolean(recorded.state.observability_dirty),
+    };
+    return recorded;
+  });
+  if (!signal?.state) return false;
+  if (!signal.state.observability_dirty) return true;
+
+  await sleep(coalesceMs);
+  if (now() >= deadlineAt) return true;
+
+  const latest = readStore(vaultBase, identity.canonicalConversationId);
+  if (!latest?.observability_dirty
+    || latest.observability_signal_sequence !== signal.sequence) return true;
+
+  const leaseNow = now();
+  if (leaseNow >= deadlineAt) return true;
+  const lease = acquireLease(vaultBase, identity.canonicalConversationId, {
+    signalSequence: signal.sequence,
+    now: leaseNow,
+    ttlMs: Math.max(1, deadlineAt - leaseNow),
   });
-  return true;
+  if (!lease?.acquired) return true;
+
+  try {
+    if (now() >= deadlineAt) return true;
+    const fresh = resolveEntry(vaultBase, input, provider);
+    if (fresh.identity?.state !== 'resolved'
+      || fresh.identity.canonicalConversationId !== identity.canonicalConversationId
+      || !fresh.entry?.session_file
+      || !sameCausalSnapshot(observed, causalSnapshot(fresh.entry))) return true;
+
+    const sessionPath = join(vaultBase, fresh.entry.session_file);
+    if (!existsSync(sessionPath)) return true;
+    const roots = identity.provider === 'codex'
+      ? resolveRoots(fresh.entry)
+      : claudeRoots(fresh.entry);
+    if (roots?.state !== 'complete' || !roots.rootPaths?.length) return true;
+
+    const runtimeState = lease.state || latest;
+    const frontier = {
+      canonical_session_id: identity.canonicalConversationId,
+      activation_id: observed.activationId || 'legacy',
+      activation_epoch: observed.activationEpoch,
+      turn_sequence: observed.turnSequence,
+      signal_sequence: signal.sequence,
+      roots_stat_hash: 'pending',
+      graph_cursor: 'pending',
+      source_manifest_hash: 'pending',
+    };
+    const readRuntimeFrontier = (candidateFrontier, guardContext) => {
+      const currentRuntime = readStore(vaultBase, identity.canonicalConversationId);
+      const currentEntry = guardContext?.entry;
+      const currentResolved = currentEntry
+        ? { identity: { state: 'resolved', canonicalConversationId: identity.canonicalConversationId }, entry: currentEntry }
+        : resolveEntry(vaultBase, input, provider);
+      if (currentResolved.identity?.state !== 'resolved'
+        || currentResolved.identity.canonicalConversationId !== identity.canonicalConversationId
+        || !currentResolved.entry) {
+        return { ...candidateFrontier, canonical_session_id: 'unresolved' };
+      }
+      const currentCausal = causalSnapshot(currentResolved.entry);
+      return {
+        ...candidateFrontier,
+        activation_id: currentCausal.activationId || 'legacy',
+        activation_epoch: currentCausal.activationEpoch,
+        turn_sequence: currentCausal.turnSequence,
+        signal_sequence: Math.max(
+          Number(currentRuntime?.observability_signal_sequence || 0),
+          Number(currentResolved.entry.observability_signal_sequence || 0),
+        ),
+      };
+    };
+    const withPublicationGuard = (_candidateFrontier, publishGuarded) => (
+      mutateRegistry(vaultBase, (registry) => publishGuarded({
+        registry,
+        entry: registry.sessions?.[identity.canonicalConversationId] || null,
+      }))
+    );
+    const writeRegistryCheckpoint = ({
+      frontier: checkpointFrontier,
+      state,
+      diagnostics,
+      snapshot,
+    }, guardContext) => {
+      const registry = guardContext?.registry;
+      const current = registry?.sessions?.[identity.canonicalConversationId];
+      if (!current) return null;
+      const currentSignal = Number(current.observability_signal_sequence || checkpointFrontier.signal_sequence);
+      registry.sessions[identity.canonicalConversationId] = {
+        ...current,
+        observability_signal_sequence: currentSignal,
+        observability_checkpoint_sequence: checkpointFrontier.signal_sequence,
+        observability_dirty: currentSignal > checkpointFrontier.signal_sequence,
+        observability_checkpoint_frontier: checkpointFrontier,
+        subagents_observability_state: state,
+        subagents_diagnostics: diagnostics || [],
+      };
+      return markObservabilityCheckpoint(vaultBase, identity.canonicalConversationId, {
+        checkpointSequence: checkpointFrontier.signal_sequence,
+        frontier: checkpointFrontier,
+        sourceManifest: snapshot?.subagents?.sourceManifest,
+        graphCache: snapshot?.subagents?.cache,
+        diagnostics,
+      });
+    };
+
+    await Promise.resolve(materialize({
+      vaultBase,
+      sessionPath,
+      entry: fresh.entry,
+      rootPaths: roots.rootPaths,
+      transcriptPath: roots.rootPaths[0],
+      caller: 'subagent-stop',
+      canonicalConversationId: identity.canonicalConversationId,
+      activationId: observed.activationId,
+      activationEpoch: observed.activationEpoch,
+      turnSequence: observed.turnSequence,
+      signalSequence: signal.sequence,
+      deadlineAt,
+      allowNone: false,
+      frontier,
+      signals: runtimeState.signals || [],
+      cache: runtimeState.graph_cache || null,
+      now,
+      readRuntimeFrontier,
+      withPublicationGuard,
+      writeRegistryCheckpoint,
+    }));
+    return true;
+  } finally {
+    releaseLease(vaultBase, identity.canonicalConversationId, {
+      ownerToken: lease.ownerToken,
+      signalSequence: signal.sequence,
+    });
+  }
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
+    const hookStartedAt = Date.now();
     const input = readHookInput();
-    refreshSubagents(getVaultBase(input), input);
+    await refreshSubagents(getVaultBase(input), input, { hookStartedAt });
     writeHookOutput({});
   } catch (error) {
     process.stderr.write(`[wendkeep] subagent-stop falhou: ${error.message}\n`);

package/hooks/subagent-usage.mjs

@@ -29,6 +29,49 @@ function walkAgentJsonl(dir) {
   return out;
 }
 
+function inspectAgentJsonlDirectory(dir) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch (error) {
+    return { state: error?.code === 'ENOENT' ? 'absent' : 'error', files: [] };
+  }
+  const files = [];
+  for (const name of names) {
+    const path = join(dir, name);
+    let stat;
+    try {
+      stat = statSync(path);
+    } catch {
+      return { state: 'error', files: [] };
+    }
+    if (stat.isDirectory()) {
+      const nested = inspectAgentJsonlDirectory(path);
+      if (nested.state === 'error' || nested.state === 'absent') return { state: 'error', files: [] };
+      files.push(...nested.files);
+    } else if (name.startsWith('agent-') && name.endsWith('.jsonl')) {
+      files.push(path);
+    }
+  }
+  return { state: 'ok', files };
+}
+
+function validJsonl(path) {
+  let lines;
+  try {
+    lines = readFileSync(path, 'utf8').split(/\r?\n/).filter((line) => line.trim());
+  } catch {
+    return false;
+  }
+  if (!lines.length) return false;
+  try {
+    for (const line of lines) JSON.parse(line);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // workflows/scripts/<name>-wf_<rid>.js  ->  { wf_<rid>: <name> }
 function workflowNameMap(sessionDir) {
   const map = {};
@@ -276,6 +319,28 @@ export function collectSubagentUsage(sessionDir) {
   };
 }
 
+// Schema-2 callers need to distinguish proven absence from read/parse failure. Keep the
+// legacy aggregate API above intact while exposing a fail-closed state for observability.
+export function collectClaudeSubagentUsageState(sessionDir) {
+  const scan = inspectAgentJsonlDirectory(join(sessionDir, 'subagents'));
+  if (scan.state === 'absent' || (scan.state === 'ok' && scan.files.length === 0)) {
+    return { state: 'none', diagnostics: [] };
+  }
+  if (scan.state !== 'ok' || scan.files.some((path) => !validJsonl(path))) {
+    return {
+      state: 'degraded',
+      diagnostics: [{ code: 'CHILD_META_INVALID', count: 1 }],
+    };
+  }
+  const collected = collectSubagentUsage(sessionDir);
+  return collected
+    ? { ...collected, state: 'complete', diagnostics: [] }
+    : {
+      state: 'degraded',
+      diagnostics: [{ code: 'CHILD_META_INVALID', count: 1 }],
+    };
+}
+
 function workflowLine(w) {
   const parts = [w.runId];
   if (w.status) parts.push(w.status);