spexcode 0.6.7 → 0.7.0-next.0

package/node_modules/@spexcode/spec-cli/dist/execution-trace.js

@@ -1,475 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const cache = new Map();
-const sessionJsonlPaths = new Map();
-const localStoreCache = new Map();
-const emptyTrace = (turn, revision = '0') => ({
-    revision: `${turn?.token ?? '0'}:${revision}`,
-    turnId: turn?.token ?? null,
-    workingNote: null,
-    steps: [],
-});
-const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
-const items = (value) => Array.isArray(value) ? value : [];
-const text = (value) => typeof value === 'string' && value.trim() ? value.trim() : null;
-const field = (value, ...names) => {
-    for (const name of names) {
-        const found = text(value[name]);
-        if (found)
-            return found;
-    }
-    return null;
-};
-const children = (dir) => { try {
-    return readdirSync(dir).sort().reverse();
-}
-catch {
-    return [];
-} };
-const sensitive = /(token|secret|password|authorization|bearer|cookie|credential|api[_-]?key|private[ _-]?key)/i;
-const detailFields = [
-    ['cmd', 'cmd'], ['command', 'command'], ['path', 'path'], ['file_path', 'path'],
-    ['query', 'query'], ['pattern', 'pattern'], ['url', 'url'], ['workdir', 'in'],
-];
-function toolKind(name) {
-    const normalized = name.toLowerCase();
-    if (/(search|browse|web)/.test(normalized))
-        return 'search';
-    if (/(read|list|find|grep|glob|stat)/.test(normalized))
-        return 'read';
-    if (/(write|edit|patch|create|delete|move|rename)/.test(normalized))
-        return 'write';
-    if (/(exec|shell|command|terminal|bash|npm|git)/.test(normalized))
-        return 'command';
-    return 'tool';
-}
-function toolLabel(name, kind) {
-    const labels = {
-        command: 'Run command', read: 'Read files', write: 'Update files', search: 'Search', tool: 'Use tool',
-    };
-    return name.trim() || labels[kind];
-}
-function recordInput(value) {
-    if (value && typeof value === 'object' && !Array.isArray(value))
-        return value;
-    if (typeof value !== 'string')
-        return null;
-    try {
-        const parsed = JSON.parse(value);
-        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-function sensitiveInput(value) {
-    if (typeof value === 'string')
-        return sensitive.test(value);
-    if (Array.isArray(value))
-        return value.some(sensitiveInput);
-    if (value && typeof value === 'object')
-        return Object.entries(value)
-            .some(([key, entry]) => sensitive.test(key) || sensitiveInput(entry));
-    return false;
-}
-function compactValue(key, value) {
-    const compact = String(value).trim().replace(/\s+/g, ' ');
-    if (key === 'path' || key === 'file_path' || key === 'workdir') {
-        const parts = compact.replace(/\\/g, '/').split('/').filter(Boolean);
-        return parts.slice(-2).join('/') || compact;
-    }
-    return compact.length > 96 ? `${compact.slice(0, 95)}...` : compact;
-}
-function detailFromInput(value) {
-    const input = recordInput(value);
-    if (!input || sensitiveInput(input))
-        return undefined;
-    const details = [];
-    for (const [key, title] of detailFields) {
-        const value = input[key];
-        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean')
-            continue;
-        details.push(`${title}: ${compactValue(key, value)}`);
-        if (details.length === 2)
-            break;
-    }
-    const lineStart = input.line_start;
-    const lineEnd = input.line_end;
-    if (details.length < 2 && (typeof lineStart === 'number' || typeof lineEnd === 'number')) {
-        details.push(`lines: ${typeof lineStart === 'number' ? lineStart : 1}-${typeof lineEnd === 'number' ? lineEnd : lineStart}`);
-    }
-    return details.length ? details.join(' · ') : undefined;
-}
-function displayableNote(value) {
-    const note = text(value)?.replace(/\s+/g, ' ');
-    return note ? (note.length > 240 ? `${note.slice(0, 239)}...` : note) : null;
-}
-function stepFromInput(id, name, input, state) {
-    const kind = toolKind(name);
-    const detail = detailFromInput(input);
-    return { id, kind, label: toolLabel(name, kind), ...(detail ? { detail } : {}), state };
-}
-function timestamp(value) {
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value !== 'string' || !value.trim())
-        return null;
-    const number = Number(value);
-    if (Number.isFinite(number))
-        return number;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function identities(...values) {
-    const result = new Set();
-    for (const value of values)
-        for (const key of ['id', 'uuid', 'message_id', 'messageId', 'client_id', 'clientId', 'client_user_message_id', 'clientUserMessageId', 'promptId']) {
-            const id = field(value || {}, key);
-            if (id)
-                result.add(id);
-        }
-    return [...result];
-}
-function at(value) {
-    for (const key of ['timestamp', 'created_at', 'createdAt', 'created', 'time']) {
-        const found = timestamp(value[key]);
-        if (found !== null)
-            return found;
-    }
-    return null;
-}
-function isPrompt(content) {
-    if (typeof content === 'string')
-        return !!content.trim();
-    const blocks = items(content);
-    return blocks.some((block) => object(block)?.type !== 'tool_result');
-}
-function project(events, sourceRevision, turn) {
-    let start = -1;
-    if (!turn) {
-        for (const [index, event] of events.entries())
-            if (event.type === 'boundary')
-                start = index;
-    }
-    else {
-        const acceptedAt = timestamp(turn.acceptedAt);
-        const exact = events.flatMap((event, index) => event.type === 'boundary' && event.ids.includes(turn.token) ? [index] : []);
-        start = exact.length === 1 ? exact[0] : -1;
-        if (start < 0 && exact.length === 0 && acceptedAt !== null) {
-            const candidates = events.flatMap((event, index) => event.type === 'boundary' && event.at !== null && event.at >= acceptedAt
-                ? [{ index, at: event.at }] : []);
-            const earliest = candidates.reduce((value, candidate) => value === null || candidate.at < value ? candidate.at : value, null);
-            const matches = earliest === null ? [] : candidates.filter((candidate) => candidate.at === earliest);
-            if (matches.length === 1)
-                start = matches[0].index;
-        }
-    }
-    if (turn && start < 0)
-        return emptyTrace(turn, sourceRevision);
-    let note = null;
-    let steps = [];
-    for (let index = start + 1; index < events.length; index++) {
-        const event = events[index];
-        if (event.type === 'boundary')
-            return emptyTrace(turn, sourceRevision);
-        if (event.type === 'note') {
-            note = event.text;
-            steps = [];
-            continue;
-        }
-        if (event.type === 'call') {
-            if (note)
-                steps.push(event.step);
-            continue;
-        }
-        const step = steps.find((value) => value.id === event.id);
-        if (step)
-            steps[steps.indexOf(step)] = { ...step, state: 'done' };
-    }
-    return note
-        ? { revision: `${turn?.token ?? '0'}:${sourceRevision}`, turnId: turn?.token ?? null, workingNote: note, steps }
-        : emptyTrace(turn, sourceRevision);
-}
-function applyRolloutEvent(value, ordinal) {
-    const event = object(value);
-    const payload = object(event?.payload);
-    if (!event || !payload)
-        return [];
-    const result = [];
-    const type = field(payload, 'type');
-    if ((event.type === 'event_msg' && type === 'user_message')
-        || (event.type === 'response_item' && (type === 'message' || type === 'input_message') && payload.role === 'user')) {
-        result.push({ type: 'boundary', ids: identities(payload, event), at: at(payload) ?? at(event) });
-    }
-    if (event.type === 'event_msg' && type === 'agent_message' && payload.phase === 'commentary') {
-        const note = displayableNote(payload.message ?? payload.text);
-        if (note)
-            result.push({ type: 'note', text: note });
-    }
-    if (event.type === 'response_item' && (type === 'custom_tool_call' || type === 'function_call')) {
-        const name = field(payload, 'name', 'tool_name') || 'tool';
-        const id = field(payload, 'call_id', 'id') || `tool-${ordinal}`;
-        result.push({ type: 'call', step: stepFromInput(id, name, payload.input ?? payload.arguments ?? payload.args, 'running') });
-    }
-    if (event.type === 'response_item' && (type === 'custom_tool_call_output' || type === 'function_call_output')) {
-        const id = field(payload, 'call_id', 'id');
-        if (id)
-            result.push({ type: 'done', id });
-    }
-    if (event.type === 'event_msg' && type === 'web_search_end') {
-        result.push({ type: 'call', step: stepFromInput(field(payload, 'id', 'call_id') || `search-${ordinal}`, 'Search', payload, 'done') });
-    }
-    return result;
-}
-function applyProjectJsonlEvent(value, ordinal) {
-    const entry = object(value);
-    const message = object(entry?.message);
-    if (!entry || !message)
-        return [];
-    const result = [];
-    if (entry.type === 'user' && message.role === 'user' && isPrompt(message.content))
-        result.push({ type: 'boundary', ids: identities(entry, message), at: at(entry) ?? at(message) });
-    if (entry.type === 'assistant' && message.role === 'assistant')
-        for (const blockValue of items(message.content)) {
-            const block = object(blockValue);
-            if (block?.type === 'text') {
-                const note = displayableNote(block.text);
-                if (note)
-                    result.push({ type: 'note', text: note });
-            }
-            if (block?.type === 'tool_use') {
-                const id = field(block, 'id') || `tool-${ordinal}`;
-                result.push({ type: 'call', step: stepFromInput(id, field(block, 'name') || 'tool', block.input, 'running') });
-            }
-        }
-    if (entry.type === 'user' && message.role === 'user')
-        for (const blockValue of items(message.content)) {
-            const block = object(blockValue);
-            if (block?.type === 'tool_result') {
-                const id = field(block, 'tool_use_id');
-                if (id)
-                    result.push({ type: 'done', id });
-            }
-        }
-    return result;
-}
-function applySessionJsonlEvent(value, ordinal) {
-    const entry = object(value);
-    const message = object(entry?.message);
-    if (!entry || entry.type !== 'message' || !message)
-        return [];
-    const result = [];
-    if (message.role === 'user' && isPrompt(message.content))
-        result.push({ type: 'boundary', ids: identities(entry, message), at: at(entry) ?? at(message) });
-    if (message.role === 'assistant')
-        for (const blockValue of items(message.content)) {
-            const block = object(blockValue);
-            if (block?.type === 'text') {
-                const note = displayableNote(block.text);
-                if (note)
-                    result.push({ type: 'note', text: note });
-            }
-            if (block?.type === 'toolCall') {
-                const id = field(block, 'id') || `tool-${ordinal}`;
-                result.push({ type: 'call', step: stepFromInput(id, field(block, 'name') || 'tool', block.arguments, 'running') });
-            }
-        }
-    if (message.role === 'toolResult') {
-        const id = field(message, 'toolCallId');
-        if (id)
-            result.push({ type: 'done', id });
-    }
-    return result;
-}
-function completeLines(buffer) {
-    const lines = [];
-    let start = 0;
-    for (let index = 0; index < buffer.length; index++) {
-        if (buffer[index] !== 10)
-            continue;
-        if (index > start)
-            lines.push(buffer.subarray(start, index));
-        start = index + 1;
-    }
-    return { lines, remainder: buffer.subarray(start) };
-}
-function readFrom(path, start) {
-    let fd = null;
-    try {
-        const size = statSync(path).size;
-        if (size <= start)
-            return Buffer.alloc(0);
-        const chunk = Buffer.allocUnsafe(size - start);
-        fd = openSync(path, 'r');
-        readSync(fd, chunk, 0, chunk.length, start);
-        return chunk;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (fd !== null)
-            closeSync(fd);
-    }
-}
-function readIncremental(path, apply, turn) {
-    if (!path)
-        return emptyTrace(turn);
-    let size;
-    try {
-        size = statSync(path).size;
-    }
-    catch {
-        return emptyTrace(turn);
-    }
-    const prior = cache.get(path);
-    const trace = prior && prior.size <= size
-        ? { ...prior, events: [...prior.events] }
-        : { size: 0, remainder: Buffer.alloc(0), events: [] };
-    const appended = readFrom(path, trace.size);
-    if (appended === null)
-        return emptyTrace(turn);
-    const { lines, remainder } = completeLines(Buffer.concat([trace.remainder, appended]));
-    for (const [index, line] of lines.entries()) {
-        try {
-            trace.events.push(...apply(JSON.parse(line.toString('utf8')), trace.size + index));
-        }
-        catch { /* malformed native data is ignored */ }
-    }
-    trace.size = size;
-    trace.remainder = remainder;
-    cache.set(path, trace);
-    return project(trace.events, String(size), turn);
-}
-const codexSessionsDir = () => join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
-export function codexRolloutPath(threadId, root = codexSessionsDir()) {
-    for (const year of children(root))
-        for (const month of children(join(root, year)))
-            for (const day of children(join(root, year, month))) {
-                const dir = join(root, year, month, day);
-                const file = children(dir).find((name) => name.includes(threadId));
-                if (file)
-                    return join(dir, file);
-            }
-    return null;
-}
-export function readCodexExecutionTrace(threadId, turn, root = codexSessionsDir()) {
-    return readIncremental(codexRolloutPath(threadId, root), applyRolloutEvent, turn);
-}
-const projectTranscriptRoot = () => join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'projects');
-function projectJsonlPath(threadId, root = projectTranscriptRoot()) {
-    for (const project of children(root)) {
-        const path = join(root, project, `${threadId}.jsonl`);
-        try {
-            if (statSync(path).isFile())
-                return path;
-        }
-        catch { /* try next */ }
-    }
-    return null;
-}
-export function readProjectJsonlExecutionTrace(threadId, turn, root = projectTranscriptRoot()) {
-    return readIncremental(projectJsonlPath(threadId, root), applyProjectJsonlEvent, turn);
-}
-const sessionJsonlRoot = () => join(process.env.SPEXCODE_PI_AGENT_DIR || join(homedir(), '.pi', 'agent'), 'sessions');
-function sessionJsonlPath(threadId, root = sessionJsonlRoot()) {
-    const key = `${root}:${threadId}`;
-    const cached = sessionJsonlPaths.get(key);
-    if (cached) {
-        try {
-            if (statSync(cached).isFile())
-                return cached;
-        }
-        catch {
-            sessionJsonlPaths.delete(key);
-        }
-    }
-    for (const directory of children(root))
-        for (const file of children(join(root, directory))) {
-            if (!file.endsWith('.jsonl'))
-                continue;
-            const path = join(root, directory, file);
-            try {
-                const header = object(JSON.parse(readFileSync(path, 'utf8').split('\n', 1)[0]));
-                if (header?.type === 'session' && header.id === threadId) {
-                    sessionJsonlPaths.set(key, path);
-                    return path;
-                }
-            }
-            catch { /* unreadable entries are not a match */ }
-        }
-    return null;
-}
-export function readSessionJsonlExecutionTrace(threadId, turn, root = sessionJsonlRoot()) {
-    return readIncremental(sessionJsonlPath(threadId, root), applySessionJsonlEvent, turn);
-}
-const localStoreRoot = () => process.env.SPEXCODE_OPENCODE_DATA_DIR
-    || join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'opencode');
-function readLocalExport(threadId) {
-    return execFileSync(process.env.SPEXCODE_OPENCODE_CMD || 'opencode', ['export', threadId, '--sanitize'], {
-        encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
-    });
-}
-function localStoreRevision(root) {
-    try {
-        const database = statSync(join(root, 'opencode.db'));
-        let writeAheadLog = '0:0';
-        try {
-            const stat = statSync(join(root, 'opencode.db-wal'));
-            writeAheadLog = `${stat.size}:${Math.floor(stat.mtimeMs)}`;
-        }
-        catch { /* a checkpointed database has no separate write-ahead log */ }
-        return `${database.size}:${Math.floor(database.mtimeMs)}:${writeAheadLog}`;
-    }
-    catch {
-        return null;
-    }
-}
-function localStoreEvents(value) {
-    const events = [];
-    for (const messageValue of items(object(value)?.messages)) {
-        const message = object(messageValue);
-        const info = object(message?.info);
-        if (!message || !info)
-            continue;
-        if (info.role === 'user')
-            events.push({ type: 'boundary', ids: identities(info, message), at: at(object(info.time) || info) });
-        if (info.role !== 'assistant')
-            continue;
-        for (const partValue of items(message.parts)) {
-            const part = object(partValue);
-            if (part?.type === 'text') {
-                const note = displayableNote(part.text);
-                if (note)
-                    events.push({ type: 'note', text: note });
-            }
-            if (part?.type === 'tool') {
-                const state = object(part.state);
-                const status = field(state || {}, 'status')?.toLowerCase() || '';
-                const id = field(part, 'callID', 'id') || `tool-${events.length}`;
-                events.push({ type: 'call', step: stepFromInput(id, field(part, 'tool') || 'tool', state?.input, /completed|error|cancelled/.test(status) ? 'done' : 'running') });
-            }
-        }
-    }
-    return events;
-}
-export function readLocalStoreExecutionTrace(threadId, turn, root = localStoreRoot(), load = readLocalExport) {
-    const revision = localStoreRevision(root);
-    if (!revision)
-        return emptyTrace(turn);
-    const key = `${root}:${threadId}`;
-    let cached = localStoreCache.get(key);
-    if (!cached || cached.revision !== revision) {
-        try {
-            cached = { revision, events: localStoreEvents(JSON.parse(load(threadId))) };
-            localStoreCache.set(key, cached);
-        }
-        catch {
-            return emptyTrace(turn, revision);
-        }
-    }
-    return project(cached.events, revision, turn);
-}
-export const noExecutionTrace = (_threadId, _turn) => null;

package/node_modules/@spexcode/spec-cli/dist/session-execution.d.ts

@@ -1,10 +0,0 @@
-import type { Context } from 'hono';
-import type { ExecutionStep } from './execution-trace.js';
-export type SessionExecution = Readonly<{
-    revision: string;
-    turnId: string | null;
-    workingNote: string | null;
-    steps: readonly ExecutionStep[];
-}>;
-export declare function readSessionExecution(id: string): SessionExecution | null;
-export declare function sessionExecutionStream(c: Context): Promise<Response>;

package/node_modules/@spexcode/spec-cli/dist/session-execution.js

@@ -1,70 +0,0 @@
-import { streamSSE } from 'hono/streaming';
-import { harnessById } from './harness.js';
-import { readAliasedRawRecord } from '@spexcode/spec-core';
-import { currentHumanTurn } from './session-timeline.js';
-const absentExecution = (turn = null) => ({ revision: `turn:${turn?.token ?? '0'}`, turnId: turn?.token ?? null, workingNote: null, steps: [] });
-// This is deliberately a read projection. Native transcript bytes stay within the adapter, while the API owns
-// only enough information for the frontend's fixed renderer to paint the current execution slice.
-export function readSessionExecution(id) {
-    let record;
-    try {
-        record = readAliasedRawRecord(id);
-    }
-    catch {
-        return null;
-    }
-    if (!record?.governed)
-        return null;
-    const turn = currentHumanTurn(id);
-    const threadId = typeof record.harness_session_id === 'string' ? record.harness_session_id : '';
-    if (!threadId)
-        return absentExecution(turn);
-    try {
-        const trace = harnessById(typeof record.harness === 'string' && record.harness ? record.harness : 'claude')
-            .executionTrace(threadId, turn);
-        return trace || absentExecution(turn);
-    }
-    catch {
-        // A missing/unreadable native source is an absent transient trace, not a synthetic conversation failure.
-        return absentExecution(turn);
-    }
-}
-const TRACE_TICK_MS = 500;
-const HEARTBEAT_TICKS = 20;
-export async function sessionExecutionStream(c) {
-    const id = c.req.param('id') || '';
-    if (!readSessionExecution(id))
-        return c.json({ error: 'no such session' }, 404);
-    return streamSSE(c, async (stream) => {
-        let aborted = false;
-        let lastRevision = '';
-        let ticks = 0;
-        const publish = async () => {
-            const execution = readSessionExecution(id);
-            if (!execution)
-                return false;
-            if (execution.revision === lastRevision)
-                return true;
-            lastRevision = execution.revision;
-            await stream.writeSSE({ event: 'execution', data: JSON.stringify(execution) });
-            return true;
-        };
-        stream.onAbort(() => { aborted = true; });
-        try {
-            if (!await publish())
-                return;
-            while (!aborted) {
-                await stream.sleep(TRACE_TICK_MS);
-                if (aborted)
-                    break;
-                if (!await publish())
-                    break;
-                if (++ticks % HEARTBEAT_TICKS === 0)
-                    await stream.writeSSE({ event: 'ping', data: 'x' });
-            }
-        }
-        catch {
-            // EventSource reconnects a dropped stream. A native trace read must never take down the session server.
-        }
-    });
-}

package/node_modules/@spexcode/spec-cli/hooks/compat/mark-active-0.5.2-eef1.fixture

@@ -1,53 +0,0 @@
-#!/usr/bin/env bash
-# @@@ mark-active - the SINGLE freshness hook, wired to BOTH UserPromptSubmit and PreToolUse. It branches
-# on ONE structured signal read straight from the hook payload (stdin JSON), so the state is HARD — never
-# text-sniffed from the TUI:
-#   the agent is pausing to ask the HUMAN (hp_is_ask) → status: asking, with the question text as the note
-#                                  (the deterministic capture of a question).
-#   any other tool, or a prompt submit → the agent is working → status: active (drop a now-stale proposal/note).
-# WHAT counts as "asking" is the [[harness-adapter]]'s call (Claude: the AskUserQuestion tool; Codex: the
-# request_user_input tool) — read via hp_is_ask, so this hook never names a harness tool.
-# Fires BEFORE the tool runs, so a `spex session done` declaration (itself a tool) lands AFTER this and wins;
-# the next real tool flips back to active, forcing a fresh Stop-gate declaration. Pure shell (no node/tsx) so
-# it stays cheap on every tool call — it value-replaces status/proposal/note in session.json with sed, never jq.
-# @@@ global store - state lives NOT in the worktree but in the per-session GLOBAL record session.json, keyed
-# by the harness session_id, grouped per-project (see hp_store_dir). GATED on `governed`: a user-self-launched
-# (non-governed) session has no board to feed, so this no-ops on it. cwd = the session worktree.
-. "${SPEXCODE_HARNESS_LIB:?harness.sh not exported by dispatch.sh}"
-payload=$(cat 2>/dev/null)
-# an IN-PROCESS SUBAGENT's tool call (Claude's Task tool) fires the parent's hooks with the PARENT's
-# session_id — flipping here let a supervising parent's own subagents erase its declared park/ask within
-# seconds and race the stop-gate into "undeclared stop" (issue #60). A subagent working is not the parent
-# agent ACTING, so its calls never touch the record; the parent's own next tool call still flips. The
-# discriminator is the payload's own top-level agent_id stamp (hp_is_subagent) — deterministic, never a
-# timing window.
-[ -n "$(hp_is_subagent "$payload")" ] && exit 0
-sid=$(hp_session_id "$payload"); [ -n "$sid" ] || exit 0
-sdir=$(hp_store_dir "$sid") || exit 0
-rec="$sdir/session.json"
-# board-lifecycle gate: only a GOVERNED (dashboard-launched) session has a board state to maintain.
-grep -q '"governed"[[:space:]]*:[[:space:]]*true' "$rec" 2>/dev/null || exit 0
-
-jget() { sed -n "s/.*\"$1\"[[:space:]]*:[[:space:]]*\"\([^\"]*\)\".*/\1/p" "$rec" 2>/dev/null | head -1; }
-
-if [ -n "$(hp_is_ask "$payload")" ]; then
-  status=asking
-  note=$(hp_ask_note "$payload")   # first question's text → the note (best-effort)
-else
-  status=active
-  note=
-fi
-
-# cheap path: already active with nothing stale to clear → no-op (the common every-tool case).
-[ "$status" = active ] && [ "$(jget status)" = active ] && [ -z "$(jget proposal)" ] && [ -z "$(jget note)" ] && exit 0
-
-# value-replace status + clear proposal + (re)set note, in place. The record is written one-field-per-line
-# with these keys ALWAYS present (sessions.ts writeRecord), so each is a single value substitution — no key
-# add/remove, no JSON parser. Escape \ / & in the note for the sed REPLACEMENT (the note never contains ").
-note_esc=$(printf '%s' "$note" | sed 's/[\\/&]/\\&/g')
-tmp=$(mktemp) || exit 0
-sed -e "s/\(\"status\"[[:space:]]*:[[:space:]]*\)\"[^\"]*\"/\1\"$status\"/" \
-    -e "s/\(\"proposal\"[[:space:]]*:[[:space:]]*\)\"[^\"]*\"/\1\"\"/" \
-    -e "s/\(\"note\"[[:space:]]*:[[:space:]]*\)\"[^\"]*\"/\1\"$note_esc\"/" \
-    "$rec" > "$tmp" && mv "$tmp" "$rec"
-exit 0

package/node_modules/@spexcode/spec-cli/hooks/compat/mark-active-sed-v0.fixture

@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-# @@@ mark-active - the SINGLE freshness hook, wired to BOTH UserPromptSubmit and PreToolUse. It branches
-# on ONE structured signal read straight from the hook payload (stdin JSON), so the state is HARD — never
-# text-sniffed from the TUI:
-#   the agent is pausing to ask the HUMAN (hp_is_ask) → status: asking, with the question text as the note
-#                                  (the deterministic capture of a question).
-#   any other tool, or a prompt submit → the agent is working → status: active (drop a now-stale proposal/note).
-# WHAT counts as "asking" is the [[harness-adapter]]'s call (Claude: the AskUserQuestion tool; Codex: the
-# request_user_input tool) — read via hp_is_ask, so this hook never names a harness tool.
-# Fires BEFORE the tool runs, so a `spex session done` declaration (itself a tool) lands AFTER this and wins;
-# the next real tool flips back to active, forcing a fresh Stop-gate declaration. Pure shell (no node/tsx) so
-# it stays cheap on every tool call — it value-replaces status/proposal/note in session.json with sed, never jq.
-# @@@ global store - state lives NOT in the worktree but in the per-session GLOBAL record session.json, keyed
-# by the harness session_id, grouped per-project (see hp_store_dir). GATED on `governed`: a user-self-launched
-# (non-governed) session has no board to feed, so this no-ops on it. cwd = the session worktree.
-. "${SPEXCODE_HARNESS_LIB:?harness.sh not exported by dispatch.sh}"
-payload=$(cat 2>/dev/null)
-sid=$(hp_session_id "$payload"); [ -n "$sid" ] || exit 0
-sdir=$(hp_store_dir "$sid") || exit 0
-rec="$sdir/session.json"
-# board-lifecycle gate: only a GOVERNED (dashboard-launched) session has a board state to maintain.
-grep -q '"governed"[[:space:]]*:[[:space:]]*true' "$rec" 2>/dev/null || exit 0
-
-jget() { sed -n "s/.*\"$1\"[[:space:]]*:[[:space:]]*\"\([^\"]*\)\".*/\1/p" "$rec" 2>/dev/null | head -1; }
-
-if [ -n "$(hp_is_ask "$payload")" ]; then
-  status=asking
-  note=$(hp_ask_note "$payload")   # first question's text → the note (best-effort)
-else
-  status=active
-  note=
-fi
-
-# cheap path: already active with nothing stale to clear → no-op (the common every-tool case).
-[ "$status" = active ] && [ "$(jget status)" = active ] && [ -z "$(jget proposal)" ] && [ -z "$(jget note)" ] && exit 0
-
-# value-replace status + clear proposal + (re)set note, in place. The record is written one-field-per-line
-# with these keys ALWAYS present (sessions.ts writeRecord), so each is a single value substitution — no key
-# add/remove, no JSON parser. Escape \ / & in the note for the sed REPLACEMENT (the note never contains ").
-note_esc=$(printf '%s' "$note" | sed 's/[\\/&]/\\&/g')
-tmp=$(mktemp) || exit 0
-sed -e "s/\(\"status\"[[:space:]]*:[[:space:]]*\)\"[^\"]*\"/\1\"$status\"/" \
-    -e "s/\(\"proposal\"[[:space:]]*:[[:space:]]*\)\"[^\"]*\"/\1\"\"/" \
-    -e "s/\(\"note\"[[:space:]]*:[[:space:]]*\)\"[^\"]*\"/\1\"$note_esc\"/" \
-    "$rec" > "$tmp" && mv "$tmp" "$rec"
-exit 0