@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/core/__tests__/persona-subkind.test.js

@@ -1,65 +0,0 @@
-// Run: node --import tsx/esm --test src/core/__tests__/persona-subkind.test.ts
-//
-// Scoped persona sub-personas: a kind has specialist reviewer personas at
-// `<kind>/reviewers/<name>/PERSONA.md`, enumerated by `subPersonasFor(kind)` and
-// rendered into that kind's composed prompt (and nowhere else) by `resolve`.
-// Visibility = membership (the sub-persona's `availableTo`, default = its
-// top-level ancestor kind): only `plan` sees the `plan/reviewers/*` menu; the
-// `reviewers/` grouping dir is transparent so the kind string keeps it; the
-// sub-personas never pollute the global `availableKinds()` list; and a
-// sub-persona itself boots as a real composed persona with the terminal finish
-// contract.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { resolve } from '../personas/resolve.js';
-import { subPersonasFor, availableKinds } from '../personas/loader.js';
-const PLAN_REVIEWER_KINDS = [
-    'plan/reviewers/architecture-fit',
-    'plan/reviewers/code-smells',
-    'plan/reviewers/pattern-consistency',
-    'plan/reviewers/requirements-coverage',
-    'plan/reviewers/security',
-];
-const MENU_HEADER = 'Sub-personas you may spawn';
-test('subPersonasFor("plan") returns the five reviewers sorted, each with a non-empty whenToUse', () => {
-    const subs = subPersonasFor('plan');
-    assert.deepEqual(subs.map((s) => s.kind), PLAN_REVIEWER_KINDS, 'the five plan reviewer kind strings in sorted order — the transparent reviewers/ dir keeps the full kind path');
-    for (const s of subs) {
-        assert.ok(s.whenToUse.length > 0, `${s.kind} carries a non-empty whenToUse`);
-    }
-});
-test('availability is membership: a kind with no available sub-personas yields []', () => {
-    assert.deepEqual(subPersonasFor('explore'), [], 'no sub-persona is availableTo explore');
-    assert.deepEqual(subPersonasFor('plan/reviewers/security'), [], 'the five reviewers default availableTo:[plan] — none are available to a reviewer kind');
-});
-test('availableKinds() contains no plan/reviewers/* — sub-personas never pollute the global list', () => {
-    const kinds = availableKinds();
-    for (const k of PLAN_REVIEWER_KINDS) {
-        assert.ok(!kinds.includes(k), `${k} must not appear in availableKinds()`);
-    }
-    assert.ok(!kinds.some((k) => k.includes('reviewers')), 'no kind contains "reviewers"');
-});
-test('resolve(plan, orchestrator) renders the menu with all five reviewer strings', () => {
-    const p = resolve('plan', 'orchestrator', { lifecycle: 'terminal', hasManager: true });
-    assert.match(p.systemPrompt, new RegExp(MENU_HEADER), 'the menu header is present');
-    for (const k of PLAN_REVIEWER_KINDS) {
-        assert.ok(p.systemPrompt.includes(k), `menu lists ${k}`);
-    }
-});
-test('resolve(plan, base) ALSO renders the menu (render-for-both decision)', () => {
-    const p = resolve('plan', 'base', { lifecycle: 'terminal', hasManager: true });
-    assert.match(p.systemPrompt, new RegExp(MENU_HEADER), 'a base plan node sees the roster too');
-    for (const k of PLAN_REVIEWER_KINDS) {
-        assert.ok(p.systemPrompt.includes(k), `menu lists ${k}`);
-    }
-});
-test('resolve(general, orchestrator) does NOT render the menu (visibility = membership)', () => {
-    const p = resolve('general', 'orchestrator', { lifecycle: 'terminal', hasManager: true });
-    assert.doesNotMatch(p.systemPrompt, new RegExp(MENU_HEADER), 'general owns no roster, so no menu');
-});
-test('a reviewer sub-kind boots as a real composed persona with the terminal finish contract and no menu', () => {
-    const p = resolve('plan/reviewers/security', 'base', { lifecycle: 'terminal', hasManager: true });
-    assert.ok(p.systemPrompt.includes('concrete exploit path'), 'the security-reviewer lens expertise is present');
-    assert.match(p.systemPrompt, /owe a final result and you reap when done/i, 'the terminal finish contract composed in — it boots as a real persona');
-    assert.doesNotMatch(p.systemPrompt, new RegExp(MENU_HEADER), 'a sub-kind owns no roster of its own — it renders no menu');
-});

package/dist/core/__tests__/persona.test.js

@@ -1,107 +0,0 @@
-// Run: node --import tsx/esm --test src/core/__tests__/persona.test.ts
-//
-// The persona-transition mechanism: the two-axis model (mode × lifecycle) is
-// switchable independently, and `personaDrift` detects when a node's live
-// {mode,lifecycle} has diverged from the `persona_ack` it was last given
-// guidance for (the central injector then delivers + commits).
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { spawnNode } from '../runtime/nodes.js';
-import { promote } from '../runtime/promote.js';
-import { getNode, updateNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { personaDrift, commitPersonaAck, transitionGuidance, } from '../runtime/persona.js';
-let home;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-persona-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-// ---------------------------------------------------------------------------
-// Birth: a fresh node is born acked to its own persona — no spurious drift.
-// ---------------------------------------------------------------------------
-test('a freshly spawned node has no persona drift (born acked to its own persona)', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    assert.deepEqual(meta.persona_ack, { mode: 'base', lifecycle: 'terminal' });
-    assert.equal(personaDrift(meta.node_id), null, 'no drift at birth');
-});
-// ---------------------------------------------------------------------------
-// Fix 1: promote keeps lifecycle by default; --resident flips it.
-// ---------------------------------------------------------------------------
-test('promote flips mode→orchestrator and KEEPS lifecycle terminal by default', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    const res = promote(meta.node_id);
-    assert.equal(res.meta.mode, 'orchestrator');
-    assert.equal(res.meta.lifecycle, 'terminal', 'lifecycle is NOT forced to resident');
-});
-test('promote with resident:true ALSO flips lifecycle→resident', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    const res = promote(meta.node_id, { resident: true });
-    assert.equal(res.meta.mode, 'orchestrator');
-    assert.equal(res.meta.lifecycle, 'resident', 'resident flag flips lifecycle');
-});
-test('promote no longer returns a guidance field (injector is the single source)', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    const res = promote(meta.node_id);
-    assert.equal('guidance' in res, false, 'promote() returns facts only');
-});
-// ---------------------------------------------------------------------------
-// personaDrift detect + commit.
-// ---------------------------------------------------------------------------
-test('personaDrift detects base→orchestrator after promote, then clears on commit', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    promote(meta.node_id); // mode→orchestrator, lifecycle stays terminal
-    const drift = personaDrift(meta.node_id);
-    assert.ok(drift !== null, 'a transition is detected');
-    assert.deepEqual(drift?.from, { mode: 'base', lifecycle: 'terminal' });
-    assert.deepEqual(drift?.to, { mode: 'orchestrator', lifecycle: 'terminal' });
-    assert.ok((drift?.guidance ?? '').length > 0, 'guidance is built');
-    // Caller commits the ack after delivery — drift then clears (idempotent).
-    commitPersonaAck(meta.node_id, drift.to);
-    assert.equal(personaDrift(meta.node_id), null, 'no drift after the ack is committed');
-    assert.deepEqual(getNode(meta.node_id)?.persona_ack, { mode: 'orchestrator', lifecycle: 'terminal' });
-});
-test('personaDrift detects a lifecycle-only flip (terminal→resident)', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    // Flip only the lifecycle axis — mode unchanged.
-    updateNode(meta.node_id, { lifecycle: 'resident' });
-    const drift = personaDrift(meta.node_id);
-    assert.ok(drift !== null);
-    assert.deepEqual(drift?.from, { mode: 'base', lifecycle: 'terminal' });
-    assert.deepEqual(drift?.to, { mode: 'base', lifecycle: 'resident' });
-    assert.match(drift?.guidance ?? '', /resident/i, 'guidance describes the resident state');
-});
-// ---------------------------------------------------------------------------
-// transitionGuidance: each lifecycle case + both-axes concatenation.
-// ---------------------------------------------------------------------------
-test('transitionGuidance terminal→resident says it is never forced to submit a final', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    const g = transitionGuidance(meta.node_id, { mode: 'base', lifecycle: 'terminal' }, { mode: 'base', lifecycle: 'resident' });
-    assert.match(g, /resident/i);
-    assert.match(g, /never/i);
-    assert.doesNotMatch(g, /orchestrator/i, 'a lifecycle-only change carries no mode section');
-});
-test('transitionGuidance resident→terminal says it owes a final up the spine', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'resident' });
-    const g = transitionGuidance(meta.node_id, { mode: 'base', lifecycle: 'resident' }, { mode: 'base', lifecycle: 'terminal' });
-    assert.match(g, /terminal/i);
-    assert.match(g, /push final/i);
-});
-test('transitionGuidance concatenates BOTH sections when both axes change', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, lifecycle: 'terminal' });
-    promote(meta.node_id); // ensure roadmap/memory seeded for the orchestrator section
-    const g = transitionGuidance(meta.node_id, { mode: 'base', lifecycle: 'terminal' }, { mode: 'orchestrator', lifecycle: 'resident' });
-    assert.match(g, /orchestrator/i, 'carries the mode (base→orchestrator) section');
-    assert.match(g, /resident/i, 'carries the lifecycle (terminal→resident) section');
-});

package/dist/core/__tests__/unknown-path.test.js

@@ -1,58 +0,0 @@
-// Regression tests for unknown-subcommand error recovery hints.
-// Run with: node --import tsx/esm --test src/core/__tests__/unknown-path.test.ts
-//
-// The `next` road sign must name a command that actually exists: the FULL path
-// to the deepest matched node, not just its local name. A prior bug emitted
-// `crtr find -h` (dropping the `skill` parent) when `crtr skill find bogus` was
-// invoked, sending the caller to a nonexistent top-level command.
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { defineRoot, defineBranch, defineLeaf, walk, unknownPathError } from '../command.js';
-const leaf = defineLeaf({
-    name: 'search',
-    description: 'search',
-    whenToUse: 'x',
-    help: { name: 'search', summary: 'search', output: [], outputKind: 'object', effects: ['None. Read-only.'] },
-    run: async () => ({}),
-});
-const findBranch = defineBranch({
-    name: 'find',
-    description: 'find',
-    whenToUse: 'x',
-    help: { name: 'find', summary: 'find' },
-    children: [leaf],
-});
-const skillBranch = defineBranch({
-    name: 'skill',
-    description: 'skill',
-    whenToUse: 'x',
-    help: { name: 'skill', summary: 'skill' },
-    rootEntry: { concept: 'skill', desc: 'skill', useWhen: 'x' },
-    children: [findBranch],
-});
-const root = defineRoot({
-    tagline: 'test runtime',
-    globals: [],
-    subtrees: [skillBranch],
-});
-function nextHint(...tokens) {
-    const { node, path, remaining } = walk(root, tokens);
-    const err = unknownPathError(node, path, remaining[0]);
-    return err.details.next;
-}
-describe('unknown-path error: recovery hint names the full valid path', () => {
-    test('root-level unknown points at `crtr -h`', () => {
-        assert.match(nextHint('bogus'), /Run `crtr -h`/);
-    });
-    test('one-level unknown points at `crtr skill -h`', () => {
-        assert.match(nextHint('skill', 'bogus'), /Run `crtr skill -h`/);
-    });
-    test('two-level unknown points at `crtr skill find -h`, not `crtr find -h`', () => {
-        const hint = nextHint('skill', 'find', 'bogus');
-        assert.match(hint, /Run `crtr skill find -h`/);
-        assert.doesNotMatch(hint, /Run `crtr find -h`/);
-    });
-    test('valid children of the matched node are listed', () => {
-        assert.match(nextHint('skill', 'find', 'bogus'), /Valid children: search\./);
-    });
-});

package/dist/core/canvas/wakeups.d.ts

@@ -1,76 +0,0 @@
-import type { ArmWakeSpec, Wakeup } from './types.js';
-/** A thrown integrity-backstop error from armWake. `code` is the AC-N3 code the
- *  command surface (the ONLY sanctioned caller of armWake) maps to a rendered
- *  error block — armWake carries integrity backstops only (empty body / recur-on-
- *  deadline / unknown kind); target-resolvability + recoverable-state + the
- *  per-owner cap live in the surface (Min-6), so a non-surface armer could insert
- *  a dangling wake — every armer MUST route through the surface. */
-export declare class WakeArmError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
-}
-/** Which wakes a listWakes call returns. Distinguished by which key is present
- *  (mirrors listNodes' filter shape):
- *   - { node }    — wakes anchored to this node (node_id = ?).
- *   - { owner }   — wakes this node ARMED (owner_id = ?); the per-owner cap count.
- *   - { subtree } — wakes anchored to any node in this id set (node_id IN (…)).
- *   - { due }     — wakes whose fire_at <= this ISO instant.
- *   - { canvas }  — every wake on the canvas. */
-export type WakeScope = {
-    node: string;
-} | {
-    owner: string;
-} | {
-    subtree: string[];
-} | {
-    due: string;
-} | {
-    canvas: true;
-};
-/** INSERT one wakeup row from the pinned spec, returning its (caller-supplied)
- *  `wakeup_id`. JSON.stringifies the typed `payload` union into the TEXT column
- *  and stamps `created`.
- *
- *  Deadline upsert (design Q3, "≤1 deadline per node"): for `kind === 'deadline'`
- *  the node's existing deadline is canceled first, then the new one inserted — the
- *  partial unique index `idx_wakeups_deadline` is the schema-level backstop.
- *
- *  Integrity backstops (throw WakeArmError; the surface maps the code to AC-N3):
- *   - empty/whitespace note `body` for `noted`/`deadline` → `empty_note`.
- *   - non-NULL `recur` on a `deadline`                    → `deadline_cannot_recur`.
- *   - unknown `kind`                                      → `bad_kind`.
- *  NO target-resolvability / recoverable-state / cap backstop here (Min-6). */
-export declare function armWake(spec: ArmWakeSpec): string;
-/** UPDATE the next fire time — recurrence advancement (the daemon settles a
- *  recurring row to its next slot BEFORE enacting, crash-safe; design D4). */
-export declare function advanceWake(wakeup_id: string, nextFireIso: string): void;
-/** DELETE one wakeup by id — one-shot consumption (the daemon settles a one-shot
- *  row BEFORE enacting, crash-safe; design D4). */
-export declare function consumeWake(wakeup_id: string): void;
-/** DELETE one wakeup by id — the explicit user/surface cancel. Idempotent:
- *  0 rows ⇒ no error (AC-C2). */
-export declare function cancelWake(wakeup_id: string): void;
-/** DELETE every wake anchored to this node AND every detached wake it ARMED —
- *  deliberate close/reap (ruling A). Hooked at transition('cancel'). */
-export declare function cancelWakesFor(node_id: string): void;
-/** DELETE this node's one-shot self-alarms (recur IS NULL); node-anchored crons
- *  SURVIVE — finalize is the instance finishing, not a teardown of standing
- *  schedules (design Q1). Hooked at transition('finalize'). */
-export declare function cancelSelfAlarms(node_id: string): void;
-/** DELETE this node's pending deadline(s) — cancel-on-wake (design §6.4).
- *  Hooked at reviveNode, so the deadline always belongs to the dormancy left. */
-export declare function cancelDeadlinesFor(node_id: string): void;
-/** The daemon's per-tick due query: every row whose fire_at has arrived, in
- *  fire_at order, with `payload` parsed into the typed union. Returns exactly ONE
- *  row per recurring wake regardless of missed slots — coalescing is structural
- *  (AC-E2). */
-export declare function dueWakes(nowIso: string): Wakeup[];
-/** List wakes for a scope (node / owner / subtree / due / canvas), `payload`
- *  parsed as in dueWakes. The subtree variant binds the id set with `?`
- *  placeholders (mirroring listNodes — the codebase's one safe dynamic-IN spot);
- *  ids are NEVER string-concatenated (Min-10). */
-export declare function listWakes(scope: WakeScope): Wakeup[];
-/** True if the node has ANY pending self-anchored wake (of any kind). Consumed by
- *  the stop-guard self-wake seam so a no-child poll node releases dormant after
- *  arming instead of being nagged to finish (AC-X3/AC-R1). */
-export declare function hasPendingSelfWake(node_id: string): boolean;

package/dist/core/canvas/wakeups.js

@@ -1,185 +0,0 @@
-// wakeups.ts — the WAKEUPS table data-access layer (canvas.db, migration v7).
-//
-// One-module-per-table (the focuses.ts precedent): ALL SQL that touches the
-// `wakeups` table lives HERE and nowhere else — never appended to canvas.ts,
-// which keeps the node/edge model. A WAKEUP is one durable row = "do <kind> at
-// fire_at [every recur]", carrying a fire time, a kind, an optional payload, an
-// optional recurrence cadence, a nullable TARGET node_id, and the owner_id of
-// the node that ARMED it.
-//
-// Two anchors, two reap rules (design D1/D2):
-//   - node_id  → the revive target AND the node-anchored cancel anchor; it
-//     carries the `ON DELETE CASCADE` FK, so a pruned node's node-anchored wakes
-//     are reaped FOR FREE in pruneNodes' same `DELETE FROM nodes` (canvas.ts is
-//     UNTOUCHED — the cascade does it; there is no pruneNodes wakeups code).
-//     NULL = canvas-detached (a deferred spawn / spawn-cron).
-//   - owner_id → the armer; a PLAIN indexed column with NO FK, so a crashed-
-//     then-pruned armer's detached cron is NOT cascade-dropped (Invariant E).
-//     Reaped only by the explicit cancelWakesFor DELETE on deliberate close.
-//
-// Each function is a single-statement query mirroring the canvas.ts atomic-setter
-// pattern (setStatus/setIntent/setPresence) — no read-modify-write, serialized by
-// WAL. The data-access layer OWNS payload serialization: armWake JSON.stringifies
-// the typed per-kind union on write; dueWakes/listWakes JSON.parse it back on read
-// (Maj-1), so callers consume `payload.body` / `payload as SpawnChildOpts` directly.
-//
-// `wakeup_id` is CALLER-SUPPLIED (the command surface mints `wk-${newNodeId()}`):
-// the canvas layer never imports newNodeId from runtime/nodes.ts — that would
-// force a canvas → runtime → canvas import cycle (Min-1).
-import { openDb } from './db.js';
-/** A thrown integrity-backstop error from armWake. `code` is the AC-N3 code the
- *  command surface (the ONLY sanctioned caller of armWake) maps to a rendered
- *  error block — armWake carries integrity backstops only (empty body / recur-on-
- *  deadline / unknown kind); target-resolvability + recoverable-state + the
- *  per-owner cap live in the surface (Min-6), so a non-surface armer could insert
- *  a dangling wake — every armer MUST route through the surface. */
-export class WakeArmError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'WakeArmError';
-    }
-}
-/** Hydrate a raw row into a Wakeup, JSON.parsing `payload` back into the typed
- *  per-kind union (NULL column → null). */
-function wakeupFrom(r) {
-    const raw = r['payload'];
-    return {
-        wakeup_id: r['wakeup_id'],
-        node_id: r['node_id'] ?? null,
-        owner_id: r['owner_id'],
-        fire_at: r['fire_at'],
-        kind: r['kind'],
-        recur: r['recur'] ?? null,
-        payload: raw == null ? null : JSON.parse(raw),
-        created: r['created'],
-    };
-}
-// ---------------------------------------------------------------------------
-// Writes — each a single-statement INSERT/UPDATE/DELETE.
-// ---------------------------------------------------------------------------
-/** INSERT one wakeup row from the pinned spec, returning its (caller-supplied)
- *  `wakeup_id`. JSON.stringifies the typed `payload` union into the TEXT column
- *  and stamps `created`.
- *
- *  Deadline upsert (design Q3, "≤1 deadline per node"): for `kind === 'deadline'`
- *  the node's existing deadline is canceled first, then the new one inserted — the
- *  partial unique index `idx_wakeups_deadline` is the schema-level backstop.
- *
- *  Integrity backstops (throw WakeArmError; the surface maps the code to AC-N3):
- *   - empty/whitespace note `body` for `noted`/`deadline` → `empty_note`.
- *   - non-NULL `recur` on a `deadline`                    → `deadline_cannot_recur`.
- *   - unknown `kind`                                      → `bad_kind`.
- *  NO target-resolvability / recoverable-state / cap backstop here (Min-6). */
-export function armWake(spec) {
-    const { kind } = spec;
-    if (kind !== 'bare' && kind !== 'noted' && kind !== 'deadline' && kind !== 'spawn') {
-        throw new WakeArmError('bad_kind', `unknown wake kind: ${String(kind)}`);
-    }
-    if (kind === 'noted' || kind === 'deadline') {
-        const body = spec.payload?.body;
-        if (typeof body !== 'string' || body.trim() === '') {
-            throw new WakeArmError('empty_note', `a ${kind} wake requires a non-empty note body.`);
-        }
-    }
-    if (kind === 'deadline' && spec.recur != null) {
-        throw new WakeArmError('deadline_cannot_recur', 'a deadline wake cannot recur.');
-    }
-    // Deadline upsert: clear the node's existing deadline before inserting the new one.
-    if (kind === 'deadline' && spec.node_id != null) {
-        cancelDeadlinesFor(spec.node_id);
-    }
-    const payloadText = spec.payload == null ? null : JSON.stringify(spec.payload);
-    openDb()
-        .prepare(`INSERT INTO wakeups (wakeup_id, node_id, owner_id, fire_at, kind, recur, payload, created)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(spec.wakeup_id, spec.node_id ?? null, spec.owner_id, spec.fire_at, kind, spec.recur ?? null, payloadText, new Date().toISOString());
-    return spec.wakeup_id;
-}
-/** UPDATE the next fire time — recurrence advancement (the daemon settles a
- *  recurring row to its next slot BEFORE enacting, crash-safe; design D4). */
-export function advanceWake(wakeup_id, nextFireIso) {
-    openDb().prepare('UPDATE wakeups SET fire_at = ? WHERE wakeup_id = ?').run(nextFireIso, wakeup_id);
-}
-/** DELETE one wakeup by id — one-shot consumption (the daemon settles a one-shot
- *  row BEFORE enacting, crash-safe; design D4). */
-export function consumeWake(wakeup_id) {
-    openDb().prepare('DELETE FROM wakeups WHERE wakeup_id = ?').run(wakeup_id);
-}
-/** DELETE one wakeup by id — the explicit user/surface cancel. Idempotent:
- *  0 rows ⇒ no error (AC-C2). */
-export function cancelWake(wakeup_id) {
-    openDb().prepare('DELETE FROM wakeups WHERE wakeup_id = ?').run(wakeup_id);
-}
-/** DELETE every wake anchored to this node AND every detached wake it ARMED —
- *  deliberate close/reap (ruling A). Hooked at transition('cancel'). */
-export function cancelWakesFor(node_id) {
-    openDb()
-        .prepare('DELETE FROM wakeups WHERE node_id = ? OR owner_id = ?')
-        .run(node_id, node_id);
-}
-/** DELETE this node's one-shot self-alarms (recur IS NULL); node-anchored crons
- *  SURVIVE — finalize is the instance finishing, not a teardown of standing
- *  schedules (design Q1). Hooked at transition('finalize'). */
-export function cancelSelfAlarms(node_id) {
-    openDb().prepare('DELETE FROM wakeups WHERE node_id = ? AND recur IS NULL').run(node_id);
-}
-/** DELETE this node's pending deadline(s) — cancel-on-wake (design §6.4).
- *  Hooked at reviveNode, so the deadline always belongs to the dormancy left. */
-export function cancelDeadlinesFor(node_id) {
-    openDb().prepare("DELETE FROM wakeups WHERE node_id = ? AND kind = 'deadline'").run(node_id);
-}
-// ---------------------------------------------------------------------------
-// Reads.
-// ---------------------------------------------------------------------------
-/** The daemon's per-tick due query: every row whose fire_at has arrived, in
- *  fire_at order, with `payload` parsed into the typed union. Returns exactly ONE
- *  row per recurring wake regardless of missed slots — coalescing is structural
- *  (AC-E2). */
-export function dueWakes(nowIso) {
-    return openDb()
-        .prepare('SELECT * FROM wakeups WHERE fire_at <= ? ORDER BY fire_at')
-        .all(nowIso).map(wakeupFrom);
-}
-/** List wakes for a scope (node / owner / subtree / due / canvas), `payload`
- *  parsed as in dueWakes. The subtree variant binds the id set with `?`
- *  placeholders (mirroring listNodes — the codebase's one safe dynamic-IN spot);
- *  ids are NEVER string-concatenated (Min-10). */
-export function listWakes(scope) {
-    const db = openDb();
-    let rows;
-    if ('node' in scope) {
-        rows = db
-            .prepare('SELECT * FROM wakeups WHERE node_id = ? ORDER BY fire_at')
-            .all(scope.node);
-    }
-    else if ('owner' in scope) {
-        rows = db
-            .prepare('SELECT * FROM wakeups WHERE owner_id = ? ORDER BY fire_at')
-            .all(scope.owner);
-    }
-    else if ('subtree' in scope) {
-        if (scope.subtree.length === 0)
-            return [];
-        const placeholders = scope.subtree.map(() => '?').join(',');
-        rows = db
-            .prepare(`SELECT * FROM wakeups WHERE node_id IN (${placeholders}) ORDER BY fire_at`)
-            .all(...scope.subtree);
-    }
-    else if ('due' in scope) {
-        rows = db
-            .prepare('SELECT * FROM wakeups WHERE fire_at <= ? ORDER BY fire_at')
-            .all(scope.due);
-    }
-    else {
-        rows = db.prepare('SELECT * FROM wakeups ORDER BY fire_at').all();
-    }
-    return rows.map(wakeupFrom);
-}
-/** True if the node has ANY pending self-anchored wake (of any kind). Consumed by
- *  the stop-guard self-wake seam so a no-child poll node releases dormant after
- *  arming instead of being nagged to finish (AC-X3/AC-R1). */
-export function hasPendingSelfWake(node_id) {
-    return (openDb().prepare('SELECT 1 FROM wakeups WHERE node_id = ? LIMIT 1').get(node_id) !== undefined);
-}

package/dist/core/skill-sync/__tests__/dry-run-wrote-count.test.js

@@ -1,57 +0,0 @@
-// Regression test for the `--dry-run` `wrote` count (found by P8 integration).
-//
-// Bug: under `--dry-run`, reconcilePair returned `wrote: counts.writes` — the
-// WOULD-BE endpoint write total — even though nothing is written to disk. That
-// contradicts the `sys sync -h` contract ("wrote … 0 under --dry-run") and the
-// rendered "DRY RUN (nothing written)" header, which together promise 0. The
-// fix makes `wrote` reflect ACTUAL writes (0 under dry-run) while still using
-// the would-be counts internally to decide synced-vs-noop.
-//
-// This test FAILS on the pre-fix code (wrote === number of files that WOULD be
-// written, e.g. 2 for a one-sided bootstrap) and PASSES on the current code.
-//
-// Run: node --import tsx/esm --test src/core/skill-sync/__tests__/dry-run-wrote-count.test.ts
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import { tmpdir, homedir } from 'node:os';
-import { join } from 'node:path';
-import { reconcilePair } from '../engine.js';
-import { DEFAULT_PROFILE } from '../profile.js';
-// The engine resolves user-scope endpoints + the snapshot store off homedir(),
-// which reads $HOME at call time — so isolating $HOME isolates everything.
-let home;
-let prevHome;
-const PAIR = {
-    id: 'dryrun-regression',
-    crtr: { scope: 'user', name: 'dr' },
-    claude: { scope: 'user', name: 'dr' },
-};
-before(() => {
-    prevHome = process.env.HOME;
-    home = mkdtempSync(join(tmpdir(), 'crtr-sync-dryrun-'));
-    process.env.HOME = home;
-    // One-sided bootstrap: only the crtr side exists. A real sync here would
-    // materialize the Claude side + write the snapshot (2 endpoint files written).
-    const crtrDir = join(home, '.crouter', 'memory', 'dr');
-    mkdirSync(crtrDir, { recursive: true });
-    writeFileSync(join(crtrDir, 'SKILL.md'), '---\nkind: knowledge\nwhen-and-why-to-read: "When the regression applies, this doc should be read."\n---\n# DR\nbody\n', 'utf8');
-});
-after(() => {
-    if (prevHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = prevHome;
-    rmSync(home, { recursive: true, force: true });
-    assert.equal(homedir(), prevHome ?? homedir()); // sanity: $HOME restored
-});
-test('--dry-run reports wrote === 0 and writes nothing to disk', () => {
-    const res = reconcilePair(PAIR, DEFAULT_PROFILE, { dryRun: true });
-    // Status still reflects that a real run WOULD sync this pair...
-    assert.equal(res.status, 'synced', 'dry-run should still classify the pending change as synced');
-    // ...but the `wrote` count is ACTUAL writes — zero under --dry-run.
-    assert.equal(res.wrote, 0, 'dry-run must report wrote === 0 (contract: 0 under --dry-run)');
-    // And nothing was actually written: no Claude bundle, no snapshot.
-    assert.ok(!existsSync(join(home, '.claude', 'skills', 'dr', 'SKILL.md')), 'dry-run must not materialize the Claude endpoint');
-    assert.ok(!existsSync(join(home, '.crouter', 'skill-sync', 'snapshots', PAIR.id)), 'dry-run must not write the snapshot base');
-});