@crouton-kit/crouter 0.3.36 → 0.3.38

package/dist/core/memory-resolver.js

@@ -6,26 +6,41 @@ import { listInstalledPlugins, listInstalledPluginsInRoot, parseSkillQualifier }
 import { ambiguous, notFound, usage } from './errors.js';
 import { warn } from './output.js';
 import { pluginMemoryDir, projectScopeRoot, projectScopeRoots, scopeMemoryDir } from './scope.js';
+import { normalizeDocName, normalizeNameSegment } from './substrate/schema.js';
+import { loadProfileManifest, profileMemoryDir } from './profiles/manifest.js';
 /** Canonical, unambiguous identifier for a memory document: `<scope>/<name>`. */
 export function memoryDocId(doc) {
     return `${doc.scope}/${doc.name}`;
 }
-/** The memory scopes in resolution precedence: project > user > builtin.
- *  Project is included only when a project scope exists for the cwd. A single
- *  `scope` narrows to just that scope. */
+/** The selected profile id from the process env, or '' when none. The single
+ *  seam every profile-aware memory/config path reads through — see the plan's
+ *  synthesis decision on why this is process env, not a threaded parameter. */
+function selectedProfileId() {
+    return process.env['CRTR_PROFILE_ID'] || '';
+}
+/** The memory scopes in resolution precedence: project stack > profile > user >
+ *  builtin. Project is included only when a project scope exists for the cwd
+ *  (or the selected profile's project stack); profile is included only when a
+ *  profile is selected. A single `scope` narrows to just that scope. */
 function scopesInPrecedence(scope) {
     if (scope)
         return [scope];
     const out = [];
     if (projectScopeRoot())
         out.push('project');
+    if (selectedProfileId() !== '')
+        out.push('profile');
     out.push('user');
     out.push('builtin');
     return out;
 }
 /** Memory loads project scopes as a stack, not a single nearest root: every
- *  ancestor `.crouter/` from cwd upward contributes, nearest first. User and
- *  builtin remain singleton scopes after that stack. */
+ *  ancestor `.crouter/` from cwd upward (widened by a selected profile's
+ *  `projects`) contributes, nearest first. Profile is a singleton store
+ *  resolved through the centralized `loadProfileManifest` — never a raw path
+ *  join — and drops out silently (never throws the resolver) when the
+ *  selected profile id no longer resolves to a manifest. User and builtin
+ *  remain singleton scopes after that. */
 function memorySourcesInPrecedence(scope) {
     const out = [];
     for (const s of scopesInPrecedence(scope)) {
@@ -38,6 +53,18 @@ function memorySourcesInPrecedence(scope) {
                 });
             }
         }
+        else if (s === 'profile') {
+            const profileId = selectedProfileId();
+            if (profileId !== '') {
+                try {
+                    const { profileId: resolvedId } = loadProfileManifest(profileId);
+                    out.push({ scope: 'profile', memoryDir: profileMemoryDir(resolvedId), plugins: [] });
+                }
+                catch {
+                    // Missing/deleted/invalid selected profile: no profile memory source.
+                }
+            }
+        }
         else {
             out.push({
                 scope: s,
@@ -56,7 +83,7 @@ function loadMemoryDoc(name, scope, path) {
  *  subdirs supported), sorted by path-derived name. SKILL.md bundles are legacy
  *  Agent Skills and are ignored; crouter memory docs are plain .md files under
  *  memory/. */
-function listMemoryDocsInDir(scope, dir) {
+function listMemoryDocsInDir(scope, dir, quiet = false) {
     if (!dir || !pathExists(dir))
         return [];
     const docs = [];
@@ -76,7 +103,8 @@ function listMemoryDocsInDir(scope, dir) {
                 stack.push(join(d, e.name));
             else if (e.isFile() && e.name.endsWith('.md') && e.name !== 'SKILL.md') {
                 const file = join(d, e.name);
-                const name = relative(dir, file).replace(/\.md$/i, '').split(sep).join('/');
+                const raw = relative(dir, file).replace(/\.md$/i, '').split(sep).join('/');
+                const name = normalizeDocName(raw);
                 if (name)
                     found.push({ path: file, name });
             }
@@ -86,35 +114,52 @@ function listMemoryDocsInDir(scope, dir) {
         // COLLECTION layer: the strict frontmatter parser throws on invalid YAML.
         // Isolate one malformed doc with a clear scoped notice + skip, so a single
         // bad file can't brick `memory list`/`find` or the substrate boot render.
+        // `quiet` suppresses the notice for a targeted resolve (a leaf-name read),
+        // where another doc's health is irrelevant noise before the result.
         try {
             docs.push(loadMemoryDoc(name, scope, path));
         }
         catch (e) {
             const msg = (e instanceof Error ? e.message : String(e)).split('\n')[0];
-            warn(`invalid frontmatter in ${path}: ${msg}`);
+            if (!quiet)
+                warn(`invalid frontmatter in ${path}: ${msg}`);
         }
     }
     return docs.sort((a, b) => a.name.localeCompare(b.name));
 }
 /** All native memory docs for a scope. Project scope is a nearest-first stack of
- *  every ancestor `.crouter/memory/`; user and builtin are singleton stores. */
-export function listMemoryDocs(scope) {
+ *  every ancestor `.crouter/memory/` (widened by a selected profile's project
+ *  stack); profile is the selected profile's own singleton store, resolved
+ *  through `loadProfileManifest`; user and builtin are singleton stores. */
+export function listMemoryDocs(scope, quiet = false) {
     if (scope === 'project') {
-        return projectScopeRoots().flatMap((root) => listMemoryDocsInDir('project', join(root, 'memory')));
+        return projectScopeRoots().flatMap((root) => listMemoryDocsInDir('project', join(root, 'memory'), quiet));
     }
-    return listMemoryDocsInDir(scope, scopeMemoryDir(scope));
+    if (scope === 'profile') {
+        const profileId = selectedProfileId();
+        if (profileId === '')
+            return [];
+        try {
+            const { profileId: resolvedId } = loadProfileManifest(profileId);
+            return listMemoryDocsInDir('profile', profileMemoryDir(resolvedId), quiet);
+        }
+        catch {
+            return [];
+        }
+    }
+    return listMemoryDocsInDir(scope, scopeMemoryDir(scope), quiet);
 }
 /** All of one plugin's substrate docs, mounted under the virtual `<pluginName>/`
  *  namespace. Walks `pluginMemoryDir(plugin)` recursively for *.md, deriving each
  *  doc's name exactly as `listMemoryDocs` does (path-relative, no extension,
  *  slash-separated) then prefixing the plugin name. Builtin has no plugins. */
-export function listPluginMemoryDocs(plugin, scope) {
+export function listPluginMemoryDocs(plugin, scope, quiet = false) {
     const dir = pluginMemoryDir(plugin);
     if (!pathExists(dir))
         return [];
     const docs = [];
     for (const file of walkFiles(dir, (n) => n.endsWith('.md') && n !== 'SKILL.md')) {
-        const derived = relative(dir, file).replace(/\.md$/i, '').split(sep).join('/');
+        const derived = normalizeDocName(relative(dir, file).replace(/\.md$/i, '').split(sep).join('/'));
         if (!derived)
             continue;
         const name = `${plugin.name}/${derived}`;
@@ -123,21 +168,84 @@ export function listPluginMemoryDocs(plugin, scope) {
         }
         catch (e) {
             const msg = (e instanceof Error ? e.message : String(e)).split('\n')[0];
-            warn(`invalid frontmatter in ${file}: ${msg}`);
+            if (!quiet)
+                warn(`invalid frontmatter in ${file}: ${msg}`);
         }
     }
     return docs.sort((a, b) => a.name.localeCompare(b.name));
 }
 /** All memory docs across the resolved sources, in precedence order: each
- *  ancestor project `.crouter/` from nearest to farthest, then user, then
- *  builtin. Within each source, native docs are emitted before enabled-plugin
- *  docs, so native wins on the caller's first-wins dedup. */
-export function listAllMemoryDocs(scope) {
+ *  ancestor project `.crouter/` from nearest to farthest, then the selected
+ *  profile's memory (if any), then user, then builtin. Within each source,
+ *  native docs are emitted before enabled-plugin docs, so native wins on the
+ *  caller's first-wins dedup. */
+export function listAllMemoryDocs(scope, quiet = false) {
     return memorySourcesInPrecedence(scope).flatMap((source) => [
-        ...listMemoryDocsInDir(source.scope, source.memoryDir),
-        ...source.plugins.flatMap((p) => listPluginMemoryDocs(p, source.scope)),
+        ...listMemoryDocsInDir(source.scope, source.memoryDir, quiet),
+        ...source.plugins.flatMap((p) => listPluginMemoryDocs(p, source.scope, quiet)),
     ]);
 }
+/** Find the direct child of `dir` — a `.md` file (matched on name minus
+ *  extension) or a directory — whose NORMALIZED display name equals
+ *  `segment`. An exact literal match (no prefix to strip) wins over a
+ *  normalized match, so a `spine` dir sitting beside a `01-spine` dir (a
+ *  malformed corpus) never masks the literal one; a well-formed corpus has at
+ *  most one candidate either way. Returns the absolute child path, or null. */
+function matchNormalizedChild(dir, segment, want) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    let normalizedHit = null;
+    for (const e of entries) {
+        if (want === 'dir') {
+            if (!e.isDirectory())
+                continue;
+            if (e.name === segment)
+                return join(dir, e.name);
+            if (normalizedHit === null && normalizeNameSegment(e.name) === segment) {
+                normalizedHit = join(dir, e.name);
+            }
+        }
+        else {
+            if (!(e.isFile() && e.name.endsWith('.md')))
+                continue;
+            const base = e.name.slice(0, -3);
+            if (base === segment)
+                return join(dir, e.name);
+            if (normalizedHit === null && normalizeNameSegment(base) === segment) {
+                normalizedHit = join(dir, e.name);
+            }
+        }
+    }
+    return normalizedHit;
+}
+/** Resolve a NORMALIZED (numeric-prefix-stripped) segment path against a
+ *  physical memory dir: walk intermediate segments matching each as a
+ *  directory by normalized name, then resolve the final segment as either a
+ *  `.md` file or a directory (the bare-dir -> INDEX.md fallback needs the dir
+ *  match even when a same-named file also exists). Either half is null when
+ *  the segment path does not resolve that way. This is what makes
+ *  `00-runtime-base.md` findable as `runtime-base` and `01-spine/00-has-manager`
+ *  findable as `spine/has-manager` — the physical path keeps its pins, only
+ *  lookup is prefix-blind. */
+function resolveNormalizedPath(baseDir, segments) {
+    let curDir = baseDir;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const next = matchNormalizedChild(curDir, segments[i], 'dir');
+        if (!next)
+            return { filePath: null, dirPath: null };
+        curDir = next;
+    }
+    const last = segments[segments.length - 1];
+    return {
+        filePath: matchNormalizedChild(curDir, last, 'file'),
+        dirPath: matchNormalizedChild(curDir, last, 'dir'),
+    };
+}
 /** Direct full-path lookup of memory/<name>.md across scopes, precedence-first.
  *  Returns every scope's hit in precedence order; the resolver takes the first
  *  (highest-precedence) one — a fully-specified name is never ambiguous.
@@ -145,7 +253,12 @@ export function listAllMemoryDocs(scope) {
  *  A directory INDEX is the cleaner contract: when `<name>.md` is absent but
  *  `<name>/INDEX.md` exists, the bare dir name (`taste`) resolves to the dir's
  *  INDEX doc — carrying the dir name as its identity. (`taste/INDEX` still
- *  resolves directly as the file path.) */
+ *  resolves directly as the file path.)
+ *
+ *  `name`'s segments are already normalized (a caller-supplied identifier is
+ *  never authored with a numeric prefix); resolution against the physical tree
+ *  is prefix-blind via `resolveNormalizedPath` so a normalized name finds an
+ *  `NN-`-pinned physical file/dir. */
 function findMemoryMatches(name, scope) {
     const matches = [];
     const segments = name.split('/');
@@ -156,15 +269,17 @@ function findMemoryMatches(name, scope) {
         // ancestor `.crouter/`, then user, then builtin.
         const dir = source.memoryDir;
         if (dir) {
-            const path = join(dir, ...segments) + '.md';
-            if (!isLegacySkillDoc && pathExists(path)) {
-                matches.push(loadMemoryDoc(name, source.scope, path));
+            const { filePath, dirPath } = resolveNormalizedPath(dir, segments);
+            if (!isLegacySkillDoc && filePath !== null) {
+                matches.push(loadMemoryDoc(name, source.scope, filePath));
                 continue;
             }
-            const indexPath = join(dir, ...segments, 'INDEX.md');
-            if (pathExists(indexPath)) {
-                matches.push(loadMemoryDoc(name, source.scope, indexPath));
-                continue;
+            if (dirPath !== null) {
+                const indexPath = join(dirPath, 'INDEX.md');
+                if (pathExists(indexPath)) {
+                    matches.push(loadMemoryDoc(name, source.scope, indexPath));
+                    continue;
+                }
             }
         }
         // Plugin memory dir: a `<plugin>/<rest>` name resolves against that enabled
@@ -179,21 +294,22 @@ function findMemoryMatches(name, scope) {
             if (p.name !== pluginName)
                 continue;
             const pdir = pluginMemoryDir(p);
+            const restSegments = rest ? rest.split('/') : [];
             if (rest) {
-                const restSegments = rest.split('/');
-                const ppath = join(pdir, ...restSegments) + '.md';
-                if (restSegments.at(-1) !== 'SKILL' && pathExists(ppath)) {
-                    matches.push(loadMemoryDoc(name, source.scope, ppath));
+                const { filePath } = resolveNormalizedPath(pdir, restSegments);
+                if (restSegments.at(-1) !== 'SKILL' && filePath !== null) {
+                    matches.push(loadMemoryDoc(name, source.scope, filePath));
                     break;
                 }
             }
             // Bare name -> <plugin>/memory/INDEX.md; slashed name -> dir INDEX.
-            const pindex = rest
-                ? join(pdir, ...rest.split('/'), 'INDEX.md')
-                : join(pdir, 'INDEX.md');
-            if (pathExists(pindex)) {
-                matches.push(loadMemoryDoc(name, source.scope, pindex));
-                break;
+            const pIndexDir = rest ? resolveNormalizedPath(pdir, restSegments).dirPath : pdir;
+            if (pIndexDir !== null) {
+                const pindex = join(pIndexDir, 'INDEX.md');
+                if (pathExists(pindex)) {
+                    matches.push(loadMemoryDoc(name, source.scope, pindex));
+                    break;
+                }
             }
         }
     }
@@ -207,7 +323,9 @@ function findMemoryByLeaf(leaf, scope) {
         return [];
     let all;
     try {
-        all = listAllMemoryDocs(scope);
+        // Quiet: a targeted read must not spew other docs' frontmatter warnings
+        // before its own result (esp. a not_found) — corpus health is `lint`'s job.
+        all = listAllMemoryDocs(scope, true);
     }
     catch {
         return [];

package/dist/core/preview-registry.js

@@ -57,7 +57,6 @@ export const HELP_ICON = String.fromCodePoint(HELP_ICON_CP);
  *  private-use-area icons chosen per family concept (see command-icons.md). */
 const FAMILY_ICON_CP = {
     canvas: 0xf0e8,
-    feed: 0xf09e,
     human: 0xf007,
     memory: 0xf02d,
     node: 0xf192,
@@ -80,17 +79,14 @@ const LEAF_ICON_CP = {
     'canvas history search': 0xf002,
     'canvas history read': 0xf02d,
     'canvas history show': 0xf1da,
-    'canvas daemon start': 0xf04b,
-    'canvas daemon status': 0xf111,
-    'canvas daemon stop': 0xf04d,
+    'sys daemon start': 0xf04b,
+    'sys daemon status': 0xf111,
+    'sys daemon stop': 0xf04d,
     'canvas chord': 0xf001,
-    'canvas tmux-spread': 0xf009,
+    'surface tmux-spread': 0xf009,
     'canvas issue new': 0xf188,
     'canvas prune': 0xf0c4,
     'canvas rebuild-index': 0xf0ad,
-    'feed read': 0xf02d,
-    'feed message': 0xf0e0,
-    'feed peek': 0xf06e,
     'human ask': 0xf059,
     'human review': 0xf044,
     'human notify': 0xf0f3,
@@ -262,7 +258,7 @@ function summarizeMemoryLint(text) {
     return null;
 }
 // ---------------------------------------------------------------------------
-// Shared table/count parsing helpers for the canvas/node/feed runtime cockpit
+// Shared table/count parsing helpers for the canvas/node runtime cockpit
 // batch below. These parse the exact markdown shapes core/render.ts's generic
 // renderArray/renderResult produce (a `- field: N` bullet for a scalar count,
 // an `N <label>:` count lead-in followed by a GFM table for an array of
@@ -738,7 +734,7 @@ function summarizeCanvasHistoryShow(text) {
     const digest = summarizeTopCounts(typeCounts, 5, (name, count) => `${name}s×${count}`);
     return [{ text: `${countMatch[1]} artifacts` }, { text: digest, tone: 'muted' }];
 }
-/** `crtr canvas daemon start` (src/commands/daemon.ts:40, `spawnDaemon()` in
+/** `crtr sys daemon start` (src/commands/sys/daemon.ts:40, `spawnDaemon()` in
  *  src/daemon/manage.ts:89) has no custom `render`; the generic renderer
  *  bullets `{started:true,pid}` or `{started:false,existing_pid}`. `pid` is
  *  unconditionally set alongside `started:true` (manage.ts:125) — a
@@ -747,7 +743,7 @@ function summarizeCanvasHistoryShow(text) {
  *  false branch (a `readPidfile() ?? undefined` race), so that one stays
  *  optional. Returns null when `started` isn't a plain boolean bullet, or
  *  is `true` without a `pid` bullet. */
-function summarizeCanvasDaemonStart(text) {
+function summarizeSysDaemonStart(text) {
     const m = /^- started:\s*(true|false)\s*$/m.exec(text);
     if (m === null)
         return null;
@@ -760,14 +756,14 @@ function summarizeCanvasDaemonStart(text) {
     const pid = /^- existing_pid:\s*(\d+)\s*$/m.exec(text)?.[1];
     return [{ text: `already running${pid !== undefined ? ` · pid ${pid}` : ''}`, tone: 'muted' }];
 }
-/** `crtr canvas daemon status` (src/commands/daemon.ts:65) has no custom
+/** `crtr sys daemon status` (src/commands/sys/daemon.ts:65) has no custom
  *  `render`; the generic renderer bullets `{running:true,pid}` or
  *  `{running:false}`. `pid` is unconditionally set alongside `running:true`
  *  (daemon.ts:70 — the true branch only fires once `readPidfile()` already
  *  returned a pid), so a true-with-no-pid shape is unrecognized. Returns
  *  null when `running` isn't a plain boolean bullet, or is `true` without a
  *  `pid` bullet. */
-function summarizeCanvasDaemonStatus(text) {
+function summarizeSysDaemonStatus(text) {
     const m = /^- running:\s*(true|false)\s*$/m.exec(text);
     if (m === null)
         return null;
@@ -779,13 +775,13 @@ function summarizeCanvasDaemonStatus(text) {
     }
     return [{ text: 'not running', tone: 'error' }];
 }
-/** `crtr canvas daemon stop` (src/commands/daemon.ts:93) has no custom
+/** `crtr sys daemon stop` (src/commands/sys/daemon.ts:93) has no custom
  *  `render`; the generic renderer bullets `{stopped:true,pid}` or
  *  `{stopped:false}`. `pid` is unconditionally set alongside `stopped:true`
  *  (daemon.ts:98 — the signaled pid is echoed back in the same return), so a
  *  true-with-no-pid shape is unrecognized. Returns null when `stopped` isn't
  *  a plain boolean bullet, or is `true` without a `pid` bullet. */
-function summarizeCanvasDaemonStop(text) {
+function summarizeSysDaemonStop(text) {
     const m = /^- stopped:\s*(true|false)\s*$/m.exec(text);
     if (m === null)
         return null;
@@ -982,97 +978,6 @@ function summarizeNodeTriggersList(text) {
         out.push({ text: `… ${remaining} more`, tone: 'muted' });
     return out;
 }
-/** `crtr feed read` (src/commands/push.ts:209) has two shapes: drained
- *  (`${n} unread pointer(s) drained from ${node_id}'s inbox.\n\n${digest}`,
- *  where the digest — `coalesce()`, src/core/feed/inbox.ts:225 — groups by
- *  sender as `From ${sender} — ${N} update(s):` sections) or empty (`No
- *  unread pointers for ${node_id} (unread=0).\n\n${explanation}`).
- *  `coalesce()` always groups drained entries under at least one
- *  From-section, so a positive drained count with zero parsed senders is a
- *  shape mismatch, not a 0-sender success. Returns null on any other
- *  shape. */
-function summarizeFeedRead(text) {
-    const lines = text.split('\n');
-    const first = lines[0] ?? '';
-    const drained = /^(\d+) unread pointers? drained from (.+)'s inbox\.$/.exec(first);
-    if (drained !== null) {
-        const n = Number(drained[1]);
-        const senders = [...new Set([...text.matchAll(/^From (.+?) — \d+ update/gm)].map((m) => m[1]))];
-        if (n > 0 && senders.length === 0)
-            return null;
-        const out = [{ text: `${n} pointer${n === 1 ? '' : 's'} drained from ${senders.length} node${senders.length === 1 ? '' : 's'}` }];
-        if (senders.length > 0) {
-            const shown = senders.slice(0, 5);
-            const remaining = senders.length - shown.length;
-            out.push({ text: remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', '), tone: 'muted' });
-        }
-        return out;
-    }
-    if (/^No unread pointers for .+ \(unread=0\)\.$/.test(first)) {
-        return [{ text: 'nothing unread', tone: 'muted' }];
-    }
-    return null;
-}
-/** Teaser cap for `feed message`'s body preview — mirrors
- *  MEMORY_READ_CONTENT_LINES's role for a different leaf. */
-const FEED_MESSAGE_TEASER_LINES = 3;
-/** `crtr feed message` (src/commands/push.ts:264) has two shapes: found
- *  (`Full message ${id} (from ${from}):\n\n${body}`) or not-found (a short
- *  line — left as null, the generic fallback is fine for one line). */
-function summarizeFeedMessage(text) {
-    const lines = text.split('\n');
-    const head = /^Full message (\S+) \(from (.+)\):$/.exec(lines[0] ?? '');
-    if (head === null)
-        return null;
-    const [, id, from] = head;
-    const bodyLines = lines.slice(1);
-    let idx = 0;
-    while (idx < bodyLines.length && bodyLines[idx].trim() === '')
-        idx++;
-    const content = bodyLines.slice(idx);
-    const teaser = content.slice(0, FEED_MESSAGE_TEASER_LINES);
-    const hasMore = content.slice(FEED_MESSAGE_TEASER_LINES).some((l) => l.trim() !== '');
-    if (hasMore)
-        teaser.push('…');
-    const out = [{ text: `${id} · from ${from}` }];
-    if (teaser.some((l) => l.trim() !== '')) {
-        out.push({ text: '' });
-        for (const l of teaser)
-            out.push({ text: l });
-    }
-    return out;
-}
-/** `crtr feed peek` (src/commands/push.ts:351) has two shapes: zero-kids
- *  (`No nodes below you (0 subscriptions, ${unread} unread). ${tail}` — the
- *  "0" is a hardcoded literal, not a variable) or nonzero (`${verdictLine}
- *  \n\n${N} node(s) below you — ${working} working, ${done} done, ${dead}
- *  dead, ${unread} unread:\n${rows}`). Returns null on any other shape. */
-function summarizeFeedPeek(text) {
-    const zero = /^No nodes below you \(0 subscriptions, (\d+) unread\)\./.exec(text.split('\n')[0] ?? '');
-    if (zero !== null) {
-        const unread = Number(zero[1]);
-        return unread > 0
-            ? [{ text: `0 below · ${unread} unread`, tone: 'warning' }]
-            : [{ text: 'PASS · nothing below', tone: 'success' }];
-    }
-    const m = /(\d+) nodes? below you — (\d+) working, (\d+) done, (\d+) dead, (\d+) unread:/.exec(text);
-    if (m === null)
-        return null;
-    const [, , workingStr, doneStr, deadStr, unreadStr] = m;
-    const working = Number(workingStr);
-    const done = Number(doneStr);
-    const dead = Number(deadStr);
-    const unread = Number(unreadStr);
-    const parts = [`${working} working`, `${done} done`];
-    if (dead > 0)
-        parts.push(`${dead} dead`);
-    const lines = [{ text: parts.join(' · ') }];
-    if (dead > 0)
-        lines.push({ text: `${dead} dead — will not wake you`, tone: 'warning' });
-    else if (unread > 0)
-        lines.push({ text: `${unread} unread`, tone: 'warning' });
-    return lines;
-}
 /** `crtr push final` (makeTierLeaf's shared render, src/commands/push.ts:161)
  *  leads with a fixed sentence ('Result recorded — node finished; ...')
  *  followed unconditionally by `\n\n- report: ${report_path}` (`report_path`
@@ -1996,18 +1901,15 @@ const SUMMARIZERS = [
     { path: 'canvas history search', run: summarizeCanvasHistorySearch },
     { path: 'canvas history read', run: summarizeCanvasHistoryRead },
     { path: 'canvas history show', run: summarizeCanvasHistoryShow },
-    { path: 'canvas daemon start', run: summarizeCanvasDaemonStart },
-    { path: 'canvas daemon status', run: summarizeCanvasDaemonStatus },
-    { path: 'canvas daemon stop', run: summarizeCanvasDaemonStop },
+    { path: 'sys daemon start', run: summarizeSysDaemonStart },
+    { path: 'sys daemon status', run: summarizeSysDaemonStatus },
+    { path: 'sys daemon stop', run: summarizeSysDaemonStop },
     { path: 'canvas issue new', run: summarizeCanvasIssueNew },
     { path: 'node new', run: summarizeNodeNew },
     { path: 'node msg', run: summarizeNodeMsg },
     { path: 'node yield', run: summarizeNodeYield },
     { path: 'node lifecycle close', run: summarizeNodeLifecycleClose },
     { path: 'node triggers list', run: summarizeNodeTriggersList },
-    { path: 'feed read', run: summarizeFeedRead },
-    { path: 'feed message', run: summarizeFeedMessage },
-    { path: 'feed peek', run: summarizeFeedPeek },
     { path: 'push urgent', run: summarizePushUrgent },
     { path: 'push final', run: summarizePushFinal },
     { path: 'human ask', run: summarizeHumanAsk },

package/dist/core/profiles/manifest.d.ts

@@ -0,0 +1,33 @@
+import type { ProfileManifest } from '../../types.js';
+export declare function profilesRoot(): string;
+export declare function profileRoot(profileId: string): string;
+export declare function profileManifestPath(profileId: string): string;
+export declare function profileMemoryDir(profileId: string): string;
+export interface ProfileEntry {
+    profileId: string;
+    manifest: ProfileManifest;
+}
+/** Every profile with a readable manifest, in directory-listing order.
+ *  Enumerates ONLY immediate children of `profilesRoot()` — never recurses,
+ *  never trusts a caller-supplied id. A dir whose name doesn't match the
+ *  generated id shape, or whose `profile.json` is missing/corrupt, is skipped
+ *  rather than crashing the whole listing. */
+export declare function listProfiles(): ProfileEntry[];
+/** Resolve a CLI operand to its profile — exact id first (checked against the
+ *  actually-enumerated dirs, never a blind join), then a unique manifest
+ *  `name` match. Ambiguous names fail listing every matching id; no match
+ *  fails naming `profile list`/`profile new` as recovery. This is the ONLY
+ *  function every command leaf and future runtime consumer (Phase 5/6) should
+ *  call to turn a `<profile>` operand or `CRTR_PROFILE_ID` into a concrete,
+ *  safe profile id. */
+export declare function loadProfileManifest(profileIdOrName: string): ProfileEntry;
+/** Hold the per-profile manifest lock for the duration of `fn`. ALL manifest
+ *  mutations (create/rename/add-project/remove-project/delete/last-used)
+ *  below run inside this. */
+export declare function withProfileManifestLock<T>(profileId: string, fn: () => T): T;
+export declare function createProfile(name: string, projects?: string[]): ProfileEntry;
+export declare function updateProfileLastUsed(profileId: string): ProfileEntry;
+export declare function renameProfile(profileId: string, name: string): ProfileEntry;
+export declare function addProfileProject(profileId: string, dir: string): ProfileEntry;
+export declare function removeProfileProject(profileId: string, dir: string): ProfileEntry;
+export declare function deleteProfile(profileId: string): void;