kodingo-cli 1.1.13 → 1.3.0

package/dist/adapters/cloud-adapter/cloud-persistence.js

@@ -104,6 +104,7 @@ function mapApiRecord(r) {
         },
         createdAt: new Date(r.createdAt),
         updatedAt: new Date(r.updatedAt),
+        evidenceKind: r.evidenceKind ?? "sourced",
         // Adapter-layer fields — not on core MemoryRecord but present in API responses
         externalId: r.externalId ?? null,
         correctsId: r.correctsId ?? null,
@@ -146,6 +147,7 @@ async function saveMemory(input) {
         status: input.status ?? "proposed",
         confidence: input.confidence ?? 0.3,
         tags: input.tags ?? [],
+        evidenceKind: input.evidenceKind,
     };
     if (input.title)
         body.title = input.title;

package/dist/adapters/db-adapter/memory-persistence.js

@@ -46,6 +46,21 @@ async function initDb() {
     ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS corrects_id uuid NULL;
     ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS corrected_by_id uuid NULL;
 
+    -- Real evidence provenance (mirrors kodingo-api's schema.ts) — local-mode
+    -- writes go straight here via psql, bypassing the API's enforcement
+    -- entirely, so the same real constraint needs to exist on this table too.
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS evidence_kind text NOT NULL DEFAULT 'sourced';
+    DO $$
+    BEGIN
+      IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'kodingo_memory_evidence_kind_check') THEN
+        ALTER TABLE kodingo_memory ADD CONSTRAINT kodingo_memory_evidence_kind_check CHECK (evidence_kind IN ('sourced', 'derived'));
+      END IF;
+      IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'kodingo_memory_sourced_requires_external_id') THEN
+        ALTER TABLE kodingo_memory ADD CONSTRAINT kodingo_memory_sourced_requires_external_id
+          CHECK (evidence_kind = 'derived' OR (external_id IS NOT NULL AND btrim(external_id) <> '')) NOT VALID;
+      END IF;
+    END $$;
+
     -- Indexes
     CREATE INDEX IF NOT EXISTS kodingo_memory_created_at_idx
       ON kodingo_memory (created_at);
@@ -97,11 +112,23 @@ async function saveMemory(input) {
     const id = (0, uuid_1.v4)();
     const status = input.status ?? "proposed";
     const confidence = clamp01(input.confidence ?? 0.3);
+    // Real mechanical enforcement (mirrors kodingo-core's
+    // validateMemoryProvenance) — local-mode writes go straight to Postgres
+    // via psql, bypassing kodingo-api's routes/memory.ts entirely, so this is
+    // the one place that enforcement can actually happen for this path. Same
+    // real, honest fallback as the API: a "sourced" capture with nothing
+    // client-supplied gets a real identifier naming the capture event itself,
+    // not a fabricated placeholder.
+    const externalId = input.externalId ??
+        (input.evidenceKind === "sourced" ? `manual:${input.repoPath ?? "unknown"}:${id}` : undefined);
+    if (input.evidenceKind === "sourced" && !externalId?.trim()) {
+        throw new Error("A 'sourced' memory must include a real externalId. If this genuinely has no single real source, use evidenceKind: 'derived' instead.");
+    }
     const sql = `
     WITH inserted AS (
       INSERT INTO kodingo_memory (
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id
       )
       VALUES (
@@ -114,13 +141,14 @@ async function saveMemory(input) {
         ${sqlLiteral(status)},
         ${sqlNumberLiteral(confidence)},
         ${sqlNullableLiteral(input.symbol)},
-        ${sqlNullableLiteral(input.externalId)},
+        ${sqlNullableLiteral(externalId)},
+        ${sqlLiteral(input.evidenceKind)},
         ${sqlNullableUuidLiteral(input.correctsId)},
         ${sqlNullableUuidLiteral(input.correctedById)}
       )
       RETURNING
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
     )
@@ -137,7 +165,7 @@ async function getMemoryById(id) {
     SELECT row_to_json(result) FROM (
       SELECT
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
       FROM kodingo_memory
@@ -165,7 +193,7 @@ async function updateMemoryLifecycle(params) {
       WHERE id = ${sqlLiteral(params.id)}
       RETURNING
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
     )
@@ -218,7 +246,7 @@ async function getMemoryByExternalId(externalId, repoPath) {
     SELECT row_to_json(result) FROM (
       SELECT
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
       FROM kodingo_memory
@@ -243,7 +271,7 @@ async function getProposedOrIgnoredRecordBySymbol(params) {
     SELECT row_to_json(result) FROM (
       SELECT
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
       FROM kodingo_memory
@@ -275,7 +303,7 @@ async function updateMemoryConfidence(params) {
       WHERE id = ${sqlLiteral(params.id)}
       RETURNING
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
     )
@@ -318,7 +346,7 @@ async function queryMemory(text, limit = 10, repoPath, opts = {}) {
       SELECT row_to_json(result) FROM (
         SELECT DISTINCT ON (coalesce(symbol, id::text))
           id, type, title, content, tags, repo_path,
-          status, confidence, symbol, external_id,
+          status, confidence, symbol, external_id, evidence_kind,
           corrects_id, corrected_by_id,
           created_at
         FROM kodingo_memory
@@ -349,7 +377,7 @@ async function queryMemory(text, limit = 10, repoPath, opts = {}) {
     SELECT row_to_json(result) FROM (
       SELECT
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at,
         CASE
@@ -413,7 +441,7 @@ async function queryMemoryBySymbol(params) {
     SELECT row_to_json(result) FROM (
       SELECT
         id, type, title, content, tags, repo_path,
-        status, confidence, symbol, external_id,
+        status, confidence, symbol, external_id, evidence_kind,
         corrects_id, corrected_by_id,
         created_at
       FROM kodingo_memory
@@ -444,6 +472,7 @@ function mapRow(row) {
         confidence,
         symbol: row.symbol ?? null,
         externalId: row.external_id ?? null,
+        evidenceKind: row.evidence_kind ?? "sourced",
         correctsId: row.corrects_id ?? null,
         correctedById: row.corrected_by_id ?? null,
         createdAt: new Date(row.created_at),

package/dist/cli.js

@@ -19,6 +19,7 @@ const sync_dependencies_1 = require("./commands/sync-dependencies");
 const security_scan_1 = require("./commands/security-scan");
 const init_1 = require("./commands/init");
 const build_1 = require("./commands/build");
+const plan_1 = require("./commands/plan");
 const install_hook_1 = require("./commands/install-hook");
 const update_1 = require("./commands/update");
 const sync_1 = require("./commands/sync");
@@ -39,7 +40,7 @@ program
     .argument("<task>", "what to build or fix")
     .option("--repo <path>", "repo path (defaults to the current repo)")
     .option("--max-turns <n>", "override the agent loop's turn budget")
-    .option("--scope <small|substantial>", "manual scope estimate sizing the initial token budget (stands in for Plan mode, not built yet)")
+    .option("--scope <small|substantial>", "manual scope estimate sizing the initial token budget — overrides the scope from a prior `kodingo plan` run against this repo, if any")
     .action(async (task, options) => {
     if (options.scope && options.scope !== "small" && options.scope !== "substantial") {
         console.error(`✖ --scope must be "small" or "substantial", got "${options.scope}".`);
@@ -52,6 +53,19 @@ program
         ...(options.scope ? { scope: options.scope } : {}),
     });
 });
+// ── plan ──────────────────────────────────────────────────────────────────────
+program
+    .command("plan")
+    .description("Run Kortex Plan's local, observation-only agent loop against this repo (test-driver for kodingo-agent)")
+    .argument("<task>", "what to plan")
+    .option("--repo <path>", "repo path (defaults to the current repo)")
+    .option("--max-turns <n>", "override the agent loop's turn budget")
+    .action(async (task, options) => {
+    await (0, plan_1.planCommand)(String(task), {
+        ...(options.repo ? { repo: String(options.repo) } : {}),
+        ...(options.maxTurns ? { maxTurns: Number.parseInt(String(options.maxTurns), 10) } : {}),
+    });
+});
 // ── update ────────────────────────────────────────────────────────────────────
 program
     .command("update")

package/dist/commands/build.js

@@ -118,6 +118,18 @@ async function buildCommand(input, options = {}) {
         return;
     }
     const apiBaseUrl = apiConfig.apiUrl.replace(/\/$/, "");
+    // A real `kodingo plan` run against this same repo left a one-shot scope
+    // estimate behind — use it unless a human explicitly passed --scope,
+    // which always wins. Consumed (cleared) here so a stale plan from a
+    // different task never silently sizes a later, unrelated build.
+    let scope = options.scope;
+    const existingWs = (0, persistence_config_1.readWorkspaceConfig)(repoRoot);
+    if (!scope && existingWs?.lastPlan) {
+        scope = existingWs.lastPlan.scope;
+        console.log(`Using scope:${scope} from the last \`kodingo plan\` run against this repo (${existingWs.lastPlan.createdAt}).`);
+        const { lastPlan: _consumed, ...rest } = existingWs;
+        (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, rest);
+    }
     // Bring-your-own, if configured (~/.kodingo/byo-model.json — same file
     // kodingo-vscode already uses) — never logged, only forwarded.
     const byoModelConfig = (0, kodingo_agent_1.getByoModelConfig)();
@@ -150,13 +162,17 @@ async function buildCommand(input, options = {}) {
                 "Explore before you edit: read files, grep for symbols, and look around as needed — looking is just " +
                 "another turn, you can call tools as many times as it takes to actually understand the real code " +
                 "before changing it. Only use edit_file for surgical, minimal changes to existing files; use " +
-                "write_file only for brand-new files. Before reporting done, verify your change with run_command.",
+                "write_file only for brand-new files. Before reporting done, verify your change with run_command. " +
+                "If you discover mid-task that a prior plan, assumption, or existing memory was meaningfully wrong — " +
+                "a file assumed to exist that doesn't, an existing pattern that's actually different from what was " +
+                "documented — call propose_memory_correction to record it for human review. Only for real, meaningful " +
+                "corrections, not routine exploration findings.",
         },
         { role: "user", content: input },
     ];
     const result = await (0, kodingo_agent_1.runAgentLoop)({
         cwd: repoRoot,
-        tools: (0, kodingo_agent_1.createDefaultToolSet)(),
+        tools: (0, kodingo_agent_1.createDefaultToolSet)({ memoryCorrection: { apiBaseUrl, projectToken: apiConfig.token } }),
         initialMessages,
         modelPort,
         reporter: (0, kodingo_agent_1.createTerminalReporter)(),
@@ -164,7 +180,7 @@ async function buildCommand(input, options = {}) {
         // not a silent hard kill. See kodingo-agent's terminalCheckpointPort.
         checkpointPort: (0, kodingo_agent_1.createTerminalCheckpointPort)(),
         budgets: {
-            ...(0, kodingo_agent_1.resolveBudgetForScope)(options.scope),
+            ...(0, kodingo_agent_1.resolveBudgetForScope)(scope),
             ...(options.maxTurns ? { maxTurns: options.maxTurns } : {}),
         },
     });

package/dist/commands/capture.js

@@ -17,10 +17,16 @@ async function captureCommand(options) {
     }
     const tags = parseTags(options.tags);
     const repoPath = findRepoRoot(process.cwd());
+    // A manual capture is genuinely sourced — to the real, specific event of
+    // this human's assertion, right now. Not tied to a pre-existing external
+    // artifact the way a commit or PR is, so no externalId is set here; both
+    // backends (local-mode saveMemory, kodingo-api's routes/memory.ts)
+    // construct a real one from the capture event's own identity when absent.
     const input = {
         type: options.type,
         content,
         repoPath,
+        evidenceKind: "sourced",
     };
     if (options.title)
         input.title = options.title;

package/dist/commands/deny.js

@@ -37,12 +37,16 @@ async function denyCommand(options) {
     }
     const userTags = parseTags(options.tags);
     const tags = mergeTags(existing.tags, userTags);
+    // A denial's corrected replacement is a new, real human assertion — the
+    // correction event itself — same class as manual capture, not simply
+    // inherited from whatever the original record's provenance was.
     const input = {
         type: existing.type,
         content: correctionContent,
         status: "proposed",
         confidence: 0.7,
         correctsId: existing.id,
+        evidenceKind: "sourced",
     };
     if (existing.repo)
         input.repoPath = existing.repo;

package/dist/commands/doctor.js

@@ -58,6 +58,7 @@ async function runDoctor(results) {
             content: "doctor saved",
             tags: ["smoke", "doctor"],
             repoPath: process.cwd(),
+            evidenceKind: "derived", // a throwaway diagnostic row, not a real capture
         });
         tempId = inserted.id;
     }, results);

package/dist/commands/plan.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * kodingo plan
+ *
+ * Runs Kortex Plan's real local agentic loop (kodingo-agent) against the
+ * current repo — observation only (read_file, grep, list_directory, glob,
+ * query_memory), never edit_file/write_file/run_command. Same real
+ * test-driver identity as `kodingo build` (see build.ts's own header
+ * comment): this exercises kodingo-agent's Plan tool set headlessly, not a
+ * polished second UX.
+ *
+ * On success, the real structured output (scope, filesLikelyInvolved,
+ * openQuestions) is written to this repo's workspace config as a one-shot
+ * handoff — `kodingo build` reads and consumes it to size its own budget,
+ * so a plain `kodingo build "<task>"` run after a `kodingo plan` run for
+ * the same repo picks up a real scope estimate without a manual --scope flag.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCommand = planCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const kodingo_agent_1 = require("kodingo-agent");
+const persistence_config_1 = require("../utils/persistence-config");
+function findRepoRoot(startPath) {
+    let current = startPath;
+    while (true) {
+        if (fs.existsSync(path.join(current, ".git")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return startPath;
+        current = parent;
+    }
+}
+function resolveApiConfig(repoRoot) {
+    const config = (0, persistence_config_1.readConfig)();
+    const ws = (0, persistence_config_1.readWorkspaceConfig)(repoRoot);
+    const apiUrl = ws?.apiUrl ?? config.apiUrl;
+    const token = ws?.token ?? config.token;
+    if (!apiUrl || !token)
+        return null;
+    return { apiUrl, token };
+}
+async function planCommand(input, options = {}) {
+    const repoRoot = options.repo ? path.resolve(options.repo) : findRepoRoot(process.cwd());
+    const apiConfig = resolveApiConfig(repoRoot);
+    if (!apiConfig) {
+        console.error(`✖ No Kodingo project connected for ${repoRoot}. Run \`kodingo init\` in this repo first.`);
+        process.exitCode = 1;
+        return;
+    }
+    // Plan only ever reads — the trust prompt exists for Build's write/execute
+    // capability, so Plan doesn't need to ask for it, but it still respects an
+    // existing "always allow" grant by not double-prompting within it either way.
+    if (!(0, kodingo_agent_1.isProjectTrusted)(repoRoot)) {
+        console.log(`Note: ${repoRoot} isn't marked trusted yet — Plan only reads, so this runs regardless, but \`kodingo build\` will still ask.`);
+    }
+    const apiBaseUrl = apiConfig.apiUrl.replace(/\/$/, "");
+    const byoModelConfig = (0, kodingo_agent_1.getByoModelConfig)();
+    if (byoModelConfig) {
+        console.log(`Using bring-your-own model${byoModelConfig.label ? ` (${byoModelConfig.label})` : ""} — no shared quota consumed.`);
+    }
+    console.log(`Starting Kortex Plan against ${repoRoot} ...`);
+    const startRes = await fetch(`${apiBaseUrl}/build/agent-start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Kodingo-Token": apiConfig.token },
+        body: JSON.stringify({
+            input,
+            repo: path.basename(repoRoot),
+            mode: "plan",
+            ...(byoModelConfig ? { modelConfig: byoModelConfig } : {}),
+        }),
+    });
+    const startBody = (await startRes.json());
+    if (!startRes.ok || !startBody.sessionId) {
+        console.error(`✖ Could not start Plan session: ${startBody.error ?? startRes.status}`);
+        process.exitCode = 1;
+        return;
+    }
+    const sessionId = startBody.sessionId;
+    console.log(`Session: ${sessionId}`);
+    const modelPort = (0, kodingo_agent_1.createHttpModelCallPort)({ apiBaseUrl, projectToken: apiConfig.token, sessionId });
+    const initialMessages = [
+        {
+            role: "system",
+            content: "You are Kortex Plan, working directly against the developer's real local repository. Your job is to " +
+                "produce a real, grounded plan for the task below — not a guess. You have NO ability to edit files or " +
+                "run commands — observation only.\n\n" +
+                "Explore in this order, narrow before wide, memory before raw content — this is enforced, not just " +
+                "advice: read_file will be mechanically rejected unless you've already either (a) called query_memory " +
+                "with a query naming that file, or (b) called list_directory/glob so it actually appears in the results. " +
+                "1) Start from query_memory with a question shaped by the task itself (e.g. 'how does rate limiting work " +
+                "in this codebase'). If the answer is genuinely sufficient, reason from it directly — a well-maintained " +
+                "project should let you produce a grounded plan with little or no raw file reading at all; that's the " +
+                "point, not a shortcut you're avoiding. 2) If insufficient, either ask a different, more specific memory " +
+                "question, or fall back to real exploration — that fallback is legitimate and expected for anything " +
+                "memory doesn't cover yet. 3) When falling back, start with list_directory/glob — file names and " +
+                "structure only, never full contents at this stage. 4) Once a specific file looks relevant, query memory " +
+                "again scoped to that file ('what do we know about authRoutes.js') before reading it — memory may cover " +
+                "it even if your broader query didn't. 5) Only then read_file, as a genuine last resort.\n\n" +
+                "If something is genuinely ambiguous and you can't proceed confidently without knowing the answer, use " +
+                "ask_clarifying_question — sparingly, only for real blockers, not things you could resolve yourself by " +
+                "reading more code. Before calling submit_plan, double-check your own draft against the real codebase: " +
+                "re-verify that every file path you're about to list under filesLikelyInvolved actually exists and is " +
+                "really relevant — submit_plan will mechanically reject any path that doesn't really exist. Give an " +
+                "honest scope estimate: 'small' for a narrow, single-file change; 'substantial' for a real multi-file " +
+                "feature. Your planMarkdown has two real destinations — sent straight to Build, or downloaded and taken " +
+                "somewhere else entirely with zero further involvement from Kortex — so write it as a genuinely complete, " +
+                "standalone document: real file paths, specific locations within them, real reasoning for each change.",
+        },
+        { role: "user", content: input },
+    ];
+    const { tools, drainBackgroundWork } = (0, kodingo_agent_1.createPlanToolSet)({
+        queryMemory: { apiBaseUrl, projectToken: apiConfig.token },
+        modelPort,
+        clarificationPort: (0, kodingo_agent_1.createTerminalClarificationPort)(),
+    });
+    const result = await (0, kodingo_agent_1.runAgentLoop)({
+        cwd: repoRoot,
+        tools,
+        initialMessages,
+        modelPort,
+        reporter: (0, kodingo_agent_1.createTerminalReporter)(),
+        checkpointPort: (0, kodingo_agent_1.createTerminalCheckpointPort)(),
+        drainBackgroundWork,
+        // Plan's whole job is thorough exploration BEFORE any task-specific
+        // scope is known, so it needs real headroom by default, not the flat
+        // 40-turn default — confirmed directly: a real Plan run against Pulse
+        // hit budget_exceeded at exactly 40 turns of pure reading (689,805
+        // tokens, well under the token budget) without ever reaching
+        // submit_plan. Using the same "substantial" floor Build gets for a
+        // real multi-file task, not the bare default.
+        budgets: {
+            ...(0, kodingo_agent_1.resolveBudgetForScope)("substantial"),
+            ...(options.maxTurns ? { maxTurns: options.maxTurns } : {}),
+        },
+    });
+    try {
+        await fetch(`${apiBaseUrl}/build/${sessionId}/agent-complete`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Kodingo-Token": apiConfig.token },
+            body: JSON.stringify({ status: result.status, message: result.error }),
+        });
+    }
+    catch {
+        // Best-effort — the loop's own outcome already printed to the terminal regardless.
+    }
+    if (result.status !== "completed" || !result.structuredOutput) {
+        console.error(`✖ Plan did not complete: ${result.status}${result.error ? ` — ${result.error}` : ""}`);
+        process.exitCode = 1;
+        return;
+    }
+    const output = result.structuredOutput;
+    console.log(`\n${output.planMarkdown}\n`);
+    console.log(`Scope: ${output.scope}`);
+    console.log(`Files likely involved: ${output.filesLikelyInvolved.join(", ") || "(none)"}`);
+    if (output.openQuestions.length > 0) {
+        console.log(`Open questions:\n${output.openQuestions.map((q) => `  - ${q}`).join("\n")}`);
+    }
+    // One-shot handoff: kodingo build reads and clears this on its next run
+    // against the same repo, sizing its own budget without a manual --scope.
+    const existingWs = (0, persistence_config_1.readWorkspaceConfig)(repoRoot);
+    (0, persistence_config_1.writeWorkspaceConfig)(repoRoot, {
+        mode: "cloud",
+        apiUrl: apiConfig.apiUrl,
+        token: apiConfig.token,
+        ...existingWs,
+        lastPlan: {
+            scope: output.scope,
+            planMarkdown: output.planMarkdown,
+            filesLikelyInvolved: output.filesLikelyInvolved,
+            openQuestions: output.openQuestions,
+            createdAt: new Date().toISOString(),
+        },
+    });
+    console.log(`\n✔ Saved as this repo's last plan — \`kodingo build\` will use scope:${output.scope} automatically on its next run here.`);
+}

package/dist/commands/scan-claude.js

@@ -104,6 +104,7 @@ function extractMemoriesFromSession(messages, sessionId, repoPath) {
                 repoPath,
                 status: "proposed",
                 confidence: Math.min(0.3 + score * 0.05, 0.6),
+                evidenceKind: "sourced",
                 externalId: `claude-session:${sessionId}:${Buffer.from(para.slice(0, 40)).toString("base64").slice(0, 16)}`,
             });
         }

package/dist/commands/scan-repo.js

@@ -197,6 +197,10 @@ async function inferAndCapture(token, symbol, repo, graph, repoRoot) {
                 machineId: (0, persistence_config_1.readConfig)().machineId ?? undefined,
                 displayName: os.hostname(),
                 fingerprint: symbol.fingerprint ?? undefined,
+                // An LLM's own inferred description of a function during a bulk scan
+                // — Kortex's own conclusion, not traceable to one real external
+                // event, same class as kodingo-api's githubScanner.ts.
+                evidenceKind: "derived",
             }),
         });
         return saveRes.ok;

package/dist/ports/cloud-event-port.js

@@ -58,6 +58,7 @@ class CloudEventPort {
                     content: existing.content,
                     symbol: existing.symbol ?? "",
                     tags: existing.tags ?? [],
+                    evidenceKind: existing.evidenceKind,
                     status: existing.status,
                     confidence: existing.confidence,
                     evidence: {
@@ -100,6 +101,7 @@ class CloudEventPort {
             repoPath: this.repoPath,
             status: "proposed",
             confidence: decision.confidence ?? 0.3,
+            evidenceKind: "sourced",
             externalId,
             tags: ["signal:git", "kind:decision"],
         };

package/dist/ports/db-event-port.js

@@ -52,6 +52,7 @@ class DbEventPort {
                     content: existing.content,
                     symbol: existing.symbol ?? "",
                     tags: existing.tags ?? [],
+                    evidenceKind: existing.evidenceKind,
                     status: existing.status,
                     confidence: existing.confidence,
                     evidence: {
@@ -74,13 +75,16 @@ class DbEventPort {
                 return;
             }
         }
-        // No existing proposed/ignored record — insert new record as usual
+        // No existing proposed/ignored record — insert new record as usual.
+        // Git-signal-derived captures are genuinely sourced — externalId here is
+        // a real git:<commitHash> reference (see the caller).
         const input = {
             type: "decision",
             content,
             repoPath: this.repoPath,
             status: "proposed",
             confidence: 0.3,
+            evidenceKind: "sourced",
             externalId,
         };
         if (title)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.1.13",
+  "version": "1.3.0",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,
@@ -25,8 +25,8 @@
     "@typescript-eslint/types": "^8.61.1",
     "@typescript-eslint/typescript-estree": "^8.61.1",
     "commander": "^12.1.0",
-    "kodingo-agent": "^0.1.3",
-    "kodingo-core": "^0.2.1",
+    "kodingo-agent": "^0.2.0",
+    "kodingo-core": "^0.3.0",
     "open": "^11.0.0",
     "simple-git": "^3.30.0",
     "tree-sitter-wasms": "^0.1.13",