@north-light/crouter 0.3.314 → 0.3.316

package/dist/api/plugin-manifest-schema.d.ts

@@ -161,7 +161,8 @@ export type ManifestNode<L extends ManifestLeafBase = ManifestLeaf> = ManifestBr
 /** One mount point in the manifest's self-contained forest. */
 export interface ManifestMount<L extends ManifestLeafBase = ManifestLeaf> {
     /** `[]` mounts `node` as a new top-level command; a non-empty path names a
-     *  branch this SAME manifest already contributes. */
+     *  branch this manifest already contributes or an extensible core branch.
+     *  `human` is currently the only extensible core branch. */
     parent: string[];
     node: ManifestNode<L>;
 }

package/dist/build-root.d.ts

@@ -5,6 +5,7 @@ import { type CoreHookCatalog } from './core/command-hooks/catalog.js';
 export declare const SUBTREE_NAMES: readonly string[];
 export declare function coreHookCatalog(): Promise<CoreHookCatalog>;
 export declare function coreCommandPaths(): Promise<ReadonlySet<string>>;
+export declare function extensibleCoreBranches(): Promise<ReadonlySet<string>>;
 /** Whether argv targets the daemon-control subtree after the dispatcher's global-token normalization. This only selects a smaller canonical tree; `runCli` still parses, renders help, and reports errors. */
 export declare function isDaemonControlInvocation(argv: readonly string[]): boolean;
 /** Assemble the canonical daemon-control definitions without loading settings or plugin discovery. This path exists so `crtr sys daemon restart` can start the new generation that converts pre-SQL user state. */

package/dist/build-root.js

@@ -1,4 +1,4 @@
-import { defineRoot, GLOBAL_TOKENS } from './core/command.js';
+import { defineBranch, defineRoot, GLOBAL_TOKENS } from './core/command.js';
 import { createCoreHookCatalog } from './core/command-hooks/catalog.js';
 import { composeCoreHooks } from './core/command-hooks/compose.js';
 import { mark } from './core/timing.js';
@@ -89,8 +89,7 @@ function hookRegistryLoader() {
         return registry;
     };
 }
-export async function coreCommandPaths() {
-    const core = await loadCoreSubtrees();
+function commandPathsFor(core) {
     const paths = new Set();
     const visit = (node, prefix) => {
         if (node.kind === 'branch' && node.passthrough !== undefined)
@@ -104,6 +103,40 @@ export async function coreCommandPaths() {
         visit(subtree, subtree.name);
     return paths;
 }
+export async function coreCommandPaths() {
+    return commandPathsFor(await loadCoreSubtrees());
+}
+export async function extensibleCoreBranches() {
+    return new Set((await loadCoreSubtrees()).filter((branch) => branch.extensible === true).map((branch) => branch.name));
+}
+async function composeCorePluginMounts(core) {
+    const extensible = new Set(core.filter((branch) => branch.extensible === true).map((branch) => branch.name));
+    if (extensible.size === 0)
+        return core;
+    const [{ buildExternalCommandSnapshot }, { composeCoreBranchMounts }] = await Promise.all([
+        import('./core/command-plugins/discovery.js'),
+        import('./core/command-plugins/compose.js'),
+    ]);
+    const snapshot = buildExternalCommandSnapshot(new Set(SUBTREE_NAMES), undefined, undefined, commandPathsFor(core), extensible);
+    return core.map((branch) => {
+        const mounted = composeCoreBranchMounts(snapshot.coreMounts, [branch.name]);
+        if (mounted.length === 0)
+            return branch;
+        const { listing: _listing, ...help } = branch.help;
+        return defineBranch({
+            name: branch.name,
+            ...(branch.description !== undefined ? { description: branch.description } : {}),
+            ...(branch.whenToUse !== undefined ? { whenToUse: branch.whenToUse } : {}),
+            ...(branch.tier !== undefined ? { tier: branch.tier } : {}),
+            ...(branch.rootEntry !== undefined ? { rootEntry: branch.rootEntry } : {}),
+            ...(branch.extensible === true ? { extensible: true } : {}),
+            ...(branch.slash !== undefined ? { slash: branch.slash } : {}),
+            ...(branch.passthrough !== undefined ? { passthrough: branch.passthrough } : {}),
+            help,
+            children: [...branch.children, ...mounted],
+        });
+    });
+}
 /** Whether argv targets the daemon-control subtree after the dispatcher's global-token normalization. This only selects a smaller canonical tree; `runCli` still parses, renders help, and reports errors. */
 export function isDaemonControlInvocation(argv) {
     const tokens = argv.slice(2).filter((token) => !GLOBAL_TOKENS.has(token));
@@ -123,7 +156,8 @@ export async function resolveDaemonControlRoot() {
 export async function resolveRoot(first) {
     const loader = first !== undefined ? SUBTREE_LOADERS[first] : undefined;
     if (loader !== undefined) {
-        return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: composeCoreHooks([await loader()], hookRegistryLoader()) });
+        const core = [await loader()];
+        return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: composeCoreHooks(await composeCorePluginMounts(core), hookRegistryLoader()) });
     }
     return buildRoot();
 }
@@ -156,8 +190,9 @@ export async function buildRoot() {
     // ONE collision-resolved snapshot over every command plugin transport. Core always wins: any external contribution claiming a core top-level
     // name is dropped + recorded as an issue (surfaced via pkg plugin show,
     // sys doctor). Reads only stored manifests — zero network.
-    const snapshot = buildExternalCommandSnapshot(new Set(SUBTREE_NAMES));
+    const composedCore = await composeCorePluginMounts(core);
+    const snapshot = buildExternalCommandSnapshot(new Set(SUBTREE_NAMES), undefined, undefined, commandPathsFor(core), new Set(composedCore.filter((branch) => branch.extensible === true).map((branch) => branch.name)));
     const external = composeExternalSubtrees(snapshot);
     // Only core leaves are hookable, so external contributions compose unwrapped.
-    return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: [...composeCoreHooks(core, hookRegistryLoader()), ...external] });
+    return defineRoot({ tagline: TAGLINE, globals: GLOBALS, subtrees: [...composeCoreHooks(composedCore, hookRegistryLoader()), ...external] });
 }

package/dist/commands/human.js

@@ -28,6 +28,7 @@ export function registerHuman() {
         : `Tickets queue in the human inbox; nothing opens on screen. \`send\` routes completion back when the page carries response-bearing components, and publishes a standalone announcement when it does not. ${durableRequests} \`review\` is for live document review with anchored comments; \`show\` is a passive tmux live-watch rather than a ticket.`;
     return defineBranch({
         name: 'human',
+        extensible: true,
         rootEntry: {
             concept,
             desc: pageSurface ? 'send, components, feedback, cancel, list' : 'send, review new/comment, show, cancel, list',

package/dist/commands/pkg/browse/catalog.js

@@ -2,7 +2,7 @@
 // live in actions.ts.
 import { statSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
-import { SUBTREE_NAMES, coreCommandPaths } from '../../../build-root.js';
+import { SUBTREE_NAMES, coreCommandPaths, extensibleCoreBranches } from '../../../build-root.js';
 import { discoverPluginCommandCandidates, validateEffectiveCommandPlugins, validatePluginCommands } from '../../../core/command-plugins/discovery.js';
 import { qualifiedTopLevelCommandName } from '../../../core/command-manifests/registry.js';
 import { listDirs, pathExists, walkFiles } from '../../../core/fs-utils.js';
@@ -391,15 +391,15 @@ export async function loadCapability(entry) {
         const scope = entry.install.kind === "installed" ? entry.install.scope : "user";
         const plugin = { name: entry.name, scope, root: entry.root, manifest, enabled: entry.install.kind !== "installed" || entry.install.enabled };
         const reserved = new Set(SUBTREE_NAMES);
-        const corePaths = await coreCommandPaths();
-        let validation = validatePluginCommands(plugin, reserved, corePaths);
+        const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
+        let validation = validatePluginCommands(plugin, reserved, corePaths, extensibleBranches);
         const registryIssues = [];
         // Effective validation resolves collisions for the command that is mounted
         // today. An uninstalled or disabled plugin is not in that registry, so its
         // dossier must validate the declared tree and preview the future result.
         if (entry.install.kind === "installed" && entry.install.enabled) {
             try {
-                const effective = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths);
+                const effective = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths, extensibleBranches);
                 validation = effective.find((candidate) => candidate.plugin.root === entry.root) ?? validation;
             }
             catch (error) {

package/dist/commands/pkg/plugin-inspect.js

@@ -6,7 +6,7 @@ import { listPluginMemoryDocs } from '../../core/memory-resolver.js';
 import { validatePluginCommands, validateEffectiveCommandPlugins } from '../../core/command-plugins/discovery.js';
 import { compileHookRegistry, discoverHookRegistry } from '../../core/command-hooks/discovery.js';
 import { hasDeclaredHooks, hookReport } from '../../core/command-hooks/report.js';
-import { SUBTREE_NAMES, coreCommandPaths, coreHookCatalog } from '../../build-root.js';
+import { SUBTREE_NAMES, coreCommandPaths, coreHookCatalog, extensibleCoreBranches } from '../../build-root.js';
 import { resolveScopeArg, projectScopeRoot } from '../../core/scope.js';
 async function hookInspectionReport(plugin) {
     if (!hasDeclaredHooks(plugin.manifest))
@@ -106,7 +106,7 @@ export const pluginShow = defineLeaf({
             { name: 'enabled', type: 'boolean', required: true, constraint: 'Whether the plugin is active.' },
             { name: 'manifest', type: 'object', required: true, constraint: 'Full plugin.json contents.' },
             { name: 'docs', type: 'object[]', required: true, constraint: 'Each: {name, path}. Memory docs provided by the plugin (its `<pluginName>/` memory subtree).' },
-            { name: 'commands', type: 'object', required: false, constraint: 'Present only when the plugin declares a command manifest (manifest.commands). {manifestPath: string, mounts: string[] (accepted top-level command names), extensibleBranches: string[] (mount names accepting repository fragments), issues: object[] ({code, path?, message, received, expected, next})}. Validated statically; command execution never occurs.' },
+            { name: 'commands', type: 'object', required: false, constraint: 'Present only when the plugin declares a command manifest (manifest.commands). {manifestPath: string, mounts: string[] (accepted command paths), extensibleBranches: string[] (plugin mount names accepting repository fragments), issues: object[] ({code, path?, message, received, expected, next})}. Validated statically; command execution never occurs.' },
             { name: 'hooks', type: 'object', required: false, constraint: 'Present for every hook declaration, including hook-only plugins. {manifestPath?, executablePath?, declarations: {target, phase, op, description, effects}[], lifecycle?: {event, phase, op, description, effects}[], issues: object[] ({code, path?, message, received, expected, next}), trust: string}. Static only: no hook executable runs.' },
         ],
         outputKind: 'object',
@@ -135,17 +135,17 @@ export const pluginShow = defineLeaf({
         let commands;
         if (typeof found.manifest.commands === 'string' && found.manifest.commands.length > 0) {
             const reserved = new Set(SUBTREE_NAMES);
-            const corePaths = await coreCommandPaths();
+            const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
             // Validate against the whole effective set so cross-plugin top-level
             // name collisions show up in this plugin's issues (a collided command is
             // NOT mounted). A copy outside the effective set (disabled, or shadowed
             // by a higher-precedence copy) cannot collide, so the per-plugin
             // validator is exact for it.
-            const v = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths).find((x) => x.plugin.root === found.root) ??
-                validatePluginCommands(found, reserved, corePaths);
+            const v = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths, extensibleBranches).find((x) => x.plugin.root === found.root) ??
+                validatePluginCommands(found, reserved, corePaths, extensibleBranches);
             commands = {
                 manifestPath: v.manifestPath,
-                mounts: v.contributions.map((c) => c.node.name),
+                mounts: [...v.contributions.map((c) => c.node.name), ...v.coreMounts.map((mount) => [...mount.parent, mount.node.name].join(' '))],
                 extensibleBranches: v.contributions.filter((c) => c.node.extensible === true).map((c) => c.node.name),
                 issues: v.issues,
             };

package/dist/commands/pkg/plugin-manage.js

@@ -25,7 +25,7 @@ import { validatePluginBundle } from '../../core/command-plugins/bundle.js';
 import { compileHookRegistry, discoverCandidateHookRegistry, discoverCandidateHookRegistryForCandidates, discoverHookRegistry } from '../../core/command-hooks/discovery.js';
 import { hasDeclaredHooks, hookReport } from '../../core/command-hooks/report.js';
 import { fetchHttpPluginBundle } from '../../core/command-plugins/transport/http-fetch.js';
-import { SUBTREE_NAMES, coreCommandPaths, coreHookCatalog } from '../../build-root.js';
+import { SUBTREE_NAMES, coreCommandPaths, coreHookCatalog, extensibleCoreBranches } from '../../build-root.js';
 import { isGitUrl, resolvePluginConfigTarget, setPluginEnabled, resolveInstallScope } from './shared.js';
 /** Validate a just-installed/updated plugin's command manifest, if it declares
  *  one. Returns undefined for plugins without a `commands` pointer. Never
@@ -36,13 +36,13 @@ async function commandReport(name, scope) {
         return undefined;
     }
     const reserved = new Set(SUBTREE_NAMES);
-    const corePaths = await coreCommandPaths();
+    const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
     // Report from the effective set so a cross-plugin top-level collision is
     // visible at install time (a collided command is NOT mounted). A copy
     // outside the effective set (disabled, or shadowed) cannot collide.
-    const v = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths).find((x) => x.plugin.root === plugin.root) ??
-        validatePluginCommands(plugin, reserved, corePaths);
-    return { mounts: v.contributions.map((c) => c.node.name), issues: v.issues };
+    const v = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths, extensibleBranches).find((x) => x.plugin.root === plugin.root) ??
+        validatePluginCommands(plugin, reserved, corePaths, extensibleBranches);
+    return { mounts: [...v.contributions.map((c) => c.node.name), ...v.coreMounts.map((mount) => [...mount.parent, mount.node.name].join(' '))], issues: v.issues };
 }
 const PLUGIN_NAME_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function validateHttpInstall(name, endpoint, authEnv) {
@@ -238,7 +238,8 @@ export async function assertPluginCandidateValid(manifest, root, scope, scopeRoo
     assertManifestPageComponentsValid(manifest, where);
     assertManifestBinValid(manifest, where);
     assertManifestRequiresValid(manifest, where);
-    const commandValidation = validatePluginCommands({ name: manifest.name, scope, root, manifest, enabled: true }, new Set(SUBTREE_NAMES), await coreCommandPaths());
+    const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
+    const commandValidation = validatePluginCommands({ name: manifest.name, scope, root, manifest, enabled: true }, new Set(SUBTREE_NAMES), corePaths, extensibleBranches);
     if (commandValidation.issues.length > 0) {
         throw invalidBundleError(`plugin command behavior at ${where} is invalid`, commandValidation.issues);
     }
@@ -296,7 +297,8 @@ function writeStagedBundle(stagingRoot, manifest, bundle) {
 async function validateStagedBundle(name, scope, root, scopeRootPath, manifest) {
     const memory = await assertPluginCandidateValid(manifest, root, scope, scopeRootPath, `${root}/.crouter-plugin/plugin.json`);
     const staged = { name, scope, root, manifest, enabled: true };
-    const validation = validatePluginCommands(staged, new Set(SUBTREE_NAMES), await coreCommandPaths());
+    const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
+    const validation = validatePluginCommands(staged, new Set(SUBTREE_NAMES), corePaths, extensibleBranches);
     if (validation.issues.length > 0) {
         throw invalidBundleError(`bundle staged package for "${name}" is invalid`, validation.issues);
     }
@@ -471,7 +473,8 @@ function isInstalledGeneration(name, scope, root, version) {
 }
 async function applyBundleArchive(name, scope, target, raw, etag, options, knownVersion) {
     const { bundle, transport, scopeRootPath, root } = target;
-    const validated = await validatePluginBundle(raw, { reservedCoreNames: new Set(SUBTREE_NAMES), coreCommandPaths: await coreCommandPaths() });
+    const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
+    const validated = await validatePluginBundle(raw, { reservedCoreNames: new Set(SUBTREE_NAMES), coreCommandPaths: corePaths, extensibleCoreBranches: extensibleBranches });
     if (validated.bundle === undefined)
         throw invalidBundleError(`HTTP plugin bundle for "${name}" is invalid`, validated.issues);
     const version = knownVersion ?? bundleVersion(raw);
@@ -881,7 +884,7 @@ export const pluginInstall = defineLeaf({
             { name: 'docs', type: 'integer', required: false, constraint: 'Memory document count written from an --endpoint archive.' },
             { name: 'kinds', type: 'integer', required: false, constraint: 'Kind-registry entry count declared by an --endpoint archive\u2019s bundle.json.' },
             { name: 'pageComponents', type: 'integer', required: false, constraint: 'Page-component registration count declared by an --endpoint archive\u2019s bundle.json.' },
-            { name: 'commands', type: 'object', required: false, constraint: 'Present only when the plugin declares a command manifest. {mounts: string[] (accepted top-level command names now live for the next invocation), issues: object[] (typed validation issues that rejected a contribution — {code, path?, message, received, expected, next})}. Validated statically; commands are never executed.' },
+            { name: 'commands', type: 'object', required: false, constraint: 'Present only when the plugin declares a command manifest. {mounts: string[] (accepted command paths now live for the next invocation), issues: object[] (typed validation issues that rejected a contribution — {code, path?, message, received, expected, next})}. Validated statically; commands are never executed.' },
             { name: 'hooks', type: 'object', required: false, constraint: 'Present only when the plugin declares hooks. {manifestPath?, executablePath?, declarations: {target, phase, op, description, effects}[], lifecycle?: {event, phase, op, description, effects}[], issues: object[], trust: string}. Command targets, lifecycle events, and replacement collisions are validated statically; hook executables are never run.' },
             { name: 'warnings', type: 'string[]', required: false, constraint: 'Advisory missing PATH executable requirements declared by the installed plugin. The install still succeeds and leaves the plugin enabled.' },
             { name: 'memory', type: 'object', required: false, constraint: 'Present only when the plugin ships a memory store. {docs: integer (documents checked), migrated: string[] (store-relative documents rewritten to reach exact canonical identity), linkedSource?: string (the caller-owned directory converged in place, present only when the install keeps that directory as a live link)}.' },
@@ -1064,7 +1067,7 @@ export const pluginUpdate = defineLeaf({
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Narrows resolution.' },
         ],
         output: [
-            { name: 'updated', type: 'object[]', required: true, constraint: 'One entry per plugin processed: {name, transport?, updated, sha?, version?, docs?, kinds?, pageComponents?, commands?, hooks?, memory?, warnings?, error?}. memory is present for a plugin shipping a memory store and reports the same corpus migration install performs: {docs, migrated, linkedSource?}. Archive plugins report transport=http and replace their complete directory after an authenticated refetch; version is the archive content identifier, docs is the written memory-document count, kinds is the declared kind-registry entry count, and pageComponents is the declared page-component registration count. sha is present for git updates. A bulk update reports and skips a failed archive plugin. commands is present for validated command plugins: {mounts: string[], issues: object[]}. hooks is present for plugins declaring hooks: {manifestPath?, executablePath?, declarations: {target, phase, op, description, effects}[], lifecycle?: {event, phase, op, description, effects}[], issues: object[], trust: string}; it is static and never executes hooks. warnings lists advisory PATH requirements that remain absent after update.' }
+            { name: 'updated', type: 'object[]', required: true, constraint: 'One entry per plugin processed: {name, transport?, updated, sha?, version?, docs?, kinds?, pageComponents?, commands?, hooks?, memory?, warnings?, error?}. memory is present for a plugin shipping a memory store and reports the same corpus migration install performs: {docs, migrated, linkedSource?}. Archive plugins report transport=http and replace their complete directory after an authenticated refetch; version is the archive content identifier, docs is the written memory-document count, kinds is the declared kind-registry entry count, and pageComponents is the declared page-component registration count. sha is present for git updates. A bulk update reports and skips a failed archive plugin. commands is present for validated command plugins: {mounts: string[] (accepted command paths), issues: object[]}. hooks is present for plugins declaring hooks: {manifestPath?, executablePath?, declarations: {target, phase, op, description, effects}[], lifecycle?: {event, phase, op, description, effects}[], issues: object[], trust: string}; it is static and never executes hooks. warnings lists advisory PATH requirements that remain absent after update.' }
         ],
         outputKind: 'object',
         effects: [

package/dist/commands/sys/doctor.js

@@ -20,7 +20,7 @@ import { resolveBinContributions } from '../../core/runtime/bin-contributions.js
 import { inspectHumanActions } from '../../core/human-actions.js';
 import { buildBrokerEnv, resolvePathExecutable } from '../../core/runtime/spawn-env.js';
 import { listAllPlugins } from '../../core/resolver.js';
-import { SUBTREE_NAMES, coreCommandPaths, coreHookCatalog } from '../../build-root.js';
+import { SUBTREE_NAMES, coreCommandPaths, coreHookCatalog, extensibleCoreBranches } from '../../build-root.js';
 import { processGeneration, processLocatedGeneration, runtimeManifest, selectedGeneration } from './shared.js';
 import { CONFIG_FILE } from '../../types.js';
 function pass(scope, name, message) {
@@ -125,7 +125,8 @@ export async function runCommandPluginChecks(scopes) {
     // collisions surface here. A collision no longer costs anyone their command:
     // each claimant mounts under an origin-qualified name, so it is reported as a
     // healthy mount rather than a failure demanding the user remove a plugin.
-    const validations = validateEffectiveCommandPlugins(reserved, undefined, undefined, await coreCommandPaths());
+    const [corePaths, extensibleBranches] = await Promise.all([coreCommandPaths(), extensibleCoreBranches()]);
+    const validations = validateEffectiveCommandPlugins(reserved, undefined, undefined, corePaths, extensibleBranches);
     for (const v of validations) {
         const plugin = v.plugin;
         if (!inScope.has(plugin.scope))

package/dist/core/__tests__/integration/command-plugins.test.js

@@ -117,6 +117,33 @@ function commandsJson(topName = 'app') {
         ],
     };
 }
+function humanCommandsJson(parent = ['human'], name = 'pr') {
+    return {
+        schemaVersion: 1,
+        helpAddenda: { human: 'Pull request review commands are provided by this plugin.' },
+        mounts: [{
+                parent,
+                node: {
+                    kind: 'branch',
+                    name,
+                    description: 'pull request review',
+                    whenToUse: 'a person needs to review a pull request',
+                    summary: 'review a pull request with a person',
+                    children: [{
+                            kind: 'leaf',
+                            name: 'review',
+                            description: 'start pull request review',
+                            whenToUse: 'the pull request is ready for review',
+                            summary: 'start one pull request review',
+                            params: [{ kind: 'flag', name: 'app-id', type: 'string', required: true, constraint: 'fixture pull request id' }],
+                            output: [{ name: 'app_id', type: 'string', required: true, constraint: 'echoed fixture pull request id' }, { name: 'status', type: 'string', required: false, constraint: 'fixture status' }],
+                            outputKind: 'object',
+                            effects: ['None. Read-only.'],
+                        }],
+                },
+            }],
+    };
+}
 function extensibleDemoCommandsJson(extensible = true) {
     return {
         schemaVersion: 1,
@@ -323,6 +350,62 @@ describe('registry composition', () => {
         assert.match(leafOut, /None\. Read-only\./);
     });
 });
+describe('extensible core mounts', () => {
+    test('a plugin mounts under human in real help and dispatch receives the full path', async () => {
+        installPlugin(userRoot, 'pr-review', { manifest: humanCommandsJson() });
+        resetScopeCache();
+        const { resolveRoot } = await import('../../../build-root.js');
+        const { runCli } = await import('../../command.js');
+        const root = await resolveRoot('human');
+        const chunks = [];
+        const realWrite = process.stdout.write.bind(process.stdout);
+        const realCwd = process.cwd();
+        const requestLog = join(emptyStart, 'human-mount-request.json');
+        process.env['FIXTURE_REQUEST_LOG'] = requestLog;
+        process.chdir(emptyStart);
+        process.stdout.write = ((chunk) => {
+            chunks.push(String(chunk));
+            return true;
+        });
+        try {
+            await runCli(root, ['node', 'crtr', 'human', '-h']);
+            await runCli(root, ['node', 'crtr', 'human', 'pr', 'review', '--app-id', '42', '--json']);
+        }
+        finally {
+            process.stdout.write = realWrite;
+            process.chdir(realCwd);
+            delete process.env['FIXTURE_REQUEST_LOG'];
+        }
+        assert.match(chunks.join(''), /name="pr"[^>]*plugin="pr-review"/);
+        assert.match(chunks.join(''), /<plugin-help plugin="pr-review">/);
+        assert.deepEqual(JSON.parse(readFileSync(requestLog, 'utf8')).command, ['human', 'pr', 'review']);
+    });
+    test('plugin installation accepts a human mount', async () => {
+        const source = join(mintDir('crtr-human-mount-source-'), 'fixture');
+        mkdirSync(join(source, '.crouter-plugin'), { recursive: true });
+        mkdirSync(join(source, 'bin'), { recursive: true });
+        writeFileSync(join(source, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name: 'human-mount-install', version: '0.1.0', description: 'fixture', commands: 'commands.json', transport: { kind: 'exec', executable: 'bin/cmd.js' } }));
+        writeFileSync(join(source, 'commands.json'), JSON.stringify(humanCommandsJson()));
+        writeFileSync(join(source, 'bin', 'cmd.js'), FIXTURE_EXEC);
+        chmodSync(join(source, 'bin', 'cmd.js'), 0o755);
+        await pluginInstall.run({ installRef: source, scope: 'user' });
+    });
+    test('only explicitly extensible core branches accept mounts and core children win collisions', () => {
+        const node = listInstalledPluginsInRoot('user', userRoot);
+        installPlugin(userRoot, 'wrong-parent', { manifest: humanCommandsJson(['node']) });
+        installPlugin(userRoot, 'core-child', { manifest: humanCommandsJson(['human'], 'send') });
+        resetScopeCache();
+        const plugins = listInstalledPluginsInRoot('user', userRoot);
+        const options = { reserved: new Set(['human', 'node']), paths: new Set(['human', 'human send']), extensible: new Set(['human']) };
+        const wrongParent = validatePluginCommands(plugins.find((plugin) => plugin.name === 'wrong-parent'), options.reserved, options.paths, options.extensible);
+        const coreChild = validatePluginCommands(plugins.find((plugin) => plugin.name === 'core-child'), options.reserved, options.paths, options.extensible);
+        assert.equal(wrongParent.contributions.length, 0);
+        assert.match(wrongParent.issues[0]?.next ?? '', /extensible core branches: human/);
+        assert.equal(coreChild.contributions.length, 0);
+        assert.match(coreChild.issues[0]?.message ?? '', /conflicts with a child the extensible core branch already owns/);
+        assert.equal(node.length, 0);
+    });
+});
 // 2. Core collision
 describe('core collision', () => {
     test('a fixture claiming a core top-level name is skipped + recorded', () => {
@@ -872,6 +955,7 @@ describe('plugin help addenda', () => {
     const gate = (paths) => ({
         reservedCoreNames: RESERVED,
         coreCommandPaths: () => Promise.resolve(new Set(paths)),
+        extensibleCoreBranches: () => Promise.resolve(new Set(['human'])),
     });
     test('a helpAddenda entry survives validation and is collected attributed to its plugin', async () => {
         const m = commandsJson();

package/dist/core/command-manifests/manifest.d.ts

@@ -1,10 +1,17 @@
 import type { DeclLeaf, DeclNode, TransportKind, ManifestTimeouts, CommandManifestIssue } from './schema.js';
+export interface ValidatedCoreMount {
+    /** The explicitly extensible core branch receiving this plugin node. */
+    parent: string[];
+    node: DeclNode<DeclLeaf>;
+}
 export interface ValidatedCommandManifest {
     schemaVersion: 1;
     baseUrl?: string;
     timeouts?: ManifestTimeouts;
     /** Top-level plugin branches or repository-fragment nodes, ready to mount. */
     roots: DeclNode<DeclLeaf>[];
+    /** Plugin nodes mounted below an explicitly extensible core branch. */
+    coreMounts: ValidatedCoreMount[];
     /** Core command path (space-joined, e.g. "cron add") → attributed addendum
      *  text appended beneath that core command's help. Append-only product
      *  guidance — a plugin can never alter core contract text. */
@@ -36,4 +43,6 @@ export declare function validateCommandManifest(raw: unknown, options: {
     coreCommandPaths?: ReadonlySet<string>;
     /** A repository fragment attaches roots below an existing extensible branch. */
     extensionFragment?: boolean;
+    /** Core branch names that accept plugin children. */
+    extensibleCoreBranches?: ReadonlySet<string>;
 }): CommandManifestValidation;

package/dist/core/command-manifests/manifest.js

@@ -108,8 +108,20 @@ export function validateCommandManifest(raw, options) {
             return { issues };
         validatedMounts.push(m);
     }
-    // Materialize the forest: merge inline children with mounted nodes
-    const roots = materializeForest(validatedMounts, options.reservedCoreNames, issue);
+    // Materialize plugin-local trees separately from mounts below an explicitly
+    // extensible core branch. Core mounts remain nodes, never fake plugin roots.
+    const coreMounts = validatedMounts.filter((mount) => mount.parent.length > 0 && options.extensibleCoreBranches?.has(mount.parent[0]) === true);
+    for (const mount of coreMounts) {
+        if (mount.parent.length !== 1) {
+            issue('command_parent_invalid', 'core mount parent must name an extensible core branch directly', mount.parent.join('.'), `one extensible core branch (one of: ${[...(options.extensibleCoreBranches ?? [])].join(', ')})`, `Mount below one of the extensible core branches: ${[...(options.extensibleCoreBranches ?? [])].join(', ')}.`, mount.parent.join('.'));
+            return { issues };
+        }
+        if (options.coreCommandPaths?.has(`${mount.parent[0]} ${mount.node.name}`) === true) {
+            issue('command_collision', `contributed command "${mount.node.name}" conflicts with a child the extensible core branch already owns`, mount.node.name, `a name not already owned by the ${mount.parent[0]} core branch`, 'Rename the contributed command or remove this mount.', `${mount.parent.join('.')}.${mount.node.name}`);
+            return { issues };
+        }
+    }
+    const roots = materializeForest(validatedMounts.filter((mount) => !coreMounts.includes(mount)), options.reservedCoreNames, options.extensibleCoreBranches, issue);
     if (roots === null)
         return { issues };
     // If we got here with no issues, return the validated manifest
@@ -121,6 +133,7 @@ export function validateCommandManifest(raw, options) {
                 ...(timeouts !== undefined ? { timeouts } : {}),
                 ...(helpAddenda !== undefined ? { helpAddenda } : {}),
                 roots,
+                coreMounts,
             },
             issues: [],
         };
@@ -220,7 +233,7 @@ function validateMount(raw, index, transport, issue, nodeOptions) {
  * Materializes a flat list of mounts into a forest of top-level branches,
  * resolving nested mounts whose parent exists in a top-level inline tree regardless of order. Nested mounts that provide another nested mount's parent must appear first. Validates self-containment and no duplicates.
  */
-function materializeForest(mounts, reservedCoreNames, issue) {
+function materializeForest(mounts, reservedCoreNames, extensibleCoreBranches, issue) {
     // Separate top-level (parent: []) from nested (parent non-empty)
     const topLevel = mounts.filter((m) => m.parent.length === 0);
     const nested = mounts.filter((m) => m.parent.length > 0);
@@ -235,6 +248,12 @@ function materializeForest(mounts, reservedCoreNames, issue) {
     const roots = topLevel.map((m) => m.node.kind === 'branch'
         ? { ...m.node, children: [...m.node.children] }
         : { ...m.node });
+    for (const mount of nested) {
+        if (reservedCoreNames.has(mount.parent[0])) {
+            issue('command_parent_invalid', 'parent path starts with a core branch that is not extensible', mount.parent[0], `an extensible core branch (one of: ${[...(extensibleCoreBranches ?? [])].join(', ')})`, `Mount below one of the extensible core branches: ${[...(extensibleCoreBranches ?? [])].join(', ')}.`, mount.parent.join('.'));
+            return null;
+        }
+    }
     // Attach nested mounts
     for (const mount of nested) {
         const resolved = resolveAndAttachMount(roots, mount, issue);

package/dist/core/command-manifests/registry.d.ts

@@ -1,5 +1,5 @@
 import type { LeafDef } from '../command.js';
-import type { DeclLeafBase, DeclBranch, CommandManifestIssue } from './schema.js';
+import type { DeclLeafBase, DeclBranch, DeclNode, CommandManifestIssue } from './schema.js';
 import type { ExtensionIssueNotice } from '../command-plugins/extensions.js';
 /** Reference to an external contributor (plugin or HTTP-transport plugin). */
 export type CommandContributorRef = {
@@ -37,12 +37,22 @@ export interface CommandContribution {
 export interface ContributorIssue extends CommandManifestIssue {
     contributor: CommandContributorRef;
 }
+/** One plugin node accepted below an explicitly extensible core branch. */
+export interface CoreBranchMount {
+    parent: string[];
+    contributor: CommandContributorRef;
+    plugin: string;
+    node: DeclNode;
+    adaptLeaf: LeafAdapter;
+}
 /** Invocation-local registry snapshot after collision resolution: the accepted
  *  contributions and every discovered issue. */
 export interface CommandRegistrySnapshot {
     /** Accepted top-level contributions, deterministically ordered by
      *  contributor name. */
     contributions: CommandContribution[];
+    /** Accepted plugin nodes below an extensible core branch. */
+    coreMounts: CoreBranchMount[];
     /** Every discovered issue, including collisions. */
     issues: ContributorIssue[];
 }

package/dist/core/command-manifests/registry.js

@@ -112,6 +112,7 @@ export function resolveCommandRegistry(candidates, reservedCoreNames) {
         a.node.name.localeCompare(b.node.name));
     return {
         contributions: accepted,
+        coreMounts: [],
         issues,
     };
 }

package/dist/core/command-plugins/bundle.d.ts

@@ -48,4 +48,5 @@ export interface PluginBundleValidation {
 export declare function validatePluginBundle(archive: Uint8Array, options: {
     reservedCoreNames: ReadonlySet<string>;
     coreCommandPaths?: ReadonlySet<string>;
+    extensibleCoreBranches?: ReadonlySet<string>;
 }): Promise<PluginBundleValidation>;

package/dist/core/command-plugins/bundle.js

@@ -187,7 +187,7 @@ function parseBundleMetadata(bytes) {
         ...(memoryExtensions !== undefined ? { memory_extensions: memoryExtensions } : {}),
     };
 }
-function parseCommands(bytes, reservedCoreNames, coreCommandPaths) {
+function parseCommands(bytes, reservedCoreNames, coreCommandPaths, extensibleCoreBranches = new Set()) {
     let raw;
     try {
         raw = JSON.parse(Buffer.from(bytes).toString('utf8'));
@@ -197,7 +197,7 @@ function parseCommands(bytes, reservedCoreNames, coreCommandPaths) {
             issues: [bundleInvalid('commands.json is not valid JSON', 'invalid JSON', 'a valid command-manifest JSON object', 'Regenerate commands.json.', 'commands.json')],
         };
     }
-    const validation = validateCommandManifest(raw, { transport: 'http', reservedCoreNames, ...(coreCommandPaths !== undefined ? { coreCommandPaths } : {}) });
+    const validation = validateCommandManifest(raw, { transport: 'http', reservedCoreNames, extensibleCoreBranches, ...(coreCommandPaths !== undefined ? { coreCommandPaths } : {}) });
     return {
         ...(validation.manifest !== undefined ? { commands: validation.manifest } : {}),
         issues: validation.issues,
@@ -232,7 +232,7 @@ export async function validatePluginBundle(archive, options) {
     const metadata = parseBundleMetadata(bundle.bytes);
     if (metadata.issue !== undefined)
         return { issues: [metadata.issue] };
-    const commandValidation = parseCommands(commands.bytes, options.reservedCoreNames, options.coreCommandPaths);
+    const commandValidation = parseCommands(commands.bytes, options.reservedCoreNames, options.coreCommandPaths, options.extensibleCoreBranches);
     if (commandValidation.commands === undefined)
         return { issues: commandValidation.issues };
     return {

package/dist/core/command-plugins/compose.d.ts

@@ -1,5 +1,7 @@
-import type { BranchDef } from '../command.js';
-import type { CommandRegistrySnapshot } from '../command-manifests/registry.js';
-import type { ValidatedContribution } from './discovery.js';
+import type { BranchDef, LeafDef } from '../command.js';
+import type { CommandRegistrySnapshot, CoreBranchMount } from '../command-manifests/registry.js';
+import type { ValidatedContribution, ValidatedCoreMount } from './discovery.js';
 export declare function adaptPluginContributions(contributions: ValidatedContribution[]): CommandRegistrySnapshot;
+export declare function adaptPluginCoreMounts(mounts: ValidatedCoreMount[]): CoreBranchMount[];
 export declare function composeExternalSubtrees(snapshot: CommandRegistrySnapshot): BranchDef[];
+export declare function composeCoreBranchMounts(mounts: readonly CoreBranchMount[], parent: string[]): (BranchDef | LeafDef)[];

package/dist/core/command-plugins/compose.js

@@ -1,47 +1,65 @@
 import { defineBranch, defineLeaf } from '../command.js';
 import { executeExternalLeaf } from './transport/exec-invoke.js';
 import { invokeHttpLeaf } from './transport/http-invoke.js';
+function adaptLeaf(contribution, commandPathFor) {
+    return (leaf, commandPath) => {
+        const transport = contribution.transport;
+        const manifestCommandPath = commandPathFor(commandPath);
+        if (transport.kind === 'exec') {
+            const executable = transport.executable;
+            if (executable === undefined)
+                throw new Error(`exec plugin "${contribution.plugin.name}" has an executable leaf without transport.executable`);
+            return {
+                outputKind: 'object',
+                run: async (input) => executeExternalLeaf({ plugin: contribution.plugin, executable, commandPath: manifestCommandPath, output: leaf.output }, input),
+            };
+        }
+        const httpLeaf = leaf;
+        return {
+            outputKind: httpLeaf.rest.streaming === true ? 'jsonl' : 'object',
+            run: (input, context) => invokeHttpLeaf({
+                registration: { name: contribution.plugin.name, endpoint: transport.endpoint, ...(transport.authEnv !== undefined ? { authEnv: transport.authEnv } : {}) },
+                ...(contribution.manifest?.baseUrl !== undefined ? { baseUrl: contribution.manifest.baseUrl } : {}),
+                ...(contribution.manifest?.timeouts !== undefined ? { timeouts: contribution.manifest.timeouts } : {}),
+                params: httpLeaf.params, rest: httpLeaf.rest, output: httpLeaf.output, commandPath: manifestCommandPath,
+            }, input, context),
+        };
+    };
+}
 export function adaptPluginContributions(contributions) {
     return {
         contributions: contributions.map((contribution) => ({
             contributor: { name: contribution.plugin.name, scope: contribution.plugin.scope, sourceMarketplace: contribution.plugin.sourceMarketplace },
             node: contribution.node,
             manifestName: contribution.manifestName,
-            adaptLeaf: (leaf, commandPath) => {
-                const transport = contribution.transport;
-                const manifestCommandPath = [contribution.manifestName, ...commandPath.slice(1)];
-                if (transport.kind === 'exec') {
-                    const executable = transport.executable;
-                    if (executable === undefined)
-                        throw new Error(`exec plugin "${contribution.plugin.name}" has an executable leaf without transport.executable`);
-                    return {
-                        outputKind: 'object',
-                        run: async (input) => executeExternalLeaf({ plugin: contribution.plugin, executable, commandPath: manifestCommandPath, output: leaf.output }, input),
-                    };
-                }
-                const httpLeaf = leaf;
-                return {
-                    outputKind: httpLeaf.rest.streaming === true ? 'jsonl' : 'object',
-                    run: (input, context) => invokeHttpLeaf({
-                        registration: { name: contribution.plugin.name, endpoint: transport.endpoint, ...(transport.authEnv !== undefined ? { authEnv: transport.authEnv } : {}) },
-                        ...(contribution.manifest?.baseUrl !== undefined ? { baseUrl: contribution.manifest.baseUrl } : {}),
-                        ...(contribution.manifest?.timeouts !== undefined ? { timeouts: contribution.manifest.timeouts } : {}),
-                        params: httpLeaf.params, rest: httpLeaf.rest, output: httpLeaf.output, commandPath: manifestCommandPath,
-                    }, input, context),
-                };
-            },
+            adaptLeaf: adaptLeaf(contribution, (commandPath) => [contribution.manifestName, ...commandPath.slice(1)]),
         })),
+        coreMounts: [],
         issues: [],
     };
 }
+export function adaptPluginCoreMounts(mounts) {
+    return mounts.map((mount) => ({
+        parent: mount.parent,
+        plugin: mount.plugin.name,
+        contributor: { name: mount.plugin.name, scope: mount.plugin.scope, sourceMarketplace: mount.plugin.sourceMarketplace },
+        node: mount.node,
+        adaptLeaf: adaptLeaf({ ...mount, manifestName: mount.node.name }, (commandPath) => [...commandPath]),
+    }));
+}
 export function composeExternalSubtrees(snapshot) {
     return snapshot.contributions.map((contribution) => buildBranch(contribution, contribution.node, [contribution.node.name]));
 }
+export function composeCoreBranchMounts(mounts, parent) {
+    return mounts.filter((mount) => mount.parent.join('\u0000') === parent.join('\u0000')).map((mount) => mount.node.kind === 'branch'
+        ? buildBranch(mount, mount.node, [...parent, mount.node.name])
+        : buildLeaf(mount, mount.node, [...parent, mount.node.name]));
+}
 function buildBranch(contribution, node, path) {
     const rootEntry = node.rootEntry === undefined ? undefined : { concept: node.rootEntry.concept, desc: node.rootEntry.description, useWhen: node.rootEntry.whenToUse };
-    return defineBranch({ name: node.name, description: node.description, whenToUse: node.whenToUse, ...(node.tier !== undefined ? { tier: node.tier } : {}), ...(rootEntry !== undefined ? { rootEntry } : {}), help: { name: path.join(' '), summary: node.summary, ...(node.model !== undefined ? { model: node.model } : {}), ...(path.length === 1 && contribution.extensionIssue !== undefined ? { extensionIssue: contribution.extensionIssue } : {}) }, ...(node.passthrough !== undefined ? { passthrough: node.passthrough } : {}), children: node.children.map((child) => child.kind === 'branch' ? buildBranch(contribution, child, [...path, child.name]) : buildLeaf(contribution, child, [...path, child.name])) });
+    return defineBranch({ name: node.name, description: node.description, whenToUse: node.whenToUse, ...(node.tier !== undefined ? { tier: node.tier } : {}), ...(contribution.plugin !== undefined ? { plugin: contribution.plugin } : {}), ...(rootEntry !== undefined ? { rootEntry } : {}), help: { name: path.join(' '), summary: node.summary, ...(node.model !== undefined ? { model: node.model } : {}), ...(path.length === 1 && contribution.extensionIssue !== undefined ? { extensionIssue: contribution.extensionIssue } : {}) }, ...(node.passthrough !== undefined ? { passthrough: node.passthrough } : {}), children: node.children.map((child) => child.kind === 'branch' ? buildBranch(contribution, child, [...path, child.name]) : buildLeaf(contribution, child, [...path, child.name])) });
 }
 function buildLeaf(contribution, node, path) {
     const adapted = contribution.adaptLeaf(node, path);
-    return defineLeaf({ name: node.name, description: node.description, whenToUse: node.whenToUse, ...(node.tier !== undefined ? { tier: node.tier } : {}), help: { name: path.join(' '), summary: node.summary, params: node.params, output: node.output, outputKind: adapted.outputKind, effects: [...node.effects] }, run: adapted.run });
+    return defineLeaf({ name: node.name, description: node.description, whenToUse: node.whenToUse, ...(node.tier !== undefined ? { tier: node.tier } : {}), ...(contribution.plugin !== undefined ? { plugin: contribution.plugin } : {}), help: { name: path.join(' '), summary: node.summary, params: node.params, output: node.output, outputKind: adapted.outputKind, effects: [...node.effects] }, run: adapted.run });
 }

package/dist/core/command-plugins/discovery.d.ts

@@ -16,6 +16,13 @@ export interface ValidatedContribution {
     manifest: ValidatedCommandManifest;
     manifestName: string;
 }
+export interface ValidatedCoreMount {
+    plugin: InstalledPlugin;
+    transport: PluginTransport;
+    parent: string[];
+    node: DeclNode;
+    manifest: ValidatedCommandManifest;
+}
 export interface PluginCommandValidation {
     plugin: InstalledPlugin;
     manifestPath: string;
@@ -24,14 +31,16 @@ export interface PluginCommandValidation {
      *  Carries `helpAddenda` for the help-render lookup. */
     manifest?: ValidatedCommandManifest;
     contributions: ValidatedContribution[];
+    coreMounts: ValidatedCoreMount[];
     issues: CommandDiscoveryIssue[];
 }
 export declare function effectiveCommandPlugins(startDir?: string, profileId?: string | null): InstalledPlugin[];
-export declare function validatePluginCommands(plugin: InstalledPlugin, reservedNames?: ReadonlySet<string>, coreCommandPaths?: ReadonlySet<string>): PluginCommandValidation;
+export declare function validatePluginCommands(plugin: InstalledPlugin, reservedNames?: ReadonlySet<string>, coreCommandPaths?: ReadonlySet<string>, extensibleCoreBranches?: ReadonlySet<string>): PluginCommandValidation;
 export declare function discoverPluginCommandCandidates(startDir?: string, profileId?: string | null): PluginCommandValidation[];
-export declare function validateEffectiveCommandPlugins(reservedNames: ReadonlySet<string>, startDir?: string, profileId?: string | null, coreCommandPaths?: ReadonlySet<string>): PluginCommandValidation[];
-export declare function discoverCommandContributions(reservedNames: ReadonlySet<string>, startDir?: string, profileId?: string | null): {
+export declare function validateEffectiveCommandPlugins(reservedNames: ReadonlySet<string>, startDir?: string, profileId?: string | null, coreCommandPaths?: ReadonlySet<string>, extensibleCoreBranches?: ReadonlySet<string>): PluginCommandValidation[];
+export declare function discoverCommandContributions(reservedNames: ReadonlySet<string>, startDir?: string, profileId?: string | null, coreCommandPaths?: ReadonlySet<string>, extensibleCoreBranches?: ReadonlySet<string>): {
     contributions: ValidatedContribution[];
+    coreMounts: ValidatedCoreMount[];
     issues: CommandDiscoveryIssue[];
 };
-export declare function buildExternalCommandSnapshot(reservedCoreNames: ReadonlySet<string>, startDir?: string, profileId?: string | null): CommandRegistrySnapshot;
+export declare function buildExternalCommandSnapshot(reservedCoreNames: ReadonlySet<string>, startDir?: string, profileId?: string | null, coreCommandPaths?: ReadonlySet<string>, extensibleCoreBranches?: ReadonlySet<string>): CommandRegistrySnapshot;

package/dist/core/command-plugins/discovery.js

@@ -4,7 +4,7 @@ import { listInstalledPlugins, listInstalledPluginsInRoot } from '../resolver.js
 import { projectScopeRoots } from '../scope.js';
 import { validateCommandManifest } from '../command-manifests/manifest.js';
 import { qualifiedTopLevelCommandName, resolveCommandRegistry } from '../command-manifests/registry.js';
-import { adaptPluginContributions } from './compose.js';
+import { adaptPluginContributions, adaptPluginCoreMounts } from './compose.js';
 import { validateHttpPluginTransport } from './endpoint.js';
 import { applyCommandExtensions } from './extensions.js';
 export function effectiveCommandPlugins(startDir = process.cwd(), profileId) {
@@ -64,9 +64,12 @@ function transportFor(plugin, issues) {
 function hasExecutableLeaf(node) {
     return node.kind === 'leaf' || node.children.some(hasExecutableLeaf);
 }
+function manifestNodes(manifest) {
+    return [...manifest.roots, ...manifest.coreMounts.map((mount) => mount.node)];
+}
 function validateExecExecutable(plugin, transport, manifest, issues) {
     if (transport.executable === undefined) {
-        if (!manifest.roots.some(hasExecutableLeaf))
+        if (!manifestNodes(manifest).some(hasExecutableLeaf))
             return transport;
         issues.push({ code: 'command_manifest_invalid', plugin: plugin.name, message: 'exec transport requires executable when commands.json declares executable leaves', received: '(missing)', expected: '{ kind: "exec", executable: "plugin-relative path" }', next: 'Add plugin.json.transport.executable.', path: 'transport.executable' });
         return undefined;
@@ -110,28 +113,29 @@ function resolvePassthroughBinaries(plugin, manifest, issues) {
         for (const child of node.children)
             visit(child);
     };
-    for (const root of manifest.roots)
+    for (const root of manifestNodes(manifest))
         visit(root);
     return valid;
 }
-export function validatePluginCommands(plugin, reservedNames = new Set(), coreCommandPaths) {
+export function validatePluginCommands(plugin, reservedNames = new Set(), coreCommandPaths, extensibleCoreBranches = new Set()) {
     const issues = [];
     const commands = plugin.manifest.commands;
     const transportRaw = plugin.manifest.transport;
     let manifestPath = resolve(plugin.root, typeof commands === 'string' ? commands : 'commands.json');
+    const empty = (transport) => ({ plugin, manifestPath, ...(transport === undefined ? {} : { transport }), contributions: [], coreMounts: [], issues });
     if (commands === undefined && transportRaw === undefined)
-        return { plugin, manifestPath, contributions: [], issues };
+        return empty();
     if (typeof commands !== 'string' || commands.length === 0) {
         issues.push({ code: 'command_manifest_invalid', plugin: plugin.name, message: 'transport requires commands in plugin.json', received: '(missing)', expected: 'a plugin-root-relative commands path', next: 'Add plugin.json.commands or remove transport.', path: 'commands' });
-        return { plugin, manifestPath, contributions: [], issues };
+        return empty();
     }
     const transport = transportFor(plugin, issues);
     if (transport === undefined)
-        return { plugin, manifestPath, contributions: [], issues };
+        return empty();
     const safe = safePath(plugin.root, commands);
     if (safe === null) {
         issues.push({ code: 'command_path_unsafe', plugin: plugin.name, message: 'commands pointer escapes the plugin root or is not a regular file', received: commands, expected: 'a relative path to a regular file inside the plugin root', next: 'Fix plugin.json.commands.', path: 'commands' });
-        return { plugin, manifestPath, transport, contributions: [], issues };
+        return empty(transport);
     }
     manifestPath = safe;
     let bytes;
@@ -143,7 +147,7 @@ export function validatePluginCommands(plugin, reservedNames = new Set(), coreCo
     }
     if (bytes === null) {
         issues.push({ code: 'command_manifest_unreadable', plugin: plugin.name, message: 'commands.json is missing or unreadable', received: safe, expected: 'a readable JSON file', next: 'Reinstall or update the plugin.' });
-        return { plugin, manifestPath, transport, contributions: [], issues };
+        return empty(transport);
     }
     let raw;
     try {
@@ -151,32 +155,39 @@ export function validatePluginCommands(plugin, reservedNames = new Set(), coreCo
     }
     catch {
         issues.push({ code: 'command_manifest_invalid', plugin: plugin.name, message: 'commands.json is not valid JSON', received: safe, expected: 'a JSON object', next: 'Regenerate commands.json.' });
-        return { plugin, manifestPath, transport, contributions: [], issues };
+        return empty(transport);
     }
-    const validation = validateCommandManifest(raw, { transport: transport.kind, reservedCoreNames: reservedNames, ...(coreCommandPaths !== undefined ? { coreCommandPaths } : {}) });
+    const validation = validateCommandManifest(raw, { transport: transport.kind, reservedCoreNames: reservedNames, extensibleCoreBranches, ...(coreCommandPaths !== undefined ? { coreCommandPaths } : {}) });
     if (validation.manifest === undefined) {
         validation.issues.forEach(issueFor(plugin, issues));
-        return { plugin, manifestPath, transport, contributions: [], issues };
+        return empty(transport);
     }
     const resolvedTransport = transport.kind === 'exec'
         ? validateExecExecutable(plugin, transport, validation.manifest, issues)
         : transport;
     if (resolvedTransport === undefined)
-        return { plugin, manifestPath, transport, contributions: [], issues };
-    if (resolvedTransport.kind === 'exec' && !resolvePassthroughBinaries(plugin, validation.manifest, issues)) {
-        return { plugin, manifestPath, transport: resolvedTransport, contributions: [], issues };
-    }
+        return empty(transport);
+    if (resolvedTransport.kind === 'exec' && !resolvePassthroughBinaries(plugin, validation.manifest, issues))
+        return empty(resolvedTransport);
     const roots = validation.manifest.roots;
     if (!roots.every((node) => node.kind === 'branch')) {
         throw new Error('plugin manifest validation returned a top-level leaf');
     }
-    return { plugin, manifestPath, transport: resolvedTransport, manifest: validation.manifest, contributions: roots.map((node) => ({ plugin, transport: resolvedTransport, node, manifest: validation.manifest, manifestName: node.name })), issues };
+    return {
+        plugin,
+        manifestPath,
+        transport: resolvedTransport,
+        manifest: validation.manifest,
+        contributions: roots.map((node) => ({ plugin, transport: resolvedTransport, node, manifest: validation.manifest, manifestName: node.name })),
+        coreMounts: validation.manifest.coreMounts.map((mount) => ({ plugin, transport: resolvedTransport, parent: mount.parent, node: mount.node, manifest: validation.manifest })),
+        issues,
+    };
 }
 export function discoverPluginCommandCandidates(startDir = process.cwd(), profileId) {
     return effectiveCommandPlugins(startDir, profileId).map((plugin) => validatePluginCommands(plugin));
 }
-export function validateEffectiveCommandPlugins(reservedNames, startDir = process.cwd(), profileId, coreCommandPaths) {
-    const validations = effectiveCommandPlugins(startDir, profileId).map((plugin) => validatePluginCommands(plugin, reservedNames, coreCommandPaths));
+export function validateEffectiveCommandPlugins(reservedNames, startDir = process.cwd(), profileId, coreCommandPaths, extensibleCoreBranches = new Set()) {
+    const validations = effectiveCommandPlugins(startDir, profileId).map((plugin) => validatePluginCommands(plugin, reservedNames, coreCommandPaths, extensibleCoreBranches));
     const claims = new Map();
     for (const validation of validations)
         for (const contribution of validation.contributions) {
@@ -195,19 +206,40 @@ export function validateEffectiveCommandPlugins(reservedNames, startDir = proces
                 validation.contributions = validation.contributions.map((contribution) => contribution === claimant ? { ...contribution, node: { ...contribution.node, name: qualifiedName } } : contribution);
                 validation.issues.push({ code: 'command_collision', plugin: plugin.name, path: name, message: `top-level command "${name}" is claimed by ${claimants.map((entry) => entry.plugin.name).join(', ')} — mounted as "${qualifiedName}"`, received: claimants.map((entry) => entry.plugin.name).join(', '), expected: 'an origin-qualified top-level command for each claimant', next: `Invoke "${qualifiedName}" to use this plugin command.` });
             }
+    const coreClaims = new Map();
+    for (const validation of validations)
+        for (const mount of validation.coreMounts) {
+            const key = [...mount.parent, mount.node.name].join('/');
+            const claimants = coreClaims.get(key);
+            if (claimants === undefined)
+                coreClaims.set(key, [mount]);
+            else
+                claimants.push(mount);
+        }
+    for (const [path, claimants] of coreClaims)
+        if (claimants.length > 1)
+            for (const claimant of claimants) {
+                const validation = validations.find((candidate) => candidate.plugin.root === claimant.plugin.root);
+                validation.coreMounts = validation.coreMounts.filter((mount) => mount !== claimant);
+                validation.issues.push({ code: 'command_collision', plugin: claimant.plugin.name, path: path.replace('/', '.'), message: `contributed command "${claimant.node.name}" conflicts with another plugin child below the extensible core branch`, received: claimants.map((entry) => entry.plugin.name).join(', '), expected: `a unique child name below ${claimant.parent.join('.')}`, next: 'Rename the contributed command or remove this mount.' });
+            }
     return validations;
 }
 function contributorIssue(plugin, issue) {
     return { ...issue, contributor: { name: plugin.name, scope: plugin.scope, sourceMarketplace: plugin.sourceMarketplace } };
 }
-export function discoverCommandContributions(reservedNames, startDir = process.cwd(), profileId) {
-    const validations = validateEffectiveCommandPlugins(reservedNames, startDir, profileId);
-    return { contributions: validations.flatMap((validation) => validation.contributions), issues: validations.flatMap((validation) => validation.issues) };
+export function discoverCommandContributions(reservedNames, startDir = process.cwd(), profileId, coreCommandPaths, extensibleCoreBranches = new Set()) {
+    const validations = validateEffectiveCommandPlugins(reservedNames, startDir, profileId, coreCommandPaths, extensibleCoreBranches);
+    return { contributions: validations.flatMap((validation) => validation.contributions), coreMounts: validations.flatMap((validation) => validation.coreMounts), issues: validations.flatMap((validation) => validation.issues) };
 }
-export function buildExternalCommandSnapshot(reservedCoreNames, startDir = process.cwd(), profileId) {
-    const validations = discoverPluginCommandCandidates(startDir, profileId);
+export function buildExternalCommandSnapshot(reservedCoreNames, startDir = process.cwd(), profileId, coreCommandPaths, extensibleCoreBranches = new Set()) {
+    const validations = validateEffectiveCommandPlugins(reservedCoreNames, startDir, profileId, coreCommandPaths, extensibleCoreBranches);
     const candidates = adaptPluginContributions(validations.flatMap((validation) => validation.contributions)).contributions;
     const resolved = resolveCommandRegistry(candidates, reservedCoreNames);
     const extensions = applyCommandExtensions(resolved.contributions, startDir);
-    return { contributions: extensions.contributions, issues: [...validations.flatMap((validation) => validation.issues.map((issue) => contributorIssue(validation.plugin, issue))), ...resolved.issues] };
+    return {
+        contributions: extensions.contributions,
+        coreMounts: adaptPluginCoreMounts(validations.flatMap((validation) => validation.coreMounts)),
+        issues: [...validations.flatMap((validation) => validation.issues.map((issue) => contributorIssue(validation.plugin, issue))), ...resolved.issues],
+    };
 }

package/dist/core/command-plugins/help-addenda.d.ts

@@ -18,4 +18,5 @@ export interface HelpAddendum {
 export declare function collectHelpAddenda(commandPath: string, gate: {
     reservedCoreNames: ReadonlySet<string>;
     coreCommandPaths: () => Promise<ReadonlySet<string>>;
+    extensibleCoreBranches: () => Promise<ReadonlySet<string>>;
 }, startDir?: string, profileId?: string | null): Promise<HelpAddendum[]>;

package/dist/core/command-plugins/help-addenda.js

@@ -28,13 +28,14 @@ import { effectiveCommandPlugins, validatePluginCommands } from './discovery.js'
 export async function collectHelpAddenda(commandPath, gate, startDir, profileId) {
     if (commandPath.length === 0)
         return [];
-    const claimants = effectiveCommandPlugins(startDir, profileId).filter((plugin) => validatePluginCommands(plugin, gate.reservedCoreNames).manifest?.helpAddenda?.[commandPath] !== undefined);
+    const extensibleCoreBranches = await gate.extensibleCoreBranches();
+    const claimants = effectiveCommandPlugins(startDir, profileId).filter((plugin) => validatePluginCommands(plugin, gate.reservedCoreNames, undefined, extensibleCoreBranches).manifest?.helpAddenda?.[commandPath] !== undefined);
     if (claimants.length === 0)
         return [];
     const coreCommandPaths = await gate.coreCommandPaths();
     const out = [];
     for (const plugin of claimants) {
-        const text = validatePluginCommands(plugin, gate.reservedCoreNames, coreCommandPaths).manifest?.helpAddenda?.[commandPath];
+        const text = validatePluginCommands(plugin, gate.reservedCoreNames, coreCommandPaths, extensibleCoreBranches).manifest?.helpAddenda?.[commandPath];
         if (text !== undefined)
             out.push({ plugin: plugin.name, text });
     }

package/dist/core/command.d.ts

@@ -52,6 +52,8 @@ export interface LeafDef {
     effectiveHelp?: () => Promise<EffectiveLeafHelp>;
     /** Opt this conditionally-void leaf out of core command hooks. */
     hookEligible?: false;
+    /** Plugin that contributed this leaf to an extensible core branch. */
+    plugin?: string;
     /** Opt into editor slash-command exposure (see SlashSpec). */
     slash?: SlashSpec;
     run: (input: Record<string, unknown>, context?: LeafRunContext) => Promise<Record<string, unknown> | void>;
@@ -77,6 +79,10 @@ export interface BranchDef {
      *  subtrees (assembled into root -h by defineRoot); omitted on nested
      *  branches, whose parent representation is the branch's own children list. */
     rootEntry?: RootEntry;
+    /** Allows command plugins to contribute direct children below this core branch. */
+    extensible?: true;
+    /** Plugin that contributed this branch to an extensible core branch. */
+    plugin?: string;
     /** Opt into editor slash-command exposure (see SlashSpec). */
     slash?: SlashSpec;
     /** Opt this branch out of the tree model entirely: every token after this
@@ -105,6 +111,7 @@ export declare function defineLeaf(opts: {
     whenToUse?: string;
     tier?: SubTier;
     help: LeafHelp;
+    plugin?: string;
     slash?: SlashSpec;
     /** Opt this conditionally-void leaf out of core command hooks. */
     hookEligible?: false;
@@ -118,6 +125,8 @@ export declare function defineBranch(opts: {
     tier?: SubTier;
     help: BranchHelp;
     rootEntry?: RootEntry;
+    extensible?: true;
+    plugin?: string;
     slash?: SlashSpec;
     passthrough?: {
         bin: string;

package/dist/core/command.js

@@ -34,6 +34,7 @@ export function defineLeaf(opts) {
         help: freezeCommandMetadata(opts.help),
         slash: opts.slash === undefined ? undefined : freezeCommandMetadata(opts.slash),
         hookEligible: opts.hookEligible,
+        plugin: opts.plugin,
         run: opts.run,
         render: opts.render,
     });
@@ -65,6 +66,7 @@ export function defineBranch(opts) {
             description: c.description ?? '',
             whenToUse: c.whenToUse ?? '',
             tier: c.tier ?? 'normal',
+            ...(c.plugin !== undefined ? { plugin: c.plugin } : {}),
             ...(subCount > 0 ? { subCount } : {}),
         };
     });
@@ -76,6 +78,8 @@ export function defineBranch(opts) {
         tier: opts.tier,
         help: opts.help,
         rootEntry: opts.rootEntry,
+        extensible: opts.extensible,
+        plugin: opts.plugin,
         slash: opts.slash,
         passthrough: opts.passthrough,
         children: opts.children,
@@ -206,13 +210,14 @@ async function renderNodeWithAddenda(node, path, focusedFlag) {
     const { hasEffectiveCommandPlugins } = await import('./command-plugins/presence.js');
     if (!hasEffectiveCommandPlugins())
         return body;
-    const [{ collectHelpAddenda }, { SUBTREE_NAMES, coreCommandPaths }] = await Promise.all([
+    const [{ collectHelpAddenda }, { SUBTREE_NAMES, coreCommandPaths, extensibleCoreBranches }] = await Promise.all([
         import('./command-plugins/help-addenda.js'),
         import('../build-root.js'),
     ]);
     const addenda = await collectHelpAddenda(path.join(' '), {
         reservedCoreNames: new Set(SUBTREE_NAMES),
         coreCommandPaths,
+        extensibleCoreBranches,
     });
     return body + addenda.map((a) => `\n\n<plugin-help plugin="${a.plugin}">\n${a.text}\n</plugin-help>`).join('');
 }

package/dist/core/help.d.ts

@@ -121,6 +121,8 @@ export type SubTier = 'hidden' | 'normal' | 'common' | 'important';
  *  representation one level up). */
 export interface ListingChild {
     name: string;
+    /** Plugin that contributed this child to an extensible core branch. */
+    plugin?: string;
     /** Short description for this child's <subcommand> row. */
     description: string;
     /** Selection rubric — plainly states when to reach for this command. Expansive

package/dist/core/help.js

@@ -152,6 +152,7 @@ export function renderBranch(h) {
     for (const c of h.listing ?? []) {
         if (c.tier === 'hidden')
             continue;
+        const plugin = c.plugin === undefined ? '' : ` plugin="${attr(c.plugin)}"`;
         const subs = c.subCount !== undefined && c.subCount > 0 ? ` subcommands="${c.subCount}"` : '';
         // whenToUse plainly states when to reach for this child, rendered verbatim —
         // expansive with examples for judgment-heavy commands, concise for
@@ -159,7 +160,7 @@ export function renderBranch(h) {
         // capability-discovery rule in the root footer already teaches that.
         if (lines.length > 1)
             lines.push('');
-        lines.push(`<subcommand name="${c.name}" description="${attr(c.description)}" whenToUse="${attr(c.whenToUse)}"${subs}/>`);
+        lines.push(`<subcommand name="${c.name}" description="${attr(c.description)}" whenToUse="${attr(c.whenToUse)}"${plugin}${subs}/>`);
     }
     if (h.extensionIssue !== undefined) {
         lines.push(`<extension-issue fragment="${attr(h.extensionIssue.fragment)}">This repository's contributed commands were rejected: ${h.extensionIssue.message}. Run \`crtr sys doctor\` for the full report.</extension-issue>`);

package/dist/core/human/answer-text.d.ts

@@ -1,3 +1,5 @@
 import type { PageAnswer } from './answer.js';
-/** Render a PageAnswer as the deterministic Markdown report delivered to its asking agent. */
-export declare function renderAnswerText(answer: PageAnswer, responsePath: string): string;
+/** Render a PageAnswer as the deterministic Markdown report delivered to its asking agent.
+ *  The person sees this same prose in their own chat surface, so it carries the answer
+ *  itself and nothing addressed only to the agent. */
+export declare function renderAnswerText(answer: PageAnswer): string;

package/dist/core/human/answer-text.js

@@ -80,19 +80,21 @@ function slotLines(slot, totalSlots) {
         lines.push(...commentLines(comment));
     return lines;
 }
-/** Render a PageAnswer as the deterministic Markdown report delivered to its asking agent. */
-export function renderAnswerText(answer, responsePath) {
+/** Render a PageAnswer as the deterministic Markdown report delivered to its asking agent.
+ *  The person sees this same prose in their own chat surface, so it carries the answer
+ *  itself and nothing addressed only to the agent. */
+export function renderAnswerText(answer) {
     if (answer.kind === 'acknowledgement') {
         return [
             `The user saw **${answer.title}** and dismissed it. The page asked for nothing, so the acknowledgement is the whole answer.`,
             '',
-            `Acknowledged ${answer.completedAt}. Response record: ${responsePath}`,
+            `Acknowledged ${answer.completedAt}.`,
         ].join('\n');
     }
     const answered = answer.slots.filter((slot) => slot.state === 'answered');
     const lines = [`The user answered **${answer.title}**.`];
     for (const slot of answered)
         lines.push('', ...slotLines(slot, answer.slots.length));
-    lines.push('', `Answered ${answer.completedAt}. Typed responses: ${responsePath}`);
+    lines.push('', `Answered ${answer.completedAt}.`);
     return lines.join('\n');
 }

package/dist/daemon/human/finish.js

@@ -2,6 +2,11 @@ import { getRequest, getRequestByInboxTicket } from '../../core/human/requests.j
 import { buildPageSummary } from '../../core/human/summary.js';
 import { validateFinalPageResponses } from '../../core/human/tickets.js';
 import { composeHumanCompletion } from '../../core/human/completion.js';
+import { describePageAnswer } from '../../core/human/answer.js';
+import { renderAnswerText } from '../../core/human/answer-text.js';
+import { readPageFeedback } from '../../core/human/feedback.js';
+import { pageDocumentSha256 } from '../../core/human/feedback-companion.js';
+import { pagePath } from '../../core/human/convention.js';
 import { retireCompanion } from '../companion-retire.js';
 import { settleHumanRequest } from './settle.js';
 function requestForTicket(ticketId) {
@@ -38,10 +43,73 @@ function completionAction(request, result) {
         throw new Error(`corrupt frozen completion action: ${request.request_id}`, { cause: error });
     }
 }
-function notification(request, disposition, bodyJson) {
+function firstLine(text, maxLen = 80) {
+    const line = text.split('\n')[0] ?? '';
+    return line.length > maxLen ? `${line.slice(0, maxLen - 1)}…` : line;
+}
+function pageTitle(request) {
+    try {
+        return manifest(request).title;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The settle-time feedback addendum — answer and cancellation alike: a change
+ * notice when the final page differs from the version first commented on, and
+ * each still-open item's quote and note. Silent when the page is unchanged and
+ * nothing remains open; never a manufactured prose diff. */
+function feedbackAddendum(request) {
+    let sections;
+    try {
+        const feedback = readPageFeedback(request.request_dir);
+        if (feedback.companionNodeId === undefined)
+            return '';
+        sections = [];
+        if (feedback.firstCommentedSha256 !== undefined && pageDocumentSha256(request.request_dir) !== feedback.firstCommentedSha256) {
+            sections.push(`The page changed during feedback: the person commented on it and its companion conversation (node ${feedback.companionNodeId}) revised it in place. ` +
+                `Reread the final page at ${pagePath(request.request_dir)} before interpreting this outcome.`);
+        }
+        const open = feedback.comments.filter((comment) => comment.status === 'open');
+        if (open.length > 0) {
+            const items = open.map((comment) => [
+                ...comment.quote.split('\n').map((line) => `> ${line}`),
+                comment.note,
+            ].join('\n'));
+            sections.push([
+                `Feedback left unresolved at settlement — the companion conversation (node ${feedback.companionNodeId}) had not dealt with these items:`,
+                ...items,
+            ].join('\n\n'));
+        }
+    }
+    catch {
+        // The outcome itself is the deliverable; a broken feedback record adds nothing.
+        return '';
+    }
+    return sections.length === 0 ? '' : `\n\n${sections.join('\n\n')}`;
+}
+/** The person's answer as prose the asking agent reads directly. Short bodies
+ * ride inline; the mail layer spills a long one to a file and leaves a preview
+ * plus its path. */
+function answerBody(request, result) {
+    const answer = describePageAnswer(manifest(request), result.responses, { completedAt: result.completedAt });
+    return renderAnswerText(answer) + feedbackAddendum(request);
+}
+/** A dismissal is a rejection, not a routing event: say so plainly so the agent
+ * acts on the "no" instead of re-raising the same ask. */
+function cancelBody(request, dismissed, reason) {
+    const title = pageTitle(request);
+    const named = title === undefined ? `the human interaction ${request.request_id}` : `“${title}”`;
+    const why = reason !== undefined && reason !== '' ? reason : 'no reason was given';
+    const body = dismissed
+        ? `The user dismissed ${named} without answering — a deliberate “no, I'm not answering this.” Treat it as a rejection: no response will arrive, no partial answer exists, and the same ask must not be raised again.`
+        : `${title === undefined ? `The human interaction ${request.request_id}` : `The page “${title}”`} was canceled — ${why}. No response will arrive, and any partial answers the user had entered were discarded unsent.`;
+    return body + feedbackAddendum(request);
+}
+function notification(request, disposition, body, result) {
     if (request.requester_node_id === null)
         return undefined;
-    return { label: disposition === 'human-answer' ? 'human request answered' : 'human request canceled', disposition, body_json: bodyJson };
+    return { label: firstLine(body), disposition, body_json: { body, result } };
 }
 function retire(request) {
     return request.companion_node_id === null ? undefined : { retire: async (nodeId, outcome) => { await retireCompanion(nodeId, outcome); } };
@@ -60,7 +128,9 @@ export async function resolvePageTicket(ticketId, responses, opts = {}) {
         request_id: request.request_id,
         outcome: 'answered',
         result_json: JSON.stringify(result),
-        ...(notification(request, 'human-answer', result) === undefined ? {} : { notification: notification(request, 'human-answer', result) }),
+        ...(notification(request, 'human-answer', answerBody(request, result), result) === undefined
+            ? {}
+            : { notification: notification(request, 'human-answer', answerBody(request, result), result) }),
         ...(completionAction(request, result) === undefined ? {} : { completion_action: completionAction(request, result) }),
         ...(retire(request) === undefined ? {} : { post_commit: retire(request) }),
     });
@@ -84,7 +154,9 @@ export async function cancelHumanTicket(ticketId, opts) {
         request_id: request.request_id,
         outcome: opts.disposition === 'dismissed' ? 'dismissed' : 'canceled',
         result_json: JSON.stringify(result),
-        ...(notification(request, 'human-canceled', result) === undefined ? {} : { notification: notification(request, 'human-canceled', result) }),
+        ...(notification(request, 'human-canceled', cancelBody(request, opts.disposition === 'dismissed', opts.reason), result) === undefined
+            ? {}
+            : { notification: notification(request, 'human-canceled', cancelBody(request, opts.disposition === 'dismissed', opts.reason), result) }),
         ...(completionAction(request, result) === undefined ? {} : { completion_action: completionAction(request, result) }),
         ...(retire(request) === undefined ? {} : { post_commit: retire(request) }),
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.314",
+  "version": "0.3.316",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.314",
+  "version": "0.3.316",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.314",
+      "version": "0.3.316",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.314",
+      "version": "0.3.316",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.314",
+      "version": "0.3.316",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.314",
+      "version": "0.3.316",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"