@crouton-kit/crouter 0.3.28 → 0.3.30

package/dist/commands/sys/sync.js

@@ -0,0 +1,187 @@
+// `crtr sys sync` — the SOLE entry point for bidirectional crtr ↔ Claude skill
+// sync (R-U1). Loads the layered manifest (P2), reconciles each enrolled pair
+// once via the direction-agnostic engine (P6), summarizes the outcome, and
+// sets the exit code: non-zero IFF any pair conflicted (R-E7). A malformed
+// manifest (R-U7) or an unknown `--pair` id (OD-3) aborts hard before any
+// reconcile runs — no lenient fallback, no partial write.
+import { defineLeaf } from '../../core/command.js';
+import { usage } from '../../core/errors.js';
+import { emit, isJsonOutput } from '../../core/io.js';
+import { ExitCode } from '../../types.js';
+import { readLayeredManifest } from '../../core/skill-sync/manifest.js';
+import { resolveProfile } from '../../core/skill-sync/profile.js';
+import { reconcilePair } from '../../core/skill-sync/engine.js';
+/** Render the per-pair status table + summary line as agent-ready markdown.
+ *  Shown for both the clean and the conflict exit so the caller always sees the
+ *  full partition. */
+function renderSync(results, summary, dryRun) {
+    const parts = [];
+    parts.push(dryRun
+        ? 'crtr ↔ Claude skill sync — DRY RUN (nothing written):'
+        : 'crtr ↔ Claude skill sync:');
+    if (results.length === 0) {
+        parts.push('No enrolled pairs.');
+    }
+    else {
+        const rows = results
+            .map((r) => `| ${r.id} | ${r.status} | ${r.wrote} |`)
+            .join('\n');
+        parts.push(`| pair | status | wrote |\n| --- | --- | --- |\n${rows}`);
+    }
+    parts.push(`synced: ${summary.synced.length} · conflicts: ${summary.conflicts.length} · ` +
+        `noop: ${summary.noop.length} · files written: ${summary.wrote}`);
+    if (summary.conflicts.length > 0) {
+        parts.push(`Conflicts (NOT written): ${summary.conflicts.join(', ')}. ` +
+            'Each conflicting pair has a git-style report under ' +
+            '`~/.crouter/skill-sync/conflicts/<id>.md` — resolve the endpoints by hand, then re-run.');
+    }
+    return parts.join('\n\n');
+}
+/** Drift label for the read-only `--status` view, derived from a dry-run
+ *  reconcile: `noop` = already in agreement, `synced` = a clean merge the engine
+ *  WOULD write, `conflict` = diverged and blocked. These are the only three
+ *  statuses `reconcilePair` returns. */
+const DRIFT = {
+    noop: 'in-sync',
+    synced: 'would-write',
+    conflict: 'conflict',
+};
+/** Render one endpoint as `scope/name` (or `<scope>:<plugin>/<name>` for a
+ *  plugin-scoped side) so a reader sees where each half of the pair lives. */
+function endpointLabel(ep) {
+    return ep.scope === 'plugin' || ep.scope === 'claude-plugin'
+        ? `${ep.scope}:${ep.plugin}/${ep.name}`
+        : `${ep.scope}/${ep.name}`;
+}
+/** Render the read-only `--status` inventory: every selected pair with its
+ *  crtr↔Claude endpoints and drift state, computed via a dry-run reconcile so
+ *  nothing is written. `results` is keyed back to `pairs` by id. */
+function renderStatus(pairs, results) {
+    const parts = [];
+    parts.push('crtr ↔ Claude skill-sync pairs (read-only; nothing written):');
+    if (pairs.length === 0) {
+        parts.push('No enrolled pairs.');
+        return parts.join('\n\n');
+    }
+    const byId = new Map(results.map((r) => [r.id, r]));
+    const rows = pairs
+        .map((p) => {
+        const drift = DRIFT[byId.get(p.id).status];
+        return `| ${p.id} | ${endpointLabel(p.crtr)} | ${endpointLabel(p.claude)} | ${drift} |`;
+    })
+        .join('\n');
+    parts.push(`| pair | crtr | claude | drift |\n| --- | --- | --- | --- |\n${rows}`);
+    const inSync = results.filter((r) => r.status === 'noop').length;
+    const wouldWrite = results.filter((r) => r.status === 'synced').length;
+    const conflict = results.filter((r) => r.status === 'conflict').length;
+    parts.push(`in-sync: ${inSync} · would-write: ${wouldWrite} · conflict: ${conflict}`);
+    return parts.join('\n\n');
+}
+export const sysSyncLeaf = defineLeaf({
+    name: 'sync',
+    description: 'reconcile crtr ↔ Claude skill pairs (bidirectional)',
+    whenToUse: 'you want enrolled crtr skills and their Claude SKILL.md counterparts brought back into agreement. Performs the single, direction-agnostic 3-way reconcile over every pair in the skill-sync manifest (or just one via --pair), writing both sides + the merge base when clean and a conflict report when not.',
+    help: {
+        name: 'sys sync',
+        summary: 'reconcile enrolled crtr ↔ Claude skill pairs (bidirectional 3-way merge)',
+        params: [
+            {
+                kind: 'flag',
+                name: 'pair',
+                type: 'string',
+                required: false,
+                constraint: 'Reconcile only the pair with this id. Unknown id → hard error naming it + the valid ids, nothing written. Default: every enrolled pair.',
+            },
+            {
+                kind: 'flag',
+                name: 'dry-run',
+                type: 'bool',
+                required: false,
+                constraint: 'Compute every merge and report the would-be status, but write nothing — no endpoint, snapshot, or conflict report touched.',
+            },
+            {
+                kind: 'flag',
+                name: 'status',
+                type: 'bool',
+                required: false,
+                constraint: 'Read-only inventory mode: instead of reconciling, list every enrolled pair (honoring --pair) with its crtr↔Claude endpoints and drift state (in-sync / would-write / conflict), computed via a dry-run reconcile. Writes nothing and never exits non-zero on drift; a malformed manifest or unknown --pair id still aborts hard.',
+            },
+        ],
+        output: [
+            { name: 'synced', type: 'string[]', required: true, constraint: 'Pair ids written through cleanly to both endpoints + the merge base.' },
+            { name: 'conflicts', type: 'string[]', required: true, constraint: 'Pair ids that diverged and were NOT written; each has a report under ~/.crouter/skill-sync/conflicts/<id>.md. Non-empty → exit non-zero.' },
+            { name: 'noop', type: 'string[]', required: true, constraint: 'Pair ids already in agreement — nothing to do.' },
+            { name: 'wrote', type: 'number', required: true, constraint: 'Total endpoint files created/updated across all pairs (0 under --dry-run).' },
+        ],
+        outputKind: 'object',
+        effects: [
+            'For each clean pair: writes the merged SKILL.md + assets to BOTH the crtr and Claude endpoints and updates the per-pair merge snapshot under ~/.crouter/skill-sync/snapshots/<id>/.',
+            'For each conflicting pair: writes NOTHING to the endpoints; writes a git-style conflict report to ~/.crouter/skill-sync/conflicts/<id>.md.',
+            'Exits non-zero iff any pair conflicted. A malformed manifest or an unknown --pair id aborts hard (non-zero) before any reconcile and writes nothing.',
+            'With --dry-run: read-only — computes every merge and the would-be summary, touches no endpoint, snapshot, or report.',
+            'With --status: read-only — emits the pair inventory + drift table (in-sync / would-write / conflict) instead of reconciling; writes nothing and exits zero regardless of drift.',
+        ],
+    },
+    run: async (input) => {
+        const pairFilter = input['pair'];
+        const dryRun = input['dryRun'] ?? false;
+        const statusMode = input['status'] ?? false;
+        // Malformed manifest throws here (R-U7) → dispatcher's handle() → non-zero.
+        const { pairs } = readLayeredManifest();
+        let selected = pairs;
+        if (pairFilter !== undefined) {
+            selected = pairs.filter((p) => p.id === pairFilter);
+            if (selected.length === 0) {
+                // OD-3 / R-O2 — unknown id aborts hard, naming the bad id + valid ids,
+                // nothing written.
+                const valid = pairs.map((p) => p.id);
+                throw usage(`unknown pair id: ${pairFilter}`, {
+                    received: pairFilter,
+                    next: `Valid pair ids: ${valid.length > 0 ? valid.join(', ') : '(none)'}. Run \`crtr sys sync -h\`.`,
+                });
+            }
+        }
+        // --status: read-only inventory. Run the same engine in dry-run mode and
+        // render endpoints + drift; never write, never exit non-zero on drift.
+        if (statusMode) {
+            const results = selected.map((p) => reconcilePair(p, resolveProfile(p.frontmatter), { dryRun: true }));
+            if (isJsonOutput()) {
+                emit({
+                    pairs: selected.map((p, i) => ({
+                        id: p.id,
+                        crtr: p.crtr,
+                        claude: p.claude,
+                        drift: DRIFT[results[i].status],
+                    })),
+                });
+            }
+            else {
+                process.stdout.write(renderStatus(selected, results) + '\n');
+            }
+            process.exit(ExitCode.SUCCESS);
+        }
+        // One conflict must NOT abort the loop (R-X3): collect every pair's result,
+        // partition, then decide the exit code once. A structural error (an
+        // unresolvable endpoint, both sides missing) is a hard config fault and is
+        // allowed to propagate — only content conflicts are a collected outcome.
+        const results = [];
+        for (const pair of selected) {
+            const profile = resolveProfile(pair.frontmatter);
+            results.push(reconcilePair(pair, profile, { dryRun }));
+        }
+        const summary = {
+            synced: results.filter((r) => r.status === 'synced').map((r) => r.id),
+            conflicts: results.filter((r) => r.status === 'conflict').map((r) => r.id),
+            noop: results.filter((r) => r.status === 'noop').map((r) => r.id),
+            wrote: results.reduce((n, r) => n + r.wrote, 0),
+        };
+        if (isJsonOutput()) {
+            emit(summary);
+        }
+        else {
+            process.stdout.write(renderSync(results, summary, dryRun) + '\n');
+        }
+        // R-E7 — exit non-zero IFF a conflict was surfaced.
+        process.exit(summary.conflicts.length > 0 ? ExitCode.GENERAL : ExitCode.SUCCESS);
+    },
+});

package/dist/commands/sys.js

@@ -4,19 +4,20 @@ import { defineBranch } from '../core/command.js';
 import { configBranch } from './sys/config.js';
 import { sysDoctorLeaf } from './sys/doctor.js';
 import { sysFeedbackLeaf } from './sys/feedback.js';
+import { sysSyncLeaf } from './sys/sync.js';
 import { sysUpdateLeaf, sysVersionLeaf } from './sys/update.js';
 export function registerSys() {
     return defineBranch({
         name: 'sys',
         rootEntry: {
             concept: 'crtr configuration, diagnostics, and self-management',
-            desc: 'config, doctor, update, version, feedback',
+            desc: 'config, doctor, sync, update, version, feedback',
             useWhen: 'managing the crtr installation',
         },
         help: {
             name: 'sys',
             summary: 'crtr system configuration, diagnostics, and self-management',
         },
-        children: [configBranch, sysDoctorLeaf, sysFeedbackLeaf, sysUpdateLeaf, sysVersionLeaf],
+        children: [configBranch, sysDoctorLeaf, sysFeedbackLeaf, sysSyncLeaf, sysUpdateLeaf, sysVersionLeaf],
     });
 }

package/dist/commands/view-cycle.js

@@ -15,7 +15,7 @@
 // tmux-only; a pane with no @crtr_view tag (not a view monitor) is a no-op.
 // Output is discarded by the keybinding, so this just acts.
 import { defineLeaf } from '../core/command.js';
-import { listViews, resolveView, loadView } from '../core/tui/loader.js';
+import { listViews, resolveView, loadCore } from '../core/view/loader.js';
 // Commands reach the tmux driver through placement.ts (the sanctioned
 // model-over-driver seam, §5.1) — never `./tmux.js` directly.
 import { inTmux, currentTmux, getPaneOption, setPaneOption, paneCurrentPath, respawnPaneSync, piCommand, } from '../core/runtime/placement.js';
@@ -82,7 +82,7 @@ export const viewCycleLeaf = defineLeaf({
             if (rv === null)
                 continue;
             try {
-                await loadView(rv);
+                await loadCore(rv);
                 targetId = cand;
                 break;
             }

package/dist/commands/view-list.js

@@ -1,11 +1,11 @@
 // `crtr view list` — enumerate every resolvable view across scopes.
 //
-// Lists id · title · description · scope. Loads each view to read its manifest
-// title/description; a malformed view is shown with an error marker (it never
-// crashes the listing). Plain text — pipeable as-is. The raw array is available
-// behind --json for tooling.
+// Lists id · title · description · scope. Loads each view's core.mjs to read its
+// manifest title/description; a malformed view is shown with an error marker (it
+// never crashes the listing). Plain text — pipeable as-is. The raw array is
+// available behind --json for tooling.
 import { defineLeaf } from '../core/command.js';
-import { listViews, loadView } from '../core/tui/loader.js';
+import { listViews, loadCore } from '../core/view/loader.js';
 export const viewListLeaf = defineLeaf({
     name: 'list',
     description: 'enumerate available views (id · title · description · scope)',
@@ -24,11 +24,11 @@ export const viewListLeaf = defineLeaf({
         const rows = [];
         for (const r of listViews()) {
             try {
-                const v = await loadView(r);
+                const core = await loadCore(r);
                 rows.push({
                     id: r.id,
-                    title: v.manifest.title,
-                    description: v.manifest.description ?? '',
+                    title: core.manifest.title,
+                    description: core.manifest.description ?? '',
                     scope: r.scope,
                 });
             }

package/dist/commands/view-new.js

@@ -1,24 +1,25 @@
-// `crtr view new <name>` — scaffold a runnable view.mjs into a scope dir.
+// `crtr view new <name>` — scaffold a runnable dual-target view into a scope dir.
 //
-// Writes <viewsDir(scope)>/<name>/view.mjs from the stub in prompts/view.ts
-// (mkdir -p first). Refuses if a view of that name already resolves. The
-// scaffolded view runs as-is via `crtr view run <name>`. Mirrors how skill
-// authoring scaffolds (resolve scope → ensure dir → write → point at how to run).
+// Writes the four contract files (core.mjs + tui.mjs + web.jsx + text.mjs) under
+// <viewsDir(scope)>/<name>/ from the stubs in prompts/view.ts (mkdir -p first).
+// Refuses if a view of that name already resolves. The scaffold runs as-is via
+// `crtr view run <name>` (TUI) and `crtr view serve <name>` (web). Mirrors how
+// skill authoring scaffolds (resolve scope → ensure dir → write → point at run).
 import { mkdirSync, existsSync } from 'node:fs';
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { defineLeaf } from '../core/command.js';
 import { usage } from '../core/errors.js';
-import { resolveView } from '../core/tui/loader.js';
+import { resolveView, findViewDir } from '../core/view/loader.js';
 import { viewsDir, projectScopeRoot, ensureProjectScopeRoot } from '../core/scope.js';
 import { viewScaffold } from '../prompts/view.js';
 export const viewNewLeaf = defineLeaf({
     name: 'new',
-    description: 'scaffold a runnable view.mjs stub into a scope dir',
-    whenToUse: 'you want to author a new view — this writes a minimal, runnable view.mjs (with the contract + draw/host API documented inline) into the user or project scope, ready to open immediately with `crtr view run <name>` and to edit from there. Reach for it to start a new TUI surface rather than hand-writing the module',
+    description: 'scaffold a runnable dual-target view directory into a scope dir',
+    whenToUse: 'you want to author a new view — this writes the four contract files (core.mjs + tui.mjs + web.jsx + text.mjs, with the contract documented inline) into the user or project scope, ready to open immediately with `crtr view run <name>` (TUI) or `crtr view serve <name>` (web) and to edit from there. Reach for it to start a new view rather than hand-writing the directory',
     help: {
         name: 'view new',
-        summary: 'scaffold <viewsDir(scope)>/<name>/view.mjs from the stub; refuses if the name already resolves',
+        summary: 'scaffold <viewsDir(scope)>/<name>/{core,tui,text}.mjs + web.jsx from the stubs; refuses if the name already resolves',
         params: [
             { kind: 'positional', name: 'name', required: true, constraint: 'View id / directory name. Must not already resolve as a view.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Where to scaffold. Default: project if available, else user.' },
@@ -26,13 +27,14 @@ export const viewNewLeaf = defineLeaf({
             { kind: 'flag', name: 'description', type: 'string', required: false, constraint: 'Manifest description (picker + `view list`). Default: empty.' },
         ],
         output: [
-            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the scaffolded view.mjs.' },
+            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the scaffolded view directory.' },
+            { name: 'files', type: 'array', required: true, constraint: 'The filenames written into the view directory.' },
             { name: 'scope', type: 'string', required: true, constraint: 'The scope it was written to (user|project).' },
             { name: 'run', type: 'string', required: true, constraint: 'The command to run the new view.' },
         ],
         outputKind: 'object',
         effects: [
-            'Creates the view directory and view.mjs stub at the resolved location (mkdir -p).',
+            'Creates the view directory and the four contract files (core.mjs + tui.mjs + web.jsx + text.mjs) at the resolved location (mkdir -p).',
             'Initializes the project scope dir if --scope project is chosen and none exists yet.',
         ],
     },
@@ -48,7 +50,7 @@ export const viewNewLeaf = defineLeaf({
         // Refuse if a view of this name already resolves (any scope wins).
         const existing = resolveView(name);
         if (existing !== null) {
-            throw usage(`view already exists: ${name} (${existing.scope}) at ${existing.entry}. ` +
+            throw usage(`view already exists: ${name} (${existing.scope}) at ${existing.dir}. ` +
                 `Pick another name, or edit it directly.`);
         }
         // Ensure the project scope root exists before computing its views dir.
@@ -59,12 +61,14 @@ export const viewNewLeaf = defineLeaf({
             throw usage(`no ${scope} scope available to scaffold into — try --scope user.`);
         }
         const dir = join(baseDir, name);
-        const entry = join(dir, 'view.mjs');
-        if (existsSync(entry)) {
-            throw usage(`view file already exists: ${entry}`);
+        if (findViewDir(name) !== null || existsSync(join(dir, 'core.mjs'))) {
+            throw usage(`view directory already exists: ${dir}`);
         }
         mkdirSync(dir, { recursive: true });
-        writeFileSync(entry, viewScaffold({ id: name, title, description }), 'utf8');
-        return { path: entry, scope, run: `crtr view run ${name}` };
+        const files = viewScaffold({ id: name, title, description });
+        for (const [filename, content] of Object.entries(files)) {
+            writeFileSync(join(dir, filename), content, 'utf8');
+        }
+        return { path: dir, files: Object.keys(files), scope, run: `crtr view run ${name}` };
     },
 });

package/dist/commands/view-pick.js

@@ -7,7 +7,7 @@
 // plain list and exits 0. Reuses the core/tui terminal + draw primitives.
 import { execFileSync } from 'node:child_process';
 import { defineLeaf } from '../core/command.js';
-import { listViews } from '../core/tui/loader.js';
+import { listViews } from '../core/view/loader.js';
 import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from '../core/tui/terminal.js';
 import { createDraw, detectColorCaps } from '../core/tui/draw.js';
 export const viewPickLeaf = defineLeaf({

package/dist/commands/view-run.js

@@ -1,9 +1,11 @@
-// `crtr view run <name>` — resolve, load, and host a view.
+// `crtr view run <name>` — resolve, load, and host a view's TUI target.
 //
-// Resolves the view across scopes (project→user→builtin), dynamically imports
-// it, then hands it to the core/tui host. The host owns the screen and the
-// non-TTY path: when stdin is NOT a TTY it prints view.dump(state) and exits 0,
-// so `crtr view run <name> | cat` works anywhere. The interactive path is
+// Resolves the view across scopes (project→user→builtin), loads its core.mjs +
+// tui.mjs (+ optional text.mjs), then hands them to the dual-target core host.
+// The host owns the screen and the non-TTY path: when stdin is NOT a TTY it
+// prints the text presenter's dump and exits 0, so `crtr view run <name> | cat`
+// works anywhere. A view that ships no core.mjs is not a view — run fails with a
+// clear error naming the contract, never a fallback. The interactive path is
 // tmux-only (crtr is tmux-only) — outside tmux with a TTY we notify + no-op,
 // never a non-tmux fallback. --port / --target forward verbatim onto
 // host.options (camelCased, stringified); crtr does not interpret them.
@@ -17,8 +19,8 @@
 // a pipe (non-TTY) placement is meaningless, so they degrade to the static dump.
 import { defineLeaf } from '../core/command.js';
 import { InputError } from '../core/io.js';
-import { runView } from '../core/tui/host.js';
-import { resolveView, loadView, listViews } from '../core/tui/loader.js';
+import { runCoreView } from '../core/tui/host.js';
+import { resolveView, findViewDir, loadCore, loadTui, loadText, requireTui, listViews, } from '../core/view/loader.js';
 // Commands reach the tmux driver through placement.ts (the sanctioned
 // model-over-driver seam, §5.1) — never `./tmux.js` directly.
 import { inTmux, currentTmux, openNodeWindow, splitWindow, piCommand, setPaneOption, } from '../core/runtime/placement.js';
@@ -66,6 +68,17 @@ export const viewRunLeaf = defineLeaf({
         }
         const r = resolveView(name);
         if (r === null) {
+            // A directory exists but holds no core.mjs — it is not a valid view (e.g. a
+            // pre-contract `view.mjs`-only dir). Name the contract, don't fall back.
+            const dir = findViewDir(name);
+            if (dir !== null) {
+                throw new InputError({
+                    error: 'view_invalid',
+                    message: `'${name}' is not a valid view: ${dir} has no core.mjs`,
+                    received: name,
+                    next: `A view is a directory containing core.mjs (the portable core) plus optional tui.mjs (render + keymap), web.jsx, and text.mjs. Scaffold the shape with \`crtr view new ${name}\`.`,
+                });
+            }
             const avail = listViews().map((v) => v.id);
             throw new InputError({
                 error: 'view_not_found',
@@ -81,13 +94,22 @@ export const viewRunLeaf = defineLeaf({
             options.port = String(port);
         if (target !== undefined)
             options.target = target;
+        // Load + host the resolved view via the matching path (works for both the
+        // non-TTY dump and the interactive alt-screen — each host handles the TTY
+        // gate internally).
+        const hostView = async () => {
+            requireTui(r);
+            const core = await loadCore(r);
+            const tui = await loadTui(r);
+            const txt = await loadText(r);
+            await runCoreView(core, tui, txt, { options });
+        };
         // --window / --split: open the view as a persistent monitor in a new pane.
         if (asWindow || asSplit) {
             // Placement is tmux-only. In a pipe (non-TTY) it is meaningless — degrade
-            // to the static dump (runView handles the non-TTY path internally).
+            // to the static dump (the host handles the non-TTY path internally).
             if (!process.stdin.isTTY) {
-                const v = await loadView(r);
-                await runView(v, { options });
+                await hostView();
                 return;
             }
             if (!inTmux()) {
@@ -136,9 +158,8 @@ export const viewRunLeaf = defineLeaf({
             }
             return { hosted: 'split', view: name, pane };
         }
-        const v = await loadView(r);
         // The interactive path is tmux-only; the piped/non-TTY dump path works
-        // anywhere (runView handles it internally), so only guard when stdin is a
+        // anywhere (the host handles it internally), so only guard when stdin is a
         // TTY. Outside tmux with a TTY: notify + no-op — never a non-tmux fallback.
         if (process.stdin.isTTY && !inTmux()) {
             throw new InputError({
@@ -162,10 +183,10 @@ export const viewRunLeaf = defineLeaf({
             catch { /* best-effort */ }
         }
         try {
-            await runView(v, { options });
+            await hostView();
         }
         finally {
-            // On a clean quit (q) runView returns to the shell/pi that launched this
+            // On a clean quit (q) the host returns to the shell/pi that launched this
             // pane — clear the monitor tag so a stray Alt+V ]/[ can't respawn-pane -k
             // (and kill) whatever now owns the pane. When the cycle itself replaces
             // this view it SIGKILLs us mid-await (this finally never runs); cycle + the

package/dist/commands/view.js

@@ -1,10 +1,12 @@
 // `crtr view` — the TUI view library.
 //
-// Views are switchable raw-ANSI terminal surfaces, each a self-contained .mjs
-// the host loads and runs. This branch assembles the leaves: `list` enumerates
-// what's available, `run` hosts one (interactive in tmux, static dump when
-// piped), `new` scaffolds a fresh view.mjs, and the hidden `pick` backs the
-// /view popup. Each leaf owns its own help one level down.
+// Views are switchable surfaces with two targets from one portable core.mjs:
+// the tmux TUI (`run`) and a React+Tailwind web page. This branch assembles the
+// TUI-side leaves: `list` enumerates what's available, `run` hosts the TUI
+// target (interactive in tmux, static dump when piped), `new` scaffolds a fresh
+// view directory, and the hidden `pick` backs the /view popup. Each leaf owns
+// its own help one level down. The web target is no longer served per-view here:
+// it is hosted by the unified `crtr web serve` (the shell's /view/<id> route).
 import { defineBranch } from '../core/command.js';
 import { viewListLeaf } from './view-list.js';
 import { viewRunLeaf } from './view-run.js';
@@ -22,7 +24,7 @@ export function registerView() {
         help: {
             name: 'view',
             summary: 'host and author switchable raw-ANSI terminal views',
-            model: '`list` when you do not know which views exist — a flat roster (id/title/description/scope) across project→user→builtin. `run <name>` opens one full-screen in the current pane (tmux-only interactive; piped it prints the view\'s static dump and exits 0), forwarding --port/--target onto the view; pass --window/--split to open it as a persistent monitor (new window / split) you flip between with Alt+V then ]/[. `cycle` switches a monitor pane to the next/prev view in place (what those keys drive). `new <name>` scaffolds a runnable view.mjs stub you edit. `pick` is a hidden raw-ANSI picker the /view popup shells. Append `-h` at any leaf for its schema.',
+            model: '`list` when you do not know which views exist — a flat roster (id/title/description/scope) across project→user→builtin. `run <name>` opens the TUI target full-screen in the current pane (tmux-only interactive; piped it prints the view\'s static dump and exits 0), forwarding --port/--target onto the view; pass --window/--split to open it as a persistent monitor (new window / split) you flip between with Alt+V then ]/[. The web target (React+Tailwind) is served by the unified `crtr web serve` (the shell\'s /view/<id> route), not per-view here. `cycle` switches a monitor pane to the next/prev view in place (what those keys drive). `new <name>` scaffolds a runnable view directory (core.mjs + tui.mjs + web.jsx + text.mjs) you edit. `pick` is a hidden raw-ANSI picker the /view popup shells. Append `-h` at any leaf for its schema.',
         },
         children: [viewListLeaf, viewRunLeaf, viewCycleLeaf, viewNewLeaf, viewPickLeaf],
     });

package/dist/commands/workspace.d.ts

@@ -0,0 +1,2 @@
+import type { BranchDef } from '../core/command.js';
+export declare function registerWorkspace(): BranchDef;