spexcode 0.6.7 → 0.6.8

package/node_modules/@spexcode/session-core/dist/session-timeline.js

@@ -1,216 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, appendFileSync, mkdirSync, statSync, readdirSync, openSync, closeSync, readSync } from 'node:fs';
-import { basename, join } from 'node:path';
-import { sessionStoreDir, sessionArtifactPath } from '@spexcode/spec-core';
-const timelinePath = (id) => sessionArtifactPath(id, 'timeline.ndjson');
-const segmentsDir = (id) => sessionArtifactPath(id, 'timeline');
-const SEGMENT = /^(\d+)\.ndjson$/;
-const SEGMENT_NAME_WIDTH = 12;
-const TAIL_BLOCK_BYTES = 64 * 1024;
-// One logical timeline is legacy timeline.ndjson followed by immutable numbered segments. The directory
-// listing is its only index: numbering is append order, so there is no mutable manifest to repair.
-function segmentFiles(id) {
-    try {
-        const dir = segmentsDir(id);
-        const names = readdirSync(dir).filter((name) => SEGMENT.test(name)).sort((a, b) => {
-            const an = BigInt(SEGMENT.exec(a)[1]), bn = BigInt(SEGMENT.exec(b)[1]);
-            return an < bn ? -1 : an > bn ? 1 : 0;
-        });
-        return names.map((name) => join(dir, name));
-    }
-    catch { /* no numbered segments yet */ }
-    return [];
-}
-function timelineFiles(id) {
-    const files = [];
-    const legacy = timelinePath(id);
-    if (existsSync(legacy))
-        files.push(legacy);
-    files.push(...segmentFiles(id));
-    return files;
-}
-const segmentLimit = () => {
-    const configured = Number(process.env.SPEXCODE_TIMELINE_SEGMENT_BYTES);
-    return Number.isFinite(configured) ? Math.max(1024, Math.floor(configured)) : 4 * 1024 * 1024;
-};
-function activeSegment(id, bytes) {
-    const dir = segmentsDir(id);
-    mkdirSync(dir, { recursive: true });
-    const segments = segmentFiles(id);
-    const current = segments.at(-1);
-    if (!current)
-        return join(dir, `${String(1).padStart(SEGMENT_NAME_WIDTH, '0')}.ndjson`);
-    try {
-        if (statSync(current).size === 0 || statSync(current).size + bytes <= segmentLimit())
-            return current;
-    }
-    catch { /* a vanished active segment is recreated under its next number */ }
-    const n = BigInt(SEGMENT.exec(basename(current))[1]) + 1n;
-    return join(dir, `${String(n).padStart(SEGMENT_NAME_WIDTH, '0')}.ndjson`);
-}
-function append(id, ev) {
-    mkdirSync(sessionStoreDir(id), { recursive: true });
-    const line = JSON.stringify(ev) + '\n';
-    appendFileSync(activeSegment(id, Buffer.byteLength(line)), line);
-}
-function parseLines(lines) {
-    return lines.map((l) => {
-        try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        }
-    }).filter((e) => e != null && (e.kind === 'status' || e.kind === 'sent' || e.kind === 'dispatch-settled'));
-}
-function tailPublicEvents(path, limit) {
-    let fd = null;
-    try {
-        const size = statSync(path).size;
-        fd = openSync(path, 'r');
-        let start = size;
-        let text = '';
-        while (start > 0) {
-            const next = Math.max(0, start - TAIL_BLOCK_BYTES);
-            const buf = Buffer.alloc(start - next);
-            readSync(fd, buf, 0, buf.length, next);
-            text = buf.toString('utf8') + text;
-            const publicCount = parseLines(text.split('\n').filter(Boolean)).filter((event) => event.kind !== 'dispatch-settled').length;
-            if (publicCount >= limit || next === 0)
-                break;
-            start = next;
-        }
-        return parseLines(text.split('\n').filter(Boolean))
-            .filter((event) => event.kind !== 'dispatch-settled')
-            .slice(-limit);
-    }
-    catch {
-        return [];
-    }
-    finally {
-        if (fd !== null)
-            closeSync(fd);
-    }
-}
-// Record a lifecycle value that has already landed in session.json. TypeScript state writers call this
-// synchronously before returning, so a later write cannot erase an intermediate declaration note from the
-// conversation. Best-effort: history is an accessory to the state machine, and failing to write it must never
-// break the transition that already happened.
-export function recordStatus(id, status, proposal, note) {
-    try {
-        append(id, { ts: new Date().toISOString(), kind: 'status', status, proposal, note });
-    }
-    catch { /* the record already moved; the history line is the only loss */ }
-}
-// The DELIVERY ([[dispatch]]): appending this line IS the send, so unlike a status line it must fail LOUD —
-// the caller reports the throw rather than a false success. `text` is the message BEFORE any mechanism insert
-// (hints are transport, not conversation); `replyVia` is the effective channel the prompt seam chose. Returns
-// the new line's `mid`, which a best-effort poke carries.
-export function appendSent(id, text, from, replyVia, dispatchReceipt) {
-    const mid = randomUUID();
-    append(id, { ts: new Date().toISOString(), kind: 'sent', mid, text, from, ...(replyVia ? { replyVia } : {}), ...(dispatchReceipt ? { dispatchReceipt } : {}) });
-    return { mid };
-}
-export function sentDispatchReceipt(id, operation, requestDigest) {
-    let found = null;
-    const settled = new Set();
-    for (const path of timelineFiles(id)) {
-        for (const event of parseLines(readFileSync(path, 'utf8').split('\n').filter(Boolean))) {
-            if (event.kind === 'sent' && !found && event.dispatchReceipt?.operation === operation && event.dispatchReceipt.requestDigest === requestDigest) {
-                found = { mid: event.mid, payloadHash: event.dispatchReceipt.payloadHash, delivery: event.dispatchReceipt.delivery ?? null };
-            }
-            else if (event.kind === 'dispatch-settled' && event.operation === operation && event.requestDigest === requestDigest) {
-                settled.add(event.mid);
-            }
-        }
-    }
-    return found ? { ...found, delivered: settled.has(found.mid) } : null;
-}
-export function settleSentDispatch(id, mid) {
-    let receipt = null;
-    let settled = false;
-    for (const path of timelineFiles(id)) {
-        for (const event of parseLines(readFileSync(path, 'utf8').split('\n').filter(Boolean))) {
-            if (event.kind === 'sent' && event.mid === mid && event.dispatchReceipt?.delivery)
-                receipt = event.dispatchReceipt;
-            if (event.kind === 'dispatch-settled' && event.mid === mid)
-                settled = true;
-        }
-    }
-    if (!receipt || settled)
-        return;
-    append(id, { ts: new Date().toISOString(), kind: 'dispatch-settled', operation: receipt.operation, requestDigest: receipt.requestDigest, mid });
-}
-// The unowned read: any process may take it with nothing but filesystem access, and taking it perturbs
-// nothing. Index = event position, which is what a cursor names ([[session-cursors]]).
-export function timelineEvents(id) {
-    try {
-        return timelineFiles(id).flatMap((path) => parseLines(readFileSync(path, 'utf8').split('\n').filter(Boolean)))
-            .flatMap((stored) => {
-            if (stored.kind === 'dispatch-settled')
-                return [];
-            if (stored.kind === 'status')
-                return [stored];
-            const { dispatchReceipt: _receipt, ...event } = stored;
-            return [event];
-        });
-    }
-    catch {
-        return [];
-    }
-}
-// the same L0 read taken as CHEAPLY as it can be: a follower ([[session-follow]]) ticks over many logs, so it
-// stats first and parses only what grew. null = no log yet (a session that has authored nothing).
-export function timelineStamp(id) {
-    try {
-        const path = timelineFiles(id).at(-1);
-        if (!path)
-            return null;
-        const s = statSync(path);
-        return `${path}:${s.size}:${s.mtimeMs}`;
-    }
-    catch {
-        return null;
-    }
-}
-// the channel of the LAST HUMAN send (from == null): 'note' when the note-reply hint rode along, else null.
-// This is what makes the reply-channel hints SYMMETRIC ([[session-timeline]]): a human send with no note flag
-// arriving after a note-send is the "back at a terminal" transition, and the delivery gets the counter-insert.
-// Derived from the durable log — no new state, and it survives a server restart. Agent senders (`from` set)
-// say nothing about where the HUMAN is reading, so they neither set nor clear it.
-export function lastHumanSendVia(id) {
-    const evs = timelineEvents(id);
-    for (let i = evs.length - 1; i >= 0; i--) {
-        const e = evs[i];
-        if (e.kind === 'sent' && e.from == null)
-            return e.replyVia === 'note' ? 'note' : null;
-    }
-    return null;
-}
-export function currentHumanTurn(id) {
-    const evs = timelineEvents(id);
-    for (let i = evs.length - 1; i >= 0; i--) {
-        const e = evs[i];
-        if (e.kind === 'sent' && e.from == null)
-            return { token: e.mid, acceptedAt: e.ts };
-    }
-    return null;
-}
-// Durable tail read with no board/governance policy. A runtime that owns a compatible session directory can
-// consume the same protocol; product surfaces decide separately whether that id is visible to them.
-export function timelineTail(id, limit = 500) {
-    const wanted = Math.max(1, limit);
-    const tail = [];
-    for (const path of timelineFiles(id).reverse()) {
-        const remaining = wanted - tail.length;
-        if (remaining <= 0)
-            break;
-        tail.unshift(...tailPublicEvents(path, remaining));
-    }
-    return tail.map((e) => {
-        if (e.kind === 'status')
-            return e;
-        const { dispatchReceipt: _receipt, ...event } = e;
-        return event;
-    });
-}

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