@meetless/mla 0.1.4

package/dist/commands/kb_pending.js

@@ -0,0 +1,410 @@
+"use strict";
+// `mla kb review [--all | --session <sid|current|latest> | --doc <id>] [--json]`
+// (list mode; the same runner also backs the deprecated `mla kb pending` alias).
+//
+// B5 (notes/20260603-mla-kb-agent-proxy-and-evidence-adoption.md §3). Lists the
+// PENDING_REVIEW relationship candidates a human (or an agent proxy) must decide on.
+// Reads the control list route (GET /internal/v1/relationship-candidates) at its
+// default view (PENDING_REVIEW + LIVE posture) -- the same queue the Console review
+// inbox shows.
+//
+// Scope (notes/20260607-mla-kb-pending-session-scope-and-bulk-discard-plan.md):
+//   * default (no flag): the CURRENT session if $CLAUDE_CODE_SESSION_ID is set, else
+//     the full workspace queue. Parallel coding agents each see only the candidates
+//     touching docs THEIR session produced.
+//   * `--all`: the full workspace queue.
+//   * `--session <sid|current|latest>`: an explicit session scope.
+//   * `--doc <id>`: scope to one artifact. A value containing ":" is treated as a
+//     fully-qualified artifactId (e.g. "note:notes/foo.md", "jira:PDM-9"); a bare
+//     path is treated as a notePath the route resolves to "note:<rel>".
+//
+//   * Human view: the "needs your decision" digest (one line per candidate: type,
+//     source -> target, confidence, detector, evidence snippet, Console deep link).
+//     No in-terminal relationship graph; the Console is the deep-work surface.
+//   * `--json`: structured for an automated proxy, each candidate annotated with its
+//     mechanical-validity verdict so the agent knows which ones it may auto-reject
+//     via `mla kb review --reject --agent` (P2 reject-only policy).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runKbReviewList = exports.USER_CONFIRM_ACTIONS = exports.ALLOWED_AGENT_ACTIONS = void 0;
+exports.parseKbPendingArgs = parseKbPendingArgs;
+exports.buildPendingView = buildPendingView;
+exports.renderPendingJson = renderPendingJson;
+exports.renderPendingHuman = renderPendingHuman;
+exports.fetchAllPending = fetchAllPending;
+exports.runKbPendingWith = runKbPendingWith;
+exports.runKbPending = runKbPending;
+const config_1 = require("../lib/config");
+const http_1 = require("../lib/http");
+const governance_cache_1 = require("../lib/governance-cache");
+const kb_candidate_1 = require("../lib/kb-candidate");
+const session_scope_1 = require("../lib/session-scope");
+const relationship_candidate_query_1 = require("../lib/relationship-candidate-query");
+const USAGE = "Usage: mla kb review [--all | --session <sid|current|latest> | --doc <id>] [--json]";
+// Verdict flags belong on `mla kb review <id> <flag>`; if one leads (so the
+// overload routes here to list mode), give a targeted hint instead of a generic
+// "unknown flag".
+const VERDICT_FLAGS = new Set(["--accept", "--reject", "--reclassify", "--no-relation"]);
+function parseKbPendingArgs(argv) {
+    let json = false;
+    let all = false;
+    let session = null;
+    let doc = null;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json") {
+            json = true;
+        }
+        else if (a === "--all") {
+            all = true;
+        }
+        else if (a === "--session") {
+            const v = argv[++i];
+            if (v === undefined)
+                throw new Error("--session requires a value");
+            session = v;
+        }
+        else if (a === "--doc") {
+            const v = argv[++i];
+            if (v === undefined)
+                throw new Error("--doc requires a value");
+            doc = v;
+        }
+        else if (VERDICT_FLAGS.has(a)) {
+            throw new Error(`To record a verdict, pass the candidate id first: mla kb review <candidate-id> ${a}`);
+        }
+        else if (a.startsWith("-")) {
+            throw new Error(`Unknown flag: ${a}. ${USAGE}`);
+        }
+        else {
+            throw new Error(`mla kb review (list mode) takes no positional args; pass a scope flag. ${USAGE}`);
+        }
+    }
+    const set = (all ? 1 : 0) + (session !== null ? 1 : 0) + (doc !== null ? 1 : 0);
+    if (set > 1) {
+        throw new Error(`Pass at most one of --all, --session, or --doc. ${USAGE}`);
+    }
+    let scope;
+    if (all)
+        scope = { kind: "workspace" };
+    else if (session !== null)
+        scope = { kind: "session", value: session };
+    else if (doc !== null)
+        scope = { kind: "doc", doc };
+    else
+        scope = { kind: "default" };
+    return { scope, json };
+}
+// A-0 (A4): the governance action vocabulary. The agent may propose / triage /
+// auto-clear (the LEFT list); ACCEPT and APPLY_CORRECTION are governed changes
+// made under the user's authority and are NOT in the agent's allowed set (a
+// scoped AGENT_PROXY credential is denied them outright, A-1b). Defined once and
+// reused by the --json output (surface 3) here; the static <meetless-context>
+// hook block (surface 2, A-0c) mirrors this exact vocabulary so the agent reads
+// one policy across both channels.
+exports.ALLOWED_AGENT_ACTIONS = [
+    "triage",
+    "recommend",
+    "defer",
+    "propose_correction",
+    "auto_reject_mechanical_only",
+];
+exports.USER_CONFIRM_ACTIONS = ["accept", "apply_correction"];
+const GOVERNANCE_NOTE = "accept and apply_correction are governed changes made under the user's authority; " +
+    "by default propose and let the user confirm. A scoped AGENT_PROXY credential is denied these outright.";
+// Per-candidate verbs an agent may take WITHOUT user confirmation. "triage" is the
+// umbrella activity (top-level only); the concrete per-candidate verbs are these,
+// plus auto_reject_mechanical_only ONLY when the candidate is mechanically invalid.
+function agentActionsFor(mechanical) {
+    const allowed = ["recommend", "defer", "propose_correction"];
+    if (mechanical.autoRejectable)
+        allowed.push("auto_reject_mechanical_only");
+    return { allowed, userConfirm: [...exports.USER_CONFIRM_ACTIONS] };
+}
+function buildPendingView(items, ctx) {
+    return {
+        workspaceId: ctx.workspaceId,
+        consoleBase: ctx.consoleBase,
+        truncated: ctx.truncated,
+        scope: ctx.scope,
+        scopeNote: ctx.scopeNote,
+        rows: items.map((candidate) => ({
+            candidate,
+            mechanical: (0, kb_candidate_1.classifyMechanicalInvalidity)(candidate),
+            consoleUrl: (0, kb_candidate_1.candidateConsoleUrl)(ctx.consoleBase, candidate.id),
+        })),
+    };
+}
+function renderPendingJson(view) {
+    return JSON.stringify({
+        workspaceId: view.workspaceId,
+        scope: view.scope,
+        count: view.rows.length,
+        truncated: view.truncated,
+        // A-0 surface 3: a top-level policy summary so a programmatic agent reads
+        // the governance rule once instead of inferring it from per-row prose. This
+        // mirrors the static hook block's compact form (A-0c).
+        governance: {
+            pendingCount: view.rows.length,
+            allowedAgentActions: [...exports.ALLOWED_AGENT_ACTIONS],
+            userConfirmActions: [...exports.USER_CONFIRM_ACTIONS],
+            note: GOVERNANCE_NOTE,
+        },
+        candidates: view.rows.map((r) => ({
+            id: r.candidate.id,
+            relationType: r.candidate.relationTypeId,
+            source: { type: r.candidate.sourceType, artifactId: r.candidate.sourceArtifactId },
+            target: { type: r.candidate.targetType, artifactId: r.candidate.targetArtifactId },
+            confidence: r.candidate.confidence,
+            status: r.candidate.statusId,
+            posture: r.candidate.postureId,
+            reviewMode: r.candidate.reviewModeId,
+            detector: r.candidate.detectorFamily,
+            detectorVersion: r.candidate.detectorVersion,
+            createdAt: r.candidate.createdAt,
+            evidence: {
+                sourceQuote: r.candidate.evidenceJson?.sourceQuote ?? null,
+                targetQuote: r.candidate.evidenceJson?.targetQuote ?? null,
+                reasoning: r.candidate.evidenceJson?.reasoning ?? null,
+            },
+            autoRejectable: r.mechanical.autoRejectable,
+            autoRejectReasonCode: r.mechanical.reasonCode,
+            autoRejectReason: r.mechanical.reason,
+            // Per-candidate verbs: what THIS agent may do to THIS candidate without a
+            // user confirmation (auto_reject_mechanical_only appears only when the row
+            // is mechanically invalid), vs the governed verbs that need the user.
+            agentActions: agentActionsFor(r.mechanical),
+            consoleUrl: r.consoleUrl,
+        })),
+    }, null, 2);
+}
+function snippet(s, max = 80) {
+    if (!s)
+        return "";
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}...` : flat;
+}
+function renderPendingHuman(view) {
+    if (view.rows.length === 0) {
+        const base = `No relationship candidates pending review (workspace ${view.workspaceId}).`;
+        return view.scopeNote ? `${view.scopeNote}\n${base}` : base;
+    }
+    const lines = [];
+    if (view.scopeNote) {
+        lines.push(view.scopeNote);
+        lines.push("");
+    }
+    const n = view.rows.length;
+    lines.push(`${n} relationship candidate${n === 1 ? "" : "s"} need${n === 1 ? "s" : ""} your decision (workspace ${view.workspaceId}):`);
+    lines.push("");
+    for (const r of view.rows) {
+        const c = r.candidate;
+        const target = c.targetArtifactId ?? "(unary)";
+        lines.push(`  [${c.relationTypeId}] ${c.sourceArtifactId} -> ${target}   conf ${c.confidence.toFixed(2)}  ${c.detectorFamily}`);
+        const src = snippet(c.evidenceJson?.sourceQuote);
+        const tgt = snippet(c.evidenceJson?.targetQuote);
+        if (src || tgt)
+            lines.push(`    "${src}" vs "${tgt}"`);
+        lines.push(`    id ${c.id}`);
+        lines.push(`    review: ${r.consoleUrl}`);
+        if (r.mechanical.autoRejectable) {
+            lines.push(`    -> auto-rejectable (${r.mechanical.reasonCode}); agent may run: mla kb review ${c.id} --reject --agent`);
+        }
+        lines.push("");
+    }
+    if (view.truncated) {
+        lines.push("The workspace queue exceeded the fetch cap; some candidates are not shown. Narrow with --doc <id>.");
+        lines.push("");
+    }
+    // A-0 (A4 surface 1): the CLI caller is UNKNOWN (a human and a coding agent run
+    // the identical command), so this block dual-addresses both in one message
+    // rather than guessing. Only rendered when the queue is non-empty (the count==0
+    // path returns the plain "no candidates" line above). The wording is the one
+    // agreed with An (plan §A4): the agent should offer to triage, but accepting an
+    // edge or applying a correction is a governed change under the user's authority,
+    // so the UX default is propose-first (NOT a hard server block; the server gate
+    // restricts only AGENT_PROXY, A-1).
+    lines.push("These candidates are pending review in this workspace.");
+    lines.push("- If you are the user: you can ask your coding agent to triage these for you.");
+    lines.push("- If you are the agent: you may triage them now, and you should offer to. Read");
+    lines.push("  both documents, recommend a verdict, auto-clear ONLY mechanically-invalid ones,");
+    lines.push("  and propose the correct type when one is mis-classified.");
+    lines.push("Accepting an edge or applying a correction is a governed change made under the");
+    lines.push("user's authority; by default propose it and let the user confirm.");
+    lines.push("");
+    lines.push(`Triage:    mla kb review <id> --accept | --reject [--note "..."]`);
+    lines.push(`Auto-clear (mechanically-invalid only): mla kb review <id> --reject --agent`);
+    return lines.join("\n");
+}
+const PAGE_LIMIT = 200; // route hard cap (@Max(200))
+const MAX_PAGES = 25; // backstop: 5000 candidates before we stop and flag truncation
+// Follow the route's cursor to completion so the workspace count and the session
+// filter both operate on the full set, not a capped first page. Stops at MAX_PAGES
+// (truncated=true) as a runaway backstop. The cursor comes from our own control
+// route, so a missing id/createdAt or an unparseable date is a server bug; fail
+// LOUD rather than build a corrupt cursor and silently mis-paginate.
+async function fetchAllPending(fetchPending, workspaceId, doc) {
+    const items = [];
+    let cursor = null;
+    for (let p = 0; p < MAX_PAGES; p++) {
+        const res = await fetchPending((0, relationship_candidate_query_1.buildPendingCandidateQuery)(workspaceId, doc, PAGE_LIMIT, cursor));
+        if (Array.isArray(res.items))
+            items.push(...res.items);
+        const nc = res.nextCursor;
+        if (!nc)
+            return { items, truncated: false };
+        if (typeof nc !== "object" || typeof nc.id !== "string" || nc.id === "") {
+            throw new Error("Malformed relationship-candidates cursor from control (missing id)");
+        }
+        const rawDate = nc.createdAt;
+        const createdAt = typeof rawDate === "string"
+            ? rawDate
+            : rawDate instanceof Date
+                ? rawDate.toISOString()
+                : null;
+        if (createdAt === null || Number.isNaN(Date.parse(createdAt))) {
+            throw new Error("Malformed relationship-candidates cursor from control (bad createdAt)");
+        }
+        cursor = { id: nc.id, createdAt };
+    }
+    return { items, truncated: true };
+}
+async function runKbPendingWith(argv, 
+// A-0c (A4 surface 2): onWorkspaceCount reports the WORKSPACE-WIDE pending count
+// so the production entrypoint can drop it in the local cache the prompt-submit
+// hook reads (Patch 8: no new hot-path network call; this count is free, we
+// already fetched the queue). Reported ONLY for a non-doc scope (a `--doc` view is
+// a subset and must never overwrite the cache) and ONLY when not truncated.
+// Injected so unit tests can spy without touching the real home.
+ctx, deps) {
+    let parsed;
+    try {
+        parsed = parseKbPendingArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const env = ctx.env ?? process.env;
+    // Resolve "default": a current session if one is available, else the full queue.
+    let effective = parsed.scope;
+    if (effective.kind === "default") {
+        const sid = (env.CLAUDE_CODE_SESSION_ID || "").trim();
+        effective = sid ? { kind: "session", value: "current" } : { kind: "workspace" };
+    }
+    // Resolve a session scope BEFORE the network call so a bad session fails fast.
+    let scope = null;
+    if (effective.kind === "session") {
+        if (!deps.loadSessionScope) {
+            console.error("--session is not supported in this context.");
+            return 2;
+        }
+        try {
+            scope = deps.loadSessionScope(effective.value, {
+                env,
+                workspaceId: ctx.workspaceId,
+                nowMs: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error(e.message);
+            return 2;
+        }
+    }
+    const docArg = effective.kind === "doc" ? effective.doc : null;
+    let all;
+    try {
+        all = await fetchAllPending(deps.fetchPending, ctx.workspaceId, docArg);
+    }
+    catch (e) {
+        console.error(`Failed to list pending candidates: ${e.message}`);
+        return 1;
+    }
+    // Cache the workspace count from the COMPLETE set (every non-doc scope) so the
+    // prompt-submit governance nudge reflects the true total, not a session subset.
+    // SKIP the write when truncated: all.items.length is then a floor ("fetched up to
+    // the cap"), not the exact count, and writing it as exact would lie. The cache
+    // value does not carry truncation metadata today, so leaving the prior value
+    // (possibly stale) beats overwriting it with a wrong-but-confident number. A
+    // 5000-candidate queue never happens at pilot scale; this is a backstop. If
+    // truncation ever becomes real, extend the cache to carry a `+`/truncated flag.
+    if (effective.kind !== "doc" && !all.truncated)
+        ctx.onWorkspaceCount?.(all.items.length);
+    let items = all.items;
+    let scopeNote = null;
+    let scopeMeta;
+    if (scope) {
+        const fetched = items.length;
+        items = items.filter((c) => (0, session_scope_1.candidateInSession)(c, scope.keys));
+        const label = scope.source === "current-env"
+            ? `your current session (${scope.sessionId})`
+            : `session ${scope.sessionId} (${scope.source})`;
+        scopeNote =
+            `Scoped to ${label}: ${items.length} of ${fetched} fetched candidate${fetched === 1 ? "" : "s"} ` +
+                `touch ${scope.keys.size} doc${scope.keys.size === 1 ? "" : "s"} this session produced. Use --all for the full workspace queue.`;
+        if (scope.keys.size === 0) {
+            scopeNote += " This session produced no indexed docs yet, so nothing is attributed to it.";
+        }
+        if (all.truncated) {
+            scopeNote += " WARNING: the workspace queue exceeded the fetch cap, so this session view may be incomplete.";
+        }
+        scopeMeta = {
+            kind: "session",
+            sessionId: scope.sessionId,
+            source: scope.source,
+            sessionDocCount: scope.keys.size,
+            fetchedCount: fetched,
+            displayedCount: items.length,
+            truncated: all.truncated,
+        };
+    }
+    else if (effective.kind === "doc") {
+        scopeMeta = {
+            kind: "doc",
+            doc: effective.doc,
+            fetchedCount: items.length,
+            displayedCount: items.length,
+            truncated: all.truncated,
+        };
+    }
+    else {
+        scopeMeta = {
+            kind: "workspace",
+            fetchedCount: items.length,
+            displayedCount: items.length,
+            truncated: all.truncated,
+        };
+    }
+    const view = buildPendingView(items, {
+        workspaceId: ctx.workspaceId,
+        consoleBase: ctx.consoleBase,
+        truncated: all.truncated,
+        scope: scopeMeta,
+        scopeNote,
+    });
+    console.log(parsed.json ? renderPendingJson(view) : renderPendingHuman(view));
+    return 0;
+}
+async function runKbPending(argv) {
+    let cfg;
+    try {
+        cfg = (0, config_1.loadWorkspaceConfig)();
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const consoleBase = (0, config_1.getConsoleUrl)(cfg);
+    const deps = {
+        fetchPending: (qs) => (0, http_1.get)(cfg, `/internal/v1/relationship-candidates?${qs}`, 12000),
+        loadSessionScope: (value, opts) => (0, session_scope_1.loadSessionScope)(value, opts),
+    };
+    return runKbPendingWith(argv, {
+        workspaceId: cfg.workspaceId,
+        consoleBase,
+        // A-0c: persist the workspace-wide count for the prompt-submit hook (surface 2).
+        onWorkspaceCount: (count) => (0, governance_cache_1.writePendingCountCache)(cfg.workspaceId, count),
+    }, deps);
+}
+// kb.ts dispatches the overloaded `review` verb (list mode) and the deprecated
+// `pending` alias through this same listing runner.
+exports.runKbReviewList = runKbPending;

package/dist/commands/kb_personal.js

@@ -0,0 +1,149 @@
+"use strict";
+// `mla kb personal list` / `mla kb personal show <id>` (Phase 3, Task 3.3).
+//
+// The owner-scoped view of a user's OWN Personal-KB documents.
+//
+//   list        -> GET /internal/v1/kb/documents?ownerUserId=<actor>&posture=SHADOW
+//                  Lists ONLY the configured actor's ACTIVE personal docs. The
+//                  owner is the configured actorUserId (readKbConfig), so a user
+//                  can never list another owner's docs from their own CLI.
+//   show <id>   -> reuse `mla kb show` (the existing single-doc detail path).
+//                  Personal docs render through the same §4.2 detail view; there
+//                  is no separate personal detail endpoint to maintain.
+//
+// Mirrors the kb_pending.ts deps-injection shape: a pure `runKbPersonalWith`
+// core takes an injected fetcher (and a show-delegate) so the unit test can
+// drive it without touching the network or the real config, while the public
+// `runKbPersonal` wrapper wires the real intelGet fetcher and the real
+// `runKbShow` delegate.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePersonalShowId = normalizePersonalShowId;
+exports.parseKbPersonalArgs = parseKbPersonalArgs;
+exports.buildPersonalQuery = buildPersonalQuery;
+exports.runKbPersonalWith = runKbPersonalWith;
+exports.runKbPersonal = runKbPersonal;
+const config_1 = require("../lib/config");
+const http_1 = require("../lib/http");
+const kb_show_1 = require("./kb_show");
+const USAGE = "Usage: mla kb personal list [--json] | mla kb personal show <id>";
+// The id `mla kb personal list` prints is a bare KbDocument cuid. `mla kb show`
+// (the show delegate) only skips path-resolution when its input parses as
+// `kbdoc:<id>`; a bare token is classified as a canonical PATH and 404s. So
+// normalize a bare id into the kbdoc: form before delegating, while passing an
+// already-prefixed artifact input (kbdoc:/kbdocrev:/note:) through untouched so
+// a power user who types the canonical form is never double-prefixed.
+const ARTIFACT_PREFIXES = ["kbdoc:", "kbdocrev:", "note:"];
+function normalizePersonalShowId(raw) {
+    const t = raw.trim();
+    if (ARTIFACT_PREFIXES.some((p) => t.startsWith(p)))
+        return t;
+    return `kbdoc:${t}`;
+}
+function parseKbPersonalArgs(argv) {
+    const sub = argv[0];
+    if (sub !== "list" && sub !== "show") {
+        throw new Error(`mla kb personal takes 'list' or 'show'. ${USAGE}`);
+    }
+    let id = null;
+    let json = false;
+    for (let i = 1; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json") {
+            json = true;
+        }
+        else if (a.startsWith("-")) {
+            throw new Error(`Unknown flag: ${a}. ${USAGE}`);
+        }
+        else if (sub === "show" && id === null) {
+            id = a;
+        }
+        else {
+            throw new Error(`Unexpected argument: ${a}. ${USAGE}`);
+        }
+    }
+    if (sub === "show" && id === null) {
+        throw new Error(`mla kb personal show requires a document id. ${USAGE}`);
+    }
+    return { sub, id, json };
+}
+// Build the owner-scoped list query. Always pins posture=SHADOW: personal docs
+// are SHADOW-posture by construction (agent-distilled / private), so the list is
+// the user's private shadow corpus, never the shared LIVE workspace docs. The
+// owner is stamped explicitly so the server filters to this caller's rows only.
+function buildPersonalQuery(workspaceId, ownerUserId) {
+    const qs = new URLSearchParams();
+    qs.set("workspaceId", workspaceId);
+    qs.set("ownerUserId", ownerUserId);
+    qs.set("posture", "SHADOW");
+    return qs.toString();
+}
+function renderPersonalHuman(ws, owner, docs) {
+    if (docs.length === 0) {
+        return `No personal KB documents for ${owner} (workspace ${ws}).`;
+    }
+    const lines = [];
+    const n = docs.length;
+    lines.push(`${n} personal KB document${n === 1 ? "" : "s"} for ${owner} (workspace ${ws}):`);
+    lines.push("");
+    for (const d of docs) {
+        const path = d.canonicalPath ?? "(no path)";
+        const posture = d.currentPosture ?? "?";
+        lines.push(`  ${d.id}`);
+        lines.push(`    ${path}  [${posture}]  updated ${d.updatedAt}`);
+    }
+    lines.push("");
+    lines.push("Inspect one: mla kb personal show <id>");
+    return lines.join("\n");
+}
+async function runKbPersonalWith(argv, ctx, deps) {
+    let parsed;
+    try {
+        parsed = parseKbPersonalArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return { documents: [], code: 2 };
+    }
+    if (parsed.sub === "show") {
+        // Reuse the existing single-doc detail path. The id is normalized to the
+        // kbdoc: form first (see normalizePersonalShowId): the bare cuid `list`
+        // prints would otherwise be treated as a path by `mla kb show` and 404.
+        const code = await deps.showDocument(normalizePersonalShowId(parsed.id));
+        return { documents: [], code };
+    }
+    // list
+    let resp;
+    try {
+        resp = await deps.fetchPersonal(buildPersonalQuery(ctx.workspaceId, ctx.ownerUserId));
+    }
+    catch (e) {
+        console.error(`Failed to list personal KB documents: ${e.message}`);
+        return { documents: [], code: 1 };
+    }
+    const documents = resp.documents ?? [];
+    if (parsed.json) {
+        console.log(JSON.stringify({ workspaceId: ctx.workspaceId, ownerUserId: ctx.ownerUserId, documents }, null, 2));
+    }
+    else {
+        console.log(renderPersonalHuman(ctx.workspaceId, ctx.ownerUserId, documents));
+    }
+    return { documents, code: 0 };
+}
+async function runKbPersonal(argv) {
+    let cfg;
+    try {
+        cfg = (0, config_1.readKbConfig)();
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const deps = {
+        fetchPersonal: (qs) => (0, http_1.intelGet)(cfg, `/internal/v1/kb/documents?${qs}`, 12000),
+        // Delegate to `mla kb show <id>`: the single-doc detail path is reused
+        // wholesale, including its resolve/poll handling and exit codes.
+        showDocument: (id) => (0, kb_show_1.runKbShow)([id]),
+    };
+    const result = await runKbPersonalWith(argv, { workspaceId: cfg.workspaceId, ownerUserId: cfg.actorUserId }, deps);
+    return result.code;
+}