@soddong/agentic-runtime 0.16.0

package/dist/cli.js

@@ -0,0 +1,1731 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getClaudeCodeAdapterStatus, installClaudeCodeAdapter } from "./claude-code-adapter.js";
+import { getCodexAdapterStatus, installCodexAdapter } from "./codex-adapter.js";
+import { getRuntimeDatabaseStatus, initializeRuntimeDatabase } from "./database.js";
+import { runRuntimeExecution } from "./execution.js";
+import { getExecutionDetail, getLatestExecution, listExecutions, summarizeExecutions } from "./execution-query.js";
+import { recordHook } from "./hook-record.js";
+import { getRuntimeInfo } from "./index.js";
+import { getKiroAdapterStatus, installKiroAdapter } from "./kiro-adapter.js";
+import { listProjectModules, parseModuleLayer, registerProjectModule } from "./module-registry.js";
+import { assembleRegisteredAgentContext, isAgentContribution, registerAgentContribution } from "./agent-router.js";
+import { installProjectBundle } from "./bundle-installer.js";
+import { listProjectBundles } from "./bundle-registry.js";
+import { applySeedImportPlan, createSeedImportPlan, listSeedImportPlans } from "./seed-importer.js";
+import { createExecutionProjectFromBundle, getExecutionProjectStatus } from "./execution-projects.js";
+const HELP_TEXT = `agentic - Agentic Platform local execution CLI
+
+Usage:
+  agentic <command> [options]
+
+Commands:
+  help              Show this help message
+  version           Show runtime version
+  init              Initialize an Agentic execution project
+  docs              Show package documentation locations
+  config            Show current Agentic project configuration status
+  setup             Bootstrap Agentic project and adapter configuration
+  run <request>     Record a user request through runtime execution
+  execution list    List recorded execution history
+  execution latest  Show the latest recorded execution
+  execution show    Show one execution detail
+  execution summary Summarize recorded execution history
+  agent register    Register an installed agent package contribution
+  agent context     Assemble selected agent resource context
+  hook record       Record an agent tool hook event
+  db init           Initialize project-local platform.sqlite
+  db status         Show project-local database status
+  adapter install   Install an Agentic adapter and initialize runtime if needed
+  adapter status    Show adapter installation status
+  module register   Register an Agentic package in this project
+  module list       List registered Agentic packages
+  bundle install    Register an installed methodology seed bundle in this project
+  bundle apply      Install/register a bundle and apply its seed in one flow
+  bundle list       List installed project bundles
+  bundle status     Show installed project bundle status
+  seed import       Create a dry-run seed import plan from an installed bundle
+  seed apply        Apply a seed import plan through target package handlers
+  seed status       Show seed import plan status
+  project create    Create an execution project from an applied bundle
+  project status    Show execution project status
+
+Planned commands:
+  validate          Run validation
+  render            Render reports
+`;
+function printHelp() {
+    console.log(HELP_TEXT);
+}
+function printVersion() {
+    const info = getRuntimeInfo();
+    console.log(`${info.name} ${info.version}`);
+}
+function getPackageRoot() {
+    return new URL("..", import.meta.url).pathname;
+}
+function printDocs() {
+    const packageRoot = getPackageRoot();
+    const docs = [
+        ["README", join(packageRoot, "README.md")],
+        ["Usage", join(packageRoot, "docs", "usage.md")],
+        ["Configuration", join(packageRoot, "docs", "configuration.md")],
+        ["Operations", join(packageRoot, "docs", "operations.md")],
+        ["Build", join(packageRoot, "docs", "build.md")],
+        ["Publishing", join(packageRoot, "docs", "publishing.md")],
+        ["Delivery", join(packageRoot, "docs", "delivery.md")]
+    ];
+    const info = getRuntimeInfo();
+    console.log(`${info.name} ${info.version}`);
+    console.log("");
+    console.log("Package documentation:");
+    for (const [label, path] of docs) {
+        const status = existsSync(path) ? "" : " (missing)";
+        console.log(`  ${label.padEnd(13)} ${path}${status}`);
+    }
+    console.log("");
+    console.log("Project documentation:");
+    console.log(`  ${join(process.cwd(), ".agentic", "README.md")}`);
+}
+function getConfigPath(cwd = process.cwd()) {
+    return join(cwd, "agentic.config.json");
+}
+function printConfigStatus() {
+    const cwd = process.cwd();
+    const configPath = getConfigPath(cwd);
+    const agenticDir = join(cwd, ".agentic");
+    console.log("Agentic project configuration");
+    console.log("");
+    console.log(`Project root: ${cwd}`);
+    console.log(`Config file : ${configPath} ${existsSync(configPath) ? "(found)" : "(missing)"}`);
+    console.log(`Work dir    : ${agenticDir} ${existsSync(agenticDir) ? "(found)" : "(missing)"}`);
+    if (!existsSync(configPath)) {
+        console.log("");
+        console.log("Run 'agentic init' to create the default project configuration.");
+        return;
+    }
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf8"));
+        console.log("");
+        console.log("Config JSON : valid");
+        console.log(JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log("");
+        console.log("Config JSON : invalid");
+        console.log(message);
+    }
+}
+function writeFileIfMissing(path, content) {
+    if (existsSync(path)) {
+        return "exists";
+    }
+    writeFileSync(path, content, "utf8");
+    return "created";
+}
+const AGENTIC_INSTRUCTIONS_START_PATTERN = /<!-- agentic-runtime:start version=([^ >]+) -->/;
+const AGENTIC_INSTRUCTIONS_BLOCK_PATTERN = /<!-- agentic-runtime:start version=[^ >]+ -->[\s\S]*?<!-- agentic-runtime:end -->/;
+function createHookWrapperContent() {
+    const runtimeModuleUrl = new URL("./index.js", import.meta.url).href;
+    return `#!/usr/bin/env node
+import { recordHook } from ${JSON.stringify(runtimeModuleUrl)};
+
+let input = "";
+process.stdin.setEncoding("utf8");
+
+for await (const chunk of process.stdin) {
+  input += chunk;
+}
+
+function readOption(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+const source = readOption("--source");
+const event = readOption("--event");
+
+if (source === undefined || event === undefined) {
+  console.error("Usage: agentic-hook --source <source> --event <event>");
+  process.exit(1);
+}
+
+const rawPayload =
+  input.trim().length > 0 || source !== "kiro" || event !== "PromptSubmit"
+    ? input
+    : JSON.stringify({
+        prompt: process.env.USER_PROMPT ?? ""
+      });
+
+try {
+  const result = recordHook({
+    source,
+    event,
+    rawPayload
+  });
+
+  if (result.action === "skipped" && result.reason !== undefined) {
+    console.error(\`agentic hook skipped: \${result.reason}\`);
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(\`agentic hook record failed: \${message}\`);
+}
+`;
+}
+function ensureHookWrapper() {
+    const wrapperPath = join(process.cwd(), ".agentic", "bin", "agentic-hook.mjs");
+    mkdirSync(join(wrapperPath, ".."), { recursive: true });
+    return writeFileIfMissing(wrapperPath, createHookWrapperContent());
+}
+const AGENT_INSTRUCTIONS_BODY = `이 블록은 agentic-runtime이 관리하는 Agent 실행 지침입니다.
+사용자가 직접 작성한 내용은 이 managed block 밖에 둡니다.
+
+## Runtime Execution Policy
+
+- 이 프로젝트에서 Agentic Platform 관련 작업을 수행할 때는 먼저 사용자 지시를 runtime execution으로 기록합니다.
+- 기본 명령은 다음과 같습니다.
+
+\`\`\`bash
+npx agentic run "<사용자 지시문>"
+\`\`\`
+
+- 현재 \`agentic run\`은 router 또는 개별 Agent module 실행 전 단계의 공통 execution 기록입니다.
+- 실제 작업 수행 내용이 별도 도구나 Agent module에서 실행되더라도, 사용자 지시와 실행 접수 이력은 \`.agentic/platform.sqlite\`에 남깁니다.
+- 기록 대상은 사용자 지시, 실행 run, 실행 로그, 실행 결과입니다.
+
+## Runtime History Query Policy
+
+- 사용자가 이전 지시, 작업 이력, 최근 결과, 실패 이력, 작업 현황을 질문하면 현재 대화 기억에만 의존하지 않고 execution DB를 먼저 확인합니다.
+- 기본 조회 명령은 다음과 같습니다.
+
+\`\`\`bash
+npx agentic execution list --range 7d --format json
+npx agentic execution summary --range today --format json
+npx agentic execution latest --format json
+npx agentic execution latest --range today --status succeeded --format json
+\`\`\`
+
+- 이전 지시, 이전 결과, 마지막 완료 작업을 묻는 경우에는 현재 실행 중인 자기 run을 피하기 위해 \`--status succeeded\`를 우선 사용합니다.
+- 현재 실행 중인 작업을 묻는 경우에는 \`--status running\`, 실패 이력을 묻는 경우에는 \`--status failed\`를 사용합니다.
+- 조회 결과가 있으면 \`agentic_user_requests\`, \`agentic_execution_runs\`, \`agentic_execution_logs\`, \`agentic_execution_outputs\` 기록을 기준으로 답변합니다.
+- 조회 결과가 없거나 불완전한 경우에만 현재 대화 context와 파일 상태를 보조적으로 사용합니다.
+
+## Scope
+
+- \`agentic-runtime\`은 공통 실행 기반입니다.
+- 개별 업무 Agent module은 별도 npm package로 제공됩니다.
+- router와 개별 Agent module 연계 전까지는 \`agentic run\`을 공통 실행 접수 및 감사 추적 기준으로 사용합니다.
+
+## Agent Resource Context Policy
+
+- 사용자가 문서 작성, 산출물 작성, 검증, 가이드 기반 작업을 요청하면 설치된 Agent package의 resource context를 먼저 확인할 수 있습니다.
+- 기본 명령은 다음과 같습니다.
+
+\`\`\`bash
+npx agentic agent context "<사용자 지시문>"
+npx agentic agent context "<사용자 지시문>" --format json
+\`\`\`
+
+- 이 명령은 등록된 agent contribution을 라우팅하고, 선택된 resource file을 읽어 LLM context용 Markdown text로 조립합니다.
+- 설치된 agent package를 먼저 등록해야 하는 경우 다음 명령을 사용합니다.
+
+\`\`\`bash
+npx agentic agent register <package-name>
+\`\`\`
+
+- 선택 결과가 없거나 package root를 확인할 수 없으면 현재 대화 context와 파일 상태를 보조적으로 사용합니다.
+`;
+function compareVersion(left, right) {
+    const leftParts = left.split(/[.-]/).map((part) => Number.parseInt(part, 10));
+    const rightParts = right.split(/[.-]/).map((part) => Number.parseInt(part, 10));
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = Number.isFinite(leftParts[index]) ? leftParts[index] : 0;
+        const rightValue = Number.isFinite(rightParts[index]) ? rightParts[index] : 0;
+        if (leftValue > rightValue) {
+            return 1;
+        }
+        if (leftValue < rightValue) {
+            return -1;
+        }
+    }
+    return 0;
+}
+function createManagedAgentInstructionsBlock(version) {
+    return `<!-- agentic-runtime:start version=${version} -->\n${AGENT_INSTRUCTIONS_BODY.trimEnd()}\n<!-- agentic-runtime:end -->\n`;
+}
+function createAgentInstructionsFile(version) {
+    return `# Agentic Runtime Instructions\n\n${createManagedAgentInstructionsBlock(version)}`;
+}
+function isLegacyGeneratedAgentInstructions(content) {
+    return (content.includes("이 파일은 agentic-runtime이 생성한 Agent 실행 지침 템플릿입니다.") &&
+        content.includes("프로젝트 루트의 AGENTS.md에 필요한 내용을 반영해 사용합니다.") &&
+        content.includes("## Runtime Execution Policy"));
+}
+function stripLegacyGeneratedPrefix(content) {
+    const markerIndex = content.indexOf("<!-- agentic-runtime:start");
+    if (markerIndex <= 0 || !isLegacyGeneratedAgentInstructions(content.slice(0, markerIndex))) {
+        return content;
+    }
+    return `# Agentic Runtime Instructions\n\n${content.slice(markerIndex).trimStart()}`;
+}
+function upsertAgentInstructions(path) {
+    const version = getRuntimeInfo().version;
+    if (!existsSync(path)) {
+        writeFileSync(path, createAgentInstructionsFile(version), "utf8");
+        return "created";
+    }
+    const current = stripLegacyGeneratedPrefix(readFileSync(path, "utf8"));
+    const versionMatch = AGENTIC_INSTRUCTIONS_START_PATTERN.exec(current);
+    const nextBlock = createManagedAgentInstructionsBlock(version);
+    if (versionMatch !== null) {
+        const currentVersion = versionMatch[1] ?? "0.0.0";
+        const comparison = compareVersion(currentVersion, version);
+        if (comparison > 0) {
+            return "newer_exists";
+        }
+        if (comparison === 0 && current === readFileSync(path, "utf8")) {
+            return "exists";
+        }
+        writeFileSync(path, current.replace(AGENTIC_INSTRUCTIONS_BLOCK_PATTERN, nextBlock.trimEnd()), "utf8");
+        return "updated";
+    }
+    if (isLegacyGeneratedAgentInstructions(current)) {
+        writeFileSync(path, createAgentInstructionsFile(version), "utf8");
+        return "updated";
+    }
+    const separator = current.endsWith("\n") ? "\n" : "\n\n";
+    writeFileSync(path, `${current}${separator}${nextBlock}`, "utf8");
+    return "appended";
+}
+function initializeProject() {
+    const cwd = process.cwd();
+    const projectName = basename(cwd);
+    const agenticDir = join(cwd, ".agentic");
+    const directories = [agenticDir, join(agenticDir, "data"), join(agenticDir, "logs"), join(agenticDir, "modules")];
+    for (const directory of directories) {
+        mkdirSync(directory, { recursive: true });
+    }
+    const configPath = getConfigPath(cwd);
+    const config = {
+        projectName,
+        runtime: {
+            database: {
+                type: "sqlite",
+                path: ".agentic/platform.sqlite"
+            }
+        },
+        modules: []
+    };
+    const configStatus = writeFileIfMissing(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    const readmePath = join(agenticDir, "README.md");
+    const readmeStatus = writeFileIfMissing(readmePath, `# Agentic Project\n\nThis directory is managed by agentic-runtime.\n\n- data/: local runtime data\n- logs/: runtime logs\n- modules/: installed Agentic package metadata\n\nUse \`npx agentic docs\` to find package documentation.\nUse \`npx agentic db init\` to initialize the local SQLite database.\n`);
+    const agentInstructionsPath = join(agenticDir, "AGENTS.md");
+    const agentInstructionsStatus = upsertAgentInstructions(agentInstructionsPath);
+    const hookWrapperStatus = ensureHookWrapper();
+    console.log("Agentic project initialized");
+    console.log("");
+    console.log(`Project root: ${cwd}`);
+    console.log(`Config file : ${relative(cwd, configPath)} (${configStatus})`);
+    console.log(`Work dir    : ${relative(cwd, agenticDir)}`);
+    console.log(`README      : ${relative(cwd, readmePath)} (${readmeStatus})`);
+    console.log(`AGENTS      : ${relative(cwd, agentInstructionsPath)} (${agentInstructionsStatus})`);
+    console.log(`Hook wrapper: ${relative(cwd, join(agenticDir, "bin", "agentic-hook.mjs"))} (${hookWrapperStatus})`);
+}
+function initializeDatabase() {
+    const result = initializeRuntimeDatabase();
+    console.log("Agentic runtime database initialized");
+    console.log("");
+    console.log(`Database: ${result.databasePath}`);
+    console.log(`Created : ${result.created ? "yes" : "no"}`);
+    console.log("Tables  :");
+    for (const table of result.tables) {
+        console.log(`  - ${table}`);
+    }
+}
+function ensureProjectRuntimeReady() {
+    const cwd = process.cwd();
+    const configPath = getConfigPath(cwd);
+    const agenticDir = join(cwd, ".agentic");
+    const readmePath = join(agenticDir, "README.md");
+    const agentInstructionsPath = join(agenticDir, "AGENTS.md");
+    const databaseStatus = getRuntimeDatabaseStatus();
+    if (!existsSync(configPath) || !existsSync(readmePath) || !existsSync(agentInstructionsPath)) {
+        initializeProject();
+        console.log("");
+    }
+    else {
+        const agentInstructionsStatus = upsertAgentInstructions(agentInstructionsPath);
+        if (agentInstructionsStatus !== "exists") {
+            console.log(`Agentic instructions ${agentInstructionsStatus}: ${relative(cwd, agentInstructionsPath)}`);
+            console.log("");
+        }
+        if (!existsSync(join(agenticDir, "bin", "agentic-hook.mjs"))) {
+            const hookWrapperStatus = ensureHookWrapper();
+            console.log(`Agentic hook wrapper ${hookWrapperStatus}: ${relative(cwd, join(agenticDir, "bin", "agentic-hook.mjs"))}`);
+            console.log("");
+        }
+    }
+    if (!databaseStatus.exists || databaseStatus.tables.length === 0) {
+        initializeDatabase();
+        console.log("");
+    }
+}
+function printDatabaseStatus() {
+    const status = getRuntimeDatabaseStatus();
+    console.log("Agentic runtime database status");
+    console.log("");
+    console.log(`Database: ${status.databasePath}`);
+    console.log(`Exists  : ${status.exists ? "yes" : "no"}`);
+    if (status.tables.length === 0) {
+        console.log("Tables  : none");
+        return;
+    }
+    console.log("Tables  :");
+    for (const table of status.tables) {
+        console.log(`  - ${table}`);
+    }
+}
+async function readStdin() {
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin) {
+        input += chunk;
+    }
+    return input;
+}
+async function runExecution(args) {
+    const requestText = args.join(" ").trim();
+    if (requestText.length === 0) {
+        console.error('Usage: agentic run "<user request>"');
+        return 1;
+    }
+    const result = await runRuntimeExecution({
+        runType: "command",
+        packageName: "@soddong/agentic-runtime",
+        commandName: "run",
+        inputText: requestText,
+        requestSource: "cli",
+        handler(context) {
+            context.logger.info("Runtime CLI request recorded", {
+                requestLength: requestText.length
+            });
+            return {
+                outputType: "json",
+                contentJson: {
+                    message: "Request recorded by agentic-runtime.",
+                    requestText
+                }
+            };
+        }
+    });
+    console.log("Agentic run completed");
+    console.log("");
+    console.log(`Run ID    : ${result.runId}`);
+    console.log(`Request ID: ${result.requestId ?? "-"}`);
+    console.log(`Status    : ${result.status}`);
+    console.log(`Duration  : ${result.durationMs}ms`);
+    console.log(`Outputs   : ${result.outputCount}`);
+    return result.status === "succeeded" ? 0 : 1;
+}
+function registerModule(args) {
+    const [packageName, packageVersion, moduleLayerValue] = args;
+    if (packageName === undefined || packageVersion === undefined) {
+        console.error("Usage: agentic module register <package-name> <package-version> [runtime|domain|capability|application|support]");
+        return 1;
+    }
+    try {
+        const moduleLayer = parseModuleLayer(moduleLayerValue);
+        const module = registerProjectModule({
+            packageName,
+            packageVersion,
+            moduleLayer
+        });
+        console.log("Agentic module registered");
+        console.log("");
+        console.log(`Package: ${module.packageName}`);
+        console.log(`Version: ${module.packageVersion}`);
+        console.log(`Layer  : ${module.moduleLayer ?? "-"}`);
+        console.log(`Enabled: ${module.enabled ? "yes" : "no"}`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return 1;
+    }
+}
+function printModuleList() {
+    const modules = listProjectModules();
+    console.log("Agentic project modules");
+    console.log("");
+    if (modules.length === 0) {
+        console.log("No modules registered.");
+        return;
+    }
+    for (const module of modules) {
+        console.log(`- ${module.packageName}@${module.packageVersion}`);
+        console.log(`  layer  : ${module.moduleLayer ?? "-"}`);
+        console.log(`  enabled: ${module.enabled ? "yes" : "no"}`);
+    }
+}
+function isValidationValid(value) {
+    return (typeof value !== "object" ||
+        value === null ||
+        !("valid" in value) ||
+        value.valid !== false);
+}
+function validationIssueCount(value) {
+    if (typeof value !== "object" || value === null || !("issues" in value)) {
+        return 0;
+    }
+    const issues = value.issues;
+    return Array.isArray(issues) ? issues.length : 0;
+}
+function recordValue(value, key) {
+    return typeof value === "object" && value !== null ? value[key] : undefined;
+}
+function recordString(value, key) {
+    const raw = recordValue(value, key);
+    return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+function recordObject(value, key) {
+    const raw = recordValue(value, key);
+    return typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : undefined;
+}
+function readRequiredPackagesFromManifest(manifest) {
+    const requires = recordObject(manifest, "requires");
+    const packages = recordObject(requires, "packages");
+    if (packages === undefined) {
+        return {};
+    }
+    const result = {};
+    for (const [packageName, versionRange] of Object.entries(packages)) {
+        if (typeof versionRange === "string") {
+            result[packageName] = versionRange;
+        }
+    }
+    return result;
+}
+function inferModuleLayer(packageName) {
+    const normalizedPackageName = packageName.startsWith("@soddong/")
+        ? packageName.slice("@soddong/".length)
+        : packageName;
+    if (normalizedPackageName === "agentic-runtime") {
+        return "runtime";
+    }
+    if (normalizedPackageName.startsWith("agentic-domain-")) {
+        return "domain";
+    }
+    if (normalizedPackageName.startsWith("agentic-capability-")) {
+        return "capability";
+    }
+    if (normalizedPackageName.startsWith("agentic-contract-")) {
+        return "support";
+    }
+    return "support";
+}
+function installedPackageVersion(projectRoot, packageName) {
+    try {
+        const packageJsonPath = join(projectRoot, "node_modules", packageName, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            return undefined;
+        }
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return typeof packageJson.version === "string" ? packageJson.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function satisfiesSimpleRange(version, range) {
+    if (range.startsWith(">=")) {
+        return compareVersion(version, range.slice(2)) >= 0;
+    }
+    if (range.startsWith("^")) {
+        return compareVersion(version, range.slice(1)) >= 0;
+    }
+    if (/^\d+\.\d+\.\d+/.test(range)) {
+        return compareVersion(version, range) === 0;
+    }
+    return undefined;
+}
+function sanitizePackageJsonName(name) {
+    const sanitized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized.length > 0 ? sanitized : "agentic-execution-project";
+}
+function ensureNpmProjectPackageJson(projectRoot) {
+    const packageJsonPath = join(projectRoot, "package.json");
+    if (existsSync(packageJsonPath)) {
+        return "exists";
+    }
+    writeFileSync(packageJsonPath, JSON.stringify({
+        name: sanitizePackageJsonName(basename(projectRoot)),
+        version: "0.0.0",
+        private: true,
+        type: "module"
+    }, null, 2) + "\n", "utf8");
+    return "created";
+}
+function packageInstallSpec(packageName, versionRange) {
+    const range = versionRange?.trim();
+    return range === undefined || range.length === 0 ? packageName : `${packageName}@${range}`;
+}
+function installNpmPackage(packageName, packageSpec, projectRoot) {
+    const result = spawnSync("npm", ["install", packageSpec], {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.status !== 0) {
+        return {
+            packageName,
+            packageSpec,
+            action: "failed",
+            exitCode: result.status,
+            stderr: result.stderr
+        };
+    }
+    return {
+        packageName,
+        packageSpec,
+        action: "installed",
+        installedVersion: installedPackageVersion(projectRoot, packageName),
+        exitCode: result.status
+    };
+}
+function installBundleProviderPackage(packageName, projectRoot) {
+    const installedVersion = installedPackageVersion(projectRoot, packageName);
+    if (installedVersion !== undefined) {
+        return {
+            packageName,
+            packageSpec: packageName,
+            action: "already_installed",
+            installedVersion
+        };
+    }
+    return installNpmPackage(packageName, packageName, projectRoot);
+}
+function installRequiredPackages(requiredPackages, projectRoot) {
+    return Object.entries(requiredPackages).map(([packageName, requiredVersion]) => {
+        const installedVersion = installedPackageVersion(projectRoot, packageName);
+        if (installedVersion !== undefined && satisfiesSimpleRange(installedVersion, requiredVersion) !== false) {
+            return {
+                packageName,
+                packageSpec: packageInstallSpec(packageName, requiredVersion),
+                action: "already_installed",
+                installedVersion
+            };
+        }
+        return installNpmPackage(packageName, packageInstallSpec(packageName, requiredVersion), projectRoot);
+    });
+}
+function registerInstalledRequiredPackages(requiredPackages, projectRoot = process.cwd()) {
+    return Object.entries(requiredPackages).map(([packageName, requiredVersion]) => {
+        const installedVersion = installedPackageVersion(projectRoot, packageName);
+        if (installedVersion === undefined) {
+            return {
+                packageName,
+                requiredVersion,
+                registered: false
+            };
+        }
+        const layer = inferModuleLayer(packageName);
+        registerProjectModule({
+            packageName,
+            packageVersion: installedVersion,
+            moduleLayer: layer,
+            manifest: {
+                packageName,
+                packageVersion: installedVersion,
+                requiredVersion,
+                autoRegisteredBy: "agentic bundle apply"
+            }
+        }, projectRoot);
+        return {
+            packageName,
+            requiredVersion,
+            installedVersion,
+            registered: true,
+            layer,
+            versionSatisfied: satisfiesSimpleRange(installedVersion, requiredVersion)
+        };
+    });
+}
+function printBundle(bundle) {
+    console.log(`- ${bundle.bundleCode}@${bundle.bundleVersion}`);
+    console.log(`  package    : ${bundle.packageName}@${bundle.packageVersion}`);
+    console.log(`  methodology: ${bundle.methodologyCode ?? "-"}`);
+    console.log(`  display    : ${bundle.displayName ?? "-"}`);
+    console.log(`  enabled    : ${bundle.enabled ? "yes" : "no"}`);
+    console.log(`  validation : ${isValidationValid(bundle.validationResult) ? "passed" : "failed"}`);
+    console.log(`  issues     : ${validationIssueCount(bundle.validationResult)}`);
+}
+function printBundleList(args = []) {
+    const format = readOptionValues(args, "--format")[0] ?? "text";
+    const bundles = listProjectBundles();
+    if (format === "json") {
+        console.log(JSON.stringify(bundles, null, 2));
+        return;
+    }
+    console.log("Agentic project bundles");
+    console.log("");
+    if (bundles.length === 0) {
+        console.log("No bundles installed.");
+        return;
+    }
+    for (const bundle of bundles) {
+        printBundle(bundle);
+    }
+}
+function printSeedImportPlan(plan) {
+    console.log(`- #${plan.run.seedImportRunId} ${plan.run.bundleCode}@${plan.run.bundleVersion}`);
+    console.log(`  package   : ${plan.run.packageName}@${plan.run.packageVersion}`);
+    console.log(`  mode      : ${plan.run.importMode}`);
+    console.log(`  status    : ${plan.run.importStatus}`);
+    console.log(`  items     : ${plan.run.summary.totalItems}`);
+    console.log(`  planned   : ${plan.run.summary.plannedItems}`);
+    console.log(`  blocked   : ${plan.run.summary.blockedItems}`);
+    console.log(`  warnings  : ${plan.run.summary.warningItems}`);
+    console.log(`  skipped   : ${plan.run.summary.skippedItems}`);
+    console.log(`  applied   : ${plan.run.summary.appliedItems}`);
+    console.log(`  failed    : ${plan.run.summary.failedItems}`);
+    for (const item of plan.items) {
+        const reason = item.reasonMessage === undefined ? "" : ` (${item.reasonMessage})`;
+        console.log(`  - ${item.sourceSection} -> ${item.targetPackage}: ${item.itemStatus}${reason}`);
+    }
+}
+async function importSeed(args) {
+    const bundleCode = readOptionValues(args, "--bundle")[0];
+    const packageName = readOptionValues(args, "--package")[0];
+    const format = readOptionValues(args, "--format")[0] ?? "text";
+    if (bundleCode === undefined) {
+        console.error("Usage: agentic seed import --bundle <bundle-code> [--package <package-name>] [--format text|json]");
+        return 1;
+    }
+    try {
+        const plan = await createSeedImportPlan({
+            bundleCode,
+            packageName
+        });
+        if (format === "json") {
+            console.log(JSON.stringify(plan, null, 2));
+            return plan.run.importStatus === "applied" ? 0 : 1;
+        }
+        console.log("Agentic seed import plan created");
+        console.log("");
+        printSeedImportPlan(plan);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic seed import failed: ${message}`);
+        return 1;
+    }
+}
+async function applySeed(args) {
+    const runIdValue = readOptionValues(args, "--run")[0];
+    const bundleCode = readOptionValues(args, "--bundle")[0];
+    const packageName = readOptionValues(args, "--package")[0];
+    const format = readOptionValues(args, "--format")[0] ?? "text";
+    if (runIdValue === undefined && bundleCode === undefined) {
+        console.error("Usage: agentic seed apply --run <seed-import-run-id> [--format text|json]");
+        console.error("   or: agentic seed apply --bundle <bundle-code> [--package <package-name>] [--format text|json]");
+        return 1;
+    }
+    let seedImportRunId;
+    if (runIdValue !== undefined) {
+        seedImportRunId = Number.parseInt(runIdValue, 10);
+        if (!Number.isInteger(seedImportRunId) || seedImportRunId < 1) {
+            console.error(`Invalid seed import run id: ${runIdValue}`);
+            return 1;
+        }
+    }
+    try {
+        const plan = await applySeedImportPlan({
+            seedImportRunId,
+            bundleCode,
+            packageName
+        });
+        if (format === "json") {
+            console.log(JSON.stringify(plan, null, 2));
+            return 0;
+        }
+        console.log("Agentic seed apply completed");
+        console.log("");
+        printSeedImportPlan(plan);
+        return plan.run.importStatus === "applied" ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic seed apply failed: ${message}`);
+        return 1;
+    }
+}
+function printSeedImportStatus(args = []) {
+    const format = readOptionValues(args, "--format")[0] ?? "text";
+    const plans = listSeedImportPlans();
+    if (format === "json") {
+        console.log(JSON.stringify(plans, null, 2));
+        return;
+    }
+    console.log("Agentic seed import status");
+    console.log("");
+    if (plans.length === 0) {
+        console.log("No seed import plans found.");
+        return;
+    }
+    for (const plan of plans) {
+        printSeedImportPlan(plan);
+    }
+}
+async function installBundle(args) {
+    const packageName = args[0]?.startsWith("-") === false ? args[0] : undefined;
+    const bundleCode = readOptionValues(args, "--bundle")[0];
+    if (packageName === undefined) {
+        console.error("Usage: agentic bundle install <package-name> [--bundle <bundle-code>]");
+        return 1;
+    }
+    try {
+        const result = await installProjectBundle({
+            packageName,
+            bundleCode
+        });
+        console.log("Agentic bundle installed");
+        console.log("");
+        console.log(`Package          : ${result.packageName}@${result.packageVersion}`);
+        console.log(`Package root     : ${result.packageRoot}`);
+        console.log(`Bundle           : ${result.bundle.bundleCode}@${result.bundle.bundleVersion}`);
+        console.log(`Methodology      : ${result.bundle.methodologyCode ?? "-"}`);
+        console.log(`Display name     : ${result.bundle.displayName ?? "-"}`);
+        console.log(`Validation       : ${isValidationValid(result.validation) ? "passed" : "failed"}`);
+        console.log(`Validation issues: ${validationIssueCount(result.validation)}`);
+        console.log(`Stages           : ${result.summary.stageCount}`);
+        console.log(`Activities       : ${result.summary.activityCount}`);
+        console.log(`Artifact reqs    : ${result.summary.artifactRequirementCount}`);
+        console.log(`Generated outputs: ${result.summary.generatedOutputLinkCount}`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic bundle install failed: ${message}`);
+        return 1;
+    }
+}
+async function applyBundle(args) {
+    const packageName = args[0]?.startsWith("-") === false ? args[0] : undefined;
+    const bundleCode = readOptionValues(args, "--bundle")[0];
+    const format = readOptionValues(args, "--format")[0] ?? "text";
+    const strictRequired = hasArg(args, "--strict-required");
+    const installRequired = hasArg(args, "--install-required");
+    if (packageName === undefined) {
+        console.error("Usage: agentic bundle apply <package-name> [--bundle <bundle-code>] [--format text|json] [--strict-required] [--install-required]");
+        return 1;
+    }
+    try {
+        const projectRoot = process.cwd();
+        const installResults = [];
+        if (installRequired) {
+            ensureNpmProjectPackageJson(projectRoot);
+            const providerInstallResult = installBundleProviderPackage(packageName, projectRoot);
+            installResults.push(providerInstallResult);
+            if (providerInstallResult.action === "failed") {
+                const result = {
+                    status: "failed",
+                    installResults
+                };
+                if (format === "json") {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    console.error(`agentic bundle apply failed: npm install ${providerInstallResult.packageSpec}`);
+                    if (providerInstallResult.stderr !== undefined && providerInstallResult.stderr.trim().length > 0) {
+                        console.error(providerInstallResult.stderr.trim());
+                    }
+                }
+                return 1;
+            }
+        }
+        ensureProjectRuntimeReady();
+        const installedBundle = await installProjectBundle({
+            packageName,
+            bundleCode
+        });
+        const requiredPackages = readRequiredPackagesFromManifest(installedBundle.bundle.bundleManifest);
+        if (installRequired) {
+            const requiredInstallResults = installRequiredPackages(requiredPackages, projectRoot);
+            installResults.push(...requiredInstallResults);
+            const failedInstall = requiredInstallResults.find((item) => item.action === "failed");
+            if (failedInstall !== undefined) {
+                const result = {
+                    status: "failed",
+                    bundle: installedBundle,
+                    installResults
+                };
+                if (format === "json") {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    console.error(`agentic bundle apply failed: npm install ${failedInstall.packageSpec}`);
+                    if (failedInstall.stderr !== undefined && failedInstall.stderr.trim().length > 0) {
+                        console.error(failedInstall.stderr.trim());
+                    }
+                }
+                return 1;
+            }
+        }
+        const registrations = registerInstalledRequiredPackages(requiredPackages);
+        const missingRequiredPackages = registrations.filter((item) => !item.registered);
+        const unsatisfiedRequiredPackages = registrations.filter((item) => item.versionSatisfied === false);
+        if (strictRequired && (missingRequiredPackages.length > 0 || unsatisfiedRequiredPackages.length > 0)) {
+            const result = {
+                status: "blocked",
+                bundle: installedBundle,
+                requiredPackages: registrations,
+                missingRequiredPackages,
+                unsatisfiedRequiredPackages
+            };
+            if (format === "json") {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log("Agentic bundle apply blocked");
+                console.log("");
+                console.log(`Bundle: ${installedBundle.bundle.bundleCode}@${installedBundle.bundle.bundleVersion}`);
+                printNpmInstallSummary(installResults);
+                console.log("");
+                printRequiredPackageRegistrationSummary(registrations);
+            }
+            return 1;
+        }
+        await createSeedImportPlan({
+            bundleCode: installedBundle.bundle.bundleCode,
+            packageName: installedBundle.packageName
+        });
+        const appliedPlan = await applySeedImportPlan({
+            bundleCode: installedBundle.bundle.bundleCode,
+            packageName: installedBundle.packageName
+        });
+        const result = {
+            status: appliedPlan.run.importStatus,
+            bundle: installedBundle,
+            installResults,
+            requiredPackages: registrations,
+            missingRequiredPackages,
+            unsatisfiedRequiredPackages,
+            seedApply: appliedPlan
+        };
+        if (format === "json") {
+            console.log(JSON.stringify(result, null, 2));
+            return appliedPlan.run.importStatus === "applied" ? 0 : 1;
+        }
+        console.log("Agentic bundle apply completed");
+        console.log("");
+        console.log(`Package: ${installedBundle.packageName}@${installedBundle.packageVersion}`);
+        console.log(`Bundle : ${installedBundle.bundle.bundleCode}@${installedBundle.bundle.bundleVersion}`);
+        console.log("");
+        printNpmInstallSummary(installResults);
+        console.log("");
+        printRequiredPackageRegistrationSummary(registrations);
+        console.log("");
+        printSeedImportPlan(appliedPlan);
+        return appliedPlan.run.importStatus === "applied" ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic bundle apply failed: ${message}`);
+        return 1;
+    }
+}
+function printNpmInstallSummary(installResults) {
+    if (installResults.length === 0) {
+        console.log("NPM packages: install not requested");
+        return;
+    }
+    console.log("NPM packages:");
+    for (const result of installResults) {
+        const version = result.installedVersion === undefined ? "" : ` (installed: ${result.installedVersion})`;
+        console.log(`  - ${result.packageSpec}: ${result.action}${version}`);
+    }
+}
+function printRequiredPackageRegistrationSummary(registrations) {
+    if (registrations.length === 0) {
+        console.log("Required packages: none declared");
+        return;
+    }
+    console.log("Required packages:");
+    for (const registration of registrations) {
+        const status = registration.registered
+            ? registration.versionSatisfied === false
+                ? "registered, version warning"
+                : "registered"
+            : "missing";
+        const installed = registration.installedVersion === undefined ? "-" : registration.installedVersion;
+        console.log(`  - ${registration.packageName}@${registration.requiredVersion}: ${status} (installed: ${installed}, layer: ${registration.layer ?? "-"})`);
+    }
+}
+function printExecutionProjectStatus(status) {
+    console.log("Agentic execution project status");
+    console.log("");
+    console.log(`Project: ${status.project.projectCode}`);
+    console.log(`Name   : ${status.project.projectName}`);
+    console.log(`Bundle : ${status.project.bundleCode}@${status.project.bundleVersion}`);
+    console.log(`Status : ${status.project.projectStatusCode}`);
+    console.log("");
+    console.log("Stages:");
+    for (const stage of status.stages) {
+        console.log(`- ${stage.stage.stageName}: ${stage.stage.stageStatusCode} (${stage.completedActivityCount}/${stage.activityCount} activities completed)`);
+    }
+    console.log("");
+    console.log("Artifacts:");
+    console.log(`- expected outputs: ${status.expectedOutputArtifactCount}`);
+    console.log(`- created artifact instances: ${status.createdArtifactInstanceCount}`);
+}
+async function createExecutionProjectCommand(args) {
+    const projectCode = readOptionValues(args, "--code")[0];
+    const projectName = readOptionValues(args, "--name")[0];
+    const bundleCode = readOptionValues(args, "--bundle")[0];
+    const packageName = readOptionValues(args, "--package")[0];
+    const format = readFormat(args);
+    if (projectCode === undefined || projectName === undefined || bundleCode === undefined) {
+        console.error("Usage: agentic project create --bundle <bundle-code> --code <project-code> --name <project-name> [--package <package-name>] [--format text|json]");
+        return 1;
+    }
+    try {
+        ensureProjectRuntimeReady();
+        const status = await createExecutionProjectFromBundle({
+            projectCode,
+            projectName,
+            bundleCode,
+            packageName
+        });
+        if (format === "json") {
+            console.log(JSON.stringify(status, null, 2));
+        }
+        else {
+            console.log("Agentic execution project created");
+            console.log("");
+            printExecutionProjectStatus(status);
+        }
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic project create failed: ${message}`);
+        return 1;
+    }
+}
+function printExecutionProjectStatusCommand(args) {
+    const projectCode = readOptionValues(args, "--code")[0];
+    const format = readFormat(args);
+    if (projectCode === undefined) {
+        console.error("Usage: agentic project status --code <project-code> [--format text|json]");
+        return 1;
+    }
+    try {
+        const status = getExecutionProjectStatus({
+            projectCode
+        });
+        if (format === "json") {
+            console.log(JSON.stringify(status, null, 2));
+        }
+        else {
+            printExecutionProjectStatus(status);
+        }
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic project status failed: ${message}`);
+        return 1;
+    }
+}
+function resolveInstalledPackageRoots(projectRoot = process.cwd()) {
+    const projectRequire = createRequire(join(projectRoot, "package.json"));
+    const packageRoots = {};
+    for (const module of listProjectModules(projectRoot)) {
+        if (!module.enabled) {
+            continue;
+        }
+        try {
+            packageRoots[module.packageName] = dirname(projectRequire.resolve(`${module.packageName}/package.json`));
+        }
+        catch {
+            // Missing package roots are handled by the context command error path.
+        }
+    }
+    return packageRoots;
+}
+function candidateContributionExports(packageExports) {
+    return [
+        packageExports.agentContribution,
+        packageExports.documentAgentContribution
+    ];
+}
+async function registerAgentPackage(args) {
+    const [packageName] = args;
+    if (packageName === undefined || packageName.trim().length === 0) {
+        console.error("Usage: agentic agent register <package-name>");
+        return 1;
+    }
+    try {
+        const projectRequire = createRequire(join(process.cwd(), "package.json"));
+        const packageMainPath = projectRequire.resolve(packageName);
+        const packageExports = await import(pathToFileURL(packageMainPath).href);
+        const contribution = candidateContributionExports(packageExports).find(isAgentContribution);
+        if (contribution === undefined) {
+            console.error(`No agent contribution export found in package: ${packageName}`);
+            console.error("Expected export: agentContribution");
+            return 1;
+        }
+        const module = registerAgentContribution(contribution, process.cwd());
+        console.log("Agent contribution registered");
+        console.log("");
+        console.log(`Agent  : ${contribution.manifest.agentId}`);
+        console.log(`Package: ${module.packageName}`);
+        console.log(`Version: ${module.packageVersion}`);
+        console.log(`Layer  : ${module.moduleLayer ?? "-"}`);
+        console.log(`Enabled: ${module.enabled ? "yes" : "no"}`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic agent register failed: ${message}`);
+        return 1;
+    }
+}
+function runAgentContextCommand(args) {
+    const format = readFormat(args);
+    const requestText = args
+        .filter((arg, index) => {
+        if (arg === "--format") {
+            return false;
+        }
+        return args[index - 1] !== "--format";
+    })
+        .join(" ")
+        .trim();
+    if (requestText.length === 0) {
+        console.error('Usage: agentic agent context "<user request>" [--format text|json]');
+        return 1;
+    }
+    try {
+        const context = assembleRegisteredAgentContext({
+            requestText
+        }, {
+            projectRoot: process.cwd(),
+            packageRoots: resolveInstalledPackageRoots()
+        });
+        if (format === "json") {
+            console.log(JSON.stringify(context ?? null, null, 2));
+        }
+        else if (context === undefined) {
+            console.log("No registered agent context matched the request.");
+        }
+        else {
+            console.log(context.contentText);
+        }
+        return context === undefined ? 1 : 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic agent context failed: ${message}`);
+        return 1;
+    }
+}
+function hasArg(args, name) {
+    return args.includes(name);
+}
+function readOptionValues(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === name) {
+            const value = args[index + 1];
+            if (value !== undefined) {
+                values.push(value);
+            }
+        }
+    }
+    return values;
+}
+const EXECUTION_RANGES = new Set([
+    "1h",
+    "6h",
+    "24h",
+    "7d",
+    "30d",
+    "today",
+    "yesterday",
+    "this-week",
+    "last-week",
+    "this-month",
+    "last-month"
+]);
+const EXECUTION_STATUSES = new Set(["pending", "running", "succeeded", "failed", "cancelled"]);
+function parsePositiveInteger(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`Invalid positive integer: ${value}`);
+    }
+    return parsed;
+}
+function parseExecutionQuery(args, defaults = {}) {
+    const rangeValue = readOptionValues(args, "--range")[0];
+    const statusValue = readOptionValues(args, "--status")[0];
+    const limitValue = readOptionValues(args, "--limit")[0];
+    if (rangeValue !== undefined && !EXECUTION_RANGES.has(rangeValue)) {
+        throw new Error(`Invalid execution range: ${rangeValue}`);
+    }
+    if (statusValue !== undefined && !EXECUTION_STATUSES.has(statusValue)) {
+        throw new Error(`Invalid execution status: ${statusValue}`);
+    }
+    return {
+        ...defaults,
+        range: rangeValue === undefined ? defaults.range : rangeValue,
+        from: readOptionValues(args, "--from")[0] ?? defaults.from,
+        to: readOptionValues(args, "--to")[0] ?? defaults.to,
+        source: readOptionValues(args, "--source")[0] ?? defaults.source,
+        status: statusValue === undefined ? defaults.status : statusValue,
+        limit: parsePositiveInteger(limitValue) ?? defaults.limit
+    };
+}
+function readFormat(args) {
+    const format = readOptionValues(args, "--format")[0] ?? "text";
+    if (format !== "text" && format !== "json") {
+        throw new Error(`Invalid format: ${format}`);
+    }
+    return format;
+}
+function truncate(value, maxLength) {
+    if (value === undefined || value.length === 0) {
+        return "-";
+    }
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength - 3)}...`;
+}
+function printExecutionRecord(record, index) {
+    if (index !== undefined) {
+        console.log(`[${index}]`);
+    }
+    console.log(`Run ID  : ${record.runId}`);
+    console.log(`Status  : ${record.runStatus}`);
+    console.log(`Source  : ${record.source ?? "-"}`);
+    console.log(`Command : ${record.commandName ?? "-"}`);
+    console.log(`Created : ${record.createdAt}`);
+    console.log(`Started : ${record.startedAt ?? "-"}`);
+    console.log(`Ended   : ${record.endedAt ?? "-"}`);
+    console.log(`Request : ${truncate(record.requestText, 240)}`);
+    console.log(`Output  : ${truncate(record.latestOutputText ?? record.latestOutputJson, 240)}`);
+}
+function printExecutionList(records) {
+    console.log("Agentic execution history");
+    console.log("");
+    if (records.length === 0) {
+        console.log("No execution records found.");
+        return;
+    }
+    records.forEach((record, index) => {
+        if (index > 0) {
+            console.log("");
+        }
+        printExecutionRecord(record, index + 1);
+    });
+}
+function printExecutionSummary(summary) {
+    console.log("Agentic execution summary");
+    console.log("");
+    console.log(`Total    : ${summary.total}`);
+    console.log(`Pending  : ${summary.pending}`);
+    console.log(`Running  : ${summary.running}`);
+    console.log(`Succeeded: ${summary.succeeded}`);
+    console.log(`Failed   : ${summary.failed}`);
+    console.log(`Cancelled: ${summary.cancelled}`);
+}
+function printExecutionDetail(detail) {
+    console.log("Agentic execution detail");
+    console.log("");
+    printExecutionRecord(detail.record);
+    console.log("");
+    console.log("Logs:");
+    if (detail.logs.length === 0) {
+        console.log("  - none");
+    }
+    else {
+        for (const log of detail.logs) {
+            console.log(`  - #${log.sequenceNo} ${log.createdAt} ${log.logLevel}/${log.logType}: ${log.message}`);
+        }
+    }
+    console.log("");
+    console.log("Outputs:");
+    if (detail.outputs.length === 0) {
+        console.log("  - none");
+        return;
+    }
+    for (const output of detail.outputs) {
+        console.log(`  - #${output.outputId} ${output.createdAt} ${output.outputType}: ${truncate(output.contentText ?? output.contentJson ?? output.filePath, 360)}`);
+    }
+}
+function runExecutionQueryCommand(args) {
+    const [subcommand, ...queryArgs] = args;
+    try {
+        if (subcommand === "list") {
+            const format = readFormat(queryArgs);
+            const records = listExecutions(parseExecutionQuery(queryArgs, { range: "24h", limit: 20 }));
+            if (format === "json") {
+                console.log(JSON.stringify(records, null, 2));
+            }
+            else {
+                printExecutionList(records);
+            }
+            return 0;
+        }
+        if (subcommand === "latest") {
+            const format = readFormat(queryArgs);
+            const record = getLatestExecution(parseExecutionQuery(queryArgs, { range: "24h" }));
+            if (format === "json") {
+                console.log(JSON.stringify(record ?? null, null, 2));
+            }
+            else if (record === undefined) {
+                console.log("No execution records found.");
+            }
+            else {
+                printExecutionRecord(record);
+            }
+            return 0;
+        }
+        if (subcommand === "summary") {
+            const format = readFormat(queryArgs);
+            const summary = summarizeExecutions(parseExecutionQuery(queryArgs, { range: "today", limit: 200 }));
+            if (format === "json") {
+                console.log(JSON.stringify(summary, null, 2));
+            }
+            else {
+                printExecutionSummary(summary);
+            }
+            return 0;
+        }
+        if (subcommand === "show") {
+            const [runId, ...showArgs] = queryArgs;
+            if (runId === undefined) {
+                console.error("Usage: agentic execution show <run-id> [--format text|json]");
+                return 1;
+            }
+            const format = readFormat(showArgs);
+            const detail = getExecutionDetail(runId);
+            if (format === "json") {
+                console.log(JSON.stringify(detail ?? null, null, 2));
+            }
+            else if (detail === undefined) {
+                console.log(`Execution not found: ${runId}`);
+            }
+            else {
+                printExecutionDetail(detail);
+            }
+            return detail === undefined ? 1 : 0;
+        }
+        console.error("Unknown command: execution" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Usage: agentic execution list|latest|show|summary");
+        return 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic execution failed: ${message}`);
+        return 1;
+    }
+}
+function printCodexAdapterInstallResult(result) {
+    console.log("Codex adapter prepared");
+    console.log("");
+    console.log(`Plugin root : ${result.pluginRoot}`);
+    console.log(`Marketplace : ${result.marketplacePath}`);
+    console.log(`Files       : ${result.filesWritten.length}`);
+    console.log("Bridge      : agentic-runtime-codex@agentic-runtime");
+    console.log(`Marketplace registered: ${result.marketplaceRegistered ? "yes" : "no"}`);
+    console.log(`Plugin installed      : ${result.pluginInstalled ? "yes" : "no"}`);
+    if (result.messages.length > 0) {
+        console.log("");
+        console.log("Notes:");
+        for (const message of result.messages) {
+            console.log(`  - ${message}`);
+        }
+    }
+    console.log("");
+    console.log("After Codex loads the plugin, review and trust the hook if Codex asks for approval.");
+}
+function printKiroAdapterInstallResult(result) {
+    console.log("Kiro adapter prepared");
+    console.log("");
+    console.log(`Adapter root   : ${result.adapterRoot}`);
+    console.log(`Steering file  : ${result.steeringPath}`);
+    console.log(`V3 hook file   : ${result.v3HookPath}`);
+    console.log(`V2 agent config: ${result.v2AgentConfigPath}`);
+    console.log(`IDE prompt hook: ${result.idePromptHookPath}`);
+    console.log(`IDE stop hook  : ${result.ideStopHookPath}`);
+    console.log(`Files          : ${result.filesWritten.length}`);
+    console.log(`Kiro CLI       : ${result.kiroCliAvailable ? "found" : "missing"}`);
+    console.log(`V3 hooks       : ${result.v3HooksConfigured ? "configured" : "missing"}`);
+    console.log(`V2 hooks       : ${result.v2HooksConfigured ? "configured" : "missing"}`);
+    console.log(`IDE hook files : ${result.ideHookFilesPrepared ? "prepared" : "missing"}`);
+    console.log(`Set default    : ${result.setDefaultRequested ? (result.defaultAgentConfigured ? "succeeded" : "failed") : "not requested"}`);
+    if (result.messages.length > 0) {
+        console.log("");
+        console.log("Notes:");
+        for (const message of result.messages) {
+            console.log(`  - ${message}`);
+        }
+    }
+}
+function printClaudeCodeAdapterInstallResult(result) {
+    console.log("Claude Code adapter prepared");
+    console.log("");
+    console.log(`Settings file: ${result.settingsPath}`);
+    console.log(`Rule file    : ${result.rulePath}`);
+    console.log(`Files        : ${result.filesWritten.length}`);
+    console.log(`Claude CLI   : ${result.claudeCliAvailable ? "found" : "missing"}`);
+    console.log(`Hooks        : ${result.hooksConfigured ? "configured" : "not configured"}`);
+    if (result.messages.length > 0) {
+        console.log("");
+        console.log("Notes:");
+        for (const message of result.messages) {
+            console.log(`  - ${message}`);
+        }
+    }
+}
+function installAdapter(args) {
+    const [adapterName] = args;
+    if (adapterName !== "codex" && adapterName !== "kiro" && adapterName !== "claude-code") {
+        console.error("Usage: agentic adapter install codex [--prepare-only] [--force]");
+        console.error("   or: agentic adapter install kiro [--force] [--set-default]");
+        console.error("   or: agentic adapter install claude-code [--force]");
+        return 1;
+    }
+    ensureProjectRuntimeReady();
+    if (adapterName === "kiro") {
+        const result = installKiroAdapter(process.cwd(), {
+            force: hasArg(args, "--force"),
+            setDefault: hasArg(args, "--set-default")
+        });
+        printKiroAdapterInstallResult(result);
+        return 0;
+    }
+    if (adapterName === "claude-code") {
+        const result = installClaudeCodeAdapter(process.cwd(), {
+            force: hasArg(args, "--force")
+        });
+        printClaudeCodeAdapterInstallResult(result);
+        return 0;
+    }
+    const result = installCodexAdapter(process.cwd(), {
+        prepareOnly: hasArg(args, "--prepare-only"),
+        force: hasArg(args, "--force")
+    });
+    printCodexAdapterInstallResult(result);
+    return 0;
+}
+function printAdapterStatus(args) {
+    const [adapterName] = args;
+    if (adapterName !== "codex" && adapterName !== "kiro" && adapterName !== "claude-code") {
+        console.error("Usage: agentic adapter status codex|kiro|claude-code");
+        return 1;
+    }
+    if (adapterName === "kiro") {
+        const status = getKiroAdapterStatus();
+        console.log("Kiro adapter status");
+        console.log("");
+        console.log(`Adapter files         : ${status.adapterRootExists ? "found" : "missing"}`);
+        console.log(`Steering file         : ${status.steeringExists ? "found" : "missing"}`);
+        console.log(`Kiro CLI              : ${status.kiroCliAvailable ? "found" : "missing"}`);
+        console.log(`V3 hook file          : ${status.v3HookExists ? "found" : "missing"}`);
+        console.log(`V3 UserPromptSubmit   : ${status.v3PromptHookConfigured ? "configured" : "missing"}`);
+        console.log(`V3 Stop               : ${status.v3StopHookConfigured ? "configured" : "missing"}`);
+        console.log(`V2 agent config       : ${status.v2AgentConfigExists ? "found" : "missing"}`);
+        console.log(`V2 agent name         : ${status.v2AgentName}`);
+        console.log(`V2 userPromptSubmit   : ${status.v2PromptHookConfigured ? "configured" : "missing"}`);
+        console.log(`V2 stop               : ${status.v2StopHookConfigured ? "configured" : "missing"}`);
+        console.log(`IDE Prompt Submit file: ${status.idePromptHookExists ? "found" : "missing"}`);
+        console.log(`IDE Agent Stop file   : ${status.ideStopHookExists ? "found" : "missing"}`);
+        if (status.notes.length > 0) {
+            console.log("");
+            console.log("Notes:");
+            for (const note of status.notes) {
+                console.log(`  - ${note}`);
+            }
+        }
+        return 0;
+    }
+    if (adapterName === "claude-code") {
+        const status = getClaudeCodeAdapterStatus();
+        console.log("Claude Code adapter status");
+        console.log("");
+        console.log(`Settings file       : ${status.settingsExists ? "found" : "missing"}`);
+        console.log(`Runtime rule        : ${status.ruleExists ? "found" : "missing"}`);
+        console.log(`Claude CLI          : ${status.claudeCliAvailable ? "found" : "missing"}`);
+        console.log(`UserPromptSubmit hook: ${status.userPromptHookConfigured ? "configured" : "missing"}`);
+        console.log(`Stop hook           : ${status.stopHookConfigured ? "configured" : "missing"}`);
+        if (status.notes.length > 0) {
+            console.log("");
+            console.log("Notes:");
+            for (const note of status.notes) {
+                console.log(`  - ${note}`);
+            }
+        }
+        return 0;
+    }
+    const status = getCodexAdapterStatus();
+    console.log("Codex adapter status");
+    console.log("");
+    console.log(`Plugin files : ${status.pluginRootExists ? "found" : "missing"}`);
+    console.log(`Marketplace  : ${status.marketplaceExists ? "found" : "missing"}`);
+    console.log(`Codex CLI    : ${status.codexCliAvailable ? "found" : "missing"}`);
+    if (status.notes.length > 0) {
+        console.log("");
+        console.log("Notes:");
+        for (const note of status.notes) {
+            console.log(`  - ${note}`);
+        }
+    }
+    return 0;
+}
+async function recordHookEvent(args) {
+    const source = readOptionValues(args, "--source")[0];
+    const event = readOptionValues(args, "--event")[0];
+    if ((source !== "codex" || (event !== "UserPromptSubmit" && event !== "Stop")) &&
+        (source !== "claude-code" || (event !== "UserPromptSubmit" && event !== "Stop")) &&
+        (source !== "kiro" || (event !== "PromptSubmit" && event !== "AgentStop"))) {
+        console.error("Usage: agentic hook record --source codex --event UserPromptSubmit|Stop");
+        console.error("   or: agentic hook record --source claude-code --event UserPromptSubmit|Stop");
+        console.error("   or: agentic hook record --source kiro --event PromptSubmit|AgentStop");
+        return 1;
+    }
+    try {
+        const stdin = await readStdin();
+        const rawPayload = stdin.trim().length > 0 || source !== "kiro" || event !== "PromptSubmit"
+            ? stdin
+            : JSON.stringify({
+                prompt: process.env.USER_PROMPT ?? ""
+            });
+        const result = recordHook({
+            source,
+            event,
+            rawPayload
+        });
+        if (result.action === "skipped" && result.reason !== undefined) {
+            console.error(`agentic hook skipped: ${result.reason}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agentic hook record failed: ${message}`);
+        return 0;
+    }
+}
+function setupProject(args) {
+    const adapters = readOptionValues(args, "--adapter");
+    const prepareOnly = hasArg(args, "--prepare-only");
+    const force = hasArg(args, "--force");
+    const setDefault = hasArg(args, "--set-default");
+    initializeProject();
+    initializeDatabase();
+    if (adapters.length === 0) {
+        return 0;
+    }
+    for (const adapter of adapters) {
+        if (adapter !== "codex" && adapter !== "kiro" && adapter !== "claude-code") {
+            console.error(`Unsupported adapter: ${adapter}`);
+            return 1;
+        }
+        if (adapter === "kiro") {
+            const result = installKiroAdapter(process.cwd(), {
+                force,
+                setDefault
+            });
+            console.log("");
+            printKiroAdapterInstallResult(result);
+            continue;
+        }
+        if (adapter === "claude-code") {
+            const result = installClaudeCodeAdapter(process.cwd(), {
+                force
+            });
+            console.log("");
+            printClaudeCodeAdapterInstallResult(result);
+            continue;
+        }
+        const result = installCodexAdapter(process.cwd(), {
+            prepareOnly,
+            force
+        });
+        console.log("");
+        printCodexAdapterInstallResult(result);
+    }
+    return 0;
+}
+export async function runCli(argv = process.argv.slice(2)) {
+    const [command, ...rest] = argv;
+    if (command === undefined || command === "help" || command === "--help" || command === "-h") {
+        printHelp();
+        return 0;
+    }
+    if (command === "version" || command === "--version" || command === "-v") {
+        printVersion();
+        return 0;
+    }
+    if (command === "docs") {
+        printDocs();
+        return 0;
+    }
+    if (command === "config") {
+        printConfigStatus();
+        return 0;
+    }
+    if (command === "setup") {
+        return setupProject(rest);
+    }
+    if (command === "run") {
+        return runExecution(rest);
+    }
+    if (command === "execution") {
+        return runExecutionQueryCommand(rest);
+    }
+    if (command === "agent") {
+        const [subcommand, ...agentArgs] = rest;
+        if (subcommand === "register") {
+            return registerAgentPackage(agentArgs);
+        }
+        if (subcommand === "context") {
+            return runAgentContextCommand(agentArgs);
+        }
+        console.error("Unknown command: agent" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Usage: agentic agent register <package-name>");
+        console.error("   or: agentic agent context \"<user request>\" [--format text|json]");
+        return 1;
+    }
+    if (command === "hook") {
+        const [subcommand, ...hookArgs] = rest;
+        if (subcommand === "record") {
+            return recordHookEvent(hookArgs);
+        }
+        console.error("Unknown command: hook" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Run 'agentic help' for available commands.");
+        return 1;
+    }
+    if (command === "init") {
+        initializeProject();
+        return 0;
+    }
+    if (command === "db") {
+        const [subcommand] = rest;
+        if (subcommand === "init") {
+            initializeDatabase();
+            return 0;
+        }
+        if (subcommand === "status") {
+            printDatabaseStatus();
+            return 0;
+        }
+        console.error("Unknown command: db" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Run 'agentic help' for available commands.");
+        return 1;
+    }
+    if (command === "module") {
+        const [subcommand, ...moduleArgs] = rest;
+        if (subcommand === "register") {
+            return registerModule(moduleArgs);
+        }
+        if (subcommand === "list") {
+            printModuleList();
+            return 0;
+        }
+        console.error("Unknown command: module" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Run 'agentic help' for available commands.");
+        return 1;
+    }
+    if (command === "bundle") {
+        const [subcommand, ...bundleArgs] = rest;
+        if (subcommand === "install") {
+            return await installBundle(bundleArgs);
+        }
+        if (subcommand === "apply") {
+            return await applyBundle(bundleArgs);
+        }
+        if (subcommand === "list" || subcommand === "status") {
+            printBundleList(bundleArgs);
+            return 0;
+        }
+        console.error("Unknown command: bundle" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Usage: agentic bundle install <package-name> [--bundle <bundle-code>]");
+        console.error("   or: agentic bundle apply <package-name> [--bundle <bundle-code>] [--format text|json] [--strict-required] [--install-required]");
+        console.error("   or: agentic bundle list [--format text|json]");
+        console.error("   or: agentic bundle status [--format text|json]");
+        return 1;
+    }
+    if (command === "seed") {
+        const [subcommand, ...seedArgs] = rest;
+        if (subcommand === "import") {
+            return await importSeed(seedArgs);
+        }
+        if (subcommand === "apply") {
+            return await applySeed(seedArgs);
+        }
+        if (subcommand === "status") {
+            printSeedImportStatus(seedArgs);
+            return 0;
+        }
+        console.error("Unknown command: seed" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Usage: agentic seed import --bundle <bundle-code> [--package <package-name>] [--format text|json]");
+        console.error("   or: agentic seed apply --run <seed-import-run-id> [--format text|json]");
+        console.error("   or: agentic seed apply --bundle <bundle-code> [--package <package-name>] [--format text|json]");
+        console.error("   or: agentic seed status [--format text|json]");
+        return 1;
+    }
+    if (command === "project") {
+        const [subcommand, ...projectArgs] = rest;
+        if (subcommand === "create") {
+            return await createExecutionProjectCommand(projectArgs);
+        }
+        if (subcommand === "status") {
+            return printExecutionProjectStatusCommand(projectArgs);
+        }
+        console.error("Unknown command: project" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Usage: agentic project create --bundle <bundle-code> --code <project-code> --name <project-name> [--package <package-name>] [--format text|json]");
+        console.error("   or: agentic project status --code <project-code> [--format text|json]");
+        return 1;
+    }
+    if (command === "adapter") {
+        const [subcommand, ...adapterArgs] = rest;
+        if (subcommand === "install") {
+            return installAdapter(adapterArgs);
+        }
+        if (subcommand === "status") {
+            return printAdapterStatus(adapterArgs);
+        }
+        console.error("Unknown command: adapter" + (subcommand === undefined ? "" : ` ${subcommand}`));
+        console.error("Run 'agentic help' for available commands.");
+        return 1;
+    }
+    const suffix = rest.length > 0 ? ` ${rest.join(" ")}` : "";
+    console.error(`Unknown command: ${command}${suffix}`);
+    console.error("Run 'agentic help' for available commands.");
+    return 1;
+}
+try {
+    process.exitCode = await runCli();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map