@peterxiaoyang/superspec 0.1.6 → 0.1.8

package/adapters/codex/install-map.json

@@ -27,6 +27,11 @@
       "source": "templates/workflow/skills/superspec-archive/SKILL.md",
       "target": ".codex/skills/superspec-archive/SKILL.md"
     },
+    {
+      "kind": "hook",
+      "source": "templates/hooks/codex-hooks.json",
+      "target": ".codex/hooks.json"
+    },
     {
       "kind": "prompt",
       "source": "templates/workflow/prompts/architect.md",

package/bin/superspec-hook.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runEntry } from "./launch.js";
+
+await runEntry("../dist/superspec_hook.js", "main_hook");

package/dist/src/apply_worker_chain_lifecycle.d.ts

@@ -0,0 +1,19 @@
+import type { JsonMap, Reason } from "./util.ts";
+export type ApplyWorkerChainLifecycleState = {
+    completionReasons: Reason[];
+    packetBlockers: Reason[];
+    activeBlockingReasons: Reason[];
+    activePresence: "none" | "single_open" | "blocked";
+    active: JsonMap | null;
+    openActiveChainIds: Set<string>;
+    validTerminalChainIds: Set<string>;
+    validClosedChainIds: Set<string>;
+    validClosedGreenEvidenceIds: Set<string>;
+    takeoverBaselines: {
+        fingerprint: unknown;
+        successorGreenRefs: string[];
+    }[];
+};
+export declare function serial_completion_green(ev: JsonMap): boolean;
+export declare function apply_worker_chain_lifecycle_state(repoRoot: string, changeRoot: string, evidences: JsonMap[], taskId: string): ApplyWorkerChainLifecycleState;
+export declare function apply_worker_chain_lifecycle_reasons(repoRoot: string, changeRoot: string, evidences: JsonMap[], taskId: string): Reason[];

package/dist/src/apply_worker_chain_lifecycle.js

@@ -0,0 +1,278 @@
+import { isObject, reason, renderList, repr } from "./util.js";
+import { find_pass, live_pass } from "./evidence.js";
+import { apply_worker_implementation_fingerprint, apply_worker_executor_input_ref_digest, compute_apply_worker_freshness, fingerprint_matches, pinned_artifact_ref_reasons as shared_pinned_artifact_ref_reasons, pre_edit_evidence_ref_reasons, read_pinned_artifact_json, worker_input_ref_digest, worker_test_run_reasons, } from "./apply_worker_chain.js";
+function pinned_artifact_ref_matches(changeRoot, refItem, role, taskId, chainId, kind = "worker_report") {
+    return shared_pinned_artifact_ref_reasons(changeRoot, refItem, `${role}_ref`, { kind, role, taskId, chainId }).length === 0;
+}
+function executor_worker_test_run_refs_valid(changeRoot, ev, taskId, chainId) {
+    return worker_test_run_reasons(changeRoot, ev, taskId, chainId).length === 0;
+}
+function report_origin_matches(refItem, expected) {
+    return isObject(refItem) && typeof expected === "string" && refItem.origin_packet_fingerprint === expected;
+}
+function report_input_refs_match(refItem, refs) {
+    return isObject(refItem) && refItem.input_ref_digest === worker_input_ref_digest(refs);
+}
+function report_input_digest_matches(refItem, expectedDigest) {
+    return isObject(refItem) && refItem.input_ref_digest === expectedDigest;
+}
+function chain_green_ids(ev) {
+    if (Array.isArray(ev.green_test_run_evidence_refs)) {
+        return ev.green_test_run_evidence_refs.map(String).filter(Boolean).sort();
+    }
+    const greenId = isObject(ev.green_test_run_evidence_ref)
+        ? String(ev.green_test_run_evidence_ref.evidence_id ?? "")
+        : String(ev.green_test_run_evidence_ref ?? "");
+    return greenId ? [greenId] : [];
+}
+function active_pre_edit_input_refs(evidences, active) {
+    const preIds = Array.isArray(active.pre_edit_evidence_refs) ? active.pre_edit_evidence_refs.map(String) : [];
+    return preIds.map((evidenceId) => {
+        const ev = live_pass(evidences, { kind: "test_run" }).find((item) => String(item.evidence_id ?? "") === evidenceId);
+        return ev
+            ? { kind: "test_run", evidence_id: evidenceId, phase: ev.phase, semantic_status: ev.semantic_status }
+            : { kind: "test_run", evidence_id: evidenceId };
+    });
+}
+function closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId) {
+    const active = live_pass(evidences, { gate: "task_complete", kind: "apply_worker_chain", task_id: taskId })
+        .find((item) => item.chain_state === "active" && item.apply_worker_chain_id === chainId);
+    if (!active)
+        return false;
+    if (pre_edit_evidence_ref_reasons(evidences, active, taskId).length > 0)
+        return false;
+    if (!pinned_artifact_ref_matches(changeRoot, ev.executor_report_ref, "executor", taskId, chainId))
+        return false;
+    if (!pinned_artifact_ref_matches(changeRoot, ev.task_code_review_report_ref, "code-reviewer", taskId, chainId))
+        return false;
+    if (!pinned_artifact_ref_matches(changeRoot, ev.verifier_report_ref, "verifier", taskId, chainId))
+        return false;
+    if (!report_origin_matches(ev.executor_report_ref, active.executor_packet_fingerprint))
+        return false;
+    if (!report_input_digest_matches(ev.executor_report_ref, apply_worker_executor_input_ref_digest(evidences, active)))
+        return false;
+    if (!report_input_refs_match(ev.task_code_review_report_ref, [ev.executor_report_ref]))
+        return false;
+    if (typeof ev.observed_freshness_fingerprint !== "string" && !(isObject(ev.observed_freshness_fingerprint) && typeof ev.observed_freshness_fingerprint.fingerprint_digest === "string"))
+        return false;
+    const verifierReport = read_pinned_artifact_json(changeRoot, ev.verifier_report_ref);
+    const verifierObserved = verifierReport?.observed_freshness_fingerprint ?? (isObject(ev.verifier_report_ref) ? ev.verifier_report_ref.observed_freshness_fingerprint : undefined);
+    if (!fingerprint_matches(verifierObserved, ev.observed_freshness_fingerprint))
+        return false;
+    const greenIds = chain_green_ids(ev);
+    if (greenIds.length === 0)
+        return false;
+    const greenRuns = greenIds.map((greenId) => live_pass(evidences, { gate: "task_complete", kind: "test_run", task_id: taskId }).find((item) => (String(item.evidence_id ?? "") === greenId
+        && item.semantic_status === "expected_success"
+        && (item.phase === undefined || item.phase === "green")
+        && item.apply_execution_chain === "executor_worker"
+        && item.apply_worker_chain_id === chainId
+        && executor_worker_test_run_refs_valid(changeRoot, item, taskId, chainId)))).filter((item) => isObject(item));
+    if (greenRuns.length !== greenIds.length)
+        return false;
+    if (!report_input_refs_match(ev.verifier_report_ref, [
+        ev.executor_report_ref,
+        ev.task_code_review_report_ref,
+        ...greenRuns.map((green) => ({ kind: "test_run", evidence_id: String(green.evidence_id ?? ""), phase: green.phase, semantic_status: green.semantic_status })),
+        ...active_pre_edit_input_refs(evidences, active),
+    ]))
+        return false;
+    const currentFreshness = compute_apply_worker_freshness(repoRoot, changeRoot, evidences, taskId, chainId, {
+        executor_report_ref: ev.executor_report_ref,
+        task_code_review_report_ref: ev.task_code_review_report_ref,
+        green_test_run_evidence_ref: greenIds[0],
+        green_test_run_evidence_refs: greenIds,
+        verifier_report_ref: ev.verifier_report_ref,
+    });
+    if (Array.isArray(currentFreshness.unexpected_guard_owned_dirty_paths) && currentFreshness.unexpected_guard_owned_dirty_paths.length > 0)
+        return false;
+    if (Array.isArray(currentFreshness.protected_dirty_paths) && currentFreshness.protected_dirty_paths.length > 0)
+        return false;
+    if (!greenRuns.every((green) => fingerprint_matches(green.implementation_fingerprint, currentFreshness.implementation_fingerprint)))
+        return false;
+    if (!fingerprint_matches(isObject(ev.task_code_review_report_ref) ? ev.task_code_review_report_ref.observed_implementation_fingerprint : undefined, currentFreshness.implementation_fingerprint))
+        return false;
+    return fingerprint_matches(currentFreshness, verifierObserved);
+}
+function pinned_takeover_baseline_valid(changeRoot, refItem, taskId, chainId) {
+    return shared_pinned_artifact_ref_reasons(changeRoot, refItem, "serial_takeover_baseline_ref", { kind: "status_report", role: "verifier", taskId, chainId }).length === 0;
+}
+function abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, active, taskId, chainId) {
+    if (!active)
+        return false;
+    if ("restored_implementation_fingerprint" in ev) {
+        const activeScope = Array.isArray(active.declared_task_write_scope) ? active.declared_task_write_scope.map(String).filter(Boolean) : [];
+        const current = apply_worker_implementation_fingerprint(repoRoot, changeRoot, [], { declaredTaskWriteScope: activeScope });
+        if (fingerprint_matches(ev.restored_implementation_fingerprint, active.source_implementation_fingerprint)
+            && fingerprint_matches(current, active.source_implementation_fingerprint))
+            return true;
+    }
+    if ("serial_takeover_baseline_ref" in ev) {
+        return pinned_takeover_baseline_valid(changeRoot, ev.serial_takeover_baseline_ref, taskId, chainId)
+            && Array.isArray(ev.successor_green_evidence_refs)
+            && ev.successor_green_evidence_refs.length > 0
+            && ev.successor_green_evidence_refs.every((item) => typeof item === "string" && item.length > 0);
+    }
+    return false;
+}
+export function serial_completion_green(ev) {
+    return (ev.runner_origin === undefined || ev.runner_origin === "main-thread")
+        && ev.apply_execution_chain !== "executor_worker"
+        && typeof ev.apply_worker_chain_id !== "string";
+}
+export function apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidences, taskId) {
+    const chains = find_pass(evidences, { gate: "task_complete", kind: "apply_worker_chain", task_id: taskId });
+    const activeByChain = new Map();
+    const activeCounts = new Map();
+    for (const ev of chains) {
+        if (String(ev.chain_state ?? "") !== "active")
+            continue;
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            continue;
+        const bucket = activeCounts.get(chainId) ?? [];
+        bucket.push(ev);
+        activeCounts.set(chainId, bucket);
+        if (!activeByChain.has(chainId))
+            activeByChain.set(chainId, ev);
+    }
+    const chainIdsWithActive = new Set([...activeByChain.keys()]);
+    const terminalValidity = new Map();
+    const chainIdsWithTerminal = new Set(chains
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            return false;
+        let valid = false;
+        if (String(ev.chain_state ?? "") === "closed")
+            valid = closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId);
+        if (String(ev.chain_state ?? "") === "abandoned")
+            valid = abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, activeByChain.get(chainId), taskId, chainId);
+        terminalValidity.set(ev, valid);
+        return valid;
+    })
+        .map((ev) => String(ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean));
+    const openActiveChainIds = new Set([...activeByChain.keys()].filter((chainId) => !chainIdsWithTerminal.has(chainId)));
+    const validClosedChainIds = new Set(chains
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        const valid = String(ev.chain_state ?? "") === "closed" && (terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
+        return chainId && valid;
+    })
+        .map((ev) => String(ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean));
+    const validClosedGreenEvidenceIds = new Set(chains
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        const valid = String(ev.chain_state ?? "") === "closed" && (terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
+        return chainId && valid;
+    })
+        .flatMap(chain_green_ids));
+    const takeoverBaselines = [];
+    const completionReasons = [];
+    const duplicateActives = [...activeCounts.entries()]
+        .filter(([chainId]) => openActiveChainIds.has(chainId))
+        .map(([, items]) => items)
+        .filter((items) => items.length > 1)
+        .flatMap((items) => items.map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? "")))
+        .filter(Boolean)
+        .sort();
+    const openActiveValues = [...openActiveChainIds].map((chainId) => activeByChain.get(chainId)).filter((ev) => isObject(ev));
+    const parallelActives = openActiveValues.length > 1
+        ? openActiveValues.map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? "")).filter(Boolean).sort()
+        : [];
+    const activeConflicts = [...new Set([...duplicateActives, ...parallelActives])].sort();
+    if (activeConflicts.length > 0) {
+        completionReasons.push(reason("apply_worker_chain_active_conflict", `task ${taskId} has conflicting active apply worker chain markers: ${renderList(activeConflicts)}`, activeConflicts));
+    }
+    const terminalsByChain = new Map();
+    for (const ev of chains) {
+        const state = String(ev.chain_state ?? "");
+        if (state !== "closed" && state !== "abandoned")
+            continue;
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            continue;
+        const bucket = terminalsByChain.get(chainId) ?? [];
+        bucket.push(ev);
+        terminalsByChain.set(chainId, bucket);
+    }
+    const duplicateTerminals = [...terminalsByChain.values()]
+        .filter((items) => items.length > 1)
+        .flatMap((items) => items.map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? "")))
+        .filter(Boolean)
+        .sort();
+    if (duplicateTerminals.length > 0) {
+        completionReasons.push(reason("apply_worker_chain_terminal_conflict", `task ${taskId} has duplicate apply worker chain terminal markers: ${renderList(duplicateTerminals)}`, duplicateTerminals));
+    }
+    const invalidTerminals = chains
+        .filter((ev) => String(ev.chain_state ?? "") === "closed" || String(ev.chain_state ?? "") === "abandoned")
+        .filter((ev) => {
+        const chainId = String(ev.apply_worker_chain_id ?? "");
+        if (!chainId)
+            return true;
+        if (String(ev.chain_state ?? "") === "closed")
+            return !(terminalValidity.get(ev) ?? closed_apply_worker_chain_valid(repoRoot, changeRoot, ev, evidences, taskId, chainId));
+        const valid = terminalValidity.get(ev) ?? abandoned_apply_worker_chain_valid(repoRoot, changeRoot, ev, activeByChain.get(chainId), taskId, chainId);
+        if (valid && isObject(ev.serial_takeover_baseline_ref)) {
+            const baseline = read_pinned_artifact_json(changeRoot, ev.serial_takeover_baseline_ref);
+            if (baseline?.implementation_fingerprint !== undefined) {
+                takeoverBaselines.push({
+                    fingerprint: baseline.implementation_fingerprint,
+                    successorGreenRefs: Array.isArray(ev.successor_green_evidence_refs) ? ev.successor_green_evidence_refs.map(String).filter(Boolean) : [],
+                });
+            }
+        }
+        return !valid;
+    })
+        .map((ev) => String(ev.evidence_id ?? ev.apply_worker_chain_id ?? ""))
+        .filter(Boolean)
+        .sort();
+    if (invalidTerminals.length > 0) {
+        completionReasons.push(reason("apply_worker_chain_terminal_invalid", `task ${taskId} has invalid apply worker chain terminal markers: ${renderList(invalidTerminals)}`, invalidTerminals));
+    }
+    for (const chainId of [...openActiveChainIds].sort()) {
+        if (!chainIdsWithTerminal.has(chainId)) {
+            completionReasons.push(reason("apply_worker_chain_active", `task ${taskId} has active apply worker chain and cannot use non-chain task completion: ${chainId}`, [chainId]));
+        }
+    }
+    for (const ev of evidences) {
+        if (!isObject(ev) || ev._invalid || ev.status !== "pass" || ev.task_id !== taskId)
+            continue;
+        const chainId = typeof ev.apply_worker_chain_id === "string" ? ev.apply_worker_chain_id : "";
+        if (!chainId)
+            continue;
+        if (!chainIdsWithActive.has(chainId)) {
+            completionReasons.push(reason("apply_worker_chain_missing_active", `task ${taskId} references apply_worker_chain_id=${repr(chainId)} without a matching active marker`, [chainId]));
+        }
+    }
+    if (duplicateTerminals.length > 0 || activeConflicts.length > 0) {
+        validClosedChainIds.clear();
+        validClosedGreenEvidenceIds.clear();
+    }
+    const activeBlockingReasons = completionReasons.filter((item) => (item.code === "apply_worker_chain_active_conflict"
+        || item.code === "apply_worker_chain_terminal_conflict"
+        || item.code === "apply_worker_chain_terminal_invalid"
+        || item.code === "apply_worker_chain_missing_active"));
+    const activePresence = activeBlockingReasons.length > 0
+        ? "blocked"
+        : openActiveValues.length === 1
+            ? "single_open"
+            : "none";
+    return {
+        completionReasons,
+        packetBlockers: activeBlockingReasons,
+        activeBlockingReasons,
+        activePresence,
+        active: activePresence === "single_open" ? openActiveValues[0] : null,
+        openActiveChainIds,
+        validTerminalChainIds: chainIdsWithTerminal,
+        validClosedChainIds,
+        validClosedGreenEvidenceIds,
+        takeoverBaselines,
+    };
+}
+export function apply_worker_chain_lifecycle_reasons(repoRoot, changeRoot, evidences, taskId) {
+    return apply_worker_chain_lifecycle_state(repoRoot, changeRoot, evidences, taskId).completionReasons;
+}

package/dist/src/archive.js

@@ -35,6 +35,8 @@ function write_text(path, text) {
 function excluded_manifest_entry(relPath) {
     if (relPath.endsWith(STATE_LOCK_FILENAME) || relPath.endsWith("superspec-state.tmp"))
         return true;
+    if (relPath === ".superspec/hook-runtime" || relPath.startsWith(".superspec/hook-runtime/"))
+        return true;
     if (relPath === ".superspec/artifacts/archive-preservation.json")
         return true;
     return false;

package/dist/src/cli_args.d.ts

@@ -9,6 +9,11 @@ export type ParsedArgs = {
     task_id?: string;
     test_id?: string;
     phase?: "red" | "characterization" | "green";
+    event_ref?: string;
+    workflow?: string;
+    entrypoint_token?: string;
+    end_reason?: string;
+    lifecycle_token?: string;
     role?: string;
     evidence_kind?: string;
     round?: number;

package/dist/src/cli_args.js

@@ -11,6 +11,8 @@ const SIMPLE_COMMANDS = [
     "check-verify-ready",
     "check-archive-ready",
     "check-archived",
+    "hook-health",
+    "hook-session-status",
 ];
 const COMMANDS = [
     "init",
@@ -27,6 +29,13 @@ const COMMANDS = [
     "apply-code-review-packet",
     "apply-verify-packet",
     "ledger-render",
+    "hook-check-write",
+    "hook-check-command",
+    "hook-record-test",
+    "hook-record-subagent-start",
+    "hook-record-subagent-stop",
+    "hook-session-begin",
+    "hook-session-end",
 ];
 const COMMAND_LIST = COMMANDS.join(",");
 const COMMAND_CHOICES = COMMANDS.map((item) => `'${item}'`).join(", ");
@@ -61,6 +70,13 @@ function requiredValueFlags(command) {
         flags.push("--task-id", "--executor-report-ref", "--task-code-review-report-ref", "--green-test-run-evidence-ref");
     if (command === "ledger-render")
         flags.push("--gate");
+    if (command === "hook-check-write" || command === "hook-check-command" || command === "hook-record-test"
+        || command === "hook-record-subagent-start" || command === "hook-record-subagent-stop")
+        flags.push("--event-ref");
+    if (command === "hook-session-begin")
+        flags.push("--workflow", "--entrypoint-token");
+    if (command === "hook-session-end")
+        flags.push("--reason");
     return flags;
 }
 function requiredBooleanFlags(command) {
@@ -84,6 +100,8 @@ function optionalValueFlags(command) {
         return ["--red-test-run-evidence-ref", "--characterization-test-run-evidence-ref"];
     if (command === "ledger-render")
         return ["--round"];
+    if (command === "hook-session-end")
+        return ["--lifecycle-token"];
     return [];
 }
 function formatUsage(command) {
@@ -376,6 +394,29 @@ export function parse_argv(argv) {
             throw new GuardError("--round 必须是大于等于 1 的整数");
         return { command, change, gate, round };
     }
+    if (command === "hook-check-write" || command === "hook-check-command" || command === "hook-record-test"
+        || command === "hook-record-subagent-start" || command === "hook-record-subagent-stop") {
+        const eventRef = getValue("--event-ref");
+        if (!eventRef)
+            throw new Error("缺少必填参数 --event-ref");
+        return { command, change, format, event_ref: eventRef };
+    }
+    if (command === "hook-session-begin") {
+        const workflow = getValue("--workflow");
+        const entrypointToken = getValue("--entrypoint-token");
+        if (!workflow)
+            throw new Error("缺少必填参数 --workflow");
+        if (!entrypointToken)
+            throw new Error("缺少必填参数 --entrypoint-token");
+        return { command, change, format, workflow, entrypoint_token: entrypointToken };
+    }
+    if (command === "hook-session-end") {
+        const endReason = getValue("--reason");
+        const lifecycleToken = getValue("--lifecycle-token");
+        if (!endReason)
+            throw new Error("缺少必填参数 --reason");
+        return { command, change, format, end_reason: endReason, lifecycle_token: lifecycleToken ?? "" };
+    }
     if (command === "check-task-reopen" || command === "check-task-edit" || command === "check-task-complete") {
         const taskId = getValue("--task-id");
         if (!taskId)

package/dist/src/core.js

@@ -23,6 +23,7 @@ import { dirty_worktree_paths, dirty_worktree_reasons, dirty_write_scope_red_rea
 import { append_ledger, load_state, compute_fingerprints, prepare_recomputed_state_write, read_ledger_text, record_supersede_ledger_events, restore_state_snapshot_locked, state_corrupt_reasons, state_file, state_file_corrupt, state_stale_reasons, force_unlock_state, with_state_lock, write_prepared_state_locked, } from "./state.js";
 import { archive_manifest_path, begin_archive_preservation_bundle, check_archived, preset_upgrade_reasons, preset_upgrade_required_from_context, write_archive_preservation_bundle, } from "./archive.js";
 import { check_archive_ready, check_apply_ready, check_artifact, check_init, check_superspec_gate, check_review_complete, check_review_ready, check_task_complete, check_task_edit, check_task_reopen, check_verify_complete, evidence_schema_guard, superspec_agent_reasons, superspec_workflow_skill_reasons, openspec_cli_capability_reasons, openspec_init_reasons, } from "./gates.js";
+import { hookCheckCommand, hookCheckWrite, hookHealth, hookRecordSubagentStart, hookRecordSubagentStop, hookRecordTest, hookSessionBegin, hookSessionEnd, hookSessionStatus, } from "./hooks/guard_api.js";
 const RETRY_WAIT = new Int32Array(new SharedArrayBuffer(4));
 const DEFAULT_MAX_STATE_WRITE_RETRIES = 5;
 function sleep_ms(ms) {
@@ -42,6 +43,39 @@ export function load_context(change) {
     const evidences = index_evidence(changeRoot);
     return [status, repoRoot, changeRoot, evidences];
 }
+function is_hook_command(command) {
+    return command === "hook-check-write"
+        || command === "hook-check-command"
+        || command === "hook-record-test"
+        || command === "hook-record-subagent-start"
+        || command === "hook-record-subagent-stop"
+        || command === "hook-health"
+        || command === "hook-session-begin"
+        || command === "hook-session-status"
+        || command === "hook-session-end";
+}
+function dispatch_hook_command(args) {
+    const change = args.change;
+    if (args.command === "hook-check-write")
+        return [hookCheckWrite(change, args.event_ref ?? ""), "hook"];
+    if (args.command === "hook-check-command")
+        return [hookCheckCommand(change, args.event_ref ?? ""), "hook"];
+    if (args.command === "hook-record-test")
+        return [hookRecordTest(change, args.event_ref ?? ""), "hook"];
+    if (args.command === "hook-record-subagent-start")
+        return [hookRecordSubagentStart(change, args.event_ref ?? ""), "hook"];
+    if (args.command === "hook-record-subagent-stop")
+        return [hookRecordSubagentStop(change, args.event_ref ?? ""), "hook"];
+    if (args.command === "hook-health")
+        return [hookHealth(change), "hook"];
+    if (args.command === "hook-session-begin")
+        return [hookSessionBegin(change, args.workflow ?? "", args.entrypoint_token ?? ""), "hook"];
+    if (args.command === "hook-session-status")
+        return [hookSessionStatus(change), "hook"];
+    if (args.command === "hook-session-end")
+        return [hookSessionEnd(change, args.end_reason ?? "", args.lifecycle_token ?? ""), "hook"];
+    throw new GuardError(`unknown hook command: ${args.command}`);
+}
 export function cmd_status(change) {
     const [status, repoRoot, changeRoot] = runtime.load_context(change);
     const amap = artifact_status_map(status);
@@ -117,6 +151,8 @@ export function cmd_init_summary(change, changeRoot, decision) {
 function dispatch_once(args) {
     const change = args.change;
     const cmd = args.command;
+    if (is_hook_command(cmd))
+        return dispatch_hook_command(args);
     if (cmd === "check-archived")
         return [check_archived(change, repo_root_from_cwd()), "archive"];
     const [status, repoRoot, changeRoot, evidences] = runtime.load_context(change);

package/dist/src/evidence.js

@@ -5,6 +5,7 @@ import { normalize_gate } from "./openspec.js";
 import { superspec_dir } from "./paths.js";
 import { findings_schema_reasons, review_digest_schema_reasons, standing_authorization_schema_reasons, user_decision_schema_reasons, } from "./disclosure.js";
 import { pinned_artifact_ref_reasons as shared_pinned_artifact_ref_reasons, worker_test_run_reasons, } from "./apply_worker_chain.js";
+import { strictRoleRunlogReasons, strictRuntimeEvidenceReasons } from "./hooks/validation.js";
 function file_ref_reasons(baseRoot, ev, field, code) {
     const problems = [];
     const raw = ev[field];
@@ -509,6 +510,7 @@ export function validate_evidence_schema(ev, change, changeRoot, repoRoot) {
         problems.push(...human_confirmation_reasons(ev));
     if (ev.kind === "test_run")
         problems.push(...test_run_reasons(ev, changeRoot));
+    problems.push(...strictRuntimeEvidenceReasons(ev));
     if (ev.kind === "apply_worker_chain")
         problems.push(...apply_worker_chain_reasons(ev, changeRoot));
     // DISC Phase 1: disclosure evidence kinds and reviewer findings[] are schema-checked fail-closed.
@@ -556,6 +558,7 @@ export function validate_evidence_schema(ev, change, changeRoot, repoRoot) {
         const targetRoot = ev.kind === "source_guidance" ? repoRoot : changeRoot;
         problems.push(...role_target_ref_reasons(ev, targetRoot));
         problems.push(...output_ref_target_overlap_reasons(ev, changeRoot, targetRoot));
+        problems.push(...strictRoleRunlogReasons(changeRoot, ev));
     }
     if (ev.kind === "source_guidance") {
         if (!REVIEW_GUIDANCE_ROLES.includes(String(ev.agent_role))) {