sneakoscope 6.0.3 → 6.1.2

package/dist/core/subagents/subagent-evidence.js

@@ -0,0 +1,663 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
+export const SUBAGENT_EVIDENCE_SCHEMA = 'sks.subagent-evidence.v1';
+export const SUBAGENT_EVENT_SCHEMA = 'sks.subagent-event.v1';
+export const SUBAGENT_PARENT_SUMMARY_SCHEMA = 'sks.subagent-parent-summary.v1';
+export const SUBAGENT_EVIDENCE_FILENAME = 'subagent-evidence.json';
+export const SUBAGENT_EVENT_LOG_FILENAME = 'subagent-events.jsonl';
+export const SUBAGENT_PARENT_SUMMARY_FILENAME = 'subagent-parent-summary.json';
+export function normalizeSubagentEvent(payload, explicitEventName) {
+    const row = isRecord(payload) ? payload : {};
+    const nested = isRecord(row.payload)
+        ? row.payload
+        : isRecord(row.data)
+            ? row.data
+            : isRecord(row.input)
+                ? row.input
+                : {};
+    const merged = { ...nested, ...row };
+    const eventName = normalizeEventName(explicitEventName
+        ?? row.hook_event_name
+        ?? row.hookEventName
+        ?? row.event_name
+        ?? row.eventName
+        ?? row.event
+        ?? row.type
+        ?? nested.hook_event_name
+        ?? nested.hookEventName
+        ?? nested.event_name
+        ?? nested.eventName
+        ?? nested.event
+        ?? nested.type);
+    if (!eventName)
+        return null;
+    const persistedOutcome = row.schema === SUBAGENT_EVENT_SCHEMA
+        ? normalizePersistedOutcome(row.outcome, eventName)
+        : null;
+    const explicitThreadId = firstText(row.thread_id, row.threadId, row.agent_thread_id, row.agentThreadId, row.subagent_thread_id, row.subagentThreadId, nested.thread_id, nested.threadId, nested.agent_thread_id, nested.agentThreadId, nested.subagent_thread_id, nested.subagentThreadId, recordId(row.thread), recordId(nested.thread));
+    const agentId = firstText(row.agent_id, row.agentId, nested.agent_id, nested.agentId, recordId(row.agent), recordId(nested.agent));
+    const sessionId = firstText(row.session_id, row.sessionId, nested.session_id, nested.sessionId, recordId(row.session), recordId(nested.session));
+    // Official SubagentStart/SubagentStop payloads identify the child with
+    // agent_id. session_id is the parent/session scope and must never be used as
+    // a child identity because every sibling can share it.
+    const threadId = explicitThreadId || agentId || null;
+    const threadIdSource = explicitThreadId
+        ? 'thread_id'
+        : agentId
+            ? 'agent_id'
+            : null;
+    return {
+        schema: SUBAGENT_EVENT_SCHEMA,
+        event_name: eventName,
+        thread_id: threadId,
+        thread_id_source: threadIdSource,
+        agent_id: agentId || null,
+        session_id: sessionId || null,
+        turn_id: firstText(row.turn_id, row.turnId, nested.turn_id, nested.turnId) || null,
+        run_id: firstText(row.run_id, row.runId, row.workflow_run_id, row.workflowRunId, nested.run_id, nested.runId, nested.workflow_run_id, nested.workflowRunId) || null,
+        run_epoch: firstText(row.run_epoch, row.runEpoch, row.execution_epoch, row.executionEpoch, nested.run_epoch, nested.runEpoch, nested.execution_epoch, nested.executionEpoch) || null,
+        model: firstText(row.model, nested.model) || null,
+        outcome: persistedOutcome ?? (eventName === 'SubagentStart'
+            ? 'started'
+            : stopFailed(merged)
+                ? 'failed'
+                : stopAmbiguous(merged)
+                    ? 'ambiguous'
+                    : 'stopped'),
+        occurred_at: firstText(row.occurred_at, row.timestamp, row.created_at, row.ts, nested.occurred_at, nested.timestamp, nested.created_at, nested.ts) || nowIso()
+    };
+}
+export function buildSubagentEvidence(input) {
+    const requestedSubagents = normalizeRequested(input.requestedSubagents);
+    const normalizedEvents = (input.events || [])
+        .map((event) => normalizeSubagentEvent(event))
+        .filter((event) => Boolean(event));
+    const parentSummary = normalizeSubagentParentSummary(input.parentSummary);
+    const runScope = resolveRunScope(input, normalizedEvents, parentSummary);
+    const scopedEvents = scopeSubagentEvents(normalizedEvents, runScope);
+    const events = scopedEvents.events;
+    const starts = new Set();
+    const successfulStops = new Set();
+    const failedStops = new Set();
+    const unmatchedStops = new Set();
+    const ambiguousStops = new Set();
+    const eventSources = new Set();
+    let missingThreadId = false;
+    const parentSummaryStructurallyTrustworthy = parentSummary.trustworthy
+        && runScope.blockers.length === 0
+        && runScope.parentBlockers.length === 0;
+    const parentCompletedStructurallyTrustworthy = parentSummaryStructurallyTrustworthy
+        && parentSummary.status === 'completed';
+    for (const event of events) {
+        eventSources.add(event.event_name);
+        if (!event.thread_id) {
+            missingThreadId = true;
+            continue;
+        }
+        if (event.event_name === 'SubagentStart') {
+            starts.add(event.thread_id);
+            continue;
+        }
+        if (!starts.has(event.thread_id)) {
+            unmatchedStops.add(event.thread_id);
+            continue;
+        }
+        if (event.outcome === 'failed') {
+            failedStops.add(event.thread_id);
+            successfulStops.delete(event.thread_id);
+            ambiguousStops.delete(event.thread_id);
+            continue;
+        }
+        if (event.outcome === 'ambiguous') {
+            ambiguousStops.add(event.thread_id);
+            successfulStops.delete(event.thread_id);
+            failedStops.delete(event.thread_id);
+            continue;
+        }
+        const parentOutcome = parentSummary.thread_outcomes.get(event.thread_id);
+        if (parentOutcome === 'failed') {
+            failedStops.add(event.thread_id);
+            successfulStops.delete(event.thread_id);
+            ambiguousStops.delete(event.thread_id);
+        }
+        else if (parentOutcome === 'completed' && parentCompletedStructurallyTrustworthy) {
+            successfulStops.add(event.thread_id);
+            failedStops.delete(event.thread_id);
+            ambiguousStops.delete(event.thread_id);
+        }
+        else {
+            ambiguousStops.add(event.thread_id);
+            successfulStops.delete(event.thread_id);
+            failedStops.delete(event.thread_id);
+        }
+    }
+    const parentOutcomeThreadIds = [...parentSummary.thread_outcomes.keys()].sort();
+    const parentOutcomeThreadIdSet = new Set(parentOutcomeThreadIds);
+    const missingParentOutcomeThreadIds = [...starts]
+        .filter((threadId) => !parentOutcomeThreadIdSet.has(threadId))
+        .sort();
+    const unobservedParentOutcomeThreadIds = parentOutcomeThreadIds
+        .filter((threadId) => !starts.has(threadId));
+    const parentThreadIdentityBlockers = [
+        ...missingParentOutcomeThreadIds.map((threadId) => `parent_thread_outcome_missing_for_started_thread:${threadId}`),
+        ...unobservedParentOutcomeThreadIds.map((threadId) => `parent_thread_outcome_without_start:${threadId}`)
+    ];
+    const parentSummaryTrustworthy = parentSummaryStructurallyTrustworthy
+        && parentThreadIdentityBlockers.length === 0;
+    if (!parentSummaryTrustworthy) {
+        for (const threadId of successfulStops) {
+            successfulStops.delete(threadId);
+            if (!failedStops.has(threadId))
+                ambiguousStops.add(threadId);
+        }
+    }
+    const completedThreadIds = [...successfulStops]
+        .filter((threadId) => starts.has(threadId))
+        .sort();
+    const failedThreadIds = [...failedStops]
+        .filter((threadId) => starts.has(threadId))
+        .sort();
+    const startedThreadIds = [...starts].sort();
+    const stoppedThreadIds = new Set([...completedThreadIds, ...failedThreadIds]);
+    const openThreadIds = startedThreadIds.filter((threadId) => !stoppedThreadIds.has(threadId));
+    const preparationOnly = input.preparationOnly === true || isPreparationStatus(input.workflowStatus);
+    const parentSummaryPresent = input.parentSummaryPresent
+        ?? parentSummary.present;
+    const blockers = [];
+    if (preparationOnly)
+        blockers.push('subagent_workflow_preparation_only');
+    if (requestedSubagents < 1)
+        blockers.push('requested_subagents_missing');
+    if (missingThreadId)
+        blockers.push('subagent_event_thread_id_missing');
+    if (startedThreadIds.length < requestedSubagents) {
+        blockers.push(`requested_subagent_starts_incomplete:${startedThreadIds.length}/${requestedSubagents}`);
+    }
+    else if (startedThreadIds.length > requestedSubagents) {
+        blockers.push(`requested_subagent_starts_exceeded:${startedThreadIds.length}/${requestedSubagents}`);
+    }
+    if (completedThreadIds.length < requestedSubagents) {
+        blockers.push(`requested_subagent_completions_incomplete:${completedThreadIds.length}/${requestedSubagents}`);
+    }
+    else if (completedThreadIds.length > requestedSubagents) {
+        blockers.push(`requested_subagent_completions_exceeded:${completedThreadIds.length}/${requestedSubagents}`);
+    }
+    if (failedThreadIds.length > 0)
+        blockers.push(`subagent_threads_failed:${failedThreadIds.length}`);
+    if (openThreadIds.length > 0)
+        blockers.push(`subagent_threads_still_open:${openThreadIds.length}`);
+    if (unmatchedStops.size > 0)
+        blockers.push(`subagent_stops_without_start:${unmatchedStops.size}`);
+    if (ambiguousStops.size > 0)
+        blockers.push(`subagent_thread_outcomes_ambiguous:${ambiguousStops.size}`);
+    blockers.push(...runScope.blockers, ...runScope.parentBlockers);
+    blockers.push(...parentThreadIdentityBlockers);
+    if (!parentSummaryPresent)
+        blockers.push('parent_summary_missing');
+    else if (!parentSummary.trustworthy)
+        blockers.push(...parentSummary.blockers);
+    if (parentSummary.status === 'failed')
+        blockers.push('parent_summary_failed');
+    for (const blocker of input.additionalBlockers || []) {
+        const normalized = String(blocker || '').trim();
+        if (normalized)
+            blockers.push(normalized);
+    }
+    const uniqueBlockers = uniqueStrings(blockers);
+    const ok = uniqueBlockers.length === 0;
+    const status = preparationOnly
+        ? 'preparation_only'
+        : ok
+            ? 'completed'
+            : failedThreadIds.length > 0
+                ? 'blocked'
+                : 'incomplete';
+    return {
+        schema: SUBAGENT_EVIDENCE_SCHEMA,
+        workflow: 'official_codex_subagent',
+        requested_subagents: requestedSubagents,
+        started_threads: startedThreadIds.length,
+        completed_threads: completedThreadIds.length,
+        failed_threads: failedThreadIds.length,
+        started_thread_ids: startedThreadIds,
+        completed_thread_ids: completedThreadIds,
+        failed_thread_ids: failedThreadIds,
+        open_thread_ids: openThreadIds,
+        unmatched_stop_thread_ids: [...unmatchedStops].sort(),
+        event_sources: [...eventSources].sort(eventSourceOrder),
+        parent_summary_present: parentSummaryPresent,
+        parent_summary_trustworthy: parentSummaryTrustworthy,
+        parent_summary_status: parentSummary.status,
+        ambiguous_stop_thread_ids: [...ambiguousStops].sort(),
+        run_id: runScope.runId,
+        run_epoch: runScope.runEpoch,
+        run_scope_source: runScope.source,
+        rejected_stale_events: scopedEvents.staleEvents.length,
+        rejected_stale_thread_ids: uniqueStrings(scopedEvents.staleEvents.map((event) => event.thread_id || '')).sort(),
+        unbound_run_events: scopedEvents.unboundEvents.length,
+        preparation_only: preparationOnly,
+        status,
+        ok,
+        blockers: uniqueBlockers
+    };
+}
+export async function recordSubagentEvent(artifactDir, payload, explicitEventName) {
+    const event = normalizeSubagentEvent(payload, explicitEventName);
+    if (!event)
+        return null;
+    await appendJsonlBounded(path.join(artifactDir, SUBAGENT_EVENT_LOG_FILENAME), event, 1024 * 1024);
+    return event;
+}
+export async function readSubagentEvents(artifactDir) {
+    const text = await fsp.readFile(path.join(artifactDir, SUBAGENT_EVENT_LOG_FILENAME), 'utf8').catch(() => '');
+    const events = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const event = normalizeSubagentEvent(parsed);
+        if (event)
+            events.push(event);
+    }
+    return events;
+}
+export async function writeSubagentEvidence(artifactDir, input) {
+    const events = input.events ?? await readSubagentEvents(artifactDir);
+    const evidence = buildSubagentEvidence({ ...input, events });
+    await writeJsonAtomic(path.join(artifactDir, SUBAGENT_EVIDENCE_FILENAME), evidence);
+    return evidence;
+}
+export async function persistOrReuseTrustworthySubagentParentSummary(artifactDir, value, opts = {}) {
+    const incoming = normalizeSubagentParentSummary(value);
+    const file = path.join(artifactDir, SUBAGENT_PARENT_SUMMARY_FILENAME);
+    const workflowFailed = isFailureWorkflowStatus(opts.workflowStatus);
+    const activeRunId = firstText(opts.runId);
+    const incomingMatchesActiveRun = !activeRunId || !incoming.run_id || incoming.run_id === activeRunId;
+    if (incoming.trustworthy && incoming.status === 'failed' && incoming.raw && incomingMatchesActiveRun) {
+        await writeJsonAtomic(file, incoming.raw);
+        return incoming.raw;
+    }
+    if (workflowFailed || incoming.status === 'failed' || parentResultExplicitlyFailed(value)) {
+        await fsp.rm(file, { force: true }).catch(() => undefined);
+        if (workflowFailed && incoming.trustworthy && incoming.status === 'completed')
+            return null;
+        return value;
+    }
+    if (incoming.trustworthy && incoming.raw) {
+        if (!incomingMatchesActiveRun)
+            return reuseMatchingPersistedParentSummary(file, activeRunId, value);
+        await writeJsonAtomic(file, incoming.raw);
+        return incoming.raw;
+    }
+    return reuseMatchingPersistedParentSummary(file, activeRunId, value);
+}
+export function bindTrustworthySubagentParentSummaryToRun(value, runId) {
+    const normalizedRunId = firstText(runId);
+    if (!normalizedRunId)
+        return value;
+    const summary = normalizeSubagentParentSummary(value);
+    if (!summary.trustworthy || !summary.raw)
+        return value;
+    if (summary.run_id && summary.run_id !== normalizedRunId)
+        return null;
+    return summary.run_id
+        ? summary.raw
+        : { ...summary.raw, run_id: normalizedRunId };
+}
+async function reuseMatchingPersistedParentSummary(file, activeRunId, fallback) {
+    const persisted = await fsp.readFile(file, 'utf8')
+        .then((text) => JSON.parse(text))
+        .catch(() => null);
+    const previous = normalizeSubagentParentSummary(persisted);
+    if (!previous.trustworthy || !previous.raw)
+        return fallback;
+    if (activeRunId && previous.run_id !== activeRunId)
+        return fallback;
+    return previous.raw;
+}
+export const normalizeSubagentEvidence = buildSubagentEvidence;
+function normalizeEventName(value) {
+    const normalized = String(value || '').trim().toLowerCase().replace(/[^a-z]+/g, '');
+    if (normalized === 'subagentstart')
+        return 'SubagentStart';
+    if (normalized === 'subagentstop')
+        return 'SubagentStop';
+    return null;
+}
+function normalizePersistedOutcome(value, eventName) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (eventName === 'SubagentStart')
+        return normalized === 'started' ? 'started' : null;
+    if (normalized === 'stopped' || normalized === 'failed' || normalized === 'ambiguous')
+        return normalized;
+    return null;
+}
+function stopFailed(row) {
+    const status = firstText(row.status, row.outcome, row.result, row.state).toLowerCase();
+    const resultText = firstText(row.last_assistant_message, row.lastAssistantMessage, row.summary, row.message, row.result_text, row.resultText);
+    return row.ok === false
+        || row.success === false
+        || row.failed === true
+        || Boolean(row.error)
+        || /^(failed|failure|error|blocked|cancelled|canceled|interrupted|timed[_ -]?out)$/.test(status)
+        || containsUnambiguousFailureText(resultText);
+}
+function stopAmbiguous(row) {
+    const resultText = firstText(row.last_assistant_message, row.lastAssistantMessage, row.summary, row.message, row.result_text, row.resultText);
+    return containsAmbiguousOutcomeText(resultText);
+}
+export function normalizeSubagentParentSummary(value) {
+    const present = hasMeaningfulSummary(value);
+    const parsed = parseStructuredParentSummary(value);
+    const threadOutcomes = new Map();
+    const blockers = [];
+    if (!parsed) {
+        if (present)
+            blockers.push('parent_summary_untrusted');
+        return {
+            present,
+            trustworthy: false,
+            status: present ? 'ambiguous' : null,
+            summary: null,
+            run_id: null,
+            run_epoch: null,
+            thread_outcomes: threadOutcomes,
+            blockers,
+            raw: null
+        };
+    }
+    const summary = String(parsed.summary || '').trim();
+    if (typeof parsed.summary !== 'string' || !summary)
+        blockers.push('parent_summary_text_missing');
+    const topLevelKeys = new Set(['schema', 'status', 'summary', 'thread_outcomes', 'changed_files', 'verification', 'blockers', 'run_id', 'run_epoch']);
+    for (const key of Object.keys(parsed)) {
+        if (!topLevelKeys.has(key))
+            blockers.push(`parent_summary_unknown_field:${key}`);
+    }
+    if (parsed.changed_files !== undefined && (!Array.isArray(parsed.changed_files) || parsed.changed_files.some((item) => typeof item !== 'string'))) {
+        blockers.push('parent_summary_changed_files_invalid');
+    }
+    if (parsed.verification !== undefined && !Array.isArray(parsed.verification))
+        blockers.push('parent_summary_verification_invalid');
+    if (parsed.blockers !== undefined && (!Array.isArray(parsed.blockers) || parsed.blockers.some((item) => typeof item !== 'string'))) {
+        blockers.push('parent_summary_blockers_invalid');
+    }
+    if (!Array.isArray(parsed.thread_outcomes) || parsed.thread_outcomes.length === 0) {
+        blockers.push('parent_thread_outcomes_missing');
+    }
+    for (const row of Array.isArray(parsed.thread_outcomes) ? parsed.thread_outcomes : []) {
+        if (!isRecord(row)) {
+            blockers.push('parent_thread_outcome_invalid');
+            continue;
+        }
+        const rowKeys = new Set(['thread_id', 'status', 'summary']);
+        for (const key of Object.keys(row)) {
+            if (!rowKeys.has(key))
+                blockers.push(`parent_thread_outcome_unknown_field:${key}`);
+        }
+        const threadId = firstText(row?.thread_id);
+        const status = strictTerminalOutcome(row?.status);
+        const rowSummary = typeof row?.summary === 'string' ? row.summary.trim() : '';
+        if (!threadId) {
+            blockers.push('parent_thread_outcome_thread_id_missing');
+            continue;
+        }
+        if (threadOutcomes.has(threadId)) {
+            blockers.push(`parent_thread_outcome_duplicate:${threadId}`);
+            continue;
+        }
+        threadOutcomes.set(threadId, status);
+        if (status === 'ambiguous')
+            blockers.push(`parent_thread_outcome_ambiguous:${threadId}`);
+        if (!rowSummary)
+            blockers.push(`parent_thread_outcome_summary_missing:${threadId}`);
+        if (status === 'completed' && containsFailedOrAmbiguousOutcomeText(rowSummary)) {
+            blockers.push(`parent_thread_outcome_text_contradiction:${threadId}`);
+        }
+    }
+    const status = strictTerminalOutcome(parsed.status);
+    if (status === 'ambiguous')
+        blockers.push('parent_summary_status_ambiguous');
+    if (status === 'completed' && containsFailedOrAmbiguousOutcomeText(summary))
+        blockers.push('parent_summary_text_contradiction');
+    if (status === 'completed' && Array.isArray(parsed.blockers) && parsed.blockers.length > 0) {
+        blockers.push('parent_summary_completed_with_blockers');
+    }
+    return {
+        present: true,
+        trustworthy: blockers.length === 0,
+        status,
+        summary: summary || null,
+        run_id: firstText(parsed.run_id) || null,
+        run_epoch: firstText(parsed.run_epoch) || null,
+        thread_outcomes: threadOutcomes,
+        blockers: uniqueStrings(blockers.length ? blockers : []),
+        raw: parsed
+    };
+}
+function parseStructuredParentSummary(value) {
+    if (isRecord(value))
+        return validStructuredParentSummary(value);
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    const trimmed = value.trim();
+    const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(trimmed)?.[1]?.trim();
+    const candidates = [trimmed, ...(fenced ? [fenced] : [])];
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(candidate);
+            const valid = validStructuredParentSummary(parsed);
+            if (valid)
+                return valid;
+        }
+        catch { }
+    }
+    return null;
+}
+function validStructuredParentSummary(value) {
+    if (!isRecord(value) || value.schema !== SUBAGENT_PARENT_SUMMARY_SCHEMA)
+        return null;
+    if (!Array.isArray(value.thread_outcomes))
+        return null;
+    return value;
+}
+function strictTerminalOutcome(value) {
+    const status = String(value || '').trim().toLowerCase();
+    if (status === 'completed')
+        return 'completed';
+    if (status === 'blocked' || status === 'failed')
+        return 'failed';
+    return 'ambiguous';
+}
+function containsUnambiguousFailureText(value) {
+    const source = String(value || '').trim();
+    if (!source)
+        return false;
+    const scrubbed = source
+        .replace(/\b(?:no|without)\s+(?:errors?|failures?|blockers?|issues?)\b/gi, ' ')
+        .replace(/\bno\s+(?:\d+\s+)?(?:tests?|suites?|checks?|cases?)\s+(?:failed|failing|errored)\b/gi, ' ')
+        .replace(/\bnot\s+blocked\b/gi, ' ')
+        .replace(/\b(?:did\s+not|didn't)\s+fail\b/gi, ' ')
+        .replace(/\b(?:type\s*check|typecheck|build|compilation|compile|compiler|npm\s+test|tests?|test\s+suites?)\s+(?:did\s+not|didn't)\s+fail\b/gi, ' ')
+        .replace(/\b(?:failed|failure|error|blocked)[- ]paths?\b/gi, ' ')
+        .replace(/\b(?:could\s+not|unable\s+to)\s+(?:reproduce|find|detect|observe|identify)\b[^.!?\n]*/gi, ' ')
+        .replace(/(?:실패한|차단된|오류(?:가|는)?\s*발생한?)\s*(?:테스트|검사|항목|문제)(?:가|이|는|은)?\s*(?:없음|없다|없습니다)/g, ' ')
+        .replace(/(?:실패|오류|에러|차단|문제)(?:가|이|는|은)?\s*(?:없음|없다|없습니다|없이)/g, ' ')
+        .replace(/차단되지\s*않(?:음|았다|았습니다)/g, ' ');
+    return /^(?:failed|failure|error|blocked|cancelled|canceled|interrupted|timed\s*out|incomplete)\b/i.test(scrubbed)
+        || /\b\d+\s+(?:tests?|suites?|checks?|cases?)\s+(?:failed|failing|errored)\b/i.test(scrubbed)
+        || /\b(?:type\s*check|typecheck|build|compilation|compile|compiler|npm\s+test|npm\s+run\s+(?:test|build|typecheck)|tests?|test\s+suites?|lint|verification)\b[^.!?\n]{0,40}\b(?:failed|failing|failure|errored|errors?)\b/i.test(scrubbed)
+        || /\b(?:compilation|compiler|typescript|tsc)\s+error(?:\s+TS\d+)?\b/i.test(scrubbed)
+        || /\berror\s+TS\d+\b/i.test(scrubbed)
+        || /\b(?:slice|thread|task|work|review|integration|execution|run|job|agent|subagent)\b[^.!?\n]{0,32}\b(?:failed|blocked|cancelled|canceled|interrupted|timed\s*out|not\s+completed|incomplete)\b/i.test(scrubbed)
+        || /\b(?:could\s+not|unable\s+to|failed\s+to)\s+(?:complete|finish|deliver|execute|run|continue|return)\b/i.test(scrubbed)
+        || /(?:작업|슬라이스|스레드|검수|통합|실행|에이전트|서브\s*에이전트)[^.!?\n]{0,20}(?:실패|차단|중단|미완료)/i.test(scrubbed)
+        || /(?:완료|수행|실행|진행|통합)하지\s*못|완료되지\s*않|미완료/i.test(scrubbed);
+}
+function containsAmbiguousOutcomeText(value) {
+    const source = String(value || '').trim();
+    if (!source)
+        return false;
+    const completedReadOnlyReview = (/\bread[- ]only\b[^.!?\n]{0,180}\b(?:review|inspection|audit)\b[^.!?\n]{0,180}\b(?:covered|completed|finished)\b/i.test(source)
+        || /읽기\s*전용[^.!?\n]{0,180}(?:검수|검토|감사)[^.!?\n]{0,180}(?:완료|점검|확인)/i.test(source)) && (/\bno files? (?:were )?(?:changed|modified)\b/i.test(source)
+        || /파일[^.!?\n]{0,40}(?:변경|수정)(?:하지\s*않|없)/i.test(source));
+    const ambiguitySource = completedReadOnlyReview
+        ? source
+            .replace(/\bno tests? (?:were )?(?:run|executed)\b/gi, ' ')
+            .replace(/\btests? (?:were )?not (?:run|executed)\b/gi, ' ')
+            .replace(/테스트[^.!?\n]{0,20}(?:미실행|실행하지\s*않)/gi, ' ')
+        : source;
+    const scrubbed = ambiguitySource
+        .replace(/\bno\s+(?:remaining\s+)?(?:unknowns?|ambiguities|pending\s+(?:checks?|work)|unverified\s+(?:checks?|work|gaps?))\b/gi, ' ')
+        .replace(/\bnot\s+(?:pending|unknown|unclear|ambiguous|inconclusive)\b/gi, ' ');
+    return /\b(?:tests?|test\s+suites?|checks?|type\s*check|typecheck|build|lint|verification)\b[^.!?\n]{0,32}\b(?:not\s+(?:run|executed|verified|completed)|pending|unknown|unclear|ambiguous|inconclusive)\b/i.test(scrubbed)
+        || /\b(?:could\s+not|unable\s+to|failed\s+to)\s+(?:verify|confirm|determine)\b/i.test(scrubbed)
+        || /\b(?:result|status|outcome)\b[^.!?\n]{0,20}\b(?:unknown|unclear|ambiguous|pending|inconclusive)\b/i.test(scrubbed)
+        || /\b(?:partially|partly)\s+(?:completed|verified|tested)\b/i.test(scrubbed)
+        || /(?:테스트|검사|타입\s*체크|빌드|검증)[^.!?\n]{0,16}(?:미실행|미검증|보류|불명확|알\s*수\s*없|확인하지\s*못)/i.test(scrubbed);
+}
+function containsFailedOrAmbiguousOutcomeText(value) {
+    return containsUnambiguousFailureText(value) || containsAmbiguousOutcomeText(value);
+}
+function parentResultExplicitlyFailed(value) {
+    if (typeof value === 'string')
+        return containsUnambiguousFailureText(value);
+    if (!isRecord(value))
+        return false;
+    const status = firstText(value.status, value.outcome, value.result, value.state).toLowerCase();
+    const resultText = firstText(value.summary, value.message, value.last_assistant_message, value.lastAssistantMessage, value.result_text, value.resultText);
+    return value.ok === false
+        || value.success === false
+        || value.failed === true
+        || Boolean(value.error)
+        || (Array.isArray(value.blockers) && value.blockers.length > 0)
+        || /^(failed|failure|error|blocked|cancelled|canceled|interrupted|timed[_ -]?out|incomplete)$/.test(status)
+        || containsUnambiguousFailureText(resultText);
+}
+function isFailureWorkflowStatus(value) {
+    return /^(parent_failed|failed|blocked|incomplete|cancelled|canceled|timed[_ -]?out)$/i.test(String(value || '').trim());
+}
+function resolveRunScope(input, events, parentSummary) {
+    const requestedRunId = firstText(input.runId);
+    const requestedRunEpoch = firstText(input.runEpoch);
+    const eventRunIds = uniqueStrings(events.map((event) => event.run_id || ''));
+    const eventTurnIds = uniqueStrings(events.map((event) => event.turn_id || ''));
+    const eventRunEpochs = uniqueStrings(events.map((event) => event.run_epoch || ''));
+    const latestEventRunId = latestText(events, (event) => event.run_id);
+    const latestEventTurnId = latestText(events, (event) => event.turn_id);
+    const latestEventRunEpoch = latestText(events, (event) => event.run_epoch);
+    const runId = requestedRunId || latestEventRunId || latestEventTurnId || parentSummary.run_id || null;
+    const runEpoch = requestedRunEpoch || latestEventRunEpoch || parentSummary.run_epoch || null;
+    const source = requestedRunId || requestedRunEpoch
+        ? 'input'
+        : latestEventRunId
+            ? 'event_run_id'
+            : latestEventTurnId
+                ? 'event_turn_id'
+                : parentSummary.run_id || parentSummary.run_epoch
+                    ? 'parent_summary'
+                    : latestEventRunEpoch
+                        ? 'event_run_epoch'
+                        : null;
+    const blockers = [];
+    const parentBlockers = [];
+    const parentRunBindingRequired = Boolean(parentSummary.run_id)
+        || (source !== 'event_turn_id' && Boolean(requestedRunId || eventRunIds.length > 0));
+    if (parentSummary.present && runId && parentRunBindingRequired) {
+        if (!parentSummary.run_id)
+            parentBlockers.push('parent_summary_run_id_missing');
+        else if (parentSummary.run_id !== runId)
+            parentBlockers.push('parent_summary_run_id_mismatch');
+    }
+    const parentEpochBindingRequired = Boolean(requestedRunEpoch || parentSummary.run_epoch || eventRunEpochs.length > 0);
+    if (parentSummary.present && runEpoch && parentEpochBindingRequired) {
+        if (!parentSummary.run_epoch)
+            parentBlockers.push('parent_summary_run_epoch_missing');
+        else if (parentSummary.run_epoch !== runEpoch)
+            parentBlockers.push('parent_summary_run_epoch_mismatch');
+    }
+    return {
+        runId,
+        runEpoch,
+        source,
+        blockers,
+        parentBlockers
+    };
+}
+function scopeSubagentEvents(events, scope) {
+    const accepted = [];
+    const staleEvents = [];
+    const unboundEvents = [];
+    for (const event of events) {
+        const eventRunId = scope.source === 'event_turn_id'
+            ? event.turn_id
+            : scope.source === 'input' || scope.source === 'parent_summary'
+                ? event.run_id || event.turn_id
+                : event.run_id;
+        if ((scope.runId && !eventRunId) || (scope.runEpoch && !event.run_epoch)) {
+            unboundEvents.push(event);
+            continue;
+        }
+        if ((scope.runId && eventRunId !== scope.runId) || (scope.runEpoch && event.run_epoch !== scope.runEpoch)) {
+            staleEvents.push(event);
+            continue;
+        }
+        accepted.push(event);
+    }
+    if (unboundEvents.length > 0)
+        scope.blockers.push(`subagent_events_run_scope_missing:${unboundEvents.length}`);
+    return { events: accepted, staleEvents, unboundEvents };
+}
+function latestText(values, pick) {
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        const value = pick(values[index]);
+        if (value)
+            return value;
+    }
+    return '';
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function normalizeRequested(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return 0;
+    return Math.max(0, Math.floor(parsed));
+}
+function isPreparationStatus(value) {
+    return /^(delegation_context_ready|context_ready|prepared|preparation_only)$/.test(String(value || '').trim().toLowerCase());
+}
+function hasMeaningfulSummary(value) {
+    if (typeof value === 'string')
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return isRecord(value) && Object.keys(value).length > 0;
+}
+function eventSourceOrder(a, b) {
+    return (a === 'SubagentStart' ? 0 : 1) - (b === 'SubagentStart' ? 0 : 1);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function recordId(value) {
+    return isRecord(value) ? value.id : undefined;
+}
+function firstText(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    return '';
+}
+//# sourceMappingURL=subagent-evidence.js.map

package/dist/core/subagents/terminology.js

@@ -0,0 +1,16 @@
+export const SUBAGENT_TERMS = Object.freeze({
+    workflow: 'subagent workflow',
+    agent: 'subagent',
+    thread: 'agent thread',
+    parent: 'parent agent',
+    customAgent: 'custom agent'
+});
+export const DEPRECATED_AGENT_TERMS = Object.freeze([
+    'shadow clone',
+    'clone roster',
+    'native agent swarm',
+    'native CLI session swarm',
+    'active pool',
+    'worker swarm'
+]);
+//# sourceMappingURL=terminology.js.map