@xingular/harness 2.0.0 → 2.0.1-unstable

package/dist/sdk/capabilities/runSnapshot.d.ts

@@ -0,0 +1,18 @@
+import type { CapabilitySet } from "./types.js";
+export interface RunCapabilitySnapshot {
+    version: 1;
+    caller: {
+        agentId: string | null;
+        projectId: string | null;
+    };
+    tools: string[];
+    connectors: string[];
+    contributions: string[];
+}
+export declare function capabilitySet(value: unknown): CapabilitySet;
+/** Writes a run's capability set once. A resumed or duplicate launch cannot replace it. */
+export declare function freezeRun(root: string, runId: string, caller: {
+    agentId?: string | null;
+    projectId?: string | null;
+}, set: CapabilitySet): RunCapabilitySnapshot;
+export declare function loadRun(root: string, runId: string): RunCapabilitySnapshot | null;

package/dist/sdk/capabilities/runSnapshot.js

@@ -0,0 +1,53 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { HarnessError, invalid } from "../core/errors.js";
+import { readJson, safeId, writeJson } from "../core/fs.js";
+const path = (root, runId) => join(root, 'runs', safeId(runId), 'capabilities.json');
+function strings(value) {
+    return Array.isArray(value) ? [...new Set(value.filter((item) => typeof item === 'string' && item.length > 0))] : [];
+}
+/** Tool names that were renamed; a pinned run keeps the current name so a continuation can use it. */
+const RENAMED_TOOLS = { checklist_write: 'todo_write' };
+function tools(value) {
+    return [...new Set(strings(value).map((name) => RENAMED_TOOLS[name] ?? name))];
+}
+export function capabilitySet(value) {
+    if (!value || typeof value !== 'object' || value.version !== 1)
+        throw invalid('A capability set must use version 1.');
+    const record = value;
+    return { version: 1, tools: tools(record.tools), connectors: strings(record.connectors), contributions: strings(record.contributions) };
+}
+/** Writes a run's capability set once. A resumed or duplicate launch cannot replace it. */
+export function freezeRun(root, runId, caller, set) {
+    const target = path(root, runId);
+    const snapshot = {
+        version: 1,
+        caller: { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null },
+        tools: tools(set.tools),
+        connectors: strings(set.connectors),
+        contributions: strings(set.contributions)
+    };
+    const stored = existsSync(target) ? readJson(target) : null;
+    const existing = stored ? { ...stored, tools: tools(stored.tools) } : null;
+    if (existing) {
+        if (JSON.stringify(existing) !== JSON.stringify(snapshot))
+            throw new HarnessError('capabilities_frozen', 'This run already has a different frozen capability set.');
+        return existing;
+    }
+    writeJson(target, snapshot);
+    return snapshot;
+}
+export function loadRun(root, runId) {
+    const stored = readJson(path(root, runId));
+    if (!stored || typeof stored !== 'object' || stored.version !== 1)
+        return null;
+    const record = stored;
+    const caller = record.caller && typeof record.caller === 'object' ? record.caller : {};
+    return {
+        version: 1,
+        caller: { agentId: typeof caller.agentId === 'string' ? caller.agentId : null, projectId: typeof caller.projectId === 'string' ? caller.projectId : null },
+        tools: tools(record.tools),
+        connectors: strings(record.connectors),
+        contributions: strings(record.contributions)
+    };
+}

package/dist/sdk/capabilities/types.d.ts

@@ -0,0 +1,29 @@
+import type { AttachScope, Attachment } from "../plugins/attachments.js";
+import type { ContributionKind, ContributionState, PluginSource } from "../plugins/types.js";
+export type CapabilityKind = ContributionKind | 'plugin';
+/** One item the caller can switch on or off, or that a plugin makes available. */
+export interface Capability {
+    id: string;
+    pluginId: string;
+    kind: CapabilityKind;
+    name: string;
+    description: string;
+    source: PluginSource;
+    state: ContributionState;
+    attachment: Attachment | null;
+}
+export interface CapabilityCatalogue {
+    plugins: import("../plugins/types.js").Plugin[];
+    capabilities: Capability[];
+}
+/** The callable capabilities a run starts with. Permission to run still goes through the gate. */
+export interface CapabilitySet {
+    version: 1;
+    tools: string[];
+    connectors: string[];
+    contributions: string[];
+}
+export interface CapabilityScope extends AttachScope {
+    cwd?: string | null;
+    accountId?: string | null;
+}

package/dist/sdk/capabilities/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sdk/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/sdk/cli.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// The `xagent` command.
+//
+//   xagent serve --state <dir> [--data <dir>] [--name <product>] [--builtins <dir>]…
+//                [--host-secrets] [--host-policy] [--host-tools] [--host-directory]
+//       Serves the harness to a host process over stdin/stdout (newline-delimited JSON).
+//   xagent wiki <command>     Project notes, skills and history, from inside a terminal session.
+//   xagent refine <command>   Refine a variant from evidence (refine demo needs no model).
+//   xagent mcp <command>      Connected apps, from inside a terminal session.
+//   xagent plugins <command>  List, install, switch and trust plugins.
+//   xagent web <command>      Search keys for web_search.
+//   xagent browser <command>  How the agent's browser runs.
+//   xagent worktree <command> Managed git worktrees of the repository you are in.
+import { resolve } from 'node:path';
+import manifest from "../../package.json" with { type: 'json' };
+import { log } from "./core/bus.js";
+import { createHarness } from "./harness.js";
+import { runPluginsCli, terminalAsk } from "./plugins/cli.js";
+import { runHubCli } from "./hub/cli.js";
+import { runRefineCli } from "./refine/cli.js";
+import { runBrowserCli, runWebCli } from "./world/cli.js";
+import { remoteDirectory, remotePolicy, remoteSecrets, remoteTools } from "./server/remote.js";
+import { RpcPeer, stdioTransport } from "./server/rpc.js";
+import { attach } from "./server/serve.js";
+import { runAppsCli, runWikiCli } from "./terminal/cli.js";
+import { runStandaloneTerminal, standaloneArguments } from "./terminal/standalone.js";
+import { runWorktreeCli } from "./worktrees/cli.js";
+const USAGE = `Usage: xagent [--data <dir>] [--state <dir>]
+       xagent <terminal | serve | daemon | attach | wiki | mcp | plugins | hub | refine | web | browser | worktree> [arguments]
+
+  --version          Print the package version
+  (no command)       Start the interactive Harness terminal
+  terminal           Start the interactive Harness terminal
+  serve --state <dir> [--data <dir>] [--name <product>] [--builtins <dir>]
+        [--host-secrets] [--host-policy] [--host-tools] [--host-directory]
+                     Serve the harness over newline-delimited JSON
+  wiki <command>     Wiki, skill and history commands for a terminal session
+  mcp <command>      Connected-app commands for a terminal session
+  plugins <command>  List, install, switch and trust plugins (plugins help)
+  hub <command>      Browse and install curated items (hub help)
+  refine <command>   Refine a harness from evidence (refine demo, refine run)
+  web <command>      Search keys for the web tools (web help)
+  browser <command>  How the agent's browser runs (browser help)
+  worktree <command> Managed git worktrees (worktree help)
+
+Standalone terminal options:
+  --data <dir>       Data directory (interactive profile default; otherwise
+                     ~/.xingular-harness/data; npm run dev passes its own data root)
+  --state <dir>      State directory (interactive profile default; otherwise
+                     ~/.xingular-harness/state; npm run dev passes its own state directory)
+  --account-state <dir>
+                     Sign in as the accounts kept in that state directory (its
+                     accounts folder and secrets file); npm run dev shares the
+                     installed command's account state by default
+  --worktree [name], -w [name]
+                     Start in a new managed worktree of this repository, or in
+                     the named one
+  --variant <scope>  Run on this variant scope's head (default: interactive profile scope)
+  --remote-control, --rc
+                     Turn on /remote-control at start, to continue from a phone or iPad
+  --daemon           Run in the long-lived harness for these folders (started when needed),
+                     so a reply keeps running when this window closes
+
+Long-lived harness (ADR-0083):
+  daemon <start | stop | status>
+                     Start, stop or check the harness that --daemon windows use
+  attach [session]   Reattach a window to a reply that kept running after its window closed
+`;
+function flags(argv) {
+    const values = {};
+    const switches = new Set();
+    for (let index = 0; index < argv.length; index += 1) {
+        const name = argv[index];
+        if (!name.startsWith('--'))
+            continue;
+        const next = argv[index + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+            ;
+            (values[name.slice(2)] ??= []).push(next);
+            index += 1;
+        }
+        else
+            switches.add(name.slice(2));
+    }
+    return { values, switches };
+}
+function serveCommand(argv) {
+    const { values, switches } = flags(argv);
+    const stateArgument = values.state?.[0];
+    if (!stateArgument) {
+        process.stderr.write('serve needs --state <dir>.\n');
+        return Promise.resolve(2);
+    }
+    // The socket path is built from this folder, so a relative one would depend on where the host ran.
+    const stateDir = resolve(stateArgument);
+    const peer = new RpcPeer(stdioTransport());
+    const options = {
+        stateDir,
+        dataRoot: values.data?.[0] ? resolve(values.data[0]) : null,
+        productName: values.name?.[0],
+        builtins: values.builtins,
+        ...(switches.has('host-secrets') ? { secrets: remoteSecrets(peer) } : {}),
+        ...(switches.has('host-policy') ? { policy: remotePolicy(peer) } : {}),
+        ...(switches.has('host-directory') ? { directory: remoteDirectory(peer) } : {})
+    };
+    const harness = createHarness(options);
+    if (switches.has('host-tools'))
+        harness.sessions.provide(remoteTools(peer));
+    attach(harness, peer);
+    return new Promise((resolve) => {
+        let closing = false;
+        const shutdown = () => {
+            if (closing)
+                return;
+            closing = true;
+            void Promise.race([harness.close(), new Promise((done) => setTimeout(done, 5000))]).then(() => resolve(0));
+        };
+        peer.handle('harness.shutdown', () => void setImmediate(shutdown));
+        process.stdin.on('end', shutdown);
+        process.on('SIGTERM', shutdown);
+        process.on('SIGINT', shutdown);
+        peer.send({ notice: { type: 'ready' } });
+        log('ready');
+    });
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-v')) {
+        process.stdout.write(`${manifest.version}\n`);
+        return 0;
+    }
+    const [command, ...rest] = argv;
+    if (argv.includes('--help') || argv.includes('-h')) {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    const terminalArgs = standaloneArguments(argv);
+    if (terminalArgs !== null)
+        return runStandaloneTerminal(terminalArgs);
+    if (command === 'serve')
+        return serveCommand(rest);
+    if (command === 'daemon' || command === 'attach') {
+        // ADR-0083: the long-lived harness for these folders, and reattaching a window to it.
+        const positional = rest[0] && !rest[0].startsWith('-') ? rest[0] : undefined;
+        const { resolveStandaloneOptions } = await import("./terminal/standalone.js");
+        const { paths, profile } = resolveStandaloneOptions(positional ? rest.slice(1) : rest);
+        const daemon = await import("./terminal/daemon.js");
+        return command === 'daemon' ? daemon.runDaemonCommand(positional, paths, profile) : daemon.runAttach(paths, profile, positional, process.cwd());
+    }
+    if (command === 'wiki')
+        return runWikiCli(rest);
+    if (command === 'mcp')
+        return runAppsCli(rest);
+    if (command === 'plugins')
+        return runPluginsCli(rest, { ask: terminalAsk() });
+    if (command === 'hub')
+        return runHubCli(rest);
+    if (command === 'refine')
+        return runRefineCli(rest);
+    if (command === 'web')
+        return runWebCli(rest);
+    if (command === 'browser')
+        return runBrowserCli(rest);
+    if (command === 'worktree')
+        return runWorktreeCli(rest);
+    process.stdout.write(USAGE);
+    return command ? 2 : 0;
+}
+void main().then((code) => process.exit(code), (error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/sdk/commands/extensionOwners.d.ts

@@ -0,0 +1,4 @@
+import type * as Pi from '@earendil-works/pi-coding-agent';
+import type { Found } from "../plugins/discover.js";
+/** Restore package identity lost when Harness passes individually selected paths to Pi. */
+export declare function applyExtensionOwners(loader: Pi.DefaultResourceLoader, found: readonly Found[]): void;

package/dist/sdk/commands/extensionOwners.js

@@ -0,0 +1,17 @@
+import { resolve, sep } from 'node:path';
+/** Restore package identity lost when Harness passes individually selected paths to Pi. */
+export function applyExtensionOwners(loader, found) {
+    for (const extension of loader.getExtensions().extensions) {
+        if (extension.hidden)
+            continue;
+        const path = resolve(extension.resolvedPath || extension.path);
+        const owner = found.filter(item => item.kind === 'extension' && item.packageRoot && (path === resolve(item.path) || path.startsWith(`${resolve(item.path)}${sep}`)))
+            .sort((a, b) => b.path.length - a.path.length)[0];
+        if (!owner?.packageRoot)
+            continue;
+        const sourceInfo = { ...extension.sourceInfo, origin: 'package', baseDir: owner.packageRoot, source: owner.source ?? owner.packageRoot };
+        extension.sourceInfo = sourceInfo;
+        for (const command of extension.commands.values())
+            command.sourceInfo = sourceInfo;
+    }
+}

package/dist/sdk/commands/list.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "../plugins/types.js";
+import { type ListedCommand } from "./registry.js";
+export declare function listCommands(plugins: readonly Plugin[]): ListedCommand[];

package/dist/sdk/commands/list.js

@@ -0,0 +1,90 @@
+// `commands.list`: every slash command a front end offers for one scope, from one source. The
+// terminal palette and a host's menu both read it, so they never keep their own lists.
+import { BUILTIN_PLUGIN_REGISTRY } from "../plugins/builtin.js";
+import { pluginCommandPrefix } from "../plugins/commandPrefix.js";
+import { packageManifest } from "../plugins/manifest.js";
+import { CORE_COMMANDS } from "./registry.js";
+import { commandRoutes, promptCommandAvailable } from "./routes.js";
+export function listCommands(plugins) {
+    const out = new Map();
+    const taken = new Set();
+    for (const command of CORE_COMMANDS) {
+        const aliases = 'aliases' in command ? [...command.aliases] : [];
+        out.set(command.name, {
+            name: command.name,
+            ...(aliases.length ? { aliases } : {}),
+            ...('args' in command ? { args: command.args } : {}),
+            description: command.description,
+            group: command.group,
+            source: 'core',
+            kind: command.kind
+        });
+        taken.add(command.name);
+        aliases.forEach((alias) => taken.add(alias));
+    }
+    for (const command of BUILTIN_PLUGIN_REGISTRY.commands()) {
+        if (command.rootOnly)
+            continue;
+        const name = `${command.prefix}:${command.name}`;
+        out.set(name, { name, description: command.description, group: 'Plugins', source: 'plugin', owner: command.pluginId });
+    }
+    for (const module of BUILTIN_PLUGIN_REGISTRY.modules) {
+        const prefix = module.commandPrefix ?? module.descriptor.id;
+        const fallback = BUILTIN_PLUGIN_REGISTRY.defaultCommand(prefix);
+        if (fallback)
+            out.set(`${prefix}:`, { name: `${prefix}:`, description: fallback.description, group: 'Plugins', source: 'plugin', owner: module.descriptor.id });
+    }
+    const extensions = [];
+    const extensionCommandNames = new Set();
+    for (const plugin of plugins) {
+        for (const contribution of plugin.contributions) {
+            if (contribution.kind !== 'code' || contribution.state !== 'on' || !contribution.path || !contribution.registered)
+                continue;
+            contribution.registered.commands.forEach(name => extensionCommandNames.add(name));
+        }
+    }
+    for (const plugin of plugins) {
+        for (const contribution of plugin.contributions) {
+            if (contribution.state !== 'on')
+                continue;
+            if (contribution.kind === 'code' && contribution.registered && contribution.path) {
+                const packageRoot = (plugin.source === 'package' || plugin.id.startsWith('package:')) ? plugin.path : null;
+                const prefix = pluginCommandPrefix(packageRoot
+                    ? { path: contribution.path, origin: 'package', baseDir: packageRoot }
+                    : { path: contribution.path });
+                for (const command of contribution.registered.commands) {
+                    const name = `${prefix}:${command}`;
+                    extensions.push({ prefix, name: command, owner: packageRoot ? `package:${packageRoot}` : `extension:${contribution.path}`, path: contribution.path,
+                        listed: { name, group: 'Plugins', source: 'extension', owner: plugin.id } });
+                }
+            }
+            // Catalogue entries without a path are observed extension commands, not templates.
+            if (contribution.kind === 'command' && contribution.path) {
+                const packageRoot = (plugin.source === 'package' || plugin.id.startsWith('package:')) ? plugin.path : null;
+                const producer = plugin.contributions.find(item => item.kind === 'code' && item.state === 'on' && item.path && item.registered?.resources?.some(resource => resource.kind === 'command' && resource.path === contribution.path));
+                if (packageRoot || producer?.path) {
+                    const prefix = pluginCommandPrefix(packageRoot ? { path: contribution.path, origin: 'package', baseDir: packageRoot } : { path: producer.path });
+                    const name = packageRoot && packageManifest(packageRoot).defaultPrompt === contribution.name ? '' : contribution.name;
+                    if (/^[a-z][a-z0-9-]*$/.test(name) || name === '') {
+                        extensions.push({ prefix, name, owner: packageRoot ? `package:${packageRoot}` : `extension:${producer.path}`, path: contribution.path,
+                            listed: { name: `${prefix}:${name}`, description: contribution.description, group: 'Prompts', source: 'prompt', owner: plugin.id } });
+                    }
+                }
+                else if (promptCommandAvailable(contribution.name, taken, extensionCommandNames) && !out.has(contribution.name)) {
+                    out.set(contribution.name, { name: contribution.name, description: contribution.description, group: 'Prompts', source: 'prompt', owner: plugin.id });
+                }
+            }
+            if (contribution.kind === 'skill') {
+                const name = `skill:${contribution.name}`;
+                if (!out.has(name))
+                    out.set(name, { name, description: contribution.description, group: 'Skills', source: 'skill', owner: plugin.id });
+            }
+        }
+    }
+    const indexed = commandRoutes(extensions);
+    for (const [name, routes] of indexed.routes) {
+        if (routes.length === 1 && !indexed.conflictingPrefixes.has(routes[0].prefix) && !out.has(name))
+            out.set(name, routes[0].listed);
+    }
+    return [...out.values()];
+}

package/dist/sdk/commands/promptLoader.d.ts

@@ -0,0 +1,5 @@
+import type * as Pi from '@earendil-works/pi-coding-agent';
+import type { Found } from "../plugins/discover.js";
+import type { CommandRoute } from "./routes.js";
+/** Pi deduplicates by bare filename before its override; scan paths separately before qualifying. */
+export declare function wrapPromptLoader(pi: typeof Pi, loader: Pi.DefaultResourceLoader, found: readonly Found[], paths: readonly string[], cwd: string, agentDir: string, extensions?: () => readonly CommandRoute[], bare?: Set<string>): Promise<Set<string>>;

package/dist/sdk/commands/promptLoader.js

@@ -0,0 +1,76 @@
+import { readdirSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { namespacePrompts, promptPackageRoot } from "./promptRoutes.js";
+import { pluginCommandPrefix } from "../plugins/commandPrefix.js";
+const originalGetters = new WeakMap();
+/** Pi deduplicates by bare filename before its override; scan paths separately before qualifying. */
+export async function wrapPromptLoader(pi, loader, found, paths, cwd, agentDir, extensions = () => [], bare = new Set()) {
+    const scan = async (paths) => {
+        const files = paths.flatMap(path => {
+            try {
+                return statSync(path).isDirectory()
+                    ? readdirSync(path).filter(name => name.endsWith('.md') && !name.startsWith('.')).sort().map(name => join(path, name))
+                    : [path];
+            }
+            catch {
+                return [];
+            }
+        });
+        const templates = [];
+        for (const path of [...new Set(files)]) {
+            const scanner = new pi.DefaultResourceLoader({ cwd, agentDir, settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true, additionalPromptTemplatePaths: [path] });
+            await scanner.reload();
+            templates.push(...scanner.getPrompts().prompts);
+        }
+        return templates;
+    };
+    const templates = await scan(paths);
+    const discovered = new Map();
+    for (const extension of loader.getExtensions().extensions) {
+        if (extension.hidden)
+            continue;
+        const handlers = extension.handlers.get('resources_discover');
+        if (!handlers)
+            continue;
+        const source = extension.sourceInfo;
+        extension.handlers.set('resources_discover', handlers.map((handler, index) => async (event, context) => {
+            const result = await handler(event, context);
+            const key = `${extension.resolvedPath}:${index}`;
+            if (!result)
+                discovered.delete(key);
+            else {
+                const paths = (result.promptPaths ?? []).map(path => resolve(dirname(extension.resolvedPath), path));
+                const isPackage = source.origin === 'package' && !!source.baseDir;
+                const root = isPackage ? source.baseDir : extension.resolvedPath;
+                const commandOwner = isPackage ? undefined : { prefix: pluginCommandPrefix(source), owner: `extension:${source.path}` };
+                const owners = paths.map(path => ({ kind: 'prompt', path, origin: isPackage ? 'package' : 'shared', packageRoot: root, source: source.source, project: source.scope === 'project', enabled: true, ...(commandOwner ? { commandOwner } : {}) }));
+                discovered.set(key, { owners, prompts: await scan(paths) });
+            }
+            return result;
+        }));
+    }
+    bare.clear();
+    for (const prompt of templates)
+        if (promptPackageRoot(prompt, found))
+            bare.add(prompt.name);
+    const getPrompts = originalGetters.get(loader) ?? loader.getPrompts.bind(loader);
+    originalGetters.set(loader, getPrompts);
+    loader.getPrompts = () => {
+        const base = getPrompts();
+        const dynamic = [...discovered.values()];
+        const owners = [...found, ...dynamic.flatMap(item => item.owners)];
+        const byPath = new Map(base.prompts.map(prompt => [prompt.filePath, prompt]));
+        for (const prompt of [...templates, ...dynamic.flatMap(item => item.prompts)]) {
+            if (byPath.has(prompt.filePath))
+                continue;
+            if (promptPackageRoot(prompt, owners) || ![...byPath.values()].some(item => item.name === prompt.name && !promptPackageRoot(item, owners)))
+                byPath.set(prompt.filePath, prompt);
+        }
+        bare.clear();
+        for (const prompt of byPath.values())
+            if (promptPackageRoot(prompt, owners))
+                bare.add(prompt.name);
+        return { ...base, prompts: namespacePrompts([...byPath.values()], owners, extensions()) };
+    };
+    return bare;
+}

package/dist/sdk/commands/promptRoutes.d.ts

@@ -0,0 +1,13 @@
+import type { PromptTemplate } from '@earendil-works/pi-coding-agent';
+import type { Found } from "../plugins/discover.js";
+import { type CommandRoute } from "./routes.js";
+export type PromptOwner = Found & {
+    commandOwner?: {
+        prefix: string;
+        owner: string;
+    };
+};
+export declare function promptOwner(path: string, found: readonly PromptOwner[]): PromptOwner | undefined;
+export declare function promptPackageRoot(prompt: PromptTemplate, found: readonly PromptOwner[]): string | null;
+/** Rewrite only package-owned templates; the original content and Pi's argument substitution stay intact. */
+export declare function namespacePrompts(prompts: readonly PromptTemplate[], found: readonly PromptOwner[], extensions?: readonly CommandRoute[]): PromptTemplate[];

package/dist/sdk/commands/promptRoutes.js

@@ -0,0 +1,46 @@
+import { resolve, sep } from 'node:path';
+import { pluginCommandPrefix } from "../plugins/commandPrefix.js";
+import { packageManifest } from "../plugins/manifest.js";
+import { commandRoutes } from "./routes.js";
+/** Resolve ownership from the Harness-selected resources, not the user-controlled filename. */
+function promptOwners(path, found) {
+    const target = resolve(path);
+    return found.filter(item => item.kind === 'prompt' && item.packageRoot && (target === resolve(item.path) || target.startsWith(`${resolve(item.path)}${sep}`)))
+        .sort((a, b) => b.path.length - a.path.length);
+}
+export function promptOwner(path, found) {
+    return promptOwners(path, found)[0];
+}
+export function promptPackageRoot(prompt, found) {
+    return promptOwner(prompt.filePath, found)?.packageRoot ?? (prompt.sourceInfo.origin === 'package' ? prompt.sourceInfo.baseDir ?? null : null);
+}
+/** Rewrite only package-owned templates; the original content and Pi's argument substitution stay intact. */
+export function namespacePrompts(prompts, found, extensions = []) {
+    const loose = [];
+    const routes = [];
+    for (const prompt of prompts) {
+        const owners = new Set(promptOwners(prompt.filePath, found).map(owner => owner.packageRoot));
+        if (owners.size > 1)
+            continue;
+        const packageRoot = promptPackageRoot(prompt, found);
+        if (!packageRoot) {
+            if (!prompt.name.includes(':'))
+                loose.push(prompt);
+            continue;
+        }
+        const attribution = promptOwner(prompt.filePath, found)?.commandOwner;
+        const prefix = attribution?.prefix ?? pluginCommandPrefix({ path: prompt.filePath, origin: 'package', baseDir: packageRoot });
+        const name = !attribution && packageManifest(packageRoot).defaultPrompt === prompt.name ? '' : prompt.name;
+        if (name && !/^[a-z][a-z0-9-]*$/.test(name))
+            continue;
+        routes.push({ prefix, name, owner: attribution?.owner ?? `package:${packageRoot}`, path: prompt.filePath, prompt });
+    }
+    const index = commandRoutes([...extensions, ...routes]);
+    const selected = routes.flatMap(route => {
+        const key = `${route.prefix}:${route.name}`;
+        return !index.conflictingPrefixes.has(route.prefix) && index.routes.get(key)?.length === 1
+            ? [{ ...route.prompt, name: key }]
+            : [];
+    });
+    return [...loose, ...selected];
+}