@north-light/crouter 0.3.317 → 0.3.319

package/dist/commands/canvas-history/shared.js

@@ -1,139 +1 @@
-// Shared corpus/filter parsing between `canvas history search` and
-// `canvas history grep` \u2014 both leaves scope + filter the same per-cwd episodic
-// corpus (search ranks/browses it, grep line-matches it), so the scope/filter
-// flags, their param schemas, and their CLI-side parsing/validation are one
-// seam. This is internal reuse only: neither leaf's public flag set or output
-// shape is shared, and nothing here is re-exported as a command alias.
-import { usage } from '../../core/errors.js';
-export const TYPES = ['report', 'doc', 'roadmap', 'meta', 'inbox', 'transcript'];
-export const ORIGINS = [
-    'human', 'inbox', 'wake', 'revive', 'restart-continuation',
-    'stop-guard', 'park', 'recovery', 'context-nudge', 'kickoff', 'unknown',
-];
-export const ROLES = ['user', 'assistant', 'toolResult'];
-export const NODE_KINDS = ['advisor', 'developer', 'spec', 'design', 'review', 'explore', 'plan', 'general'];
-export const STATUSES = ['active', 'idle', 'done', 'dead', 'canceled'];
-const REL_UNITS = {
-    s: 1000,
-    m: 60_000,
-    h: 3_600_000,
-    d: 86_400_000,
-    w: 604_800_000,
-    mo: 2_592_000_000,
-    y: 31_536_000_000,
-};
-/** ISO 8601 (`2026-06-01`) \u2192 epoch ms (absolute); relative (`7d`, `2w`, `1mo`)
- *  \u2192 now minus the duration. Throws usage on an unparseable value. */
-export function parseWhen(field, raw) {
-    const rel = raw.match(/^(\d+)(mo|[smhdwy])$/);
-    if (rel !== null)
-        return Date.now() - Number(rel[1]) * REL_UNITS[rel[2]];
-    const abs = Date.parse(raw);
-    if (!Number.isNaN(abs))
-        return abs;
-    throw usage(`--${field} must be ISO 8601 (2026-06-01) or relative (7d, 2w, 1mo); received: ${raw}`);
-}
-export function splitCsv(v) {
-    if (v === undefined || v === '')
-        return undefined;
-    return v.split(',').map((s) => s.trim()).filter((s) => s !== '');
-}
-/** The scope/filter param schema shared by search and grep help \u2014 everything
- *  except the query/pattern positional and each leaf's own result-shaping
- *  flags (search: --body/--sort/--snippet-lines/--full; grep: none). */
-export const filterParams = [
-    { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Search another project\'s record. Default: the calling node\'s cwd (process cwd when not a node). Mutually exclusive with --all-cwds.' },
-    { kind: 'flag', name: 'all-cwds', type: 'bool', required: false, constraint: 'Search every cwd on the canvas. Mutually exclusive with --cwd.' },
-    { kind: 'flag', name: 'under', type: 'string', required: false, constraint: 'Restrict to a node and its subscription descendants (one initiative / sub-DAG).' },
-    { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Restrict to specific node ids. Comma-separated for several.' },
-    { kind: 'flag', name: 'type', type: 'string', required: false, constraint: `Corpus to search; comma-separated for several. One of: ${TYPES.join(', ')}. report = push history; doc = context artifacts; roadmap = roadmap.md specifically; meta = node name/description/kind; inbox = inbox history including full un-clipped direct-message bodies (diagnostic, not curated work). Default: report, doc, roadmap, meta \u2014 inbox is opt-in only, pass --type inbox explicitly.` },
-    { kind: 'flag', name: 'report-kind', type: 'enum', choices: ['final', 'update'], required: false, constraint: 'Narrow reports to outcome summaries (final) or progress (update). Implies --type report.' },
-    { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: `Node kind; comma-separated for several. One of: ${NODE_KINDS.join(', ')}.` },
-    { kind: 'flag', name: 'status', type: 'string', required: false, constraint: `Node lifecycle status; comma-separated for several. One of: ${STATUSES.join(', ')} (e.g. done = completed work only).` },
-    { kind: 'flag', name: 'since', type: 'string', required: false, constraint: 'Lower bound on artifact timestamp. ISO 8601 (2026-06-01) or relative (7d, 2w, 1mo).' },
-    { kind: 'flag', name: 'until', type: 'string', required: false, constraint: 'Upper bound on artifact timestamp. ISO 8601 or relative.' },
-    { kind: 'flag', name: 'origin', type: 'string', required: false, constraint: `What drove a message to arrive; comma-separated for several. One of: ${ORIGINS.join(', ')}. Applies to transcript + inbox artifacts, which are the only ones that arrive — passing it therefore excludes every generated turn on its own. \`unknown\` is a message carrying no stamp, and is its own bucket rather than a fallback.` },
-    { kind: 'flag', name: 'role', type: 'string', required: false, constraint: `Transcript message role; comma-separated for several. One of: ${ROLES.join(', ')}.` },
-    { kind: 'flag', name: 'from', type: 'string', required: false, constraint: 'Case-insensitive substring against sender attribution — the node that sent a delivery. Applies to transcript + inbox artifacts.' },
-];
-/** Parse + validate the shared scope/filter flags from a leaf's raw input.
- *  Pure and client-side; the corpus scan itself runs server-side in crtrd. */
-export function parseFilters(input) {
-    const cwd = input['cwd'];
-    const allCwds = input['allCwds'] === true;
-    if (cwd !== undefined && allCwds)
-        throw usage('--cwd and --all-cwds are mutually exclusive.');
-    const types = splitCsv(input['type']);
-    if (types !== undefined) {
-        const bad = types.find((t) => !TYPES.includes(t));
-        if (bad !== undefined)
-            throw usage(`--type must be one of: ${TYPES.join(', ')}; received: ${bad}`);
-    }
-    const origins = splitCsv(input['origin']);
-    if (origins !== undefined) {
-        const bad = origins.find((o) => !ORIGINS.includes(o));
-        if (bad !== undefined)
-            throw usage(`--origin must be one of: ${ORIGINS.join(', ')}; received: ${bad}`);
-    }
-    const roles = splitCsv(input['role']);
-    if (roles !== undefined) {
-        const bad = roles.find((r) => !ROLES.includes(r));
-        if (bad !== undefined)
-            throw usage(`--role must be one of: ${ROLES.join(', ')}; received: ${bad}`);
-    }
-    // Session files are large and there is no persistent index, so the whole
-    // conversation corpus is reachable only through a narrowed scan. The guard
-    // lives in the failure rather than in a permanently visible constraint:
-    // agents who never search transcripts never pay to understand it.
-    if (types !== undefined && types.includes('transcript')) {
-        const narrowed = input['node'] !== undefined || input['under'] !== undefined || input['since'] !== undefined;
-        if (!narrowed) {
-            throw usage('--type transcript needs a narrowing flag: pass --node, --under, or --since.', { next: 'Transcripts are the full conversation corpus — scanning every node in a cwd reads every session file. Narrow first.' });
-        }
-    }
-    return {
-        cwd,
-        allCwds,
-        under: input['under'],
-        nodes: splitCsv(input['node']),
-        types,
-        reportKind: input['reportKind'],
-        kinds: splitCsv(input['kind']),
-        statuses: splitCsv(input['status']),
-        sinceMs: input['since'] !== undefined ? parseWhen('since', input['since']) : undefined,
-        untilMs: input['until'] !== undefined ? parseWhen('until', input['until']) : undefined,
-        origins,
-        roles,
-        from: input['from'],
-    };
-}
-/** Copy every parsed filter onto a wire query. search, grep, and stats share
- *  the whole filter vocabulary, so the mapping lives once. */
-export function applyFilters(q, f) {
-    if (f.cwd !== undefined)
-        q['cwd'] = f.cwd;
-    if (f.allCwds)
-        q['all_cwds'] = true;
-    if (f.under !== undefined)
-        q['under'] = f.under;
-    if (f.nodes !== undefined)
-        q['nodes'] = f.nodes;
-    if (f.types !== undefined)
-        q['types'] = f.types;
-    if (f.reportKind !== undefined)
-        q['report_kind'] = f.reportKind;
-    if (f.kinds !== undefined)
-        q['kinds'] = f.kinds;
-    if (f.statuses !== undefined)
-        q['statuses'] = f.statuses;
-    if (f.sinceMs !== undefined)
-        q['since_ms'] = f.sinceMs;
-    if (f.untilMs !== undefined)
-        q['until_ms'] = f.untilMs;
-    if (f.origins !== undefined)
-        q['origins'] = f.origins;
-    if (f.roles !== undefined)
-        q['roles'] = f.roles;
-    if (f.from !== undefined)
-        q['from'] = f.from;
-}
+var g=Object.defineProperty;var d=(e,n)=>g(e,"name",{value:n,configurable:!0});import{usage as s}from"../../core/errors.js";const u=["report","doc","roadmap","meta","inbox","transcript"],f=["human","inbox","wake","revive","restart-continuation","stop-guard","park","recovery","context-nudge","kickoff","unknown"],p=["user","assistant","toolResult"],w=["advisor","developer","spec","design","review","explore","plan","general"],y=["active","idle","done","dead","canceled"],h={s:1e3,m:6e4,h:36e5,d:864e5,w:6048e5,mo:2592e6,y:31536e6};function m(e,n){const t=n.match(/^(\d+)(mo|[smhdwy])$/);if(t!==null)return Date.now()-Number(t[1])*h[t[2]];const i=Date.parse(n);if(!Number.isNaN(i))return i;throw s(`--${e} must be ISO 8601 (2026-06-01) or relative (7d, 2w, 1mo); received: ${n}`)}d(m,"parseWhen");function o(e){if(!(e===void 0||e===""))return e.split(",").map(n=>n.trim()).filter(n=>n!=="")}d(o,"splitCsv");const b=[{kind:"flag",name:"cwd",type:"path",required:!1,constraint:"Search another project's record. Default: the calling node's cwd (process cwd when not a node). Mutually exclusive with --all-cwds."},{kind:"flag",name:"all-cwds",type:"bool",required:!1,constraint:"Search every cwd on the canvas. Mutually exclusive with --cwd."},{kind:"flag",name:"under",type:"string",required:!1,constraint:"Restrict to a node and its subscription descendants (one initiative / sub-DAG)."},{kind:"flag",name:"node",type:"string",required:!1,constraint:"Restrict to specific node ids. Comma-separated for several."},{kind:"flag",name:"type",type:"string",required:!1,constraint:`Corpus to search; comma-separated for several. One of: ${u.join(", ")}. report = push history; doc = context artifacts; roadmap = roadmap.md specifically; meta = node name/description/kind; inbox = inbox history including full un-clipped direct-message bodies (diagnostic, not curated work). Default: report, doc, roadmap, meta \u2014 inbox is opt-in only, pass --type inbox explicitly.`},{kind:"flag",name:"report-kind",type:"enum",choices:["final","update"],required:!1,constraint:"Narrow reports to outcome summaries (final) or progress (update). Implies --type report."},{kind:"flag",name:"kind",type:"string",required:!1,constraint:`Node kind; comma-separated for several. One of: ${w.join(", ")}.`},{kind:"flag",name:"status",type:"string",required:!1,constraint:`Node lifecycle status; comma-separated for several. One of: ${y.join(", ")} (e.g. done = completed work only).`},{kind:"flag",name:"since",type:"string",required:!1,constraint:"Lower bound on artifact timestamp. ISO 8601 (2026-06-01) or relative (7d, 2w, 1mo)."},{kind:"flag",name:"until",type:"string",required:!1,constraint:"Upper bound on artifact timestamp. ISO 8601 or relative."},{kind:"flag",name:"origin",type:"string",required:!1,constraint:`What drove a message to arrive; comma-separated for several. One of: ${f.join(", ")}. Applies to transcript + inbox artifacts, which are the only ones that arrive \u2014 passing it therefore excludes every generated turn on its own. \`unknown\` is a message carrying no stamp, and is its own bucket rather than a fallback.`},{kind:"flag",name:"role",type:"string",required:!1,constraint:`Transcript message role; comma-separated for several. One of: ${p.join(", ")}.`},{kind:"flag",name:"from",type:"string",required:!1,constraint:"Case-insensitive substring against sender attribution \u2014 the node that sent a delivery. Applies to transcript + inbox artifacts."}];function x(e){const n=e.cwd,t=e.allCwds===!0;if(n!==void 0&&t)throw s("--cwd and --all-cwds are mutually exclusive.");const i=o(e.type);if(i!==void 0){const r=i.find(a=>!u.includes(a));if(r!==void 0)throw s(`--type must be one of: ${u.join(", ")}; received: ${r}`)}const c=o(e.origin);if(c!==void 0){const r=c.find(a=>!f.includes(a));if(r!==void 0)throw s(`--origin must be one of: ${f.join(", ")}; received: ${r}`)}const l=o(e.role);if(l!==void 0){const r=l.find(a=>!p.includes(a));if(r!==void 0)throw s(`--role must be one of: ${p.join(", ")}; received: ${r}`)}if(i!==void 0&&i.includes("transcript")&&!(e.node!==void 0||e.under!==void 0||e.since!==void 0))throw s("--type transcript needs a narrowing flag: pass --node, --under, or --since.",{next:"Transcripts are the full conversation corpus \u2014 scanning every node in a cwd reads every session file. Narrow first."});return{cwd:n,allCwds:t,under:e.under,nodes:o(e.node),types:i,reportKind:e.reportKind,kinds:o(e.kind),statuses:o(e.status),sinceMs:e.since!==void 0?m("since",e.since):void 0,untilMs:e.until!==void 0?m("until",e.until):void 0,origins:c,roles:l,from:e.from}}d(x,"parseFilters");function _(e,n){n.cwd!==void 0&&(e.cwd=n.cwd),n.allCwds&&(e.all_cwds=!0),n.under!==void 0&&(e.under=n.under),n.nodes!==void 0&&(e.nodes=n.nodes),n.types!==void 0&&(e.types=n.types),n.reportKind!==void 0&&(e.report_kind=n.reportKind),n.kinds!==void 0&&(e.kinds=n.kinds),n.statuses!==void 0&&(e.statuses=n.statuses),n.sinceMs!==void 0&&(e.since_ms=n.sinceMs),n.untilMs!==void 0&&(e.until_ms=n.untilMs),n.origins!==void 0&&(e.origins=n.origins),n.roles!==void 0&&(e.roles=n.roles),n.from!==void 0&&(e.from=n.from)}d(_,"applyFilters");export{w as NODE_KINDS,f as ORIGINS,p as ROLES,y as STATUSES,u as TYPES,_ as applyFilters,b as filterParams,x as parseFilters,m as parseWhen,o as splitCsv};

package/dist/commands/canvas-history/stats.js

@@ -1,68 +1,6 @@
-// `canvas history stats` — the grouped-count projection over the same corpus
-// search and grep scan. A distinct leaf rather than a flag on search because
-// the output shape differs: counts by one dimension, not a hit list. Grouping
-// by origin is what turns the per-message stamps into a census — "what actually
-// drove work here" — without a second command family.
-import { defineLeaf } from '../../core/command.js';
-import { usage } from '../../core/errors.js';
-import { cliClient, rethrowAsCliError } from '../api-client.js';
-import { applyFilters, filterParams, parseFilters } from './shared.js';
-const GROUP_KEYS = ['origin', 'node', 'kind', 'day', 'type', 'role'];
-export const statsLeaf = defineLeaf({
-    name: 'stats',
-    description: 'grouped counts over the cwd\'s node history — the projection view',
-    whenToUse: 'you want the SHAPE of the record rather than individual hits — how much of it came from where, who produced it, or when it happened. Group by origin to census what drove agents to run (cron wakes, inbox deliveries, recovery re-drives, people), by node/kind to see who produced the work, by day for volume over time, by type for corpus composition. Takes every scope and filter `canvas history search` takes, so any query you can search you can also count. Want the matching artifacts themselves? Use `canvas history search` or `canvas history grep`.',
-    help: {
-        name: 'canvas history stats',
-        summary: 'counts by one dimension over the per-cwd episodic record — origin census, per-node volume, activity by day',
-        params: [
-            { kind: 'flag', name: 'group-by', type: 'enum', choices: GROUP_KEYS, required: false, default: 'type', constraint: 'The dimension to count by. origin = what drove an inbound message (transcript + inbox only); role = transcript message role; node / kind = who produced it; day = artifact date; type = corpus composition.' },
-            ...filterParams,
-        ],
-        output: [
-            { name: 'group_by', type: 'string', required: true, constraint: 'The dimension counted.' },
-            { name: 'groups', type: 'object[]', required: true, constraint: '{key, count}, descending by count then key.' },
-            { name: 'total', type: 'int', required: true, constraint: 'Artifacts that carried the grouped dimension. Lower than `scanned` when grouping by one not every artifact has (origin, role).' },
-            { name: 'scanned', type: 'int', required: true, constraint: 'Artifacts matched by the filters before grouping.' },
-        ],
-        outputKind: 'object',
-        effects: ['None. Read-only.'],
-    },
-    run: async (input) => {
-        const by = input['groupBy'] ?? 'type';
-        if (!GROUP_KEYS.includes(by)) {
-            throw usage(`--group-by must be one of: ${GROUP_KEYS.join(', ')}; received: ${by}`);
-        }
-        // Filter validation stays client-side (pure); the corpus scan + grouping
-        // run server-side in crtrd, where canvas.db and the session files live.
-        const f = parseFilters(input);
-        const q = { group_by: by };
-        applyFilters(q, f);
-        try {
-            const res = await cliClient().historyStats(q);
-            return { group_by: res.group_by, groups: res.groups, total: res.total, scanned: res.scanned };
-        }
-        catch (err) {
-            rethrowAsCliError(err);
-        }
-    },
-    render: (r) => {
-        const groups = r['groups'];
-        const by = String(r['group_by']);
-        const total = r['total'];
-        const scanned = r['scanned'];
-        if (groups.length === 0) {
-            return `0 artifacts carried \`${by}\` (${scanned} scanned).`;
-        }
-        const width = Math.max(...groups.map((g) => g.key.length));
-        const max = groups[0].count;
-        const rows = groups
-            .map((g) => {
-            const bar = '█'.repeat(Math.max(1, Math.round((g.count / max) * 24)));
-            return `  ${g.key.padEnd(width)}  ${String(g.count).padStart(6)}  ${bar}`;
-        })
-            .join('\n');
-        const tail = total === scanned ? `${total} artifacts` : `${total} of ${scanned} scanned carried \`${by}\``;
-        return `by ${by}:\n\n${rows}\n\n- ${tail}`;
-    },
-});
+var h=Object.defineProperty;var s=(o,e)=>h(o,"name",{value:e,configurable:!0});import{defineLeaf as m}from"../../core/command.js";import{usage as g}from"../../core/errors.js";import{cliClient as l,rethrowAsCliError as f}from"../api-client.js";import{applyFilters as b,filterParams as w,parseFilters as v}from"./shared.js";const i=["origin","node","kind","day","type","role"],_=m({name:"stats",description:"grouped counts over the cwd's node history \u2014 the projection view",whenToUse:"you want the SHAPE of the record rather than individual hits \u2014 how much of it came from where, who produced it, or when it happened. Group by origin to census what drove agents to run (cron wakes, inbox deliveries, recovery re-drives, people), by node/kind to see who produced the work, by day for volume over time, by type for corpus composition. Takes every scope and filter `canvas history search` takes, so any query you can search you can also count. Want the matching artifacts themselves? Use `canvas history search` or `canvas history grep`.",help:{name:"canvas history stats",summary:"counts by one dimension over the per-cwd episodic record \u2014 origin census, per-node volume, activity by day",params:[{kind:"flag",name:"group-by",type:"enum",choices:i,required:!1,default:"type",constraint:"The dimension to count by. origin = what drove an inbound message (transcript + inbox only); role = transcript message role; node / kind = who produced it; day = artifact date; type = corpus composition."},...w],output:[{name:"group_by",type:"string",required:!0,constraint:"The dimension counted."},{name:"groups",type:"object[]",required:!0,constraint:"{key, count}, descending by count then key."},{name:"total",type:"int",required:!0,constraint:"Artifacts that carried the grouped dimension. Lower than `scanned` when grouping by one not every artifact has (origin, role)."},{name:"scanned",type:"int",required:!0,constraint:"Artifacts matched by the filters before grouping."}],outputKind:"object",effects:["None. Read-only."]},run:s(async o=>{const e=o.groupBy??"type";if(!i.includes(e))throw g(`--group-by must be one of: ${i.join(", ")}; received: ${e}`);const n=v(o),r={group_by:e};b(r,n);try{const t=await l().historyStats(r);return{group_by:t.group_by,groups:t.groups,total:t.total,scanned:t.scanned}}catch(t){f(t)}},"run"),render:s(o=>{const e=o.groups,n=String(o.group_by),r=o.total,t=o.scanned;if(e.length===0)return`0 artifacts carried \`${n}\` (${t} scanned).`;const c=Math.max(...e.map(a=>a.key.length)),d=e[0].count,u=e.map(a=>{const y="\u2588".repeat(Math.max(1,Math.round(a.count/d*24)));return`  ${a.key.padEnd(c)}  ${String(a.count).padStart(6)}  ${y}`}).join(`
+`),p=r===t?`${r} artifacts`:`${r} of ${t} scanned carried \`${n}\``;return`by ${n}:
+
+${u}
+
+- ${p}`},"render")});export{_ as statsLeaf};

package/dist/commands/canvas-history.js

@@ -1,32 +1 @@
-// `canvas history` — search and recall the cwd-wide content corpus: ranked
-// search over every node's reports/context docs, plus reading one hit's full
-// body by ref. One node's own artifact listing lives at `node inspect
-// artifacts` (a single-node read, not a graph-wide one). Distinct from `crtr
-// memory`, which is curated semantic knowledge held independent of any episode.
-// This branch owns CONTENT; it never duplicates the graph (use `node lifecycle
-// revive` to reopen a found node, `node inspect show` for its topology).
-import { envNodeCwd } from '../shared/env.js';
-import { defineBranch } from '../core/command.js';
-import { searchLeaf } from './canvas-history/search.js';
-import { grepLeaf } from './canvas-history/grep.js';
-import { readLeaf } from './canvas-history/read.js';
-import { statsLeaf } from './canvas-history/stats.js';
-/** A tiny per-cwd `<corpus>` marker for branch -h — just enough context to
- *  anchor the help text without scanning nodes or files. Uses only the injected
- *  node cwd env (or the process cwd outside a node), so help stays cheap. */
-function corpusBlock() {
-    const cwd = envNodeCwd() ?? process.cwd();
-    return `<corpus cwd="${cwd}"/>`;
-}
-export const historyBranch = defineBranch({
-    name: 'history',
-    description: 'search and recall the cwd-wide content corpus — every node\'s reports, context docs, and conversations',
-    whenToUse: 'you want to find or re-read what was DONE in a cwd — a past design, a final report, a roadmap, a finding — across every node that ran there, WITHOUT already knowing which node. Use it when picking up prior work ("that caching work from last week"), recovering an artifact, or surveying a project\'s history. Already have the node id and just want everything IT left behind? Use `node inspect artifacts <id>` instead — this branch is the cwd-wide search corpus, not a per-node listing. Distinct from `crtr memory` (curated semantic knowledge, not episodes) and from `canvas dashboard`/`node inspect` (graph topology, not content).',
-    help: {
-        name: 'canvas history',
-        summary: 'search and recall the cwd-wide content corpus — every node\'s reports and context docs in this cwd',
-        model: 'The accumulated record of every node that ran in a cwd and the artifacts it left — its reports (final/update outcome summaries), context docs (specs, designs, roadmaps, findings), and the conversations themselves. `search` finds by content (ranked, filtered, sorted; omit the query to browse by recency); `grep` finds by an exact ECMAScript regex over body lines (pattern required, one hit per matching line — use this over `search` when you know the literal string/pattern, not just the topic); `read` pulls one hit\'s full body by its <node-id>:<relpath> ref, `--format raw` for the verbatim bytes; `stats` counts the same filtered corpus by one dimension instead of listing hits. Corpus is a DIMENSION here, not a location: `--type` selects which record you search, and every leaf takes the same scope and filters. This is the episodic record of what was DONE — distinct from `crtr memory`, which is curated semantic knowledge. Already have a node id and want everything IT left behind (not a cwd-wide search)? Use `node inspect artifacts <node-id>` instead. Two corpora are opt-in diagnostics rather than curated work: `--type inbox` is one node\'s full inbox history including un-clipped message bodies, and `--type transcript` is the conversation itself, message by message, each inbound turn carrying the origin that drove it (`--origin`, `--role`, `--from`, and `stats --group-by origin` for the census). Transcripts require a narrowing flag because there is no index. To reopen a node you found, use `node lifecycle revive`; for its place in the graph, `node inspect show`.',
-        dynamicState: corpusBlock,
-    },
-    children: [searchLeaf, grepLeaf, readLeaf, statsLeaf],
-});
+var n=Object.defineProperty;var t=(e,r)=>n(e,"name",{value:r,configurable:!0});import{envNodeCwd as o}from"../shared/env.js";import{defineBranch as a}from"../core/command.js";import{searchLeaf as s}from"./canvas-history/search.js";import{grepLeaf as i}from"./canvas-history/grep.js";import{readLeaf as d}from"./canvas-history/read.js";import{statsLeaf as c}from"./canvas-history/stats.js";function h(){return`<corpus cwd="${o()??process.cwd()}"/>`}t(h,"corpusBlock");const g=a({name:"history",description:"search and recall the cwd-wide content corpus \u2014 every node's reports, context docs, and conversations",whenToUse:'you want to find or re-read what was DONE in a cwd \u2014 a past design, a final report, a roadmap, a finding \u2014 across every node that ran there, WITHOUT already knowing which node. Use it when picking up prior work ("that caching work from last week"), recovering an artifact, or surveying a project\'s history. Already have the node id and just want everything IT left behind? Use `node inspect artifacts <id>` instead \u2014 this branch is the cwd-wide search corpus, not a per-node listing. Distinct from `crtr memory` (curated semantic knowledge, not episodes) and from `canvas dashboard`/`node inspect` (graph topology, not content).',help:{name:"canvas history",summary:"search and recall the cwd-wide content corpus \u2014 every node's reports and context docs in this cwd",model:"The accumulated record of every node that ran in a cwd and the artifacts it left \u2014 its reports (final/update outcome summaries), context docs (specs, designs, roadmaps, findings), and the conversations themselves. `search` finds by content (ranked, filtered, sorted; omit the query to browse by recency); `grep` finds by an exact ECMAScript regex over body lines (pattern required, one hit per matching line \u2014 use this over `search` when you know the literal string/pattern, not just the topic); `read` pulls one hit's full body by its <node-id>:<relpath> ref, `--format raw` for the verbatim bytes; `stats` counts the same filtered corpus by one dimension instead of listing hits. Corpus is a DIMENSION here, not a location: `--type` selects which record you search, and every leaf takes the same scope and filters. This is the episodic record of what was DONE \u2014 distinct from `crtr memory`, which is curated semantic knowledge. Already have a node id and want everything IT left behind (not a cwd-wide search)? Use `node inspect artifacts <node-id>` instead. Two corpora are opt-in diagnostics rather than curated work: `--type inbox` is one node's full inbox history including un-clipped message bodies, and `--type transcript` is the conversation itself, message by message, each inbound turn carrying the origin that drove it (`--origin`, `--role`, `--from`, and `stats --group-by origin` for the census). Transcripts require a narrowing flag because there is no index. To reopen a node you found, use `node lifecycle revive`; for its place in the graph, `node inspect show`.",dynamicState:h},children:[s,i,d,c]});export{g as historyBranch};

package/dist/commands/canvas-issue.js

@@ -1,149 +1,14 @@
-// `crtr canvas issue new` — capture a quick todo/idea/bug into a GitHub issue.
-//
-// Bound to the alt+c → c → (idea|bug) prefix chord: the menu opens a tmux
-// display-popup that runs this leaf in the originating pane's cwd (the popup is
-// started with `-d #{pane_current_path}`). The leaf:
-//   1. reads a free-text note from the popup's TTY (type, Ctrl-D to submit),
-//   2. asks pi headlessly for a concise issue title (same machinery as node
-//      auto-naming; falls back to the note's first line),
-//   3. files it — `gh issue create --label <type>` when the cwd is a GitHub
-//      repo, else a `<git-root>/.todos/<slug>.md` markdown note with frontmatter,
-//   4. flashes a tmux status-line toast confirming where it landed.
-//
-// The popup is opened with `-E`, so it auto-closes when this leaf exits; the
-// toast is the durable confirmation channel. Prompts/status go to stderr so the
-// rendered result (stdout) stays clean.
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { generateIssueTitle, titleSlug } from '../core/runtime/naming.js';
-import { displayMessage, paneCurrentPath } from '../core/runtime/tmux-chrome.js';
-/** Issue types the capture chord offers — each maps to a GitHub label. */
-const TYPES = {
-    idea: { color: 'a2eeef', description: 'Captured idea / enhancement' },
-    bug: { color: 'd73a4a', description: 'Captured bug report' },
-};
-/** Read the whole note from stdin, TTY or pipe alike, until EOF (Ctrl-D in the
- *  popup). The framework's stdin param can't be used here: it short-circuits to
- *  '' when stdin is a TTY, which is exactly the popup case. */
-function readNote() {
-    return new Promise((resolve) => {
-        const chunks = [];
-        process.stdin.on('data', (c) => chunks.push(c));
-        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-        process.stdin.on('error', () => resolve(Buffer.concat(chunks).toString('utf8')));
-        process.stdin.resume();
-    });
-}
-/** Run a command in `cwd`, capturing stdout. Returns null on any non-zero exit
- *  or spawn failure (so callers can branch on "is this a gh repo"). */
-function run(cmd, args, cwd) {
-    try {
-        const r = spawnSync(cmd, args, { cwd, encoding: 'utf8' });
-        if (r.status !== 0 || typeof r.stdout !== 'string')
-            return null;
-        return r.stdout.trim();
-    }
-    catch {
-        return null;
-    }
-}
-/** The GitHub `owner/repo` for `cwd`, or null when it is not a gh-resolvable
- *  repo (no git remote, no gh auth, gh absent). */
-function ghRepo(cwd) {
-    const r = run('gh', ['repo', 'view', '--json', 'nameWithOwner', '-q', '.nameWithOwner'], cwd);
-    return r !== null && r !== '' ? r : null;
-}
-/** Best-effort: ensure the `<type>` label exists before creating the issue
- *  (gh issue create fails on an unknown label). Ignores "already exists". */
-function ensureLabel(cwd, type) {
-    const { color, description } = TYPES[type];
-    spawnSync('gh', ['label', 'create', type, '--color', color, '--description', description], { cwd, encoding: 'utf8' });
-}
-export const issueNewLeaf = defineLeaf({
-    name: 'new',
-    description: 'capture a todo/idea/bug note into a GitHub issue (or a .todos/ markdown note)',
-    whenToUse: 'the alt+c \u2192 i chord runs this inside a tmux popup; rarely run by hand',
-    tier: 'hidden',
-    help: {
-        name: 'canvas issue new',
-        summary: 'Capture a free-text note as a GitHub issue labeled with its type (idea|bug). Reads the note from the popup TTY, auto-generates the title via a headless pi call, and files it with `gh issue create` when the cwd is a GitHub repo, else writes `<git-root>/.todos/<slug>.md`. Bound to the alt+c \u2192 i prefix chord.',
-        params: [
-            { kind: 'flag', name: 'type', type: 'enum', choices: ['idea', 'bug'], required: true, constraint: 'Issue type / label.' },
-            { kind: 'flag', name: 'body', type: 'string', required: false, constraint: 'The note text. Omit to read it from stdin/the popup TTY (type, Ctrl-D to submit).' },
-            { kind: 'flag', name: 'cwd', type: 'string', required: false, constraint: 'Directory whose repo the issue targets. Defaults to --pane\u2019s path, then process.cwd().' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane whose cwd/client to use for repo resolution and the confirmation toast.' },
-        ],
-        output: [
-            { name: 'created', type: 'boolean', required: true, constraint: 'True when a note was filed.' },
-            { name: 'target', type: 'string', required: false, constraint: 'Where it landed: "github" or "file".' },
-            { name: 'type', type: 'string', required: false, constraint: 'The issue type/label.' },
-            { name: 'title', type: 'string', required: false, constraint: 'The generated issue title.' },
-            { name: 'url', type: 'string', required: false, constraint: 'Issue URL when target is github.' },
-            { name: 'path', type: 'string', required: false, constraint: 'File path when target is file.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Creates a GitHub issue via `gh issue create` (and the label if missing), OR writes a markdown note under `<git-root>/.todos/`.',
-            'Flashes a tmux status-line toast confirming the capture.',
-        ],
-    },
-    run: async (input) => {
-        const type = input['type']?.trim();
-        if (type === undefined || !(type in TYPES)) {
-            throw new InputError({
-                error: 'bad_type',
-                message: `unknown issue type: ${String(input['type'])}`,
-                field: 'type',
-                next: `Valid types: ${Object.keys(TYPES).join(' | ')}.`,
-            });
-        }
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const cwd = input['cwd'] ??
-            (pane !== undefined && pane !== '' ? paneCurrentPath(pane) ?? undefined : undefined) ??
-            process.cwd();
-        let note = input['body'] ?? '';
-        if (note === '') {
-            process.stderr.write(`New ${type} \u2014 type your note, then Ctrl-D to submit (Ctrl-C to cancel):\n\n`);
-            note = await readNote();
-        }
-        note = note.trim();
-        if (note === '') {
-            displayMessage('crtr: nothing captured \u2014 empty note', pane);
-            return { created: false };
-        }
-        process.stderr.write('\nCreating\u2026\n');
-        const title = await generateIssueTitle(note);
-        const repo = ghRepo(cwd);
-        if (repo !== null) {
-            ensureLabel(cwd, type);
-            const url = run('gh', ['issue', 'create', '--title', title, '--body', note, '--label', type], cwd);
-            if (url !== null && url !== '') {
-                displayMessage(`crtr: \u2713 ${type} filed \u2192 ${url}`, pane, 5000);
-                return { created: true, target: 'github', type, title, url };
-            }
-            // gh failed mid-create (e.g. auth/network) — fall through to a local note
-            // so the capture is never lost.
-            process.stderr.write('gh issue create failed; saving a local .todos note instead\n');
-        }
-        // No GitHub repo (or gh failed): write a markdown note at the git root.
-        const root = run('git', ['rev-parse', '--show-toplevel'], cwd) ?? cwd;
-        const dir = join(root, '.todos');
-        const stamp = new Date().toISOString();
-        const fileStamp = stamp.replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
-        const path = join(dir, `${fileStamp}-${titleSlug(title)}.md`);
-        const frontmatter = `---\ntype: ${type}\ntitle: ${JSON.stringify(title)}\ncreated: ${stamp}\nstatus: open\n---\n\n${note}\n`;
-        try {
-            mkdirSync(dir, { recursive: true });
-            writeFileSync(path, frontmatter, 'utf8');
-        }
-        catch (e) {
-            displayMessage(`crtr: failed to save note: ${e.message}`, pane, 5000);
-            throw new InputError({ error: 'write_failed', message: `could not write ${path}`, next: 'Check directory permissions.' });
-        }
-        displayMessage(`crtr: \u2713 ${type} saved \u2192 .todos/${fileStamp}-${titleSlug(title)}.md`, pane, 5000);
-        return { created: true, target: 'file', type, title, path };
-    },
-});
+var T=Object.defineProperty;var a=(t,e)=>T(t,"name",{value:e,configurable:!0});import{spawnSync as h}from"node:child_process";import{mkdirSync as S,writeFileSync as k}from"node:fs";import{join as g}from"node:path";import{defineLeaf as q}from"../core/command.js";import{InputError as w}from"../core/io.js";import{generateIssueTitle as C,titleSlug as y}from"../core/runtime/naming.js";import{displayMessage as u,paneCurrentPath as v}from"../core/runtime/tmux-chrome.js";const d={idea:{color:"a2eeef",description:"Captured idea / enhancement"},bug:{color:"d73a4a",description:"Captured bug report"}};function x(){return new Promise(t=>{const e=[];process.stdin.on("data",r=>e.push(r)),process.stdin.on("end",()=>t(Buffer.concat(e).toString("utf8"))),process.stdin.on("error",()=>t(Buffer.concat(e).toString("utf8"))),process.stdin.resume()})}a(x,"readNote");function l(t,e,r){try{const n=h(t,e,{cwd:r,encoding:"utf8"});return n.status!==0||typeof n.stdout!="string"?null:n.stdout.trim()}catch{return null}}a(l,"run");function O(t){const e=l("gh",["repo","view","--json","nameWithOwner","-q",".nameWithOwner"],t);return e!==null&&e!==""?e:null}a(O,"ghRepo");function j(t,e){const{color:r,description:n}=d[e];h("gh",["label","create",e,"--color",r,"--description",n],{cwd:t,encoding:"utf8"})}a(j,"ensureLabel");const B=q({name:"new",description:"capture a todo/idea/bug note into a GitHub issue (or a .todos/ markdown note)",whenToUse:"the alt+c \u2192 i chord runs this inside a tmux popup; rarely run by hand",tier:"hidden",help:{name:"canvas issue new",summary:"Capture a free-text note as a GitHub issue labeled with its type (idea|bug). Reads the note from the popup TTY, auto-generates the title via a headless pi call, and files it with `gh issue create` when the cwd is a GitHub repo, else writes `<git-root>/.todos/<slug>.md`. Bound to the alt+c \u2192 i prefix chord.",params:[{kind:"flag",name:"type",type:"enum",choices:["idea","bug"],required:!0,constraint:"Issue type / label."},{kind:"flag",name:"body",type:"string",required:!1,constraint:"The note text. Omit to read it from stdin/the popup TTY (type, Ctrl-D to submit)."},{kind:"flag",name:"cwd",type:"string",required:!1,constraint:"Directory whose repo the issue targets. Defaults to --pane\u2019s path, then process.cwd()."},{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane whose cwd/client to use for repo resolution and the confirmation toast."}],output:[{name:"created",type:"boolean",required:!0,constraint:"True when a note was filed."},{name:"target",type:"string",required:!1,constraint:'Where it landed: "github" or "file".'},{name:"type",type:"string",required:!1,constraint:"The issue type/label."},{name:"title",type:"string",required:!1,constraint:"The generated issue title."},{name:"url",type:"string",required:!1,constraint:"Issue URL when target is github."},{name:"path",type:"string",required:!1,constraint:"File path when target is file."}],outputKind:"object",effects:["Creates a GitHub issue via `gh issue create` (and the label if missing), OR writes a markdown note under `<git-root>/.todos/`.","Flashes a tmux status-line toast confirming the capture."]},run:a(async t=>{const e=t.type?.trim();if(e===void 0||!(e in d))throw new w({error:"bad_type",message:`unknown issue type: ${String(t.type)}`,field:"type",next:`Valid types: ${Object.keys(d).join(" | ")}.`});const r=t.pane??process.env.TMUX_PANE,n=t.cwd??(r!==void 0&&r!==""?v(r)??void 0:void 0)??process.cwd();let s=t.body??"";if(s===""&&(process.stderr.write(`New ${e} \u2014 type your note, then Ctrl-D to submit (Ctrl-C to cancel):
+
+`),s=await x()),s=s.trim(),s==="")return u("crtr: nothing captured \u2014 empty note",r),{created:!1};process.stderr.write(`
+Creating\u2026
+`);const i=await C(s);if(O(n)!==null){j(n,e);const o=l("gh",["issue","create","--title",i,"--body",s,"--label",e],n);if(o!==null&&o!=="")return u(`crtr: \u2713 ${e} filed \u2192 ${o}`,r,5e3),{created:!0,target:"github",type:e,title:i,url:o};process.stderr.write(`gh issue create failed; saving a local .todos note instead
+`)}const b=l("git",["rev-parse","--show-toplevel"],n)??n,p=g(b,".todos"),f=new Date().toISOString(),m=f.replace(/[:.]/g,"-").replace("T","_").slice(0,19),c=g(p,`${m}-${y(i)}.md`),$=`---
+type: ${e}
+title: ${JSON.stringify(i)}
+created: ${f}
+status: open
+---
+
+${s}
+`;try{S(p,{recursive:!0}),k(c,$,"utf8")}catch(o){throw u(`crtr: failed to save note: ${o.message}`,r,5e3),new w({error:"write_failed",message:`could not write ${c}`,next:"Check directory permissions."})}return u(`crtr: \u2713 ${e} saved \u2192 .todos/${m}-${y(i)}.md`,r,5e3),{created:!0,target:"file",type:e,title:i,path:c}},"run")});export{B as issueNewLeaf};

package/dist/commands/canvas-prune.js

@@ -1,108 +1 @@
-// `crtr canvas prune` — bounded retention for the node graph.
-//
-// The canvas never deleted a node before this: dead/done/canceled rows + their
-// `nodes/<id>/` dirs accumulated without limit. `prune` is the retention sweep —
-// remove TERMINAL nodes (dead | done | canceled) older than a TTL; the edges→nodes
-// FK (ON DELETE CASCADE) GCs their edges, and each node's dir is removed too.
-// Live nodes (active | idle) and nodes with an open managed worktree are never touched.
-//
-// Exported as a leaf; `crtr canvas` (canvas.ts) mounts it.
-import { defineLeaf } from '../core/command.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-const DEFAULT_TTL_DAYS = 14;
-export const canvasPruneLeaf = defineLeaf({
-    name: 'prune',
-    description: 'remove terminal nodes (dead/done/canceled) older than a TTL',
-    whenToUse: 'you want to bound the canvas\u2019s on-disk growth \u2014 sweep away nodes that are finished (done), crashed (dead), or closed (canceled) and older than a retention window, reclaiming their rows, edges (cascade-deleted by the schema), and `nodes/<id>/` dirs. Run it as an operator/cron chore; live nodes (active/idle) and nodes with an open managed worktree are never touched, and you can preview the sweep before it deletes anything',
-    help: {
-        name: 'canvas prune',
-        summary: 'delete terminal nodes older than a TTL (edges cascade, dirs removed); --max N for a count cap; --dry-run to preview',
-        params: [
-            {
-                kind: 'flag',
-                name: 'max',
-                type: 'int',
-                required: false,
-                constraint: 'COUNT mode (instead of the TTL sweep): keep the N most-recently-active nodes plus every protected node, deleting the oldest remaining terminal nodes. Active/idle nodes regardless of process state and nodes with an open managed worktree are NEVER deleted, so the real floor is max(N, protectedCount). Recency = telemetry.json mtime, falling back to created. Combine with --dry-run to preview.',
-            },
-            {
-                kind: 'flag',
-                name: 'ttl',
-                type: 'int',
-                required: false,
-                default: DEFAULT_TTL_DAYS,
-                constraint: `Retention window in days: only dead/done/canceled nodes created more than this many days ago are pruned, except nodes with an open managed worktree. Default: ${DEFAULT_TTL_DAYS}.`,
-            },
-            {
-                kind: 'flag',
-                name: 'include-stale',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'ALSO prune stale active/idle nodes past the TTL whose process is gone (pi_pid null or dead) — reaps abandoned roots the daemon never reconciled. A genuinely-running node (live pi_pid), a node with an open managed worktree, and the caller are protected.',
-            },
-            {
-                kind: 'flag',
-                name: 'empty',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'Instead of the TTL sweep, reap EMPTY nodes — nodes (of any age or status) whose engine never produced an assistant message, the useless shells that just take up graph + disk space. A node mid-first-turn, the caller, and a node with an open managed worktree are spared. Combine with --dry-run to preview.',
-            },
-            {
-                kind: 'flag',
-                name: 'dry-run',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'Report what WOULD be pruned without deleting anything.',
-            },
-        ],
-        output: [
-            { name: 'pruned', type: 'integer', required: true, constraint: 'How many nodes were pruned (0 under --dry-run since nothing is deleted; the candidate count is in `nodes`).' },
-            { name: 'dryRun', type: 'boolean', required: true, constraint: 'True when nothing was deleted (preview only).' },
-            { name: 'ttlDays', type: 'integer', required: true, constraint: 'The retention window used.' },
-            { name: 'nodes', type: 'object[]', required: true, constraint: 'One per pruned (or, under --dry-run, prunable) node: {node_id,status,created}.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'With --max N: COUNT mode — keep the N most-recently-active nodes plus every protected node, deleting the oldest remaining terminal nodes; active/idle nodes regardless of process state, open-managed-worktree nodes, and the caller are never deleted. Takes precedence over the TTL/--empty sweeps.',
-            'Deletes matching `nodes` rows; their edges cascade-delete via the FK; each node\u2019s `nodes/<id>/` dir is removed. Nodes with an open managed worktree are excluded.',
-            'No-op on live nodes (active/idle), nodes with an open managed worktree, and terminal nodes newer than the TTL. With --include-stale: also deletes active/idle nodes past the TTL whose process is gone (pi_pid null/dead); genuinely-running nodes and the caller are kept.',
-            'Under --dry-run: read-only, deletes nothing.',
-        ],
-    },
-    run: async (input) => {
-        const ttlDays = input['ttl'] ?? DEFAULT_TTL_DAYS;
-        const dryRun = input['dryRun'] ?? false;
-        const includeStale = input['includeStale'] ?? false;
-        const empty = input['empty'] ?? false;
-        const maxNodes = input['max'];
-        // Precedence COUNT (--max) > EMPTY (--empty) > TTL sweep — the server applies
-        // the same order; sending the winning mode keeps it unambiguous. The prune
-        // itself + target-gone notifications run inside crtrd (it owns the feed).
-        const req = { dry_run: dryRun, ttl_days: ttlDays };
-        if (maxNodes !== undefined)
-            req.limit = maxNodes;
-        else if (empty)
-            req.empty = true;
-        else
-            req.include_stale = includeStale;
-        try {
-            const res = await cliClient().prune(req);
-            return {
-                pruned: res.dry_run ? 0 : res.pruned.length,
-                dryRun: res.dry_run,
-                ttlDays: res.ttl_days,
-                nodes: res.pruned.map((p) => ({
-                    node_id: p.node_id,
-                    status: p.status,
-                    created: p.created,
-                })),
-            };
-        }
-        catch (err) {
-            rethrowAsCliError(err);
-        }
-    },
-});
+var u=Object.defineProperty;var s=(e,a)=>u(e,"name",{value:a,configurable:!0});import{defineLeaf as p}from"../core/command.js";import{cliClient as h,rethrowAsCliError as m}from"./api-client.js";const r=14,f=p({name:"prune",description:"remove terminal nodes (dead/done/canceled) older than a TTL",whenToUse:"you want to bound the canvas\u2019s on-disk growth \u2014 sweep away nodes that are finished (done), crashed (dead), or closed (canceled) and older than a retention window, reclaiming their rows, edges (cascade-deleted by the schema), and `nodes/<id>/` dirs. Run it as an operator/cron chore; live nodes (active/idle) and nodes with an open managed worktree are never touched, and you can preview the sweep before it deletes anything",help:{name:"canvas prune",summary:"delete terminal nodes older than a TTL (edges cascade, dirs removed); --max N for a count cap; --dry-run to preview",params:[{kind:"flag",name:"max",type:"int",required:!1,constraint:"COUNT mode (instead of the TTL sweep): keep the N most-recently-active nodes plus every protected node, deleting the oldest remaining terminal nodes. Active/idle nodes regardless of process state and nodes with an open managed worktree are NEVER deleted, so the real floor is max(N, protectedCount). Recency = telemetry.json mtime, falling back to created. Combine with --dry-run to preview."},{kind:"flag",name:"ttl",type:"int",required:!1,default:r,constraint:`Retention window in days: only dead/done/canceled nodes created more than this many days ago are pruned, except nodes with an open managed worktree. Default: ${r}.`},{kind:"flag",name:"include-stale",type:"bool",required:!1,default:!1,constraint:"ALSO prune stale active/idle nodes past the TTL whose process is gone (pi_pid null or dead) \u2014 reaps abandoned roots the daemon never reconciled. A genuinely-running node (live pi_pid), a node with an open managed worktree, and the caller are protected."},{kind:"flag",name:"empty",type:"bool",required:!1,default:!1,constraint:"Instead of the TTL sweep, reap EMPTY nodes \u2014 nodes (of any age or status) whose engine never produced an assistant message, the useless shells that just take up graph + disk space. A node mid-first-turn, the caller, and a node with an open managed worktree are spared. Combine with --dry-run to preview."},{kind:"flag",name:"dry-run",type:"bool",required:!1,default:!1,constraint:"Report what WOULD be pruned without deleting anything."}],output:[{name:"pruned",type:"integer",required:!0,constraint:"How many nodes were pruned (0 under --dry-run since nothing is deleted; the candidate count is in `nodes`)."},{name:"dryRun",type:"boolean",required:!0,constraint:"True when nothing was deleted (preview only)."},{name:"ttlDays",type:"integer",required:!0,constraint:"The retention window used."},{name:"nodes",type:"object[]",required:!0,constraint:"One per pruned (or, under --dry-run, prunable) node: {node_id,status,created}."}],outputKind:"object",effects:["With --max N: COUNT mode \u2014 keep the N most-recently-active nodes plus every protected node, deleting the oldest remaining terminal nodes; active/idle nodes regardless of process state, open-managed-worktree nodes, and the caller are never deleted. Takes precedence over the TTL/--empty sweeps.","Deletes matching `nodes` rows; their edges cascade-delete via the FK; each node\u2019s `nodes/<id>/` dir is removed. Nodes with an open managed worktree are excluded.","No-op on live nodes (active/idle), nodes with an open managed worktree, and terminal nodes newer than the TTL. With --include-stale: also deletes active/idle nodes past the TTL whose process is gone (pi_pid null/dead); genuinely-running nodes and the caller are kept.","Under --dry-run: read-only, deletes nothing."]},run:s(async e=>{const a=e.ttl??r,i=e.dryRun??!1,l=e.includeStale??!1,c=e.empty??!1,o=e.max,t={dry_run:i,ttl_days:a};o!==void 0?t.limit=o:c?t.empty=!0:t.include_stale=l;try{const n=await h().prune(t);return{pruned:n.dry_run?0:n.pruned.length,dryRun:n.dry_run,ttlDays:n.ttl_days,nodes:n.pruned.map(d=>({node_id:d.node_id,status:d.status,created:d.created}))}}catch(n){m(n)}},"run")});export{f as canvasPruneLeaf};