npm - @kage-core/kage-graph-mcp - Versions diffs - 1.0.0 → 1.1.0 - Mend

@kage-core/kage-graph-mcp 1.0.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,726 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const daemon_js_1 = require("./daemon.js");
+const kernel_js_1 = require("./kernel.js");
+function usage() {
+    console.log(`Kage Repo-Recall MVP
+Usage:
+  kage index --project <dir>
+  kage init --project <dir>
+  kage policy --project <dir>
+  kage doctor --project <dir>
+  kage setup list
+  kage setup <agent> --project <dir> [--write] [--json]
+  kage setup doctor --project <dir> [--json]
+  kage daemon start --project <dir> [--port 3111]
+  kage daemon stop --project <dir>
+  kage daemon status --project <dir> [--json]
+  kage daemon doctor --project <dir> [--json]
+  kage viewer --project <dir> [--port 3113]
+  kage branch --project <dir> [--json]
+  kage metrics --project <dir> [--json]
+  kage quality --project <dir> [--json]
+  kage benchmark --project <dir> [--json]
+  kage code-graph --project <dir> [--json]
+  kage code-graph "<query>" --project <dir> [--json]
+  kage graph --project <dir> [--json]
+  kage graph --project <dir> --mermaid
+  kage graph "<query>" --project <dir> [--json]
+  kage recall "<query>" --project <dir> [--json] [--explain]
+  kage observe --project <dir> --event <json>
+  kage distill --project <dir> --session <id>
+  kage learn --project <dir> --learning <text> [--title <title>] [--type <type>] [--evidence <text>] [--verified-by <text>] [--tags a,b] [--paths a,b]
+  kage feedback --project <dir> --packet <packet-id> --kind helpful|wrong|stale
+  kage capture --project <dir> --title <title> --body <body> [--type <type>] [--summary <summary>] [--tags a,b] [--paths a,b] [--stack a,b]
+  kage propose --project <dir> --from-diff
+  kage review-artifact --project <dir>
+  kage promote --project <dir> --public <packet-id>
+  kage export-public --project <dir>
+  kage registry --project <dir> [--json]
+  kage marketplace --project <dir> [--json]
+  kage org status --project <dir> --org <org> [--json]
+  kage org upload --project <dir> --org <org> --packet <approved-packet-id>
+  kage org review --project <dir> --org <org> --packet <org-packet-id> --approve|--reject
+  kage org recall "<query>" --project <dir> --org <org> [--json]
+  kage org export --project <dir> --org <org> [--json]
+  kage layered-recall "<query>" --project <dir> [--org <org>] [--global] [--json]
+  kage global build --project <dir> [--org <org>] [--json]
+  kage review --project <dir>
+  kage validate --project <dir>
+Types:
+  ${kernel_js_1.MEMORY_TYPES.join(", ")}
+`);
+    process.exit(1);
+}
+function takeArg(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function listArg(value) {
+    return value ? value.split(",").map((item) => item.trim()).filter(Boolean) : [];
+}
+function projectArg(args) {
+    return takeArg(args, "--project") ?? process.cwd();
+}
+function numberArg(args, name, fallback) {
+    const value = takeArg(args, name);
+    return value ? Number(value) : fallback;
+}
+function firstPositional(args) {
+    return args.find((arg, index) => index > 0 && !arg.startsWith("--") && !args[index - 1]?.startsWith("--"));
+}
+async function review(projectDir) {
+    const pending = (0, kernel_js_1.loadPendingPackets)(projectDir);
+    if (pending.length === 0) {
+        console.log("No pending packets to review.");
+        return;
+    }
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        for (const packet of pending) {
+            console.log("\n─────────────────────────────────────────");
+            console.log(`Title: ${packet.title}`);
+            console.log(`Type:  ${packet.type}`);
+            console.log(`ID:    ${packet.id}`);
+            console.log(`Tags:  ${packet.tags.join(", ") || "(none)"}`);
+            console.log(`Paths: ${packet.paths.join(", ") || "(none)"}`);
+            console.log("\n" + packet.body);
+            const answer = (await rl.question("\n(a) approve  (r) reject  (s) skip  (q) quit: ")).trim().toLowerCase();
+            if (answer === "q")
+                break;
+            if (answer === "a") {
+                const path = (0, kernel_js_1.approvePending)(projectDir, packet.id);
+                console.log(`Approved: ${path}`);
+            }
+            else if (answer === "r") {
+                const path = (0, kernel_js_1.rejectPending)(projectDir, packet.id);
+                console.log(`Rejected: ${path}`);
+            }
+            else {
+                console.log("Skipped.");
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command)
+        usage();
+    if (command === "index") {
+        const result = (0, kernel_js_1.indexProject)(projectArg(args));
+        console.log(`Indexed ${result.projectDir}`);
+        console.log(`Packets: ${result.packets}`);
+        console.log(`Migrated legacy nodes: ${result.migrated}`);
+        if (result.policyPath)
+            console.log(`Agent policy: ${result.policyPath}`);
+        console.log(`Indexes:\n${result.indexes.map((path) => `  - ${path}`).join("\n")}`);
+        return;
+    }
+    if (command === "init") {
+        const result = (0, kernel_js_1.initProject)(projectArg(args));
+        console.log(`Initialized Kage memory for ${result.index.projectDir}`);
+        console.log(`Packets: ${result.index.packets}`);
+        console.log(`Migrated legacy nodes: ${result.index.migrated}`);
+        if (result.index.policyPath)
+            console.log(`Agent policy: ${result.index.policyPath}`);
+        console.log(result.validation.ok ? "Validation passed." : "Validation failed.");
+        if (result.validation.errors.length)
+            console.log(`Errors:\n${result.validation.errors.map((error) => `  - ${error}`).join("\n")}`);
+        if (result.validation.warnings.length)
+            console.log(`Warnings:\n${result.validation.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        console.log("\nFirst recall preview:\n");
+        console.log(result.sampleRecall.context_block);
+        if (!result.validation.ok)
+            process.exit(2);
+        return;
+    }
+    if (command === "policy") {
+        const result = (0, kernel_js_1.installAgentPolicy)(projectArg(args));
+        console.log(`${result.created ? "Created" : result.updated ? "Updated" : "Already current"} agent policy: ${result.path}`);
+        return;
+    }
+    if (command === "doctor") {
+        const result = (0, kernel_js_1.doctorProject)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Doctor: ${result.projectDir}`);
+        console.log(`Memory root: ${result.memoryRoot}`);
+        console.log(`Git branch: ${result.gitBranch ?? "(not a git repo)"}`);
+        console.log(`Packets: ${result.packets}`);
+        console.log(`Pending: ${result.pending}`);
+        console.log(`Public candidates: ${result.publicCandidates}`);
+        console.log(`Graph entities: ${result.graphEntities}`);
+        console.log(`Graph edges: ${result.graphEdges}`);
+        console.log(`Registry recommendations: ${result.registryRecommendations.length}`);
+        console.log(`Indexes present: ${result.indexesPresent.join(", ") || "(none)"}`);
+        console.log(`Indexes missing: ${result.indexesMissing.join(", ") || "(none)"}`);
+        console.log(result.validation.ok ? "Validation: passed" : "Validation: failed");
+        if (result.validation.errors.length)
+            console.log(`Errors:\n${result.validation.errors.map((error) => `  - ${error}`).join("\n")}`);
+        if (result.validation.warnings.length)
+            console.log(`Warnings:\n${result.validation.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        console.log("\nRecall smoke test:\n");
+        console.log(result.sampleRecall);
+        if (!result.validation.ok)
+            process.exit(2);
+        return;
+    }
+    if (command === "setup") {
+        const action = args[1];
+        if (action === "list") {
+            console.log(kernel_js_1.SETUP_AGENTS.join("\n"));
+            return;
+        }
+        if (action === "doctor") {
+            const result = (0, kernel_js_1.setupDoctor)(projectArg(args));
+            if (args.includes("--json")) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log("Kage setup doctor");
+            for (const item of result) {
+                console.log(`- ${item.agent}: ${item.configured ? "configured" : "not detected"}${item.config_path ? ` (${item.config_path})` : ""}`);
+            }
+            return;
+        }
+        if (!action || !kernel_js_1.SETUP_AGENTS.includes(action))
+            usage();
+        const result = (0, kernel_js_1.setupAgent)(action, projectArg(args), { write: args.includes("--write") });
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage setup for ${result.agent}`);
+        if (result.config_path)
+            console.log(`Config path: ${result.config_path}`);
+        console.log(result.write_supported ? `Write support: ${result.wrote ? "wrote config" : "available with --write"}` : "Write support: print-only");
+        console.log("\nConfig:\n");
+        console.log(result.config);
+        if (result.instructions.length) {
+            console.log("\nInstructions:");
+            for (const instruction of result.instructions)
+                console.log(`- ${instruction}`);
+        }
+        if (result.warnings.length) {
+            console.log("\nWarnings:");
+            for (const warning of result.warnings)
+                console.log(`- ${warning}`);
+        }
+        return;
+    }
+    if (command === "daemon") {
+        const action = args[1];
+        const projectDir = projectArg(args);
+        if (action === "start") {
+            await (0, daemon_js_1.startDaemon)(projectDir, { restPort: numberArg(args, "--port", 3111) });
+            return;
+        }
+        if (action === "stop") {
+            const result = (0, daemon_js_1.stopDaemon)(projectDir);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result, null, 2));
+            else
+                console.log(result.message);
+            if (!result.ok)
+                process.exit(2);
+            return;
+        }
+        if (action === "status") {
+            const result = (0, daemon_js_1.readDaemonStatus)(projectDir);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result ?? { ok: false }, null, 2));
+            else if (result)
+                console.log(`Kage daemon pid ${result.pid} at http://${result.host}:${result.rest_port}`);
+            else
+                console.log("No Kage daemon status found.");
+            return;
+        }
+        if (action === "doctor") {
+            const result = (0, daemon_js_1.daemonDoctor)(projectDir);
+            if (args.includes("--json")) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(`Daemon configured: ${result.configured ? "yes" : "no"}`);
+            console.log(`Daemon running: ${result.running ? "yes" : "no"}`);
+            console.log("Endpoints:");
+            for (const endpoint of result.endpoints)
+                console.log(`- ${endpoint}`);
+            if (result.warnings.length)
+                console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+            return;
+        }
+        usage();
+    }
+    if (command === "viewer") {
+        await (0, daemon_js_1.startViewer)(projectArg(args), { port: numberArg(args, "--port", 3113) });
+        return;
+    }
+    if (command === "graph") {
+        const query = firstPositional(args);
+        if (query) {
+            const result = (0, kernel_js_1.queryGraph)(projectArg(args), query);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result, null, 2));
+            else
+                console.log(result.context_block);
+            return;
+        }
+        if (args.includes("--mermaid")) {
+            const result = (0, kernel_js_1.graphMermaid)(projectArg(args));
+            console.log("```mermaid");
+            console.log(result.mermaid);
+            console.log("```");
+            return;
+        }
+        const graph = (0, kernel_js_1.buildKnowledgeGraph)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(graph, null, 2));
+            return;
+        }
+        console.log(`Kage Graph: ${graph.project_dir}`);
+        console.log(`Entities: ${graph.entities.length}`);
+        console.log(`Edges: ${graph.edges.length}`);
+        console.log(`Episodes: ${graph.episodes.length}`);
+        console.log(`Branch: ${graph.repo_state.branch ?? "(none)"}`);
+        console.log("\nTop facts:");
+        for (const edge of graph.edges.slice(0, 10))
+            console.log(`- ${edge.fact}`);
+        return;
+    }
+    if (command === "code-graph") {
+        const query = firstPositional(args);
+        if (query) {
+            const result = (0, kernel_js_1.queryCodeGraph)(projectArg(args), query);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result, null, 2));
+            else
+                console.log(result.context_block);
+            return;
+        }
+        const graph = (0, kernel_js_1.buildCodeGraph)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(graph, null, 2));
+            return;
+        }
+        console.log(`Kage Code Graph: ${graph.project_dir}`);
+        console.log(`Files: ${graph.files.length}`);
+        console.log(`Symbols: ${graph.symbols.length}`);
+        console.log(`Imports: ${graph.imports.length}`);
+        console.log(`Calls: ${graph.calls.length}`);
+        console.log(`Routes: ${graph.routes.length}`);
+        console.log(`Tests: ${graph.tests.length}`);
+        console.log(`Packages/scripts: ${graph.packages.length}`);
+        console.log(`Branch: ${graph.repo_state.branch ?? "(none)"}`);
+        console.log("\nTop symbols:");
+        for (const symbol of graph.symbols.slice(0, 10))
+            console.log(`- ${symbol.kind} ${symbol.name} (${symbol.path}:${symbol.line})`);
+        return;
+    }
+    if (command === "branch") {
+        const result = (0, kernel_js_1.buildBranchOverlay)(projectArg(args));
+        if (args.includes("--json"))
+            console.log(JSON.stringify(result, null, 2));
+        else {
+            console.log(`Branch: ${result.branch ?? "(detached)"}`);
+            console.log(`Head: ${result.head ?? "(none)"}`);
+            console.log(`Merge base: ${result.merge_base ?? "(none)"}`);
+            console.log(`Changed files: ${result.changed_files.join(", ") || "(none)"}`);
+            console.log(`Pending packets: ${result.pending_packet_ids.length}`);
+        }
+        return;
+    }
+    if (command === "metrics") {
+        const result = (0, kernel_js_1.kageMetrics)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Metrics: ${result.project_dir}`);
+        console.log(`Readiness score: ${result.harness.readiness_score}/100`);
+        console.log(`Validation: ${result.harness.validation_ok ? "passed" : "failed"} (${result.harness.errors} errors, ${result.harness.warnings} warnings)`);
+        console.log(`Policy installed: ${result.harness.policy_installed ? "yes" : "no"}`);
+        console.log("\nCode graph:");
+        console.log(`  Files: ${result.code_graph.files}`);
+        console.log(`  Symbols: ${result.code_graph.symbols}`);
+        console.log(`  Imports: ${result.code_graph.imports}`);
+        console.log(`  Calls: ${result.code_graph.calls}`);
+        console.log(`  Routes: ${result.code_graph.routes}`);
+        console.log(`  Tests: ${result.code_graph.tests}`);
+        console.log(`  Indexer coverage: ${result.code_graph.indexer_coverage_percent}%`);
+        console.log(`  Languages: ${Object.entries(result.code_graph.languages).map(([name, count]) => `${name}=${count}`).join(", ") || "(none)"}`);
+        console.log(`  Parsers: ${Object.entries(result.code_graph.parsers).map(([name, count]) => `${name}=${count}`).join(", ") || "(none)"}`);
+        console.log("\nMemory graph:");
+        console.log(`  Approved packets: ${result.memory_graph.approved_packets}`);
+        console.log(`  Pending packets: ${result.memory_graph.pending_packets}`);
+        console.log(`  Episodes: ${result.memory_graph.episodes}`);
+        console.log(`  Entities: ${result.memory_graph.entities}`);
+        console.log(`  Edges: ${result.memory_graph.edges}`);
+        console.log(`  Evidence coverage: ${result.memory_graph.evidence_coverage_percent}%`);
+        console.log(`  Average quality: ${result.memory_graph.average_quality_score}/100`);
+        console.log(`  Duplicate candidates: ${result.memory_graph.duplicate_candidate_pairs}`);
+        console.log("\nToken savings:");
+        console.log(`  Indexed source tokens: ${result.savings.estimated_indexed_source_tokens}`);
+        console.log(`  Memory tokens: ${result.savings.estimated_memory_tokens}`);
+        console.log(`  Recall context tokens: ${result.savings.estimated_recall_context_tokens}`);
+        console.log(`  Estimated tokens saved per recall: ${result.savings.estimated_tokens_saved_per_recall}`);
+        if (result.quality) {
+            console.log("\nQuality:");
+            console.log(`  Useful memory ratio: ${result.quality.useful_memory_ratio_percent}%`);
+            console.log(`  Duplicate burden: ${result.quality.duplicate_burden}%`);
+            console.log(`  Evidence coverage: ${result.quality.evidence_coverage_percent}%`);
+            console.log(`  Review queue size: ${result.quality.totals.pending}`);
+        }
+        if (result.pain) {
+            console.log("\nPain avoided:");
+            console.log(`  Recall hit rate: ${result.pain.recall_hit_rate_percent}%`);
+            console.log(`  Estimated rediscovery avoided: ${result.pain.estimated_rediscovery_avoided}`);
+            console.log(`  Estimated tokens saved: ${result.pain.estimated_tokens_saved}`);
+            console.log(`  Time to first use: ${result.pain.time_to_first_use_seconds}s`);
+        }
+        return;
+    }
+    if (command === "quality") {
+        const result = (0, kernel_js_1.qualityReport)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Quality: ${result.project_dir}`);
+        console.log(`Useful memory ratio: ${result.useful_memory_ratio_percent}%`);
+        console.log(`Duplicate burden: ${result.duplicate_burden}%`);
+        console.log(`Evidence coverage: ${result.evidence_coverage_percent}%`);
+        console.log(`Path grounding coverage: ${result.path_grounding_coverage_percent}%`);
+        console.log(`Review queue size: ${result.totals.pending}`);
+        console.log(`Approved vs pending ratio: ${result.approved_to_pending_ratio}`);
+        console.log(`Type coverage: ${Object.entries(result.memory_type_coverage).map(([type, count]) => `${type}=${count}`).join(", ") || "(none)"}`);
+        return;
+    }
+    if (command === "benchmark") {
+        const result = (0, kernel_js_1.benchmarkProject)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Benchmark: ${result.project_dir}`);
+        for (const [name, value] of Object.entries(result.pain_metrics))
+            console.log(`${name}: ${value}`);
+        return;
+    }
+    if (command === "learn") {
+        const learning = takeArg(args, "--learning");
+        if (!learning)
+            usage();
+        const result = (0, kernel_js_1.learn)({
+            projectDir: projectArg(args),
+            learning,
+            title: takeArg(args, "--title"),
+            type: takeArg(args, "--type"),
+            evidence: takeArg(args, "--evidence"),
+            verifiedBy: takeArg(args, "--verified-by"),
+            tags: listArg(takeArg(args, "--tags")),
+            paths: listArg(takeArg(args, "--paths")),
+            stack: listArg(takeArg(args, "--stack")),
+        });
+        if (!result.ok) {
+            console.error(`Learning capture blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Captured session learning: ${result.path}`);
+        console.log(`Review with: kage review --project ${projectArg(args)}`);
+        return;
+    }
+    if (command === "propose") {
+        if (!args.includes("--from-diff"))
+            usage();
+        const result = (0, kernel_js_1.proposeFromDiff)(projectArg(args));
+        if (!result.ok) {
+            console.error(`Proposal blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Wrote branch review summary: ${result.path}`);
+        if (result.packetPath)
+            console.log(`Captured pending change memory: ${result.packetPath}`);
+        console.log(`Changed files: ${result.changedFiles.join(", ")}`);
+        console.log(`Review memory: kage review --project ${projectArg(args)}`);
+        console.log(`Review artifact: kage review-artifact --project ${projectArg(args)}`);
+        return;
+    }
+    if (command === "review-artifact") {
+        const result = (0, kernel_js_1.createReviewArtifact)(projectArg(args));
+        console.log(`Wrote review artifact: ${result.path}`);
+        console.log(`Pending packets: ${result.pending}`);
+        return;
+    }
+    if (command === "promote") {
+        const id = takeArg(args, "--public");
+        if (!id)
+            usage();
+        const result = (0, kernel_js_1.createPublicCandidate)(projectArg(args), id);
+        if (!result.ok) {
+            console.error(`Promotion blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Created public review candidate: ${result.path}`);
+        console.log("This file is local only until a human publishes it.");
+        return;
+    }
+    if (command === "export-public") {
+        const result = (0, kernel_js_1.exportPublicBundle)(projectArg(args));
+        if (!result.ok) {
+            console.error(`Public bundle blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Exported public bundle: ${result.path}`);
+        console.log(`Packets: ${result.packetCount}`);
+        return;
+    }
+    if (command === "registry") {
+        const result = (0, kernel_js_1.registryRecommendations)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.length === 0) {
+            console.log("No registry recommendations found for this repo.");
+            return;
+        }
+        for (const item of result) {
+            console.log(`${item.id} [${item.kind}] ${item.title}`);
+            console.log(`  ${item.summary}`);
+            console.log(`  matched: ${item.matched.join(", ") || "(repo metadata)"}`);
+            console.log(`  trust: ${item.trust}; install: ${item.install}`);
+        }
+        return;
+    }
+    if (command === "marketplace") {
+        const result = (0, kernel_js_1.buildMarketplace)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Marketplace manifest: ${result.path}`);
+        console.log(`Packs: ${result.packs.length}`);
+        for (const pack of result.packs) {
+            console.log(`- ${pack.id} [${pack.kind}] ${pack.title} (${pack.install})`);
+        }
+        return;
+    }
+    if (command === "org") {
+        const action = args[1];
+        const org = takeArg(args, "--org") ?? "local";
+        const projectDir = projectArg(args);
+        if (action === "status") {
+            const result = (0, kernel_js_1.orgStatus)(projectDir, org);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result, null, 2));
+            else {
+                console.log(`Org memory: ${result.org}`);
+                console.log(`Path: ${result.path}`);
+                console.log(`Inbox: ${result.inbox}`);
+                console.log(`Approved: ${result.approved}`);
+                console.log(`Rejected: ${result.rejected}`);
+                console.log(`Audit events: ${result.audit_events}`);
+                if (result.registry_path)
+                    console.log(`Registry: ${result.registry_path}`);
+            }
+            return;
+        }
+        if (action === "upload") {
+            const id = takeArg(args, "--packet");
+            if (!id)
+                usage();
+            const result = (0, kernel_js_1.orgUploadPacket)(projectDir, org, id);
+            if (!result.ok) {
+                console.error(`Org upload blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+                process.exit(2);
+            }
+            console.log(`Created org review candidate: ${result.path}`);
+            console.log("Approve explicitly with: kage org review --approve");
+            return;
+        }
+        if (action === "review") {
+            const id = takeArg(args, "--packet");
+            if (!id || (!args.includes("--approve") && !args.includes("--reject")))
+                usage();
+            const result = (0, kernel_js_1.orgReviewPacket)(projectDir, org, id, args.includes("--approve") ? "approve" : "reject");
+            if (!result.ok) {
+                console.error(`Org review failed:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+                process.exit(2);
+            }
+            console.log(`Org review wrote: ${result.path}`);
+            return;
+        }
+        if (action === "recall") {
+            const query = firstPositional(args.slice(1));
+            if (!query)
+                usage();
+            const result = (0, kernel_js_1.orgRecall)(projectDir, org, query);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result, null, 2));
+            else
+                console.log(result.context_block);
+            return;
+        }
+        if (action === "export") {
+            const result = (0, kernel_js_1.exportOrgRegistry)(projectDir, org);
+            if (args.includes("--json"))
+                console.log(JSON.stringify(result, null, 2));
+            else
+                console.log(`Exported org registry: ${result.registry_path}`);
+            return;
+        }
+        usage();
+    }
+    if (command === "layered-recall") {
+        const query = firstPositional(args);
+        if (!query)
+            usage();
+        const result = (0, kernel_js_1.layeredRecall)(projectArg(args), query, {
+            org: takeArg(args, "--org"),
+            includeGlobal: args.includes("--global"),
+        });
+        if (args.includes("--json"))
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.log(result.context_block);
+        return;
+    }
+    if (command === "global") {
+        const action = args[1];
+        if (action !== "build")
+            usage();
+        const result = (0, kernel_js_1.buildGlobalCdnBundle)(projectArg(args), takeArg(args, "--org") ?? "local");
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (!result.ok) {
+            console.error(`Global bundle failed:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Global registry: ${result.manifest_path}`);
+        console.log(`Latest alias: ${result.alias_path}`);
+        console.log(`Marketplace: ${result.marketplace_path}`);
+        console.log(`Public packets: ${result.packet_count}`);
+        console.log(`Marketplace packs: ${result.marketplace_packs}`);
+        return;
+    }
+    if (command === "recall") {
+        const query = firstPositional(args);
+        if (!query)
+            usage();
+        const result = (0, kernel_js_1.recall)(projectArg(args), query, 5, args.includes("--explain"));
+        if (args.includes("--json"))
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.log(result.context_block);
+        return;
+    }
+    if (command === "observe") {
+        const event = takeArg(args, "--event");
+        if (!event)
+            usage();
+        const result = (0, kernel_js_1.observe)(projectArg(args), JSON.parse(event));
+        if (args.includes("--json"))
+            console.log(JSON.stringify(result, null, 2));
+        else if (result.ok && result.duplicate)
+            console.log(`Observation already stored: ${result.path}`);
+        else if (result.ok)
+            console.log(`Stored observation: ${result.path}`);
+        else {
+            console.error(`Observation blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        return;
+    }
+    if (command === "distill") {
+        const sessionId = takeArg(args, "--session");
+        if (!sessionId)
+            usage();
+        const result = (0, kernel_js_1.distillSession)(projectArg(args), sessionId);
+        if (args.includes("--json"))
+            console.log(JSON.stringify(result, null, 2));
+        else {
+            console.log(`Distilled session: ${sessionId}`);
+            console.log(`Observations: ${result.observations}`);
+            console.log(`Candidates: ${result.candidates.filter((candidate) => candidate.ok).length}`);
+            if (result.errors.length)
+                console.log(`Errors:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+        }
+        if (!result.ok)
+            process.exit(2);
+        return;
+    }
+    if (command === "feedback") {
+        const id = takeArg(args, "--packet");
+        const kind = takeArg(args, "--kind");
+        if (!id || !kind)
+            usage();
+        const result = (0, kernel_js_1.recordFeedback)(projectArg(args), id, kind);
+        if (!result.ok) {
+            console.error(`Feedback failed:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Recorded ${kind} feedback for ${id}`);
+        return;
+    }
+    if (command === "capture") {
+        const title = takeArg(args, "--title");
+        const body = takeArg(args, "--body");
+        if (!title || !body)
+            usage();
+        const type = takeArg(args, "--type");
+        const input = {
+            projectDir: projectArg(args),
+            title,
+            body,
+            type,
+            summary: takeArg(args, "--summary"),
+            tags: listArg(takeArg(args, "--tags")),
+            paths: listArg(takeArg(args, "--paths")),
+            stack: listArg(takeArg(args, "--stack")),
+        };
+        const result = (0, kernel_js_1.capture)(input);
+        if (!result.ok) {
+            console.error(`Capture blocked:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+            process.exit(2);
+        }
+        console.log(`Captured pending packet: ${result.path}`);
+        console.log(`Review with: kage review --project ${input.projectDir}`);
+        return;
+    }
+    if (command === "review") {
+        await review(projectArg(args));
+        return;
+    }
+    if (command === "validate") {
+        const result = (0, kernel_js_1.validateProject)(projectArg(args));
+        if (result.errors.length)
+            console.log(`Errors:\n${result.errors.map((error) => `  - ${error}`).join("\n")}`);
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        console.log(result.ok ? "Validation passed." : "Validation failed.");
+        if (!result.ok)
+            process.exit(2);
+        return;
+    }
+    usage();
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});