@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/runtime/kickoff.js

@@ -1,327 +1,30 @@
-// The revive kickoff — the message auto-injected as a node's first turn when it
-// comes back FRESH (a refresh-yield, or `node lifecycle revive --fresh`). The node's
-// in-memory context is gone, so this message IS its bearings: everything is
-// read from disk and framed so the node can rebuild and continue without a
-// round-trip. Resuming a saved conversation needs none of this (the
-// conversation already holds the context).
-//
-// Layout (the framing a revived node sees), all of it inside one
-// <runtime kind="revive" …> card envelope:
-//   <roadmap file=…>…</roadmap>            its evolving plan — the source of truth
-//   <context-dir path=…>…</context-dir>    what artifacts exist on disk
-//   <feed>Awaiting N nodes … digest</feed> live wait state + unread/catch-up feed
-//   <yield-message>…</yield-message>       the note its prior self left on yield
-//
-// The roadmap (NOT the original spawn prompt) carries the goal on a refresh: its
-// frozen core holds goal + exit criteria, its body the live plan. context/
-// initial-prompt.md is NEVER injected into a node's prompts — it lives on disk
-// purely as a log of the original mandate; by the time a node is running it is
-// usually stale, and the roadmap is the doc the node keeps current. The
-// yield-message is one-shot (cleared when session_start confirms the revive).
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, readdirSync, } from 'node:fs';
-import { join } from 'node:path';
-import { contextDir, reportsDir, getNode, subscriptionsOf, subscribersOf, } from '../canvas/index.js';
-import { activeBackgroundBashJobs, bashJobCommandLine, formatBashElapsed } from '../bash-jobs.js';
-import { readRoadmap, roadmapPath } from './roadmap.js';
-import { buildWakeBearings } from './bearings.js';
-import { personaDrift } from './persona.js';
-import { coalesce, nodeMailEntry } from '../feed/inbox.js';
-import { claimKickoffMail } from '../canvas/deliveries.js';
-import { formatCard } from '../../shared/generated-context.js';
-/** The runtime-restart continuation exactly as delivered. `revive.ts` injects
- *  it as the prompt of a strict resume that follows a cleanly aborted turn. */
-export const RUNTIME_RESTART_CONTINUATION = formatCard('restart-continuation', {}, 'continue');
-// Companion context files: the goal (the spawning mandate) and the one-shot
-// yield message (a note from the prior self to the revived self).
-/** The goal file — the prompt/task a node was spawned with, persisted at birth
- *  so a fresh revive can re-read its mandate. */
-export function goalPath(nodeId) {
-    return join(contextDir(nodeId), 'initial-prompt.md');
-}
-export function readGoal(nodeId) {
-    const p = goalPath(nodeId);
-    return existsSync(p) ? readFileSync(p, 'utf8') : null;
-}
-/** Persist the spawning prompt as the node's goal. No-op for an empty prompt
- *  (e.g. a bare root). Idempotent enough — call once at spawn/boot. */
-export function writeGoal(nodeId, text) {
-    const body = text.trim();
-    if (body === '')
-        return;
-    mkdirSync(contextDir(nodeId), { recursive: true });
-    writeFileSync(goalPath(nodeId), body + '\n', 'utf8');
-}
-/** Write the goal ONLY if the node has none yet. This is how a bare root (no
- *  spawn prompt) acquires its mandate: the first real user message becomes the
- *  goal. Returns true when it wrote one, false when a goal already existed or
- *  the text was empty. Guarded so a later message never clobbers the mandate. */
-export function captureGoalIfAbsent(nodeId, text) {
-    const existing = readGoal(nodeId);
-    if (existing !== null && existing.trim() !== '')
-        return false;
-    const body = text.trim();
-    if (body === '')
-        return false;
-    writeGoal(nodeId, body);
-    return true;
-}
-/** The yield-message file — a short note `crtr node yield` records for the next
- *  fresh/cycling revive ("on wake, do X"). It remains durable through failed
- *  launch attempts and is cleared only when session_start confirms a boot. */
-export function yieldMessagePath(nodeId) {
-    return join(contextDir(nodeId), 'yield-message.md');
-}
-export function writeYieldMessage(nodeId, text) {
-    const body = text.trim();
-    if (body === '')
-        return;
-    mkdirSync(contextDir(nodeId), { recursive: true });
-    writeFileSync(yieldMessagePath(nodeId), body + '\n', 'utf8');
-}
-/** Read the pending yield message without mutating its confirmation state. */
-export function readYieldMessage(nodeId) {
-    const p = yieldMessagePath(nodeId);
-    if (!existsSync(p))
-        return null;
-    const body = readFileSync(p, 'utf8').trim();
-    return body !== '' ? body : null;
-}
-/** Idempotently commit delivery of the yield message after a confirmed boot. */
-export function clearYieldMessage(nodeId) {
-    try {
-        rmSync(yieldMessagePath(nodeId));
-    }
-    catch { /* best-effort */ }
-}
-/** List the node's context/ dir (filenames, sorted). Empty when absent. */
-export function listContextDir(nodeId) {
-    const dir = contextDir(nodeId);
-    if (!existsSync(dir))
-        return [];
-    return readdirSync(dir).sort();
-}
-/** A retained report proves this node has already done work. It must restart
- * from current context, never by replaying its birth mandate. */
-export function hasRetainedReports(nodeId) {
-    const dir = reportsDir(nodeId);
-    return existsSync(dir) && readdirSync(dir).some((file) => file.endsWith('.md'));
-}
-/** Claim wake mail for this launch without acknowledging it before a turn. */
-export function drainBearings(meta, executionId) {
-    const nodeId = meta.node_id;
-    // The note stays on disk until session_start confirms this launch.
-    const yieldMsg = readYieldMessage(nodeId);
-    const entries = claimKickoffMail(nodeId, executionId).map(nodeMailEntry);
-    let unreadDigest = null;
-    if (entries.length > 0) {
-        // The launch argv carries one message. Keep coalescing card-free runs, but
-        // start a new batch at each entry with cards. A batch's cards are therefore
-        // directly ahead of its coalesced text, so they cannot leap an earlier body.
-        const cardsFor = (entry) => {
-            const cards = entry.data?.['cards'];
-            return Array.isArray(cards) ? cards.filter((card) => typeof card === 'string') : [];
-        };
-        const segments = [];
-        for (const entry of entries) {
-            if (cardsFor(entry).length > 0 || segments.length === 0)
-                segments.push([]);
-            segments.at(-1).push(entry);
-        }
-        unreadDigest = segments.map((segment) => [
-            ...cardsFor(segment[0]),
-            coalesce(segment).map((delivery) => delivery.text).join('\n\n'),
-        ].join('\n\n')).join('\n\n');
-    }
-    const drift = personaDrift(nodeId);
-    const driftGuidance = drift?.guidance === undefined || drift.guidance === ''
-        ? null
-        : drift.guidance;
-    return { yieldMsg, unreadDigest, driftGuidance };
-}
-// Fresh-revive catch-up bug: on a refresh-yield (resume:false) the old
-// conversation is gone AND earlier deliveries are already acknowledged,
-// so the revived node loses sight of reports its
-// subscriptions pushed BEFORE the yield. The bodies are never lost — they persist
-// at reports/<ts>-<kind>.md forever — but a fresh revive needs a bounded index
-// that says history exists and how to expand it, not every path preloaded.
-const REPORT_HISTORY_SOURCE_CAP = 8;
-function reportKind(filename) {
-    return filename.match(/^[0-9]{8}T[0-9]{6}-(.+)\.md$/)?.[1] ?? 'report';
-}
-/** Condensed report-history index for each ACTIVE subscription of `nodeId` —
- *  independent of publisher liveness, so a finished worker's history still
- *  surfaces for catch-up. Each source carries only its count and newest report
- *  ref; older refs stay one command away via `node inspect artifacts`. */
-function reportHistorySources(nodeId) {
-    const out = [];
-    for (const sub of subscriptionsOf(nodeId).filter((s) => s.active)) {
-        const dir = reportsDir(sub.node_id);
-        if (!existsSync(dir))
-            continue;
-        const files = readdirSync(dir)
-            .filter((f) => f.endsWith('.md'))
-            .sort() // YYYYMMDDTHHmmss-<kind>.md — lexical sort = chronological
-            .reverse(); // most recent first
-        if (files.length === 0)
-            continue;
-        const pub = getNode(sub.node_id);
-        out.push({
-            nodeId: sub.node_id,
-            name: pub?.name ?? sub.node_id,
-            count: files.length,
-            latest: files[0],
-        });
-    }
-    return out.sort((a, b) => b.latest.localeCompare(a.latest));
-}
-/** Render the <feed> block PURELY: the live "awaiting" roster (a read), the
- *  already-drained unread digest (from drainBearings), and a progressive index
- *  to on-disk report history. No delivery mutation. */
-function feedBlock(nodeId, unreadDigest) {
-    // Awaiting = active subscriptions whose publisher is still live (active|idle).
-    const awaiting = subscriptionsOf(nodeId)
-        .filter((s) => s.active)
-        .map((s) => getNode(s.node_id))
-        .filter((m) => m !== null && (m.status === 'active' || m.status === 'idle'));
-    const lines = [];
-    if (awaiting.length > 0) {
-        const n = awaiting.length;
-        const subj = n === 1 ? 'it is' : 'they are';
-        const pron = n === 1 ? 'it' : 'they';
-        const verb = n === 1 ? 'pushes' : 'push';
-        // State aliveness + the automatic wake at the source explicitly, so there is
-        // no reason to check, poll, or verify separately.
-        lines.push(`Awaiting ${n} node${n === 1 ? '' : 's'} — ${subj} alive and running right now, and will wake you the moment ${pron} ${verb}. The wake is automatic; nothing to check, poll, or verify.`);
-        for (const m of awaiting)
-            lines.push(`  - ${m.name} (${m.node_id}) — ${m.status}`);
-        lines.push('', unreadDigest ??
-            '(no unread reports yet — expected while they run: a worker leaves no pointer until it pushes, so an empty feed means still working, not stalled)');
-    }
-    else {
-        lines.push('Awaiting 0 nodes.');
-        lines.push('', unreadDigest ?? '(no unread reports)');
-    }
-    // Include a bounded history index because acknowledged reports are absent
-    // from the unread digest after a refresh.
-    const history = reportHistorySources(nodeId);
-    if (history.length > 0) {
-        const visible = history.slice(0, REPORT_HISTORY_SOURCE_CAP);
-        const hidden = history.length - visible.length;
-        const total = history.reduce((sum, h) => sum + h.count, 0);
-        lines.push('', `Report history on disk (collapsed): ${total} report${total === 1 ? '' : 's'} across ${history.length} subscribed node${history.length === 1 ? '' : 's'}. This is a catch-up index for earlier reports; read only what matters.`, ...visible.map((h) => {
-            const ref = `${h.nodeId}:reports/${h.latest}`;
-            return `  - ${h.name} (${h.nodeId}): ${h.count} report${h.count === 1 ? '' : 's'}; latest ${reportKind(h.latest)}: ${ref}`;
-        }), ...(hidden > 0 ? [`  - … ${hidden} more subscribed node${hidden === 1 ? '' : 's'} with reports hidden`] : []), 'Expand: `crtr canvas history read <ref>` for one listed report; `crtr node inspect artifacts <node-id> --type report` for that node\'s full report list; `crtr node inspect artifacts <node-id> --type inbox` for retained inbox history including full message bodies.');
-    }
-    return `<feed>\n${lines.join('\n')}\n</feed>`;
-}
-/** One-line label for a job: its purpose when the caller gave one, else its real
- *  command line, clipped so a long pipeline stays scannable. */
-function jobLabel(purpose, command) {
-    const raw = (purpose ?? bashJobCommandLine(command)).trim() || '(no command)';
-    return raw.length > 120 ? `${raw.slice(0, 117)}…` : raw;
-}
-/** Live file-backed background bash jobs this node owns. A fresh revive has no
- *  memory of handing anything off, so without this block the node cannot tell a
- *  command it started is still running: it can neither read the log nor decide
- *  whether to wait, and may relaunch the same work. Returns null — and the
- *  kickoff omits the block entirely — when nothing is live. */
-function backgroundJobsBlock(nodeId) {
-    const jobs = activeBackgroundBashJobs(contextDir(nodeId));
-    if (jobs.length === 0)
-        return null;
-    const now = Date.now();
-    const one = jobs.length === 1;
-    const lines = [
-        `${jobs.length} background bash job${one ? '' : 's'} you started ${one ? 'is' : 'are'} STILL RUNNING, detached from any turn and unaffected by your refresh. ` +
-            `Each one sends you a message when it exits — that wake is automatic, so do not poll it and do not relaunch the same command.`,
-    ];
-    for (const job of jobs) {
-        lines.push(`  - ${job.jobId} — ${jobLabel(job.purpose, job.command)} · running ${formatBashElapsed(now - job.startedAtMs)} · log ${job.logPath}`);
-    }
-    lines.push('', 'Read output so far: `tail -n 50 <log>` (or `crtr node bash list --tail 20`). Abandon one: `crtr node bash kill <job-id>`.');
-    return `<background-jobs>\n${lines.join('\n')}\n</background-jobs>`;
-}
-// buildReviveKickoff — assemble the full fresh-revive first message.
-/** Assemble the auto-injected first message for a FRESH revive of `meta` from its
- *  already-drained `bearings` (see drainBearings) plus pure on-disk reads of the
- *  node's goal, roadmap, and context dir, framed so the revived node can rebuild
- *  its bearings in one turn. PURE: no state mutation, so calling it twice yields
- *  the same string and consumes nothing — drainBearings owns the one-shot reads. */
-export function buildReviveKickoff(meta, bearings, wakeReason) {
-    const nodeId = meta.node_id;
-    const parts = [
-        'You have been revived fresh after a context refresh — your previous in-memory ' +
-            'context is gone, by design. Everything below was just read from disk; it is your ' +
-            'full bearings. Rebuild from it and continue toward your goal.',
-    ];
-    // Wake provenance (Invariant B/D): when a scheduled bare self-alarm fired this
-    // revive, the <crtr-wake> block reframes the generic "you were revived" above
-    // into "a TIMER woke you" — placed before the roadmap/disk bearings, so "why you
-    // woke" precedes "what to rebuild from". Only the daemon's bare-wake branch
-    // passes wakeReason.
-    if (wakeReason !== undefined)
-        parts.push(buildWakeBearings(wakeReason));
-    // The roadmap is the source of truth on a fresh revive: its frozen core holds
-    // the goal/exit criteria, its body the live plan the node kept current. The
-    // original spawn prompt (context/initial-prompt.md) is deliberately NOT injected
-    // — it lives on disk only as a log, and by now it is usually stale.
-    const roadmap = readRoadmap(nodeId);
-    const hasRoadmapBody = roadmap !== null && roadmap.trim() !== '';
-    parts.push(`<roadmap file="${roadmapPath(nodeId)}">\n${hasRoadmapBody ? roadmap.trim() : '(no roadmap on disk yet)'}\n</roadmap>`);
-    // With NO roadmap the kickoff above carries no mandate at all, and an
-    // amnesiac fresh boot just stops (and is auto-finalized by the stop-guard) —
-    // observed when the daemon relaunches a spawned-but-never-launched node
-    // (audit 2026-06-09, Bug 4: mq45b6ch-9ecc2f03), whose only mandate on disk IS
-    // the goal. Surface the goal then. When a roadmap exists it stays the sole
-    // source of truth (the goal is usually stale by comparison) — unchanged.
-    if (!hasRoadmapBody && !hasRetainedReports(nodeId)) {
-        const goal = readGoal(nodeId);
-        if (goal !== null && goal.trim() !== '') {
-            parts.push(`<goal file="${goalPath(nodeId)}">\n${goal.trim()}\n</goal>`);
-        }
-    }
-    // The yield note is retained on disk until confirmed boot so a pre-session_start
-    // retry can replay it, but its addressable delivery is the inline block below.
-    const files = listContextDir(nodeId).filter((file) => file !== 'yield-message.md');
-    parts.push(`<context-dir path="${contextDir(nodeId)}">\n${files.length > 0 ? files.join('\n') : '(empty)'}\n</context-dir>`);
-    // Hidden applet/situation-origin ambient context (see situational-context.ts)
-    // is deliberately NOT injected here — this kickoff is the VISIBLE revive prompt.
-    // canvas-context-intro's session_start handler re-fires on every fresh/cycling
-    // revive (a new pi process boot) and re-injects buildContextIntro(), whose
-    // bearings body already nests the stored situational card; that seam covers
-    // this path, so duplicating it here would both repeat the card and put hidden
-    // ambient context into a visible prompt.
-    // Live background bash jobs sit beside the context-dir listing: both describe
-    // this node's OWN in-flight state, and both precede <feed>, which is about the
-    // other nodes it awaits. Absent when nothing is running.
-    const jobsBlock = backgroundJobsBlock(nodeId);
-    if (jobsBlock !== null)
-        parts.push(jobsBlock);
-    parts.push(feedBlock(nodeId, bearings.unreadDigest));
-    parts.push(bearings.yieldMsg !== null
-        ? `<yield-message>\n${bearings.yieldMsg.trim()}\n</yield-message>`
-        : '<yield-message/>');
-    // A node that reports UP the spine (has subscribers awaiting its result)
-    // finishes with `push final`. A human-attended node (no subscribers — a root
-    // conversation working directly with the user) has no result to submit and
-    // must not be told to finish: it stays resident and keeps working with the
-    // user.
-    const reportsUp = subscribersOf(nodeId).length > 0;
-    parts.push(reportsUp
-        ? "If there is work to do, perform it. Otherwise stop — pipe the result to `crtr push final` through a single-quoted heredoc " +
-            'if the goal is met, or end your turn to stay dormant awaiting your workers.'
-        : 'If there is work to do, perform it. Otherwise end your turn — you are working ' +
-            'directly with the user, so stay available and continue the conversation when they ' +
-            'write back.');
-    // Non-document framing for a persona change made while the node was away.
-    // The replacement context's current snapshots carry all eligible documents;
-    // context-intro acknowledges the transition after those snapshots persist.
-    if (bearings.driftGuidance !== null) {
-        parts.push(`<persona-transition>\nYour role was changed while you were away. ${bearings.driftGuidance}\n</persona-transition>`);
-    }
-    // The envelope keeps a fresh revive out of canvas-goal-capture's
-    // first-real-input path, which would otherwise overwrite a bare root's
-    // mandate and rename it.
-    return formatCard('revive', {}, `\n${parts.join('\n\n')}\n`);
-}
+var M=Object.defineProperty;var s=(e,t)=>M(e,"name",{value:t,configurable:!0});import{existsSync as p,readFileSync as b,writeFileSync as $,rmSync as S,mkdirSync as w,readdirSync as m}from"node:fs";import{join as x}from"node:path";import{contextDir as f,reportsDir as k,getNode as v,subscriptionsOf as j,subscribersOf as T}from"../canvas/index.js";import{activeBackgroundBashJobs as A,bashJobCommandLine as B,formatBashElapsed as E}from"../bash-jobs.js";import{readRoadmap as O,roadmapPath as N}from"./roadmap.js";import{buildWakeBearings as C}from"./bearings.js";import{personaDrift as G}from"./persona.js";import{coalesce as D,nodeMailEntry as P}from"../feed/inbox.js";import{claimKickoffMail as Y}from"../canvas/deliveries.js";import{formatCard as R}from"../../shared/generated-context.js";const dt=R("restart-continuation",{},"continue");function g(e){return x(f(e),"initial-prompt.md")}s(g,"goalPath");function _(e){const t=g(e);return p(t)?b(t,"utf8"):null}s(_,"readGoal");function U(e,t){const n=t.trim();n!==""&&(w(f(e),{recursive:!0}),$(g(e),n+`
+`,"utf8"))}s(U,"writeGoal");function ut(e,t){const n=_(e);if(n!==null&&n.trim()!=="")return!1;const o=t.trim();return o===""?!1:(U(e,o),!0)}s(ut,"captureGoalIfAbsent");function y(e){return x(f(e),"yield-message.md")}s(y,"yieldMessagePath");function ct(e,t){const n=t.trim();n!==""&&(w(f(e),{recursive:!0}),$(y(e),n+`
+`,"utf8"))}s(ct,"writeYieldMessage");function L(e){const t=y(e);if(!p(t))return null;const n=b(t,"utf8").trim();return n!==""?n:null}s(L,"readYieldMessage");function lt(e){try{S(y(e))}catch{}}s(lt,"clearYieldMessage");function F(e){const t=f(e);return p(t)?m(t).sort():[]}s(F,"listContextDir");function J(e){const t=k(e);return p(t)&&m(t).some(n=>n.endsWith(".md"))}s(J,"hasRetainedReports");function ft(e,t){const n=e.node_id,o=L(n),i=Y(n,t).map(P);let r=null;if(i.length>0){const a=s(c=>{const h=c.data?.cards;return Array.isArray(h)?h.filter(I=>typeof I=="string"):[]},"cardsFor"),u=[];for(const c of i)(a(c).length>0||u.length===0)&&u.push([]),u.at(-1).push(c);r=u.map(c=>[...a(c[0]),D(c).map(h=>h.text).join(`
+
+`)].join(`
+
+`)).join(`
+
+`)}const d=G(n),l=d?.guidance===void 0||d.guidance===""?null:d.guidance;return{yieldMsg:o,unreadDigest:r,driftGuidance:l}}s(ft,"drainBearings");const K=8;function W(e){return e.match(/^[0-9]{8}T[0-9]{6}-(.+)\.md$/)?.[1]??"report"}s(W,"reportKind");function H(e){const t=[];for(const n of j(e).filter(o=>o.active)){const o=k(n.node_id);if(!p(o))continue;const i=m(o).filter(d=>d.endsWith(".md")).sort().reverse();if(i.length===0)continue;const r=v(n.node_id);t.push({nodeId:n.node_id,name:r?.name??n.node_id,count:i.length,latest:i[0]})}return t.sort((n,o)=>o.latest.localeCompare(n.latest))}s(H,"reportHistorySources");function q(e,t){const n=j(e).filter(r=>r.active).map(r=>v(r.node_id)).filter(r=>r!==null&&(r.status==="active"||r.status==="idle")),o=[];if(n.length>0){const r=n.length,d=r===1?"it is":"they are",l=r===1?"it":"they",a=r===1?"pushes":"push";o.push(`Awaiting ${r} node${r===1?"":"s"} \u2014 ${d} alive and running right now, and will wake you the moment ${l} ${a}. The wake is automatic; nothing to check, poll, or verify.`);for(const u of n)o.push(`  - ${u.name} (${u.node_id}) \u2014 ${u.status}`);o.push("",t??"(no unread reports yet \u2014 expected while they run: a worker leaves no pointer until it pushes, so an empty feed means still working, not stalled)")}else o.push("Awaiting 0 nodes."),o.push("",t??"(no unread reports)");const i=H(e);if(i.length>0){const r=i.slice(0,K),d=i.length-r.length,l=i.reduce((a,u)=>a+u.count,0);o.push("",`Report history on disk (collapsed): ${l} report${l===1?"":"s"} across ${i.length} subscribed node${i.length===1?"":"s"}. This is a catch-up index for earlier reports; read only what matters.`,...r.map(a=>{const u=`${a.nodeId}:reports/${a.latest}`;return`  - ${a.name} (${a.nodeId}): ${a.count} report${a.count===1?"":"s"}; latest ${W(a.latest)}: ${u}`}),...d>0?[`  - \u2026 ${d} more subscribed node${d===1?"":"s"} with reports hidden`]:[],"Expand: `crtr canvas history read <ref>` for one listed report; `crtr node inspect artifacts <node-id> --type report` for that node's full report list; `crtr node inspect artifacts <node-id> --type inbox` for retained inbox history including full message bodies.")}return`<feed>
+${o.join(`
+`)}
+</feed>`}s(q,"feedBlock");function z(e,t){const n=(e??B(t)).trim()||"(no command)";return n.length>120?`${n.slice(0,117)}\u2026`:n}s(z,"jobLabel");function Q(e){const t=A(f(e));if(t.length===0)return null;const n=Date.now(),o=t.length===1,i=[`${t.length} background bash job${o?"":"s"} you started ${o?"is":"are"} STILL RUNNING, detached from any turn and unaffected by your refresh. Each one sends you a message when it exits \u2014 that wake is automatic, so do not poll it and do not relaunch the same command.`];for(const r of t)i.push(`  - ${r.jobId} \u2014 ${z(r.purpose,r.command)} \xB7 running ${E(n-r.startedAtMs)} \xB7 log ${r.logPath}`);return i.push("","Read output so far: `tail -n 50 <log>` (or `crtr node bash list --tail 20`). Abandon one: `crtr node bash kill <job-id>`."),`<background-jobs>
+${i.join(`
+`)}
+</background-jobs>`}s(Q,"backgroundJobsBlock");function pt(e,t,n){const o=e.node_id,i=["You have been revived fresh after a context refresh \u2014 your previous in-memory context is gone, by design. Everything below was just read from disk; it is your full bearings. Rebuild from it and continue toward your goal."];n!==void 0&&i.push(C(n));const r=O(o),d=r!==null&&r.trim()!=="";if(i.push(`<roadmap file="${N(o)}">
+${d?r.trim():"(no roadmap on disk yet)"}
+</roadmap>`),!d&&!J(o)){const c=_(o);c!==null&&c.trim()!==""&&i.push(`<goal file="${g(o)}">
+${c.trim()}
+</goal>`)}const l=F(o).filter(c=>c!=="yield-message.md");i.push(`<context-dir path="${f(o)}">
+${l.length>0?l.join(`
+`):"(empty)"}
+</context-dir>`);const a=Q(o);a!==null&&i.push(a),i.push(q(o,t.unreadDigest)),i.push(t.yieldMsg!==null?`<yield-message>
+${t.yieldMsg.trim()}
+</yield-message>`:"<yield-message/>");const u=T(o).length>0;return i.push(u?"If there is work to do, perform it. Otherwise stop \u2014 pipe the result to `crtr push final` through a single-quoted heredoc if the goal is met, or end your turn to stay dormant awaiting your workers.":"If there is work to do, perform it. Otherwise end your turn \u2014 you are working directly with the user, so stay available and continue the conversation when they write back."),t.driftGuidance!==null&&i.push(`<persona-transition>
+Your role was changed while you were away. ${t.driftGuidance}
+</persona-transition>`),R("revive",{},`
+${i.join(`
+
+`)}
+`)}s(pt,"buildReviveKickoff");export{dt as RUNTIME_RESTART_CONTINUATION,pt as buildReviveKickoff,ut as captureGoalIfAbsent,lt as clearYieldMessage,ft as drainBearings,g as goalPath,J as hasRetainedReports,F as listContextDir,_ as readGoal,L as readYieldMessage,U as writeGoal,ct as writeYieldMessage,y as yieldMessagePath};

package/dist/core/runtime/launch-config-worker.js

@@ -1,12 +1 @@
-// Runs the synchronous configuration resolver outside crtrd's process. A
-// network filesystem can block a native read indefinitely; unlike a worker
-// thread, this subprocess can be killed at the launch-config timeout.
-import { readMergedLaunchConfig } from '../config.js';
-process.once('message', (message) => {
-    try {
-        process.send?.({ config: readMergedLaunchConfig(message.cwd, message.profileId) });
-    }
-    catch (error) {
-        process.send?.({ error: error instanceof Error ? error.message : String(error) });
-    }
-});
+import{readMergedLaunchConfig as o}from"../config.js";process.once("message",e=>{try{process.send?.({config:o(e.cwd,e.profileId)})}catch(r){process.send?.({error:r instanceof Error?r.message:String(r)})}});

package/dist/core/runtime/launch-prompt.js

@@ -1,13 +1,4 @@
-// launch-prompt.ts — the minimal static system-prompt scaffold, isolated from
-// launch.ts so CLI consumers (`sys context prompt-review`) can import the exact string
-// boot uses WITHOUT pulling launch.ts's canvas-db reach (editorLabel et al.).
-// Pure: zero imports.
-/** The minimal static system prompt every node launches with — a thin launcher
- *  frame keeping the `\n\nGuidelines:` anchor the `before_agent_start` substrate
- *  hook (canvas-doc-substrate.ts) splices its `<memory kind="preference">` block
- *  before. ALL runtime/spine/lifecycle/kind prompting now lives as gated builtin
- *  memory docs (src/builtin-memory/), spliced in fresh every turn — this scaffold
- *  must never duplicate that prose. Imported by launch.ts (its own systemPrompt)
- *  and `sys context prompt-review` so the two can never drift. */
-export const LAUNCH_SYSTEM_PROMPT = 'You are a node in the crtr canvas — an agentic runtime.\n\nGuidelines:\n' +
-    '- Use the crtr canvas and memory substrate according to injected context.';
+const n=`You are a node in the crtr canvas \u2014 an agentic runtime.
+
+Guidelines:
+- Use the crtr canvas and memory substrate according to injected context.`;export{n as LAUNCH_SYSTEM_PROMPT};

package/dist/core/runtime/launch-target.js

@@ -1,55 +1 @@
-import { envProfileId } from '../../shared/env.js';
-import { resolve } from 'node:path';
-import { getNode } from '../canvas/canvas.js';
-import { usage } from '../errors.js';
-import { assertProfileActive, profileHome } from '../profiles/manifest.js';
-import { buildLaunchSpecAsync, readMergedLaunchConfigAsync } from './launch.js';
-import { resolveProfileId } from './spawn.js';
-export function resolveCreateKind(kind, profile) {
-    return kind ?? profile?.manifest.default_kind ?? 'general';
-}
-/** Validate a kind against the same cwd/profile configuration used to build its launch.
- *  Resolution is subprocess-isolated: crtrd is single-threaded and a config read can
- *  block indefinitely on a network filesystem. */
-export async function assertLaunchKind(kind, cwd = process.cwd(), profileId = envProfileId() || null) {
-    const kinds = Object.keys((await readMergedLaunchConfigAsync(cwd, profileId)).kinds);
-    if (!kinds.includes(kind)) {
-        throw usage(`unknown kind: ${kind}`, { received: kind, next: `Valid kinds: ${kinds.sort().join(', ')}.` });
-    }
-}
-/** Resolve the exact profile, kind, cwd, mode and launch recipe a create will use. */
-export async function resolveLaunchTarget(req, options = {}) {
-    const parent = req.parent ?? undefined;
-    const contextCwd = req.cwd ?? process.cwd();
-    const profileId = await resolveProfileId(req.profile, parent ?? null, contextCwd, {
-        readOnlySelection: options.readOnlyProfileSelection,
-    });
-    const profile = assertProfileActive(profileId);
-    const kind = resolveCreateKind(req.kind, profile);
-    await options.validateKind?.(kind);
-    const cwd = resolveNodeCwd({ ...req, kind }, parent, profileId, contextCwd);
-    if (options.validateKind === undefined)
-        await assertLaunchKind(kind, cwd, profileId);
-    const mode = (req.mode ?? 'base');
-    const launch = (await buildLaunchSpecAsync(kind, mode, {
-        lifecycle: req.root_lifecycle ?? (req.root === true ? 'resident' : 'terminal'),
-        hasManager: req.root !== true,
-        ...(req.model !== undefined ? { model: req.model, modelOverride: true } : {}),
-        cwd,
-        profileId,
-    })).launch;
-    return { profileId, profile, kind, mode, cwd, launch };
-}
-/** The directory a new node is pinned to. */
-export function resolveNodeCwd(req, parent, profileId, contextCwd) {
-    if (req.pin_cwd !== undefined && req.pin_cwd !== '')
-        return resolve(req.pin_cwd);
-    if (parent != null) {
-        const spawner = getNode(parent);
-        if (spawner !== null)
-            return spawner.cwd;
-    }
-    if (req.cwd !== undefined && req.cwd !== '')
-        return resolve(req.cwd);
-    return profileHome(profileId) ?? contextCwd;
-}
+var u=Object.defineProperty;var r=(e,n)=>u(e,"name",{value:n,configurable:!0});import{envProfileId as m}from"../../shared/env.js";import{resolve as s}from"node:path";import{getNode as p}from"../canvas/canvas.js";import{usage as w}from"../errors.js";import{assertProfileActive as v,profileHome as y}from"../profiles/manifest.js";import{buildLaunchSpecAsync as h,readMergedLaunchConfigAsync as g}from"./launch.js";import{resolveProfileId as k}from"./spawn.js";function x(e,n){return e??n?.manifest.default_kind??"general"}r(x,"resolveCreateKind");async function _(e,n=process.cwd(),t=m()||null){const i=Object.keys((await g(n,t)).kinds);if(!i.includes(e))throw w(`unknown kind: ${e}`,{received:e,next:`Valid kinds: ${i.sort().join(", ")}.`})}r(_,"assertLaunchKind");async function j(e,n={}){const t=e.parent??void 0,i=e.cwd??process.cwd(),o=await k(e.profile,t??null,i,{readOnlySelection:n.readOnlyProfileSelection}),l=v(o),d=x(e.kind,l);await n.validateKind?.(d);const c=C({...e,kind:d},t,o,i);n.validateKind===void 0&&await _(d,c,o);const a=e.mode??"base",f=(await h(d,a,{lifecycle:e.root_lifecycle??(e.root===!0?"resident":"terminal"),hasManager:e.root!==!0,...e.model!==void 0?{model:e.model,modelOverride:!0}:{},cwd:c,profileId:o})).launch;return{profileId:o,profile:l,kind:d,mode:a,cwd:c,launch:f}}r(j,"resolveLaunchTarget");function C(e,n,t,i){if(e.pin_cwd!==void 0&&e.pin_cwd!=="")return s(e.pin_cwd);if(n!=null){const o=p(n);if(o!==null)return o.cwd}return e.cwd!==void 0&&e.cwd!==""?s(e.cwd):y(t)??i}r(C,"resolveNodeCwd");export{_ as assertLaunchKind,x as resolveCreateKind,j as resolveLaunchTarget,C as resolveNodeCwd};