sneakoscope 7.0.2 → 7.0.3

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

@@ -1,12 +1,142 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
+import { appendJsonlBounded, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
+import { HOST_CAPABILITY_DESCRIPTORS, hostCapabilityDigest } from '../agent-bridge/agent-manifest.js';
+import { HOST_CAPABILITY_EVIDENCE_SCHEMA, HOST_CAPABILITY_RUNTIME_SCHEMA } from '../agent-bridge/host-capability-runtime.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';
+const MAX_PARENT_ARTIFACTS = 64;
+const MAX_PARENT_ARTIFACT_PATH_CHARS = 512;
+const MAX_PARENT_CAPABILITY_USES = 64;
+const MAX_PARENT_CAPABILITY_TOOL_NAMES = 64;
+const MAX_HOST_ARTIFACT_SOURCES = 64;
+const SHA256_RECEIPT_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const ARTIFACT_ROLES = new Set(['deliverable', 'scratch', 'temp', 'log']);
+const HOST_CAPABILITY_BY_ID = new Map(HOST_CAPABILITY_DESCRIPTORS.map((descriptor) => [descriptor.id, descriptor]));
+const HOST_ARTIFACT_SOURCE_TOOLS = new Set(HOST_CAPABILITY_BY_ID.get('host.artifact.receipt.v1')?.tool_names || []);
+export function trustedHostCapabilityReceiptBindingBlockers(evidence) {
+    const blockers = [];
+    const artifactSources = validateHostArtifactSources(evidence, blockers);
+    const requestedIds = evidence.runtime.requested_capability_ids;
+    const requested = new Set(requestedIds);
+    const receiptsById = new Map(evidence.capabilities_used.map((receipt) => [receipt.id, receipt]));
+    if (requested.size !== requestedIds.length
+        || receiptsById.size !== evidence.capabilities_used.length
+        || evidence.capabilities_used.some((receipt) => !requested.has(receipt.id))
+        || requestedIds.some((id) => !receiptsById.has(id))) {
+        blockers.push('host_capability_requested_receipts_mismatch');
+    }
+    for (const id of requestedIds) {
+        const descriptor = HOST_CAPABILITY_BY_ID.get(id);
+        const receipt = receiptsById.get(id);
+        if (!descriptor || !receipt)
+            continue;
+        const relevantCalls = evidence.tool_calls.filter((call) => descriptor.tool_names.includes(call.tool));
+        if (descriptor.executable === false) {
+            blockers.push(...validateArtifactCapabilityReceipt(receipt, relevantCalls, evidence.artifacts, artifactSources));
+            continue;
+        }
+        const expectedTools = uniqueStrings(relevantCalls.map((call) => call.tool)).sort();
+        const expectedHash = capabilityReceiptSha256(id, relevantCalls.map((call) => call.event_sha256), []);
+        if (JSON.stringify(receipt.tool_names) !== JSON.stringify(expectedTools)) {
+            blockers.push(`host_capability_receipt_tool_calls_mismatch:${id}`);
+        }
+        if (receipt.receipt_sha256 !== expectedHash) {
+            blockers.push(`host_capability_receipt_sha256_mismatch:${id}`);
+        }
+        if (receipt.status === 'passed') {
+            if (relevantCalls.length === 0)
+                blockers.push(`host_capability_passed_call_missing:${id}`);
+            if (relevantCalls.some((call) => call.status !== 'passed')) {
+                blockers.push(`host_capability_passed_call_failed:${id}`);
+            }
+        }
+    }
+    return uniqueStrings(blockers);
+}
+function validateArtifactCapabilityReceipt(receipt, relevantCalls, artifacts, artifactSources) {
+    const id = receipt.id;
+    const blockers = [];
+    const expectedTools = uniqueStrings(relevantCalls.map((call) => call.tool)).sort();
+    if (JSON.stringify(receipt.tool_names) !== JSON.stringify(expectedTools)) {
+        blockers.push(`host_capability_receipt_artifact_sources_mismatch:${id}`);
+    }
+    const expectedHash = capabilityReceiptSha256(id, relevantCalls.map((call) => call.event_sha256), artifactSources.map((source) => source.source_event_sha256));
+    if (receipt.receipt_sha256 !== expectedHash)
+        blockers.push(`host_capability_receipt_sha256_mismatch:${id}`);
+    if (receipt.status === 'passed') {
+        if (artifacts.length === 0)
+            blockers.push(`host_capability_passed_artifact_missing:${id}`);
+        if (artifactSources.length === 0)
+            blockers.push(`host_capability_passed_artifact_source_missing:${id}`);
+        if (relevantCalls.some((call) => call.status !== 'passed')) {
+            blockers.push(`host_capability_passed_call_failed:${id}`);
+        }
+    }
+    return blockers;
+}
+function validateHostArtifactSources(evidence, blockers) {
+    const value = evidence.artifact_sources;
+    if (!Array.isArray(value)) {
+        blockers.push('host_artifact_source_mapping_missing');
+        return [];
+    }
+    if (value.length > MAX_HOST_ARTIFACT_SOURCES)
+        blockers.push('host_artifact_source_mapping_too_many');
+    const sources = [];
+    for (const row of value.slice(0, MAX_HOST_ARTIFACT_SOURCES)) {
+        if (!isRecord(row)
+            || Object.keys(row).some((key) => !['path', 'source_tool', 'source_event_sha256'].includes(key))) {
+            blockers.push('host_artifact_source_mapping_invalid');
+            continue;
+        }
+        const artifactPath = normalizeParentArtifactPath(row.path);
+        const sourceTool = boundedParentToken(row.source_tool, 128, /^[A-Za-z][A-Za-z0-9_.:-]*$/);
+        const sourceEventSha256 = typeof row.source_event_sha256 === 'string'
+            ? row.source_event_sha256.trim().toLowerCase()
+            : '';
+        if (!artifactPath || !sourceTool || !SHA256_RECEIPT_PATTERN.test(sourceEventSha256)) {
+            blockers.push('host_artifact_source_mapping_invalid');
+            continue;
+        }
+        sources.push({ path: artifactPath, source_tool: sourceTool, source_event_sha256: sourceEventSha256 });
+    }
+    const artifactPaths = evidence.artifacts.map((artifact) => artifact.path);
+    const sourcePaths = sources.map((source) => source.path);
+    if (JSON.stringify(artifactPaths) !== JSON.stringify([...artifactPaths].sort((left, right) => left.localeCompare(right)))) {
+        blockers.push('host_artifact_source_mapping_order_mismatch');
+    }
+    if (new Set(sourcePaths).size !== sourcePaths.length)
+        blockers.push('host_artifact_source_mapping_duplicate');
+    if (artifactPaths.some((artifactPath) => !sourcePaths.includes(artifactPath))) {
+        blockers.push('host_artifact_source_mapping_missing');
+    }
+    if (sourcePaths.some((sourcePath) => !artifactPaths.includes(sourcePath))) {
+        blockers.push('host_artifact_source_mapping_forged');
+    }
+    if (JSON.stringify(sourcePaths) !== JSON.stringify(artifactPaths)) {
+        blockers.push('host_artifact_source_mapping_order_mismatch');
+    }
+    for (const source of sources) {
+        if (!HOST_ARTIFACT_SOURCE_TOOLS.has(source.source_tool)) {
+            blockers.push('host_artifact_source_mapping_forged');
+            continue;
+        }
+        const exactPassedCalls = evidence.tool_calls.filter((call) => (call.status === 'passed'
+            && call.tool === source.source_tool
+            && call.event_sha256 === source.source_event_sha256));
+        if (exactPassedCalls.length !== 1)
+            blockers.push('host_artifact_source_mapping_forged');
+    }
+    return sources;
+}
+function capabilityReceiptSha256(id, calls, artifacts) {
+    return `sha256:${sha256(JSON.stringify({ id, calls, artifacts }))}`;
+}
 export function normalizeSubagentEvent(payload, explicitEventName) {
     const row = isRecord(payload) ? payload : {};
     const nested = isRecord(row.payload)
@@ -38,9 +168,6 @@ export function normalizeSubagentEvent(payload, explicitEventName) {
     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'
@@ -77,6 +204,8 @@ export function buildSubagentEvidence(input) {
         .map((event) => normalizeSubagentEvent(event))
         .filter((event) => Boolean(event));
     const parentSummary = normalizeSubagentParentSummary(input.parentSummary);
+    const hostCapabilityEvidence = normalizeTrustedHostCapabilityEvidence(input.hostCapabilityEvidence);
+    const hostCapabilityBlockers = validateParentHostCapabilityBinding(parentSummary.raw, hostCapabilityEvidence);
     const runScope = resolveRunScope(input, normalizedEvents, parentSummary);
     const scopedEvents = scopeSubagentEvents(normalizedEvents, runScope);
     const events = scopedEvents.events;
@@ -88,6 +217,7 @@ export function buildSubagentEvidence(input) {
     const eventSources = new Set();
     let missingThreadId = false;
     const parentSummaryStructurallyTrustworthy = parentSummary.trustworthy
+        && hostCapabilityBlockers.length === 0
         && runScope.blockers.length === 0
         && runScope.parentBlockers.length === 0;
     const parentCompletedStructurallyTrustworthy = parentSummaryStructurallyTrustworthy
@@ -213,6 +343,17 @@ export function buildSubagentEvidence(input) {
         blockers.push(...parentSummary.blockers);
     if (parentSummary.status === 'failed')
         blockers.push('parent_summary_failed');
+    blockers.push(...hostCapabilityBlockers);
+    if (input.hostCapabilityEvidence !== undefined && input.hostCapabilityEvidence !== null && !hostCapabilityEvidence) {
+        blockers.push('host_capability_evidence_invalid');
+    }
+    if (hostCapabilityEvidence) {
+        blockers.push(...hostCapabilityEvidence.blockers);
+        if (hostCapabilityEvidence.ok !== (hostCapabilityEvidence.blockers.length === 0
+            && hostCapabilityEvidence.capabilities_used.every((receipt) => receipt.status === 'passed'))) {
+            blockers.push('host_capability_evidence_status_inconsistent');
+        }
+    }
     for (const blocker of input.additionalBlockers || []) {
         const normalized = String(blocker || '').trim();
         if (normalized)
@@ -224,7 +365,7 @@ export function buildSubagentEvidence(input) {
         ? 'preparation_only'
         : ok
             ? 'completed'
-            : failedThreadIds.length > 0
+            : failedThreadIds.length > 0 || hostCapabilityBlockers.length > 0 || Boolean(hostCapabilityEvidence && !hostCapabilityEvidence.ok)
                 ? 'blocked'
                 : 'incomplete';
     return {
@@ -255,7 +396,8 @@ export function buildSubagentEvidence(input) {
         preparation_only: preparationOnly,
         status,
         ok,
-        blockers: uniqueBlockers
+        blockers: uniqueBlockers,
+        ...(hostCapabilityEvidence ? { host_capability_evidence: hostCapabilityEvidence } : {})
     };
 }
 export async function recordSubagentEvent(artifactDir, payload, explicitEventName) {
@@ -392,7 +534,19 @@ export function normalizeSubagentParentSummary(value) {
     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']);
+    const topLevelKeys = new Set([
+        'schema',
+        'status',
+        'summary',
+        'thread_outcomes',
+        'changed_files',
+        'verification',
+        'blockers',
+        'run_id',
+        'run_epoch',
+        'artifacts',
+        'capabilities_used'
+    ]);
     for (const key of Object.keys(parsed)) {
         if (!topLevelKeys.has(key))
             blockers.push(`parent_summary_unknown_field:${key}`);
@@ -411,6 +565,8 @@ export function normalizeSubagentParentSummary(value) {
     if (parsed.blockers !== undefined && (!Array.isArray(parsed.blockers) || parsed.blockers.some((item) => typeof item !== 'string'))) {
         blockers.push('parent_summary_blockers_invalid');
     }
+    const parentArtifacts = validateParentArtifactReceipts(parsed.artifacts, blockers);
+    const parentCapabilities = validateParentCapabilityUseReceipts(parsed.capabilities_used, blockers);
     if (!Array.isArray(parsed.thread_outcomes) || parsed.thread_outcomes.length === 0) {
         blockers.push('parent_thread_outcomes_missing');
     }
@@ -452,6 +608,17 @@ export function normalizeSubagentParentSummary(value) {
     if (status === 'completed' && Array.isArray(parsed.blockers) && parsed.blockers.length > 0) {
         blockers.push('parent_summary_completed_with_blockers');
     }
+    if (status === 'completed') {
+        for (const receipt of parentCapabilities || []) {
+            if (receipt.status !== 'passed')
+                blockers.push(`parent_summary_capability_not_passed:${receipt.id}`);
+        }
+    }
+    const raw = {
+        ...parsed,
+        ...(parsed.artifacts === undefined ? {} : { artifacts: parentArtifacts || [] }),
+        ...(parsed.capabilities_used === undefined ? {} : { capabilities_used: parentCapabilities || [] })
+    };
     return {
         present: true,
         trustworthy: blockers.length === 0,
@@ -461,7 +628,7 @@ export function normalizeSubagentParentSummary(value) {
         run_epoch: firstText(parsed.run_epoch) || null,
         thread_outcomes: threadOutcomes,
         blockers: uniqueStrings(blockers.length ? blockers : []),
-        raw: parsed
+        raw
     };
 }
 function parseStructuredParentSummary(value) {
@@ -490,6 +657,208 @@ function validStructuredParentSummary(value) {
         return null;
     return value;
 }
+function validateParentArtifactReceipts(value, blockers) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        blockers.push('parent_summary_artifacts_invalid');
+        return undefined;
+    }
+    if (value.length > MAX_PARENT_ARTIFACTS)
+        blockers.push('parent_summary_artifacts_too_many');
+    const result = [];
+    const seen = new Set();
+    for (const row of value.slice(0, MAX_PARENT_ARTIFACTS)) {
+        if (!isRecord(row)) {
+            blockers.push('parent_summary_artifact_invalid');
+            continue;
+        }
+        const artifactPath = normalizeParentArtifactPath(row.path);
+        const kind = boundedParentToken(row.kind, 64, /^[a-z][a-z0-9_-]*$/);
+        const mediaType = boundedParentToken(row.media_type, 160, /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i);
+        const receiptHash = typeof row.sha256 === 'string' && SHA256_RECEIPT_PATTERN.test(row.sha256)
+            ? row.sha256
+            : null;
+        const bytes = typeof row.bytes === 'number' && Number.isSafeInteger(row.bytes) && row.bytes > 0
+            ? row.bytes
+            : null;
+        const role = typeof row.role === 'string' && ARTIFACT_ROLES.has(row.role)
+            ? row.role
+            : null;
+        if (!artifactPath)
+            blockers.push('parent_summary_artifact_path_invalid');
+        if (!kind)
+            blockers.push('parent_summary_artifact_kind_invalid');
+        if (!mediaType)
+            blockers.push('parent_summary_artifact_media_type_invalid');
+        if (!receiptHash)
+            blockers.push('parent_summary_artifact_sha256_invalid');
+        if (bytes === null)
+            blockers.push('parent_summary_artifact_bytes_invalid');
+        if (!role)
+            blockers.push('parent_summary_artifact_role_invalid');
+        if (!artifactPath || !kind || !mediaType || !receiptHash || bytes === null || !role)
+            continue;
+        if (seen.has(artifactPath)) {
+            blockers.push('parent_summary_artifact_path_duplicate');
+            continue;
+        }
+        seen.add(artifactPath);
+        result.push({ path: artifactPath, kind, media_type: mediaType, sha256: receiptHash, bytes, role });
+    }
+    return result;
+}
+function validateParentCapabilityUseReceipts(value, blockers) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        blockers.push('parent_summary_capabilities_used_invalid');
+        return undefined;
+    }
+    if (value.length > MAX_PARENT_CAPABILITY_USES)
+        blockers.push('parent_summary_capabilities_used_too_many');
+    const result = [];
+    const seen = new Set();
+    for (const row of value.slice(0, MAX_PARENT_CAPABILITY_USES)) {
+        if (!isRecord(row)) {
+            blockers.push('parent_summary_capability_use_invalid');
+            continue;
+        }
+        const id = typeof row.id === 'string' ? row.id.trim() : '';
+        const descriptor = HOST_CAPABILITY_BY_ID.get(id);
+        const status = row.status === 'passed' || row.status === 'failed' ? row.status : null;
+        const toolNames = normalizeParentCapabilityToolNames(row.tool_names, descriptor?.tool_names || [], status);
+        const receiptHash = typeof row.receipt_sha256 === 'string' && SHA256_RECEIPT_PATTERN.test(row.receipt_sha256)
+            ? row.receipt_sha256
+            : null;
+        if (!descriptor)
+            blockers.push(`parent_summary_capability_use_unknown:${id || '<missing>'}`);
+        if (!status)
+            blockers.push('parent_summary_capability_use_status_invalid');
+        if (!toolNames)
+            blockers.push('parent_summary_capability_use_tool_names_invalid');
+        if (!receiptHash)
+            blockers.push('parent_summary_capability_use_receipt_sha256_invalid');
+        if (!descriptor || !status || !toolNames || !receiptHash)
+            continue;
+        if (seen.has(id)) {
+            blockers.push(`parent_summary_capability_use_duplicate:${id}`);
+            continue;
+        }
+        seen.add(id);
+        result.push({ id, status, tool_names: toolNames, receipt_sha256: receiptHash });
+    }
+    return result;
+}
+function normalizeParentArtifactPath(value) {
+    if (typeof value !== 'string')
+        return null;
+    const original = value.trim();
+    if (!original || original.length > MAX_PARENT_ARTIFACT_PATH_CHARS || /[\r\n\0\\]/.test(original))
+        return null;
+    if (path.posix.isAbsolute(original) || path.win32.isAbsolute(original))
+        return null;
+    const normalized = path.posix.normalize(original).replace(/^\.\//, '');
+    if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../'))
+        return null;
+    return normalized.length <= MAX_PARENT_ARTIFACT_PATH_CHARS ? normalized : null;
+}
+function normalizeParentCapabilityToolNames(value, allowed, status) {
+    if (!Array.isArray(value) || value.length > MAX_PARENT_CAPABILITY_TOOL_NAMES)
+        return null;
+    if (status === 'passed' && value.length === 0)
+        return null;
+    const allowedSet = new Set(allowed);
+    const result = [];
+    const seen = new Set();
+    for (const item of value) {
+        const tool = boundedParentToken(item, 128, /^[A-Za-z][A-Za-z0-9_.:-]*$/);
+        if (!tool || !allowedSet.has(tool) || seen.has(tool))
+            return null;
+        seen.add(tool);
+        result.push(tool);
+    }
+    return result;
+}
+function boundedParentToken(value, maxChars, pattern) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text && text.length <= maxChars && !/[\r\n\0]/.test(text) && pattern.test(text) ? text : null;
+}
+function normalizeTrustedHostCapabilityEvidence(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (!isRecord(value)
+        || value.schema !== HOST_CAPABILITY_EVIDENCE_SCHEMA
+        || typeof value.ok !== 'boolean'
+        || !isRecord(value.runtime)
+        || value.runtime.schema !== HOST_CAPABILITY_RUNTIME_SCHEMA
+        || value.runtime.server !== 'acas-tools'
+        || value.runtime.capability_digest !== hostCapabilityDigest(HOST_CAPABILITY_DESCRIPTORS)
+        || !Array.isArray(value.runtime.requested_capability_ids)
+        || value.runtime.requested_capability_ids.some((id) => typeof id !== 'string' || !HOST_CAPABILITY_BY_ID.has(id))
+        || new Set(value.runtime.requested_capability_ids).size !== value.runtime.requested_capability_ids.length
+        || !Array.isArray(value.tool_calls)
+        || !Array.isArray(value.capabilities_used)
+        || !Array.isArray(value.artifacts)
+        || !Array.isArray(value.artifact_sources)
+        || !Array.isArray(value.blockers)
+        || value.blockers.some((blocker) => typeof blocker !== 'string')) {
+        return null;
+    }
+    const validationBlockers = [];
+    const capabilities = validateParentCapabilityUseReceipts(value.capabilities_used, validationBlockers);
+    const artifacts = validateParentArtifactReceipts(value.artifacts, validationBlockers);
+    if (!capabilities || !artifacts || validationBlockers.length > 0)
+        return null;
+    const knownTools = new Set(HOST_CAPABILITY_DESCRIPTORS.flatMap((descriptor) => descriptor.tool_names));
+    if (value.tool_calls.length > 1024 || value.tool_calls.some((row) => {
+        if (!isRecord(row))
+            return true;
+        return row.server !== 'acas-tools'
+            || typeof row.tool !== 'string'
+            || !knownTools.has(row.tool)
+            || (row.status !== 'passed' && row.status !== 'failed')
+            || typeof row.event_sha256 !== 'string'
+            || !SHA256_RECEIPT_PATTERN.test(row.event_sha256);
+    }))
+        return null;
+    const evidence = {
+        ...value,
+        capabilities_used: capabilities,
+        artifacts,
+        artifact_sources: value.artifact_sources
+    };
+    return trustedHostCapabilityReceiptBindingBlockers(evidence).length === 0 ? evidence : null;
+}
+function validateParentHostCapabilityBinding(parent, evidence) {
+    const parentClaims = hasNonEmptyHostCapabilityClaim(parent?.artifacts)
+        || hasNonEmptyHostCapabilityClaim(parent?.capabilities_used);
+    if (!evidence)
+        return parentClaims ? ['parent_summary_host_capability_evidence_missing'] : [];
+    const bindingRequired = parentClaims
+        || evidence.runtime.requested_capability_ids.length > 0
+        || evidence.tool_calls.length > 0
+        || evidence.artifacts.length > 0;
+    if (!bindingRequired)
+        return [];
+    const blockers = [];
+    const artifactBlockers = [];
+    const capabilityBlockers = [];
+    const parentArtifacts = validateParentArtifactReceipts(parent?.artifacts, artifactBlockers);
+    const parentCapabilities = validateParentCapabilityUseReceipts(parent?.capabilities_used, capabilityBlockers);
+    if (artifactBlockers.length > 0 || JSON.stringify(parentArtifacts || []) !== JSON.stringify(evidence.artifacts)) {
+        blockers.push('parent_summary_host_artifacts_mismatch');
+    }
+    if (capabilityBlockers.length > 0 || JSON.stringify(parentCapabilities || []) !== JSON.stringify(evidence.capabilities_used)) {
+        blockers.push('parent_summary_host_capabilities_mismatch');
+    }
+    return blockers;
+}
+function hasNonEmptyHostCapabilityClaim(value) {
+    return Array.isArray(value) ? value.length > 0 : value !== undefined;
+}
 function hasFocusedParentVerification(value) {
     if (!Array.isArray(value))
         return false;
@@ -578,7 +947,7 @@ function parentResultExplicitlyFailed(value) {
         || containsUnambiguousFailureText(resultText);
 }
 function isFailureWorkflowStatus(value) {
-    return /^(parent_failed|failed|blocked|incomplete|cancelled|canceled|timed[_ -]?out)$/i.test(String(value || '').trim());
+    return /^(parent_failed|host_capability_blocked|failed|blocked|incomplete|cancelled|canceled|timed[_ -]?out)$/i.test(String(value || '').trim());
 }
 function resolveRunScope(input, events, parentSummary) {
     const requestedRunId = firstText(input.runId);

package/dist/core/subagents/thread-budget.js

@@ -6,9 +6,12 @@ export const DEFAULT_NARUTO_REVIEWER_THREAD_RESERVATION = 1;
 export function resolveSubagentThreadBudget(input = {}) {
     const requested = clamp(input.requested ?? input.independentSliceCount ?? DEFAULT_NARUTO_REQUESTED_SUBAGENTS, 1, HARD_NARUTO_MAX_THREADS);
     const configured = clamp(input.configuredMaxThreads ?? DEFAULT_NARUTO_MAX_THREADS, 1, HARD_NARUTO_MAX_THREADS);
-    const parentThreads = clampNonNegative(input.parentReservedThreads ?? DEFAULT_NARUTO_PARENT_THREAD_RESERVATION, HARD_NARUTO_MAX_THREADS);
-    const reviewerThreads = clampNonNegative(input.reviewerReservedThreads ?? DEFAULT_NARUTO_REVIEWER_THREAD_RESERVATION, HARD_NARUTO_MAX_THREADS);
+    const requestedParentThreads = clampNonNegative(input.parentReservedThreads ?? DEFAULT_NARUTO_PARENT_THREAD_RESERVATION, HARD_NARUTO_MAX_THREADS);
+    const requestedReviewerThreads = clampNonNegative(input.reviewerReservedThreads ?? DEFAULT_NARUTO_REVIEWER_THREAD_RESERVATION, HARD_NARUTO_MAX_THREADS);
     const activeThreads = clampNonNegative(input.activeThreadCount ?? 0, HARD_NARUTO_MAX_THREADS);
+    const reservationCapacity = Math.max(0, configured - activeThreads - 1);
+    const parentThreads = Math.min(requestedParentThreads, reservationCapacity);
+    const reviewerThreads = Math.min(requestedReviewerThreads, reservationCapacity - parentThreads);
     const availableThreadSlots = Math.max(0, configured - parentThreads - reviewerThreads - activeThreads);
     const marginalUsefulThroughputPositive = input.marginalUsefulThroughputPositive !== false;
     const bounds = {

package/dist/core/subagents/triwiki-attention.js

@@ -55,10 +55,6 @@ function selectAnchors(useFirst, hydrateHints, hydrateOrder, limit, query) {
         return useFirst.slice(0, limit).map(stripOrder);
     const selected = [];
     const seen = new Set();
-    // Keep the leading high-trust policy anchors, then spend the remaining
-    // budget on query-relevant use_first or hydrate-first candidates. Hydrate-
-    // only rows stay hints: workers must open the cited source before relying on
-    // them, so relevance improves without treating lower-trust summaries as fact.
     for (const anchor of useFirst.slice(0, Math.min(3, limit))) {
         selected.push(stripOrder(anchor));
         seen.add(anchor.id);

package/dist/core/subagents/wave-parent-guidance.js

@@ -1,19 +1,28 @@
+import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 export const WAVE_PARENT_GUIDANCE_SCHEMA = 'sks.subagent-wave-parent-guidance.v1';
+const SUBAGENT_WAVE_LIFECYCLE_SCHEMA = 'sks.subagent-wave-lifecycle.v1';
+const OFFICIAL_SUBAGENT_PLAN_SCHEMA = 'sks.subagent-plan.v1';
+const OFFICIAL_SUBAGENT_WORKFLOW = 'official_codex_subagent';
+const CLOSE_COMPLETED_THREADS_ACTION = 'close_completed_child_threads_after_collecting_results';
+const REFRESH_LIFECYCLE_ACTION = 'refresh_wave_lifecycle_and_ready_dag';
+const SPAWN_NEXT_WAVE_ACTION = 'spawn_next_direct_child_wave_upto';
+const EMIT_PARENT_SUMMARY_ACTION = 'integrate_settled_child_results_and_emit_parent_summary';
 export function buildWaveParentGuidance(lifecycle) {
-    const remaining = Math.max(0, Math.floor(Number(lifecycle?.remaining_to_start || 0)));
-    const openThreads = Math.max(0, Math.floor(Number(lifecycle?.open_threads || 0)));
-    const recovered = Math.max(0, Math.floor(Number(lifecycle?.recovered_capacity || 0)));
+    const remaining = boundedLifecycleCount(lifecycle?.remaining_to_start);
+    const openThreads = boundedLifecycleCount(lifecycle?.open_threads);
+    const recovered = boundedLifecycleCount(lifecycle?.recovered_capacity);
     const rescan = lifecycle?.post_wave_rescan_required === true;
     const actions = [];
     if (openThreads > 0) {
-        actions.push('close_completed_child_threads_after_collecting_results');
+        actions.push(CLOSE_COMPLETED_THREADS_ACTION);
     }
     if (rescan || remaining > 0) {
-        actions.push('refresh_wave_lifecycle_and_ready_dag');
-        actions.push(`spawn_next_direct_child_wave_upto:${Math.max(1, Math.min(remaining || recovered, recovered || remaining || 1))}`);
+        actions.push(REFRESH_LIFECYCLE_ACTION);
+        const nextWaveLimit = Math.max(1, Math.min(remaining || recovered, recovered || remaining || 1));
+        actions.push(`${SPAWN_NEXT_WAVE_ACTION}:${nextWaveLimit}`);
     }
     if (remaining === 0 && openThreads === 0 && !rescan) {
-        actions.push('integrate_settled_child_results_and_emit_parent_summary');
+        actions.push(EMIT_PARENT_SUMMARY_ACTION);
     }
     return {
         schema: WAVE_PARENT_GUIDANCE_SCHEMA,
@@ -23,10 +32,41 @@ export function buildWaveParentGuidance(lifecycle) {
         open_threads: openThreads,
         recovered_capacity: recovered,
         post_wave_rescan_required: rescan,
-        current_wave: Math.max(0, Math.floor(Number(lifecycle?.current_wave || 0))),
-        completed_waves: Math.max(0, Math.floor(Number(lifecycle?.completed_waves || 0)))
+        current_wave: boundedLifecycleCount(lifecycle?.current_wave),
+        completed_waves: boundedLifecycleCount(lifecycle?.completed_waves)
     };
 }
+export function buildBoundWaveParentGuidance(plan, binding) {
+    if (!plan || typeof plan !== 'object' || Array.isArray(plan))
+        return null;
+    const row = plan;
+    const missionId = String(binding.missionId || '').trim();
+    const workflowRunId = String(binding.workflowRunId || '').trim();
+    if (!missionId || !workflowRunId)
+        return null;
+    if (row.schema !== OFFICIAL_SUBAGENT_PLAN_SCHEMA || row.workflow !== OFFICIAL_SUBAGENT_WORKFLOW)
+        return null;
+    if (String(row.mission_id || '').trim() !== missionId)
+        return null;
+    if (String(row.workflow_run_id || '').trim() !== workflowRunId)
+        return null;
+    const lifecycle = row.wave_lifecycle;
+    if (!lifecycle || typeof lifecycle !== 'object' || Array.isArray(lifecycle))
+        return null;
+    const lifecycleRow = lifecycle;
+    if (lifecycleRow.schema !== SUBAGENT_WAVE_LIFECYCLE_SCHEMA)
+        return null;
+    if (String(lifecycleRow.workflow_run_id || '').trim() !== workflowRunId)
+        return null;
+    return buildWaveParentGuidance({
+        remaining_to_start: boundedLifecycleCount(lifecycleRow.remaining_to_start),
+        open_threads: boundedLifecycleCount(lifecycleRow.open_threads),
+        recovered_capacity: boundedLifecycleCount(lifecycleRow.recovered_capacity),
+        post_wave_rescan_required: lifecycleRow.post_wave_rescan_required === true,
+        current_wave: boundedLifecycleCount(lifecycleRow.current_wave),
+        completed_waves: boundedLifecycleCount(lifecycleRow.completed_waves)
+    });
+}
 export function renderWaveParentGuidance(guidance) {
     if (!guidance.required && guidance.actions.length === 0)
         return '';
@@ -40,3 +80,8 @@ export function renderWaveParentGuidance(guidance) {
         '- after collecting results, close completed child threads so recovered capacity can be reused'
     ].join('\n');
 }
+function boundedLifecycleCount(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(HARD_NARUTO_MAX_THREADS, Math.floor(value)));
+}

package/dist/core/telegram/runtime.js

@@ -69,7 +69,6 @@ export class TelegramHubRuntime {
                     changed = await this.projectSnapshot(route, snapshot, state) || changed;
             }
             catch {
-                // A disconnected Mac is a fleet warning, not a Telegram polling failure.
             }
         }
         if (changed)

package/dist/core/triwiki/code-index-scanner.js

@@ -11,7 +11,6 @@ const EXPORT_LINE_RE = /^\s*export\s+(?:default\s+)?(?:const|let|var|function|cl
 const EXPORT_BRACE_RE = /^\s*export\s*\{/;
 const EXPORT_STAR_RE = /^\s*export\s*\*/;
 const IMPORT_SPEC_RE = /(?:from\s+|require\()\s*['"](\.\.?\/[^'"]+)['"]/g;
-// High fan-in or a large file surface both correlate with change blast-radius; simple counts avoid needing a real dependency graph.
 const RISK_HIGH_FAN_IN = 5;
 const RISK_HIGH_FILE_COUNT = 40;
 const RISK_MEDIUM_FAN_IN = 2;
@@ -258,7 +257,6 @@ function collectEntryPoints(root, dir, files) {
                 entryPoints.add(normalizeEntryPath(dir, value));
         }
         catch {
-            // malformed package.json at a module boundary is not this scanner's concern; skip entry-point inference for it
         }
     }
     for (const file of files) {
@@ -304,7 +302,6 @@ function resolveRelativeImport(root, fromRel, specifier) {
         const absolute = path.join(root, candidate);
         if (!fs.existsSync(absolute))
             continue;
-        // only resolve to a real file — a bare directory match (no extension) can't be looked up in the file->module index
         if (fs.statSync(absolute).isFile())
             return candidate;
     }

package/dist/core/triwiki/code-pack-head-freshness.js

@@ -17,19 +17,11 @@ export async function inspectCodePackHeadFreshness(root, packShaInput, opts = {}
         return staleWithCurrentHead(root, null, timeoutMs, fastHead, false, 'invalid_pack_sha');
     if (fastHead === packSha)
         return freshness(true, true, 'exact_head', fastHead, packSha, false, []);
-    // Only the non-blocking hook consumes this cache. Authoritative wiki
-    // validation always replays Git history and never trusts advisory state.
     if (opts.advisoryCache && fastHead) {
         const cached = await readAdvisoryCache(root, packSha, fastHead);
         if (cached)
             return cached;
     }
-    // One common-path Git process returns HEAD plus every committed path after
-    // the pack was generated. Excluding all parents of packSha keeps packSha in
-    // the walk (including a root commit), so its presence proves ancestry. We
-    // keep scanning after the pack marker because a later merge can introduce
-    // sibling-branch commits that Git orders after packSha. `-m` exposes merge
-    // resolution paths and `--no-renames` makes touched paths auditable.
     const history = await runProcess('git', [
         '-c',
         'core.quotepath=true',
@@ -106,8 +98,6 @@ function parseHistory(stdout, packSha) {
         }
         if (activeCommit === packSha)
             continue;
-        // Do not trim Git paths: leading/trailing whitespace is meaningful and
-        // must never be normalized into an allowlisted metadata path.
         for (const changedPath of pathText.split('\t')) {
             if (!changedPath || seenPaths.has(changedPath))
                 continue;