@lotagate/cli 0.1.21 → 0.1.22

package/dist/application/commands/runtime-command-handlers.js

@@ -0,0 +1,177 @@
+import { Writable } from 'node:stream';
+import { AuthenticationService } from '../auth/authentication-service.js';
+import { ChatService } from '../chat/chat-service.js';
+import { createLotaGateClient } from '../../infrastructure/sdk/lotagate-client-factory.js';
+import { SdkChatCompletionAdapter } from '../../infrastructure/sdk/chat-completion-adapter.js';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { MODEL_SELECT_HINT } from './command-hints.js';
+import { createImageAttachment, DEFAULT_MAX_IMAGE_BYTES, normalizeImage } from '../../infrastructure/clipboard/image-normalizer.js';
+import { buildSafeSystemPrompt } from '../agent/safe-system-prompt.js';
+import { readJsonFileBounded } from '../../infrastructure/filesystem/bounded-json-reader.js';
+import { readFileBounded } from '../../infrastructure/filesystem/bounded-file-reader.js';
+import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
+import { ProjectSessionAccess } from '../session/project-session-access.js';
+import { compactStoredSession } from '../session/session-compaction-service.js';
+import { requirePositional, getFlag, isFlagEnabled, requireStringFlag } from './cli-args.js';
+import { resolveExternalPath, resolveWorkspacePath } from '../../infrastructure/filesystem/path-resolver.js';
+import { atomicWriteFile } from '../../infrastructure/filesystem/atomic-file-store.js';
+import { loadExecutionConfig } from '../config/execution-config.js';
+import { runHeadlessAgentTurn } from '../orchestration/headless-agent-turn.js';
+import { writeStreamChunk } from './stream-output.js';
+import { formatCompactTable } from '../formatting/compact-table.js';
+export async function runSessionCommand(positionals, flags, runtime, cwd, stdout, resumeInteractive) {
+    const action = positionals[0] ?? 'list';
+    const identity = await runtime.projectTrust.inspect(cwd);
+    if (action === 'list') {
+        const sessions = await runtime.sessionStore.list(identity.fingerprint);
+        stdout.write(`${formatCompactTable(sessions.map((session) => ({ name: session.name ?? session.id, status: session.status.toUpperCase(), detail: `${session.id} · ${session.model ?? 'no model'} · ${session.updatedAt}` })), { empty: 'No sessions found.' })}\n`);
+        return 0;
+    }
+    if (action === 'import') {
+        const file = requireStringFlag(flags, 'file');
+        const bundlePath = await resolveWorkspacePath(file, { cwd, workspaceRoot: cwd });
+        const bundle = await readJsonFileBounded(bundlePath, RESOURCE_LIMITS.sessionBundleBytes);
+        const imported = await runtime.sessionStore.import(bundle, identity.fingerprint, cwd);
+        stdout.write(`${JSON.stringify(imported, null, 2)}\n`);
+        return 0;
+    }
+    const sessionId = requirePositional(positionals, 1, 'session id');
+    const session = await new ProjectSessionAccess(runtime.sessionStore).require(sessionId, identity.fingerprint);
+    if (action === 'show') {
+        stdout.write(`${JSON.stringify({ metadata: session, transcript: await runtime.sessionStore.readTranscript(sessionId) }, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'resume') {
+        if (isFlagEnabled(flags, 'interactive')) {
+            if (!(stdout instanceof Writable))
+                throw new Error('Interactive session resume requires a terminal output stream.');
+            if (resumeInteractive === undefined)
+                throw new Error('Interactive session resume is unavailable in this command host.');
+            return resumeInteractive(sessionId);
+        }
+        stdout.write(`${JSON.stringify({ metadata: session, transcript: await runtime.sessionStore.readTranscript(sessionId), resumable: session.status !== 'active' }, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'fork') {
+        const forked = await runtime.sessionStore.fork(sessionId);
+        stdout.write(`${JSON.stringify(forked, null, 2)}\n`);
+        return 0;
+    }
+    if (action === 'compact') {
+        if (positionals.length > 2)
+            throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Compaction does not accept a summary.', { category: 'session', userMessage: 'The compact command does not accept a summary. It summarizes the session automatically.' });
+        const result = await compactStoredSession(runtime, cwd, sessionId);
+        stdout.write(`${result.compacted ? `Compacted session: ${sessionId}` : `No conversation to compact: ${sessionId}`}\n`);
+        return 0;
+    }
+    if (action === 'export') {
+        const bundle = await runtime.sessionStore.export(sessionId);
+        const outputPath = getFlag(flags, 'out');
+        const serialized = `${JSON.stringify(bundle, null, 2)}\n`;
+        if (typeof outputPath === 'string' && outputPath.trim().length > 0) {
+            const resolvedOutput = await resolveWorkspacePath(outputPath, { cwd, workspaceRoot: cwd }, true);
+            await atomicWriteFile(resolvedOutput, serialized);
+            stdout.write(`Exported session: ${resolvedOutput}\n`);
+        }
+        else
+            stdout.write(serialized);
+        return 0;
+    }
+    if (action === 'recover') {
+        stdout.write(`${JSON.stringify({ sessionId, recovered: await runtime.sessionStore.recoverStaleLock(sessionId) })}\n`);
+        return 0;
+    }
+    if (action === 'repair') {
+        stdout.write(`${JSON.stringify(await runtime.sessionStore.repair(sessionId))}\n`);
+        return 0;
+    }
+    if (action === 'delete') {
+        const deleted = await runtime.sessionStore.delete(sessionId);
+        stdout.write(`${deleted ? `Deleted session: ${sessionId}` : `Session not found: ${sessionId}`}\n`);
+        return deleted ? 0 : 1;
+    }
+    throw new Error(`Unsupported session action: ${action}`);
+}
+export async function runChatCommand(positionals, runtime, cwd, stdout) {
+    const prompt = positionals.join(' ').trim();
+    if (prompt.length === 0) {
+        stdout.write('Interactive prompt editor requires a terminal. Run `lotagate` in a terminal or use `lotagate chat "prompt"` for streaming.\n');
+        return 0;
+    }
+    const loaded = await loadExecutionConfig(runtime, cwd);
+    if (loaded.config.model === null)
+        throw new CliError(CLI_ERROR_CODES.MODEL_NOT_FOUND, 'No model is selected.', { category: 'model', userMessage: 'No model is selected.', hint: MODEL_SELECT_HINT });
+    const profileName = loaded.config.profile ?? AuthenticationService.defaultProfileName();
+    const credential = await runtime.auth.requireCredential(profileName);
+    const client = createLotaGateClient(credential.profile, credential.apiKey);
+    const abortController = new AbortController();
+    const onInterrupt = () => abortController.abort();
+    process.once('SIGINT', onInterrupt);
+    try {
+        const service = new ChatService(new SdkChatCompletionAdapter(client));
+        const system = await buildSafeSystemPrompt(runtime, cwd, loaded.config.model, 'headless-safe');
+        for await (const event of service.stream(loaded.config.model, prompt, { system, signal: abortController.signal }))
+            if (event.type === 'delta')
+                await writeStreamChunk(stdout, event.content);
+        await writeStreamChunk(stdout, '\n');
+        return 0;
+    }
+    finally {
+        process.off('SIGINT', onInterrupt);
+    }
+}
+export async function runExecCommand(positionals, flags, runtime, cwd, stdout) {
+    const prompt = positionals.join(' ').trim();
+    if (prompt.length === 0)
+        throw new CliError(CLI_ERROR_CODES.MISSING_ARGUMENT, 'Missing prompt.', { category: 'arguments', userMessage: 'A prompt is required for exec.' });
+    const loaded = await loadExecutionConfig(runtime, cwd);
+    if (loaded.config.model === null)
+        throw new CliError(CLI_ERROR_CODES.MODEL_NOT_FOUND, 'No model is selected.', { category: 'model', userMessage: 'No model is selected.', hint: MODEL_SELECT_HINT });
+    const profileName = loaded.config.profile ?? AuthenticationService.defaultProfileName();
+    const credential = await runtime.auth.requireCredential(profileName);
+    const imageFlag = getFlag(flags, 'image');
+    const attachments = [];
+    let attachmentBytes = 0;
+    if (typeof imageFlag === 'string') {
+        for (const [index, imagePath] of imageFlag.split(',').map((item) => item.trim()).filter(Boolean).entries()) {
+            if (attachments.length >= RESOURCE_LIMITS.pendingAttachments)
+                throw new CliError(CLI_ERROR_CODES.ATTACHMENT_TOO_LARGE, 'Too many images were supplied.', { category: 'attachment', userMessage: 'Too many images were supplied. Reduce the image list and retry.' });
+            const resolvedImagePath = await resolveExternalPath(imagePath, { cwd });
+            const image = await readFileBounded(resolvedImagePath, DEFAULT_MAX_IMAGE_BYTES);
+            if (image.truncated)
+                throw new CliError(CLI_ERROR_CODES.ATTACHMENT_TOO_LARGE, 'Image exceeds the supported size.', { category: 'attachment', userMessage: 'An image exceeds the supported size limit.' });
+            const normalized = normalizeImage(image.bytes);
+            attachmentBytes += normalized.bytes.byteLength;
+            if (attachmentBytes > RESOURCE_LIMITS.pendingAttachmentTotalBytes)
+                throw new CliError(CLI_ERROR_CODES.ATTACHMENT_TOO_LARGE, 'Image attachment total exceeds the supported limit.', { category: 'attachment', userMessage: 'The combined image size is too large. Reduce the image list and retry.' });
+            attachments.push({ attachment: createImageAttachment(normalized, 'file', `image-${index + 1}`, imagePath), bytes: normalized.bytes });
+        }
+    }
+    const json = isFlagEnabled(flags, 'json') || isFlagEnabled(flags, 'jsonl');
+    const abortController = new AbortController();
+    const onInterrupt = () => abortController.abort();
+    process.once('SIGINT', onInterrupt);
+    try {
+        const client = createLotaGateClient(credential.profile, credential.apiKey);
+        if (attachments.length > 0) {
+            const service = new ChatService(new SdkChatCompletionAdapter(client));
+            const system = await buildSafeSystemPrompt(runtime, cwd, loaded.config.model, 'headless-safe');
+            for await (const event of service.stream(loaded.config.model, prompt, { system, signal: abortController.signal, attachments })) {
+                if (json)
+                    await writeStreamChunk(stdout, `${JSON.stringify(event)}\n`);
+                else if (event.type === 'delta')
+                    await writeStreamChunk(stdout, event.content);
+            }
+        }
+        else {
+            await runHeadlessAgentTurn({ runtime, cwd, model: loaded.config.model, client, prompt, output: stdout, json, signal: abortController.signal });
+        }
+        if (!json)
+            await writeStreamChunk(stdout, '\n');
+        return 0;
+    }
+    finally {
+        process.off('SIGINT', onInterrupt);
+    }
+}

package/dist/application/commands/stream-output.d.ts

@@ -0,0 +1,4 @@
+/** Writes streamed CLI output without allowing a slow pipe to grow memory unboundedly. */
+export declare function writeStreamChunk(output: {
+    write(value: string): unknown;
+}, value: string): Promise<void>;

package/dist/application/commands/stream-output.js

@@ -0,0 +1,10 @@
+import { once } from 'node:events';
+/** Writes streamed CLI output without allowing a slow pipe to grow memory unboundedly. */
+export async function writeStreamChunk(output, value) {
+    if (output.write(value) !== false || !isWritable(output))
+        return;
+    await once(output, 'drain');
+}
+function isWritable(value) {
+    return typeof value.once === 'function';
+}

package/dist/application/commands/utility-commands.d.ts

@@ -0,0 +1,6 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { CommandOutput } from './command-output.js';
+export declare function runDoctorCommand(runtime: CliRuntime, cwd: string, stdout: CommandOutput): Promise<number>;
+export declare function runInspectCommand(runtime: CliRuntime, cwd: string, stdout: CommandOutput): Promise<number>;
+export declare function runCompletionsCommand(positionals: readonly string[], stdout: CommandOutput): Promise<number>;
+export declare function runUpdateCommand(positionals: readonly string[], runtime: CliRuntime, cwd: string, stdout: CommandOutput): Promise<number>;

package/dist/application/commands/utility-commands.js

@@ -0,0 +1,81 @@
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_VERSION } from '../../version.js';
+import path from 'node:path';
+import { AuthenticationService } from '../auth/authentication-service.js';
+import { loadExecutionConfig } from '../config/execution-config.js';
+import { formatCompactTable } from '../formatting/compact-table.js';
+import { COMMAND_REGISTRY } from './command-runtime.js';
+export async function runDoctorCommand(runtime, cwd, stdout) {
+    const config = await loadExecutionConfig(runtime, cwd);
+    const identity = await runtime.projectTrust.inspect(cwd);
+    const profile = config.config.profile ?? AuthenticationService.defaultProfileName();
+    const credential = await runtime.credentialStore.get(profile);
+    const checks = [
+        { name: 'node', ok: Number(process.versions.node.split('.')[0]) >= 22, detail: process.version },
+        { name: 'cwd', ok: path.isAbsolute(cwd), detail: cwd },
+        { name: 'config', ok: true, detail: `${config.sources.length} file(s) loaded` },
+        { name: 'auth', ok: credential !== undefined, detail: credential === undefined ? `profile ${profile} is not configured` : `profile ${profile} configured` },
+        { name: 'project-trust', ok: await runtime.projectTrust.isTrusted(identity), detail: identity.canonicalPath },
+    ];
+    const ok = checks.every((check) => check.ok);
+    stdout.write(`Doctor · ${ok ? 'OK' : 'FAIL'}\n${formatCompactTable(checks.map((check) => ({ name: check.name, status: check.ok ? 'OK' : 'FAIL', detail: check.detail })))}\n`);
+    return ok ? 0 : 1;
+}
+export async function runInspectCommand(runtime, cwd, stdout) {
+    stdout.write(`${JSON.stringify(await runtime.projectTrust.inspect(cwd), null, 2)}\n`);
+    return 0;
+}
+export async function runCompletionsCommand(positionals, stdout) {
+    const shell = positionals[0] ?? 'powershell';
+    const commands = rootCommandNames();
+    const quotedCommands = commands.join(' ');
+    const powershellCommands = commands.map((command) => `"${command}"`).join(',');
+    const scripts = {
+        bash: `_lotagate_complete() { COMPREPLY=( $(compgen -W "${quotedCommands}" -- "\${COMP_WORDS[COMP_CWORD]}") ); }; complete -F _lotagate_complete lotagate\n`,
+        zsh: `#compdef lotagate\n_arguments "1:command:(${quotedCommands})"\n`,
+        powershell: `Register-ArgumentCompleter -CommandName lotagate -ScriptBlock { param($wordToComplete) ${powershellCommands} | Where-Object { $_ -like "$wordToComplete*" } }\n`,
+    };
+    const script = scripts[shell];
+    if (script === undefined)
+        throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, `Unsupported shell: ${shell}`, { category: 'arguments', userMessage: 'Unsupported shell. Choose bash, zsh, or powershell.' });
+    stdout.write(script);
+    return 0;
+}
+function rootCommandNames() {
+    return [...new Set(COMMAND_REGISTRY.list('direct').map((action) => action.path[0]))];
+}
+export async function runUpdateCommand(positionals, runtime, cwd, stdout) {
+    if ((positionals[0] ?? 'check') !== 'check')
+        throw new CliError(CLI_ERROR_CODES.INVALID_ARGUMENT, 'Unsupported update action.', { category: 'update', userMessage: 'Only `lotagate update check` is supported.' });
+    const config = await loadExecutionConfig(runtime, cwd);
+    const registry = process.env['LOTAGATE_NPM_REGISTRY']?.trim() || 'https://registry.npmjs.org';
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    try {
+        const response = await fetch(`${registry.replace(/\/$/u, '')}/@lotagate%2fcli/latest`, { signal: controller.signal, headers: { accept: 'application/json' } });
+        if (!response.ok)
+            throw new Error(`Registry returned HTTP ${response.status}.`);
+        const payload = await response.json();
+        if (typeof payload.version !== 'string' || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(payload.version))
+            throw new Error('Registry response did not contain a valid version.');
+        stdout.write(`${JSON.stringify({ currentVersion: CLI_VERSION, latestVersion: payload.version, channel: config.config.updateChannel, updateAvailable: compareVersions(payload.version, CLI_VERSION) > 0, installation: 'manual' }, null, 2)}\n`);
+    }
+    catch (error) {
+        stdout.write(`${JSON.stringify({ currentVersion: CLI_VERSION, channel: config.config.updateChannel, checked: false, reason: error instanceof Error ? error.message : 'Unable to query the registry.', installation: 'manual' }, null, 2)}\n`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    return 0;
+}
+function compareVersions(left, right) {
+    const parse = (value) => (value.split('-')[0] ?? '').split('.').map((part) => Number(part));
+    const a = parse(left);
+    const b = parse(right);
+    for (let index = 0; index < 3; index += 1) {
+        if ((a[index] ?? 0) !== (b[index] ?? 0))
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return 0;
+}

package/dist/application/config/execution-config.d.ts

@@ -0,0 +1,4 @@
+import type { createCompositionRoot } from '../../bootstrap/composition-root.js';
+import type { ConfigLoadResult } from '../../infrastructure/config/config-loader.js';
+/** Loads project configuration only after the project trust boundary is known. */
+export declare function loadExecutionConfig(runtime: ReturnType<typeof createCompositionRoot>, cwd: string): Promise<ConfigLoadResult>;

package/dist/application/config/execution-config.js

@@ -0,0 +1,6 @@
+/** Loads project configuration only after the project trust boundary is known. */
+export async function loadExecutionConfig(runtime, cwd) {
+    const identity = await runtime.projectTrust.inspect(cwd);
+    const trusted = await runtime.projectTrust.isTrusted(identity);
+    return runtime.configLoader.load(cwd, { includeProject: trusted });
+}

package/dist/application/extensions/extension-list-contract.d.ts

@@ -0,0 +1,13 @@
+import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
+export type ExtensionListKind = 'hook' | 'skill' | 'plugin' | 'mcp';
+export type ExtensionListScope = ExtensionScope | 'plugin' | 'builtin';
+export interface ExtensionListItem {
+    readonly name: string;
+    readonly status: string;
+    readonly detail: string;
+    readonly scope?: ExtensionListScope;
+}
+export interface ExtensionListResult {
+    readonly kind: ExtensionListKind;
+    readonly items: readonly ExtensionListItem[];
+}

package/dist/application/extensions/extension-list-contract.js

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

package/dist/application/extensions/extension-list-formatters.d.ts

@@ -0,0 +1,31 @@
+import type { HookDefinition } from '../../domain/extensions/hook-manifest.js';
+import type { CliMcpConfig, CliMcpServerConfig } from '../../domain/extensions/mcp-config.js';
+import type { InstalledPlugin } from '../../infrastructure/extensions/plugin-manager.js';
+import type { ScopedSkill } from '../../infrastructure/extensions/skill-manager.js';
+import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
+import type { ExtensionListResult } from './extension-list-contract.js';
+export declare function formatMcpList(entries: readonly {
+    scope: ExtensionScope;
+    config: CliMcpConfig;
+}[]): string;
+export declare function createMcpListResult(entries: readonly {
+    scope: ExtensionScope;
+    config: CliMcpConfig;
+}[]): ExtensionListResult;
+export declare function formatExtensionList(result: ExtensionListResult): string;
+export declare function formatMcpDetails(name: string, scope: ExtensionScope, entry: {
+    enabled: boolean;
+    config: CliMcpServerConfig;
+} | undefined): string;
+export declare function formatPluginList(entries: readonly {
+    scope: ExtensionScope;
+    plugins: readonly InstalledPlugin[];
+}[]): string;
+export declare function createPluginListResult(entries: readonly {
+    scope: ExtensionScope;
+    plugins: readonly InstalledPlugin[];
+}[]): ExtensionListResult;
+export declare function formatSkillList(skills: readonly ScopedSkill[]): string;
+export declare function createSkillListResult(skills: readonly ScopedSkill[]): ExtensionListResult;
+export declare function formatHookList(hooks: readonly HookDefinition[]): string;
+export declare function createHookListResult(hooks: readonly HookDefinition[]): ExtensionListResult;

package/dist/application/extensions/extension-list-formatters.js

@@ -0,0 +1,98 @@
+import { formatCompactTable } from '../formatting/compact-table.js';
+const SKILL_LIST_DESCRIPTION_MAX_CHARACTERS = 240;
+const SKILL_LIST_TABLE_MAX_WIDTH = 280;
+export function formatMcpList(entries) {
+    return formatExtensionList(createMcpListResult(entries));
+}
+export function createMcpListResult(entries) {
+    const items = entries.flatMap(({ scope, config }) => Object.entries(config).map(([name, entry]) => ({ name, scope, entry })));
+    return {
+        kind: 'mcp',
+        items: items
+            .sort((left, right) => left.name.localeCompare(right.name) || left.scope.localeCompare(right.scope))
+            .map(({ name, scope, entry }) => ({ name, status: entry.enabled ? 'ENABLED' : 'DISABLED', detail: `${scope} · ${formatMcpTarget(entry.config)}`, scope })),
+    };
+}
+export function formatExtensionList(result) {
+    if (result.kind === 'mcp')
+        return formatCompactTable(result.items, { empty: 'No MCP servers configured.' });
+    if (result.kind === 'plugin')
+        return formatCompactTable(result.items, { empty: 'No plugins installed.' });
+    if (result.kind === 'skill')
+        return formatCompactTable(result.items, { empty: 'No skills available.', maxWidth: SKILL_LIST_TABLE_MAX_WIDTH });
+    return formatCompactTable(result.items, { empty: 'No hooks are loaded. Hooks require a trusted project.' });
+}
+export function formatMcpDetails(name, scope, entry) {
+    if (entry === undefined)
+        return `MCP server not found: ${name}.`;
+    const config = entry.config.type === 'stdio'
+        ? { type: configType(entry.config), command: redact(entry.config.command), args: entry.config.args?.map(redact) ?? [], credentials: hasCredentials(entry.config) }
+        : { type: configType(entry.config), url: redactUrl(entry.config.url), credentials: hasCredentials(entry.config) };
+    return JSON.stringify({ name, scope, enabled: entry.enabled, ...config });
+}
+export function formatPluginList(entries) {
+    return formatExtensionList(createPluginListResult(entries));
+}
+export function createPluginListResult(entries) {
+    const items = entries.flatMap(({ scope, plugins }) => plugins.map((plugin) => ({ scope, plugin })));
+    return {
+        kind: 'plugin',
+        items: items
+            .sort((left, right) => left.plugin.manifest.name.localeCompare(right.plugin.manifest.name) || left.scope.localeCompare(right.scope))
+            .map(({ scope, plugin }) => ({ name: plugin.manifest.name, status: plugin.enabled ? 'ENABLED' : 'DISABLED', detail: `${scope} · v${plugin.manifest.version}`, scope })),
+    };
+}
+export function formatSkillList(skills) {
+    return formatExtensionList(createSkillListResult(skills));
+}
+export function createSkillListResult(skills) {
+    return {
+        kind: 'skill',
+        items: [...skills]
+            .sort((left, right) => left.skillKey.localeCompare(right.skillKey))
+            .map((skill) => ({ name: skill.skillKey, status: skill.enabled ? 'ENABLED' : 'DISABLED', detail: `${skill.scope} · ${truncate(redact(skill.description), SKILL_LIST_DESCRIPTION_MAX_CHARACTERS)}`, scope: skill.scope })),
+    };
+}
+export function formatHookList(hooks) {
+    return formatExtensionList(createHookListResult(hooks));
+}
+export function createHookListResult(hooks) {
+    return {
+        kind: 'hook',
+        items: [...hooks]
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .map((hook) => ({ name: hook.id, status: hook.event, detail: `${truncate(redact([hook.command, ...hook.args].join(' ')), 160)} · ${hook.timeoutMs}ms` })),
+    };
+}
+function formatMcpTarget(config) {
+    if (config.type === 'stdio')
+        return truncate(redact([config.command, ...(config.args ?? [])].join(' ')), 160);
+    return `${config.type} · ${redactUrl(config.url)}`;
+}
+function configType(config) { return config.type; }
+function hasCredentials(config) {
+    return config.type === 'stdio'
+        ? config.env !== undefined && Object.keys(config.env).length > 0
+        : config.auth !== undefined || (config.headers !== undefined && Object.keys(config.headers).length > 0) || /(?:key|token|secret|password|auth)=/iu.test(config.url);
+}
+function redactUrl(value) {
+    try {
+        const url = new URL(value);
+        for (const key of url.searchParams.keys())
+            if (/(key|token|secret|password|auth)/iu.test(key))
+                url.searchParams.set(key, '[REDACTED]');
+        return truncate(url.toString(), 180);
+    }
+    catch {
+        return truncate(redact(value), 180);
+    }
+}
+function redact(value) {
+    return value
+        .replace(/Bearer\s+[^\s]+/giu, 'Bearer [REDACTED]')
+        .replace(/sk-[A-Za-z0-9_-]{8,}/gu, '[REDACTED]')
+        .replace(/(api[_-]?key|password|secret|token)\s*[:=]\s*[^\s,]+/giu, '$1=[REDACTED]');
+}
+function truncate(value, maximum) {
+    return value.length <= maximum ? value : `${value.slice(0, maximum - 3)}...`;
+}

package/dist/application/extensions/extension-list-output.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOutput } from '../commands/command-output.js';
+import type { ExtensionListResult } from './extension-list-contract.js';
+export declare function writeExtensionListResult(output: CommandOutput, result: ExtensionListResult, fallbackText: string): void;

package/dist/application/extensions/extension-list-output.js

@@ -0,0 +1,7 @@
+export function writeExtensionListResult(output, result, fallbackText) {
+    if (output.writeStructured === undefined) {
+        output.write(`${fallbackText}\n`);
+        return;
+    }
+    output.writeStructured(result, `${fallbackText}\n`);
+}

package/dist/application/extensions/plugin-contribution-registry.d.ts

@@ -0,0 +1,15 @@
+import { type CliMcpConfig } from '../../domain/extensions/mcp-config.js';
+import type { PluginManifest } from '../../domain/extensions/plugin-manifest.js';
+import type { PluginSkillRoot } from '../../infrastructure/extensions/skill-roots.js';
+export interface PluginContributions {
+    plugins: readonly PluginManifest[];
+    skillRoots: readonly PluginSkillRoot[];
+    mcpConfig: CliMcpConfig;
+}
+/** Resolves only enabled, trusted declarative plugin contributions. */
+export declare class PluginContributionRegistry {
+    private readonly globalConfigDirectory;
+    constructor(globalConfigDirectory: string);
+    resolve(cwd: string, trustedProject: boolean): Promise<PluginContributions>;
+}
+export declare function mergeMcpConfigContributions(...configs: readonly CliMcpConfig[]): CliMcpConfig;

package/dist/application/extensions/plugin-contribution-registry.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { mergeMcpConfigs, validateMcpConfig } from '../../domain/extensions/mcp-config.js';
+import { CliError } from '../../domain/errors/cli-error.js';
+import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
+import { PluginManager } from '../../infrastructure/extensions/plugin-manager.js';
+import { readJsonFileBounded } from '../../infrastructure/filesystem/bounded-json-reader.js';
+import { RESOURCE_LIMITS } from '../../domain/runtime/resource-limits.js';
+/** Resolves only enabled, trusted declarative plugin contributions. */
+export class PluginContributionRegistry {
+    globalConfigDirectory;
+    constructor(globalConfigDirectory) {
+        this.globalConfigDirectory = globalConfigDirectory;
+    }
+    async resolve(cwd, trustedProject) {
+        if (!trustedProject)
+            return { plugins: [], skillRoots: [], mcpConfig: {} };
+        const globalPlugins = path.join(this.globalConfigDirectory, 'plugins');
+        const projectPlugins = path.join(cwd, '.lotagate', 'plugins');
+        const plugins = selectProjectFirstPlugins([...await new PluginManager(projectPlugins).list(), ...await new PluginManager(globalPlugins).list()]);
+        const manifests = plugins.filter((plugin) => plugin.enabled).map((plugin) => plugin.manifest);
+        return {
+            plugins: manifests,
+            skillRoots: manifests.flatMap((plugin) => plugin.skillsDirectory === undefined ? [] : [{ root: path.join(plugin.directory, plugin.skillsDirectory), pluginName: plugin.name }]),
+            mcpConfig: await loadPluginMcpConfig(manifests),
+        };
+    }
+}
+function selectProjectFirstPlugins(plugins) {
+    const seen = new Set();
+    return plugins.filter((plugin) => {
+        if (seen.has(plugin.manifest.name))
+            return false;
+        seen.add(plugin.manifest.name);
+        return true;
+    });
+}
+async function loadPluginMcpConfig(plugins) {
+    const merged = {};
+    for (const plugin of plugins) {
+        if (plugin.mcpConfig === undefined)
+            continue;
+        const config = validateMcpConfig(await readJsonFileBounded(path.join(plugin.directory, plugin.mcpConfig), RESOURCE_LIMITS.mcpConfigBytes));
+        for (const [name, entry] of Object.entries(config)) {
+            const qualifiedName = qualifyPluginMcpServerName(plugin.name, name);
+            if (merged[qualifiedName] !== undefined)
+                throw duplicateMcpServer(qualifiedName);
+            merged[qualifiedName] = entry;
+        }
+    }
+    return merged;
+}
+function qualifyPluginMcpServerName(pluginName, serverName) {
+    const pluginToken = pluginName.replace(/^@/u, '').replace('/', '_');
+    const readable = `plugin_${pluginToken}_${serverName}`;
+    if (readable.length <= 64)
+        return readable;
+    const digest = createHash('sha256').update(`${pluginName}\0${serverName}`).digest('hex').slice(0, 12);
+    const suffix = `_${digest}_${serverName.slice(0, 8)}`;
+    const available = Math.max(1, 64 - 'plugin_'.length - suffix.length);
+    return `plugin_${pluginToken.slice(0, available)}${suffix}`;
+}
+export function mergeMcpConfigContributions(...configs) {
+    try {
+        return mergeMcpConfigs(...configs);
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === CLI_ERROR_CODES.MCP_CONFIG_INVALID) {
+            const message = error.message.replace(/^Invalid MCP configuration: /u, '');
+            throw duplicateMcpServer(message.replace(/\.$/u, '').replace(/^MCP server is defined more than once: /u, ''));
+        }
+        throw error;
+    }
+}
+function duplicateMcpServer(name) {
+    return new CliError(CLI_ERROR_CODES.MCP_CONFIG_INVALID, `Multiple MCP contributions define server: ${name}`, {
+        category: 'extension',
+        userMessage: `MCP server \`${name}\` is defined more than once. Rename or remove one contribution.`,
+    });
+}

package/dist/application/extensions/skill-scope-store.d.ts

@@ -0,0 +1,23 @@
+import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
+export interface ActiveSkillScope {
+    skillName: string;
+    allowedTools: readonly string[];
+}
+/**
+ * Keeps an in-memory, per-agent-run restriction created by a loaded skill.
+ * Instances are owned by one CLI turn and must never be persisted or shared.
+ */
+export declare class SkillScopeStore {
+    private readonly scopes;
+    private initialScope;
+    constructor(initialScope?: ActiveSkillScope);
+    activate(runId: string, skill: Pick<SkillManifest, 'name' | 'allowedTools'> & {
+        skillKey?: string;
+    }): ActiveSkillScope;
+    get(runId: string): ActiveSkillScope | undefined;
+    clear(runId: string): void;
+    clearAll(): void;
+}
+export declare function createSkillScope(skill: Pick<SkillManifest, 'name' | 'allowedTools'> & {
+    skillKey?: string;
+}): ActiveSkillScope;

package/dist/application/extensions/skill-scope-store.js

@@ -0,0 +1,33 @@
+/**
+ * Keeps an in-memory, per-agent-run restriction created by a loaded skill.
+ * Instances are owned by one CLI turn and must never be persisted or shared.
+ */
+export class SkillScopeStore {
+    scopes = new Map();
+    initialScope;
+    constructor(initialScope) {
+        this.initialScope = initialScope;
+    }
+    activate(runId, skill) {
+        const scope = normalizeScope(skill);
+        this.scopes.set(runId, scope);
+        return scope;
+    }
+    get(runId) {
+        return this.scopes.get(runId) ?? this.initialScope;
+    }
+    clear(runId) { this.scopes.delete(runId); }
+    clearAll() {
+        this.scopes.clear();
+        this.initialScope = undefined;
+    }
+}
+export function createSkillScope(skill) {
+    return normalizeScope(skill);
+}
+function normalizeScope(skill) {
+    return {
+        skillName: skill.skillKey ?? skill.name,
+        allowedTools: [...new Set(skill.allowedTools)].sort((left, right) => left.localeCompare(right)),
+    };
+}

package/dist/application/formatting/compact-number.d.ts

@@ -0,0 +1,2 @@
+/** Formats large counts for compact terminal and command output. */
+export declare function formatCompactNumber(value: number): string;

package/dist/application/formatting/compact-number.js

@@ -0,0 +1,18 @@
+const COMPACT_UNITS = ['K', 'M', 'B', 'T', 'Qa', 'Qi', 'Sx', 'Sp', 'Oc', 'No', 'Dc'];
+/** Formats large counts for compact terminal and command output. */
+export function formatCompactNumber(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    const sign = value < 0 ? '-' : '';
+    let magnitude = Math.abs(value);
+    if (magnitude < 1000)
+        return `${sign}${Math.round(magnitude)}`;
+    let unitIndex = -1;
+    while (magnitude >= 1000 && unitIndex < COMPACT_UNITS.length - 1) {
+        magnitude /= 1000;
+        unitIndex += 1;
+    }
+    const decimals = magnitude >= 100 ? 0 : magnitude >= 10 ? 1 : 2;
+    const formatted = magnitude.toFixed(decimals).replace(/\.0+$|(?<=\.\d)0+$/u, '');
+    return `${sign}${formatted}${COMPACT_UNITS[unitIndex]}`;
+}