opensquid 0.5.395

package/dist/runtime/hooks/active_task_mirror.js

@@ -0,0 +1,226 @@
+/**
+ * AP.1 — mirror the harness task store into opensquid's active-task signal.
+ *
+ * The whole automation gate-set keys off `active-task.json` (design rules
+ * #1/#8/#16). This module is the ONLY place that knows the Claude-Code-specific
+ * task-store path — every gate reads opensquid's own `active-task.json`,
+ * harness-agnostic (substrate-vs-consumer discipline).
+ *
+ * WHY mirror the store rather than reconstruct from the tool-call args: a
+ * `TaskCreate` PreToolUse payload carries `subject` but NO id (the harness
+ * assigns the id in the RESPONSE, which a PreToolUse hook never sees), and a
+ * `TaskUpdate(in_progress)` payload carries `taskId` but NO subject — and the
+ * two events share no key, so they cannot be correlated. The canonical store
+ * `~/.claude/tasks/<session-id>/<task-id>.json` carries `{id, subject, status,
+ * metadata}` together; we read it and pick the `in_progress` task.
+ *
+ * Timing (H4a): `PreToolUse` fires BEFORE the tool executes, so on a status
+ * TRANSITION the on-disk file still holds the OLD status. We therefore honor the
+ * pending `args` for both directions — the task being moved to `in_progress`
+ * becomes active even though disk still says `pending`; the task being
+ * `completed`/`deleted` is excluded even though disk still says `in_progress`.
+ *
+ * Best-effort + fail-open: never throws into the hook (the caller also guards).
+ *
+ * Imports from: node:fs/promises, node:os, node:path, ../session_state.js.
+ * Imported by: src/runtime/hooks/pre-tool-use.ts.
+ */
+import { readFile, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { clearActiveTask, readActiveTask, writeActiveTask, } from '../session_state.js';
+import { isClosedStatus, readActiveTaskFromTranscript, transcriptTaskStatus, } from './transcript_tasks.js';
+/**
+ * Harness task-store directory for a session. `base` is injectable (the mirror
+ * passes it in tests); when omitted, an `OPENSQUID_HARNESS_TASKS_DIR` env
+ * override wins (lets the Gate B primitive — which has no `base` seam — be
+ * tested, and lets a user relocate the store), else the codebase-convention
+ * default `join(homedir(), '.claude', 'tasks')`.
+ */
+export const harnessTasksDir = (sessionId, base) => join(base ?? process.env.OPENSQUID_HARNESS_TASKS_DIR ?? join(homedir(), '.claude', 'tasks'), sessionId);
+/**
+ * Read + parse the harness task store for a session. Returns `[]` on an absent
+ * dir (no tasks yet) and skips malformed / shape-invalid entries. Never throws.
+ */
+export async function readHarnessTasks(sessionId, base) {
+    const dir = harnessTasksDir(sessionId, base);
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return []; // dir absent → no tasks
+    }
+    const tasks = [];
+    for (const name of entries) {
+        if (name.startsWith('.') || !name.endsWith('.json'))
+            continue; // skip .lock/.highwatermark
+        try {
+            const o = JSON.parse(await readFile(join(dir, name), 'utf8'));
+            if (typeof o.id !== 'string' ||
+                typeof o.subject !== 'string' ||
+                typeof o.status !== 'string') {
+                continue;
+            }
+            const task = { id: o.id, subject: o.subject, status: o.status };
+            if (o.metadata !== null && typeof o.metadata === 'object') {
+                const m = o.metadata;
+                const meta = {};
+                if (typeof m.taskId === 'string')
+                    meta.taskId = m.taskId;
+                if (typeof m.spec === 'string')
+                    meta.spec = m.spec;
+                if (meta.taskId !== undefined || meta.spec !== undefined)
+                    task.metadata = meta;
+            }
+            tasks.push(task);
+        }
+        catch {
+            // malformed task file → skip; one bad file must not blind the whole mirror
+        }
+    }
+    return tasks;
+}
+/**
+ * Mirror the harness in-progress task into opensquid's `active-task.json`.
+ * No-op for non-task tools. Writes the signal when a task is active, clears it
+ * when none is. Best-effort: resolves without throwing on any I/O failure.
+ */
+export async function mirrorActiveTask(sessionId, tool, args, base, transcriptPath) {
+    // T-ATM ATM.1: this Claude Code version keeps the task list in the SESSION
+    // TRANSCRIPT, not at ~/.claude/tasks/<session>/. When the hook supplies
+    // `transcriptPath`, derive the active task from there (the real source) — with
+    // the in-flight TaskUpdate overlaid (H4a). Immune to the `--resume` session-id
+    // split (no derived session dir). The legacy harness-store path below stays as
+    // a fallback for older CC versions that DO write ~/.claude/tasks/.
+    if (transcriptPath !== undefined && transcriptPath.length > 0) {
+        // T-FIX-TASKSTART-GUARD-MIRROR: metadata-only TaskUpdates (no status) are
+        // overlaid too — they are real mutations the mirror must see in-flight.
+        const pendingStatus = typeof args.status === 'string' ? args.status : undefined;
+        const pendingMd = args.metadata !== null && typeof args.metadata === 'object'
+            ? args.metadata
+            : undefined;
+        const pending = tool === 'TaskUpdate' &&
+            typeof args.taskId === 'string' &&
+            (pendingStatus !== undefined || pendingMd !== undefined)
+            ? {
+                taskId: args.taskId,
+                ...(pendingStatus !== undefined ? { status: pendingStatus } : {}),
+                ...(pendingMd !== undefined ? { metadata: pendingMd } : {}),
+            }
+            : undefined;
+        const active = await readActiveTaskFromTranscript(transcriptPath, pending);
+        if (active !== null) {
+            await writeActiveTask(sessionId, active);
+            return;
+        }
+        // T-ATM ATM.3 (2026-06-01): defensive-keep — parity with the store path's
+        // ACTRACE.1 guard below. The transcript LAGS the current assistant turn:
+        // when TaskUpdate(in_progress) and log_phase are issued in ONE turn,
+        // log_phase's own PreToolUse mirror re-derives from a transcript that does
+        // NOT yet contain that TaskUpdate → active===null → the pre-fix CLEARED the
+        // active-task.json that TaskUpdate's mirror just wrote → log_phase then threw
+        // "no active task" (the workaround-needing race). Only CLEAR when THIS tool
+        // explicitly completes/deletes the prior active task (the authoritative
+        // "done" signal. FC.6: decide keep-vs-clear by the prior's ACTUAL transcript
+        // status (with the in-flight TaskUpdate overlaid via `pending`). A genuinely
+        // lagging task is absent (null) or still open → KEEP; an explicit
+        // completed/deleted clears, so a finished task's signal cannot linger past its
+        // completing tick (the pre-FC.6 `prior.id !== completingId` kept it forever on
+        // every later non-TaskUpdate tool). Fail-open to clear on read error.
+        try {
+            const prior = await readActiveTask(sessionId);
+            if (prior !== null) {
+                const priorStatus = await transcriptTaskStatus(transcriptPath, prior.id, pending);
+                if (!isClosedStatus(priorStatus))
+                    return; // lag (null) or still open → keep
+            }
+        }
+        catch {
+            /* fail-open → clear */
+        }
+        await clearActiveTask(sessionId);
+        return;
+    }
+    // T-ATSC L1: no tool-name gate. Mirror re-derives on every PreToolUse so
+    // active-task.json stays in sync with the harness store even when the
+    // current tool is Write/Edit/Bash/Read/anything else. The H4a +
+    // AP.7 overlays below pass through for non-TaskUpdate tools (their
+    // args.taskId / args.status / args.metadata are undefined; activatingId
+    // and completingId both null; the store-derived view is canonical).
+    const tasks = await readHarnessTasks(sessionId, base);
+    // H4a — the on-disk status lags a transition (PreToolUse is pre-execution).
+    const taskId = typeof args.taskId === 'string' ? args.taskId : null;
+    const activatingId = tool === 'TaskUpdate' && args.status === 'in_progress' ? taskId : null;
+    const completingId = tool === 'TaskUpdate' && (args.status === 'completed' || args.status === 'deleted')
+        ? taskId
+        : null;
+    // 1. A task being activated this tick wins (disk may still say 'pending').
+    let active = activatingId
+        ? (tasks.find((t) => t.id === activatingId) ?? null)
+        : null;
+    // 2. Otherwise the on-disk in_progress task, excluding one being closed this tick.
+    active ??= tasks.find((t) => t.status === 'in_progress' && t.id !== completingId) ?? null;
+    if (!active) {
+        // T-ACTRACE.1 (2026-05-31): defensive clear. Before clearing,
+        // verify the previously-active task is GENUINELY absent from the
+        // harness store — not just transiently non-in_progress (mid-write
+        // snapshot). If the prior task is still present at ANY status, keep
+        // active-task.json intact + return; subsequent PreToolUse re-mirrors
+        // will rewrite once the harness mid-write completes. Race scenario:
+        // log_phase pre_research → ok; intervening Edit triggers PreToolUse
+        // → mirror reads store mid-TaskUpdate write → no in_progress
+        // visible → pre-fix would clear → next log_phase throws "no active
+        // task". This narrows the clear path to require positive evidence
+        // (prior id genuinely absent from tasks[]).
+        //
+        // L3 risk callout: this MUST NOT prevent legitimate clears in
+        // genuine no-task states. If readActiveTask returns null (no prior
+        // active-task.json) OR tasks.some(t.id === prior.id) is FALSE
+        // (prior genuinely removed), clear proceeds as before. Test cases
+        // (d) and (e) verify this.
+        try {
+            const prior = await readActiveTask(sessionId);
+            // Don't defensive-keep if the prior IS the task being completed
+            // this tick — H4a completion case: TaskUpdate(completed) for the
+            // active task while disk still says in_progress. The completingId
+            // signal is the authoritative "you ARE done" message; the prior's
+            // continued presence on disk at in_progress reflects the
+            // pre-execution state. Test "H4a completion: excludes a task
+            // being completed even though disk still says in_progress" asserts
+            // this — we MUST clear.
+            if (prior !== null &&
+                prior.id !== completingId &&
+                tasks.some((t) => t.id === prior.id && !isClosedStatus(t.status))) {
+                return; // transient mid-write of an OPEN task — keep prior active-task.json
+            }
+        }
+        catch {
+            // L4 fail-open: readActiveTask error → fall through to clear.
+        }
+        await clearActiveTask(sessionId);
+        return;
+    }
+    // H4a (metadata) — a TaskUpdate that stamps metadata reaches the store only
+    // AFTER this PreToolUse fires, so the store read above is stale for it. Prefer
+    // the pending args.metadata for the active task (same rationale as the
+    // args.status merge above). Only TaskUpdate targeting the active id: TaskCreate
+    // creates a pending task (not active) and carries no id at PreToolUse.
+    const pendingMeta = tool === 'TaskUpdate' &&
+        args.taskId === active.id &&
+        args.metadata !== null &&
+        typeof args.metadata === 'object'
+        ? args.metadata
+        : undefined;
+    const provTaskId = typeof pendingMeta?.taskId === 'string' ? pendingMeta.taskId : active.metadata?.taskId;
+    const provSpec = typeof pendingMeta?.spec === 'string' ? pendingMeta.spec : active.metadata?.spec;
+    const signal = {
+        id: active.id,
+        subject: active.subject,
+        started_at: new Date().toISOString(),
+        ...(provTaskId !== undefined ? { taskId: provTaskId } : {}),
+        ...(provSpec !== undefined ? { spec: provSpec } : {}),
+    };
+    await writeActiveTask(sessionId, signal);
+}
+//# sourceMappingURL=active_task_mirror.js.map

package/dist/runtime/hooks/active_task_mirror.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active_task_mirror.js","sourceRoot":"","sources":["../../../src/runtime/hooks/active_task_mirror.ts"],"names":[],"mappings":"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"}

package/dist/runtime/hooks/apply_patch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * T-CODEX-HOST-SHELL CHS.2 — codex `apply_patch` envelope parsing.
+ *
+ * Codex's file-edit tool reports `tool_name: "apply_patch"` with the patch
+ * text in `tool_input.command`; no pack rule matches that name, so without
+ * normalization a codex file write sails past every coding-flow gate (the
+ * post-trust CHS.1 live spike proved it). The hook bin normalizes each
+ * touched path into ONE synthesized single-path `Write` event — every PATH
+ * predicate dialect (contains/endsWith/startsWith/==) sees a normal
+ * file_path. Content: `Add File` sections carry the FULL final content as
+ * `+` lines (true artifact for the content audits); `Update`/`Delete`
+ * sections become a first-line-LABELED hunk diff — explicit, never
+ * silently-stale (the effective_content failure mode the design review
+ * caught). Zero markers parsed → [] → the caller passes the event through
+ * untouched (fail-open for unknown envelope variants).
+ *
+ * Imports from: (none — pure).
+ * Imported by: src/runtime/hooks/pre-tool-use.ts.
+ */
+export interface PatchedFile {
+    path: string;
+    kind: 'add' | 'update' | 'delete';
+    /** add: true final content; update/delete: labeled hunk diff. */
+    content: string;
+}
+export declare function parseApplyPatch(command: string): PatchedFile[];
+//# sourceMappingURL=apply_patch.d.ts.map

package/dist/runtime/hooks/apply_patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_patch.d.ts","sourceRoot":"","sources":["../../../src/runtime/hooks/apply_patch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAClC,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CA+B9D"}

package/dist/runtime/hooks/apply_patch.js

@@ -0,0 +1,54 @@
+/**
+ * T-CODEX-HOST-SHELL CHS.2 — codex `apply_patch` envelope parsing.
+ *
+ * Codex's file-edit tool reports `tool_name: "apply_patch"` with the patch
+ * text in `tool_input.command`; no pack rule matches that name, so without
+ * normalization a codex file write sails past every coding-flow gate (the
+ * post-trust CHS.1 live spike proved it). The hook bin normalizes each
+ * touched path into ONE synthesized single-path `Write` event — every PATH
+ * predicate dialect (contains/endsWith/startsWith/==) sees a normal
+ * file_path. Content: `Add File` sections carry the FULL final content as
+ * `+` lines (true artifact for the content audits); `Update`/`Delete`
+ * sections become a first-line-LABELED hunk diff — explicit, never
+ * silently-stale (the effective_content failure mode the design review
+ * caught). Zero markers parsed → [] → the caller passes the event through
+ * untouched (fail-open for unknown envelope variants).
+ *
+ * Imports from: (none — pure).
+ * Imported by: src/runtime/hooks/pre-tool-use.ts.
+ */
+const MARKER = /^\*\*\* (Add|Update|Delete) File: (.+)$/;
+export function parseApplyPatch(command) {
+    const lines = command.split('\n');
+    const out = [];
+    let cur = null;
+    const flush = () => {
+        if (cur === null)
+            return;
+        const content = cur.kind === 'add'
+            ? cur.lines
+                .filter((l) => l.startsWith('+'))
+                .map((l) => l.slice(1))
+                .join('\n')
+            : `<apply_patch ${cur.kind} — content below is the hunk diff, not the final artifact>\n${cur.lines.join('\n')}`;
+        out.push({ path: cur.path, kind: cur.kind, content });
+        cur = null;
+    };
+    for (const line of lines) {
+        const m = MARKER.exec(line);
+        if (m !== null) {
+            flush();
+            cur = {
+                path: m[2] ?? '',
+                kind: (m[1] ?? 'update').toLowerCase(),
+                lines: [],
+            };
+        }
+        else if (cur !== null && !line.startsWith('*** End Patch')) {
+            cur.lines.push(line);
+        }
+    }
+    flush();
+    return out.filter((f) => f.path.length > 0);
+}
+//# sourceMappingURL=apply_patch.js.map

package/dist/runtime/hooks/apply_patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_patch.js","sourceRoot":"","sources":["../../../src/runtime/hooks/apply_patch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AASH,MAAM,MAAM,GAAG,yCAAyC,CAAC;AAEzD,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,GAAG,GAAkB,EAAE,CAAC;IAC9B,IAAI,GAAG,GAAwE,IAAI,CAAC;IACpF,MAAM,KAAK,GAAG,GAAS,EAAE;QACvB,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO;QACzB,MAAM,OAAO,GACX,GAAG,CAAC,IAAI,KAAK,KAAK;YAChB,CAAC,CAAC,GAAG,CAAC,KAAK;iBACN,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;iBAChC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;iBACtB,IAAI,CAAC,IAAI,CAAC;YACf,CAAC,CAAC,gBAAgB,GAAG,CAAC,IAAI,+DAA+D,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACpH,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QACtD,GAAG,GAAG,IAAI,CAAC;IACb,CAAC,CAAC;IACF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YACf,KAAK,EAAE,CAAC;YACR,GAAG,GAAG;gBACJ,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;gBAChB,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,WAAW,EAAyB;gBAC7D,KAAK,EAAE,EAAE;aACV,CAAC;QACJ,CAAC;aAAM,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,CAAC;YAC7D,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,KAAK,EAAE,CAAC;IACR,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC9C,CAAC"}

package/dist/runtime/hooks/dispatch.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Hook dispatcher: turns a runtime `Event` + loaded packs into a Claude Code
+ * hook decision (`exit code 0 = allow | 2 = block` + optional stderr message).
+ *
+ * Sits between the per-host hook binaries (`pre-tool-use.ts`, `stop.ts`,
+ * `user-prompt-submit.ts`, `session-end.ts`) and the rule evaluator. Each hook
+ * binary is a thin shell that:
+ *   1. Reads stdin → parses into an Event of the right `kind`.
+ *   2. Loads active packs + builds the function registry (bootstrap.ts).
+ *   3. Calls `dispatchEvent` to produce `{ exitCode, stderr }`.
+ *   4. Writes stderr, exits with the code.
+ *
+ * The dispatcher walks `packs × skills × rules`, runs each rule's process via
+ * `evaluateProcess`, and short-circuits on the FIRST verdict. The first-match
+ * semantics matter: a high-priority pack's block decision must not be
+ * overridden by a later pack's warn. Pack ordering is the loader's
+ * responsibility (Task 1.19); the dispatcher trusts the order it's given.
+ *
+ * AUTO.1 event-kind filter: before walking a skill's rules, the dispatcher
+ * checks `event.kind ∈ skill.triggers.map(t => t.kind)`. Skills that don't
+ * subscribe to the incoming event kind are skipped entirely. This keeps
+ * tool-call hooks from re-running schedule/webhook/file-changed skills and
+ * vice versa. A skill that wants to fire on multiple kinds lists them all
+ * (e.g. `triggers: [{kind: tool_call}, {kind: schedule, cron: ...}]`). The
+ * default trigger list (when the YAML block is omitted) is a single
+ * `tool_call` entry — preserves Phase 1–7 dispatcher behavior verbatim.
+ *
+ * Drift-response policy resolution:
+ *   1. Pack-shipped `drift_response.yaml` → `Pack.driftResponse` (loaded by
+ *      `loadPack`). For each fired rule, the dispatcher consults
+ *      `pack.driftResponse?.per_rule[rule.id] ?? pack.driftResponse?.default`.
+ *   2. Pack without `drift_response.yaml` → falls back to `defaultPolicyForLevel`,
+ *      which DERIVES the policy from the fired verdict's `level` (block →
+ *      block_tool; warn/surface/pass/directive → warn). This honors the
+ *      author's `level:` by default — a `level: warn` rule warns instead of
+ *      hard-blocking — so a policy file is an OVERRIDE, not a prerequisite for
+ *      level-correct behavior. (Replaces the old blanket `block_tool` default,
+ *      which discarded the level.)
+ *   3. `corrective_skills` map (`auto_correct` policy support) is threaded
+ *      into `applyDriftResponse` via the `DriftDispatchCtx` argument so
+ *      `auto_correct` policies can look up their corrective skill name.
+ *
+ * Pack-agnostic discipline: the dispatcher does NOT special-case
+ * sangmin-personal-rules or any other named pack. It reads whatever each
+ * pack's `driftResponse` field contains; missing/empty/absent all flow
+ * through the same `??` chain.
+ *
+ * Exit-code mapping (Claude Code hook protocol):
+ *   block_tool   → { exitCode: 2, stderr: message }
+ *   warn         → { exitCode: 0, stderr: message }   (allow, but surface)
+ *   halt         → { exitCode: 0, stderr: '' }        (Task 1.14 wires real halt)
+ *   notify_pause → { exitCode: 0, stderr: '' }        (Task 1.18 wires channels)
+ *
+ * Halt and notify_pause exit 0 deliberately for Phase 1: the runtime can't
+ * actually halt the parent agent's task loop from a hook, and channel
+ * notifications need infrastructure that doesn't ship until later phases.
+ * Mapping them to exit 0 means a misconfigured pack-declared policy won't
+ * silently block tools during Phase 1; the real behavior lands when its
+ * machinery does.
+ *
+ * Imports from: runtime/types.js, runtime/evaluator.js, runtime/drift_response.js,
+ * functions/registry.js.
+ * Imported by: runtime/hooks/*.ts (per-hook binaries).
+ */
+import type { FunctionRegistry } from '../../functions/registry.js';
+import { type TickState } from '../unload_conditions.js';
+import type { ActivationScope } from '../../packs/schemas/manifest.js';
+import type { Directive, Event, Pack, Skill } from '../types.js';
+export interface DispatchResult {
+    exitCode: 0 | 2;
+    stderr: string;
+    /**
+     * G.4 — aggregated `inject_context` payloads from every skill that fired
+     * during this dispatch. Empty array on the common (no-injection) path.
+     *
+     * Only the `UserPromptSubmit` hook bin actually emits these as host
+     * context (Claude Code's `hookSpecificOutput.additionalContext` JSON
+     * envelope). Other hook bins ignore the array (the dispatcher writes a
+     * stderr warning when an `inject_context` fires on a non-`prompt_submit`
+     * event so misconfiguration is visible).
+     *
+     * Block-verdict + inject_context COEXIST: the block wins on `exitCode`,
+     * but the injections are still aggregated and returned so the user sees
+     * the recall context alongside the block message. Per Phase-2 lock #7.
+     */
+    contextInjections: string[];
+    /**
+     * T-ASC ASC.3 — aggregated `directive`-level verdicts from every rule
+     * that fired. Peer to `contextInjections`; same dispatcher-side flow
+     * (aggregate-everywhere, surface-via-prompt_submit). The UserPromptSubmit
+     * hook bin serializes the array as a fenced JSON block under a
+     * `⛔ DIRECTIVE` marker inside the same `additionalContext` envelope key
+     * (no new envelope keys — Claude Code 2.x doesn't reliably honor unknown
+     * ones).
+     *
+     * Block-verdict + directive COEXIST identically to inject_context: a
+     * block emitted by a LATER rule still raises exitCode 2, but directives
+     * emitted by EARLIER rules still surface on stdout so the agent sees
+     * both the next-action handoff and the block message.
+     */
+    directives: Directive[];
+}
+/**
+ * The per-skill unload gate decision (pure, testable). A DYNAMIC skill is
+ * skipped this event ⟺ it has a tick AND `shouldUnload(unloads_when, tick)`
+ * fires. FAIL-SAFE = default-LOADED: a missing tick (`undefined`) NEVER
+ * skips — silently skipping a gate skill because its tick read failed would
+ * be a drift hole. Pinned skills never reach this function.
+ */
+/**
+ * IDF.4 — activation_scope dispatch routing.
+ *
+ * Per-pack `activation_scope:` (v0.6 §4.5 restored by IDF.1 schema) gates
+ * whether the dispatcher should walk a pack's skills at all in the current
+ * context. Distinct axis from existing `scope:` (which is layering
+ * precedence — universal→domain→specialty→workflow→project).
+ *
+ * 5-case semantics (per T-IDENTITY-FOUNDATION L7):
+ *   - 'project'  → applies when current cwd matches project context
+ *   - 'user'     → always applies (per-user globally)
+ *   - 'hybrid'   → both project AND user signals must apply
+ *   - 'team'     → ships INERT — never fires until team-mode lands.
+ *                  Packs declaring this scope are silently dormant; users
+ *                  shipping team packs today should know this.
+ *   - 'global'   → effectively == 'user' today; distinguishing requires
+ *                  multi-user infrastructure (post-v1).
+ */
+export interface DispatchScopeCtx {
+    /** True when current cwd matches the pack's project context (today: always true when discovery loaded the pack at all). */
+    inProject: boolean;
+    /** Always true today; placeholder for future team/multi-user infrastructure. */
+    isUserSession: boolean;
+}
+/**
+ * LL.3 — inbound_channel trigger filter. Honors optional `channel:` literal
+ * (matched against the scheme prefix of `event.channelUri`) and optional
+ * `sender_pattern` regex (matched against `event.sender`). Empty/absent
+ * fields are accept-all per back-compat. Malformed regex → no match.
+ */
+interface InboundChannelTrigger {
+    kind: 'inbound_channel';
+    channel?: string;
+    sender_pattern?: string;
+}
+export declare function inboundChannelTriggerMatches(trigger: InboundChannelTrigger, event: Extract<Event, {
+    kind: 'inbound_channel';
+}>): boolean;
+export declare function activationScopeApplies(scope: ActivationScope, ctx: DispatchScopeCtx): boolean;
+export declare function shouldSkillUnload(skill: Skill, tick: TickState | undefined): boolean;
+export declare function dispatchEvent(event: Event, packs: Pack[], registry: FunctionRegistry, sessionId: string, scopeCtx?: DispatchScopeCtx): Promise<DispatchResult>;
+export {};
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/runtime/hooks/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/runtime/hooks/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,OAAO,KAAK,EAAW,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAO7E,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACxF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAe,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAI9E,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;OAaG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B;;;;;;;;;;;;;OAaG;IACH,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB;AAwDD;;;;;;GAMG;AACH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2HAA2H;IAC3H,SAAS,EAAE,OAAO,CAAC;IACnB,gFAAgF;IAChF,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;;;;GAKG;AACH,UAAU,qBAAqB;IAC7B,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,qBAAqB,EAC9B,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC,GACjD,OAAO,CAgBT;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAa7F;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAKpF;AA+BD,wBAAsB,aAAa,CACjC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,gBAA2D,GACpE,OAAO,CAAC,cAAc,CAAC,CAyQzB"}