@meetless/mla 0.1.4

package/dist/commands/summary.js

@@ -0,0 +1,250 @@
+"use strict";
+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.parseSummaryArgs = parseSummaryArgs;
+exports.runSummary = runSummary;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// `mla summary` -- aggregate view over the hook's enrichment trace JSONL
+// (T18b, §6.9). Counts/latency/cost/labels across the most recent N prompts.
+//
+//   mla summary [--last N] [--json] [--all]
+//
+// By default it auto-scopes to the CURRENT session via CLAUDE_CODE_SESSION_ID
+// (the env var the parent Claude Code shell exports, same as `mla review`), so
+// there is deliberately NO `--session` flag: the shell already told us which
+// session this is. `--all` opts back out to the cross-session aggregate; when
+// run outside a session (var unset) it defaults to global.
+//
+// Was `mla traces summarize`; the `traces show`/`traces label` subcommands were
+// removed 2026-05-31. Per-trace inspection is unnecessary from the CLI: every
+// enrichment writes its trace_id to ~/.meetless/logs/ask-traces.jsonl AND the
+// same id is printed live on each prompt's `<meetless-context trace="...">`
+// block, so the operator pins a run via the prompt or `jq`/`tail` over the
+// JSONL and opens it in the Langfuse dashboard. This command stays as the only
+// thing the JSONL can't trivially give you by hand: the rolled-up aggregates.
+//
+// The trace line schema is produced by user-prompt-submit.sh write_trace(); we
+// read only the fields we tally and treat everything as optional/best-effort so
+// a partially-written or future-extended line never crashes the summary.
+// Paths are resolved lazily from MEETLESS_HOME (same fallback as lib/config's
+// HOME) so the short-lived CLI process picks up the operator's env, and tests
+// can point at a temp dir without module-cache tricks.
+function logDir() {
+    return path.join(process.env.MEETLESS_HOME || path.join(os.homedir(), ".meetless"), "logs");
+}
+function tracesFile() {
+    return path.join(logDir(), "ask-traces.jsonl");
+}
+function readLines() {
+    if (!fs.existsSync(tracesFile()))
+        return [];
+    return fs
+        .readFileSync(tracesFile(), "utf8")
+        .split("\n")
+        .filter((l) => l.trim().length > 0);
+}
+function parse(line) {
+    try {
+        const o = JSON.parse(line);
+        return o && typeof o === "object" ? o : null;
+    }
+    catch {
+        return null;
+    }
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function percentile(sortedAsc, p) {
+    if (sortedAsc.length === 0)
+        return 0;
+    const idx = Math.ceil(p * sortedAsc.length) - 1;
+    return sortedAsc[Math.min(sortedAsc.length - 1, Math.max(0, idx))];
+}
+function isLabeled(l) {
+    if (!l)
+        return false;
+    return (l.useful === true ||
+        l.noisy === true ||
+        l.harmful === true ||
+        l.prevented_mistake === true ||
+        (typeof l.notes === "string" && l.notes.trim().length > 0));
+}
+function parseSummaryArgs(argv) {
+    const out = { last: 20, json: false, all: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json")
+            out.json = true;
+        else if (a === "--all")
+            out.all = true;
+        else if (a === "--last") {
+            const v = argv[++i];
+            const parsed = Number(v);
+            if (!v || !Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error(`--last requires a positive integer (got: ${v ?? "(none)"})`);
+            }
+            out.last = parsed;
+        }
+        else
+            throw new Error(`Unknown flag for \`mla summary\`: ${a}`);
+    }
+    return out;
+}
+function buildSummary(traces) {
+    let injected = 0;
+    let discarded = 0;
+    let failOpen = 0;
+    let timeouts = 0;
+    let totalCost = 0;
+    const latencies = [];
+    const injectedChars = [];
+    const strategies = {};
+    let useful = 0;
+    let noisy = 0;
+    let harmful = 0;
+    let labeled = 0;
+    for (const t of traces) {
+        const decision = t.arbitration?.decision ?? "";
+        if (decision === "injected")
+            injected++;
+        if (t.arbitration?.discarded_after_compute === true)
+            discarded++;
+        if (decision === "fail_open")
+            failOpen++;
+        const failReason = t.hook?.fail_open_reason ?? "";
+        if (failReason === "timeout" || t.enrichment?.status === "timeout")
+            timeouts++;
+        const lat = num(t.enrichment?.latency_ms);
+        if (lat !== null)
+            latencies.push(lat);
+        const cost = num(t.enrichment?.cost_usd);
+        if (cost !== null)
+            totalCost += cost;
+        if (decision === "injected") {
+            const chars = num(t.hook?.injected_chars);
+            if (chars !== null)
+                injectedChars.push(chars);
+        }
+        const strat = t.experiment?.variant || t.enrichment?.strategy || "unknown";
+        strategies[strat] = (strategies[strat] ?? 0) + 1;
+        const ol = t.operator_label;
+        if (ol?.useful === true)
+            useful++;
+        if (ol?.noisy === true)
+            noisy++;
+        if (ol?.harmful === true)
+            harmful++;
+        if (isLabeled(ol))
+            labeled++;
+    }
+    latencies.sort((a, b) => a - b);
+    const avgLat = latencies.length ? latencies.reduce((s, v) => s + v, 0) / latencies.length : 0;
+    const p95Lat = percentile(latencies, 0.95);
+    const avgChars = injectedChars.length
+        ? Math.round(injectedChars.reduce((s, v) => s + v, 0) / injectedChars.length)
+        : 0;
+    const timeoutRate = traces.length ? timeouts / traces.length : 0;
+    return {
+        prompt_count: traces.length,
+        injected,
+        discarded_after_compute: discarded,
+        fail_open: failOpen,
+        avg_enrichment_latency_ms: Math.round(avgLat),
+        p95_enrichment_latency_ms: p95Lat,
+        timeout_rate: timeoutRate,
+        total_cost_usd: totalCost,
+        avg_injected_chars: avgChars,
+        strategies,
+        operator_labels: { useful, noisy, harmful, unlabeled: traces.length - labeled },
+    };
+}
+function renderSummary(s) {
+    const secs = (ms) => (ms / 1000).toFixed(1) + "s";
+    const pct = (r) => (r * 100).toFixed(0) + "%";
+    const strat = Object.entries(s.strategies)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(" ");
+    return [
+        `Prompt count: ${s.prompt_count}`,
+        `Injected: ${s.injected}   Discarded after compute: ${s.discarded_after_compute}   Fail-open: ${s.fail_open}`,
+        `Avg enrichment latency: ${secs(s.avg_enrichment_latency_ms)}   P95: ${secs(s.p95_enrichment_latency_ms)}   Timeout rate: ${pct(s.timeout_rate)}`,
+        `Total cost: $${s.total_cost_usd.toFixed(2)}   Avg injected chars: ${s.avg_injected_chars}   Strategies: ${strat || "(none)"}`,
+        `Operator labels: ${s.operator_labels.useful} useful / ${s.operator_labels.noisy} noisy / ${s.operator_labels.harmful} harmful / ${s.operator_labels.unlabeled} unlabeled`,
+    ].join("\n");
+}
+function runSummary(argv) {
+    let args;
+    try {
+        args = parseSummaryArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const lines = readLines();
+    if (lines.length === 0) {
+        console.error(`No traces found at ${tracesFile()}.`);
+        return 1;
+    }
+    let traces = lines.map(parse).filter((t) => t !== null);
+    // Auto-scope to the current live session. The parent shell (Claude Code)
+    // exports CLAUDE_CODE_SESSION_ID, the same var `mla review` binds to, so the
+    // operator never passes a session id by hand. `--all` opts back out to the
+    // cross-session aggregate; outside a session (var unset) we default to global
+    // since there is no current session to scope to. Scope BEFORE --last so the
+    // window is "last N of this session", not "last N overall then filtered".
+    const session = (process.env.CLAUDE_CODE_SESSION_ID || "").trim();
+    const scoped = !args.all && session.length > 0;
+    if (scoped)
+        traces = traces.filter((t) => t.session_id === session);
+    if (traces.length === 0) {
+        console.error(scoped
+            ? `No traces for the current session (${session}) at ${tracesFile()}. Use --all for every session.`
+            : `No traces found at ${tracesFile()}.`);
+        return 1;
+    }
+    traces = traces.slice(-args.last);
+    const summary = buildSummary(traces);
+    if (args.json) {
+        console.log(JSON.stringify(summary, null, 2));
+    }
+    else {
+        console.log(renderSummary(summary));
+    }
+    return 0;
+}

package/dist/commands/turn.js

@@ -0,0 +1,114 @@
+"use strict";
+// `mla turn [N]` -- the operator-facing per-turn assist recap (Layer B of
+// notes/20260609-mla-per-turn-assist-recap-plan.md). The cheap, always-available,
+// zero-model-cost answer to "how did mla do?" for a single turn:
+//
+//   mla turn               recap the latest completed turn of the current session
+//   mla turn 5             recap turn 5
+//   mla turn --session X   target another session
+//   mla turn 5 --json      machine output (the full TurnRecap)
+//
+// It reads the same three local spool files as `mla stats` and computes the recap
+// via Layer A computeTurnRecap. `mla stats --turn [N]` is wired to this same
+// handler (commands/stats.ts) so the feature is discoverable from the stats surface
+// An framed it against. Unlike `mla _internal turn-recap` (fail-soft for the hook),
+// this is a human read: a strict argv error exits 2, a missing session exits 1.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTurnArgs = parseTurnArgs;
+exports.latestTurnIndex = latestTurnIndex;
+exports.runTurn = runTurn;
+const followthrough_1 = require("../lib/analytics/followthrough");
+const logs_1 = require("../lib/analytics/logs");
+const turn_recap_1 = require("../lib/analytics/turn-recap");
+function parseTurnArgs(argv) {
+    const out = { session: null, turn: null, json: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            case "--session":
+                out.session = argv[++i] ?? "";
+                if (!out.session)
+                    throw new Error("--session requires a value");
+                break;
+            case "--json":
+                out.json = true;
+                break;
+            default: {
+                // A number-shaped token (including a leading '-' or a decimal) is a
+                // turn-index candidate, so `mla turn -1` / `mla turn 1.5` report a clear
+                // turn error rather than the misleading "unknown flag". A non-numeric
+                // leading-dash token is a genuine unknown flag.
+                const numeric = /^-?\d*\.?\d+$/.test(a);
+                if (!numeric && a.startsWith("-"))
+                    throw new Error(`Unknown flag for \`mla turn\`: ${a}`);
+                if (out.turn !== null)
+                    throw new Error("`mla turn` takes one turn index at most");
+                if (!/^[0-9]+$/.test(a) || Number(a) < 1) {
+                    throw new Error(`turn index must be a positive integer: ${a}`);
+                }
+                out.turn = Number(a);
+            }
+        }
+    }
+    return out;
+}
+// The latest turn that left ANY trace on disk for this session: the max turn_index
+// across the three spool files (the inject side, the pull side, the cite side).
+// Reading all three (not just ask-traces) means a turn that only produced a pull or
+// a citation still counts as the latest, and a NOT_RUN turn whose minimal trace
+// line landed is found too. Returns null when the session has no turns yet.
+function latestTurnIndex(sessionId, readLog) {
+    let max = null;
+    const bump = (t) => {
+        if (max === null || t > max)
+            max = t;
+    };
+    for (const raw of readLog("ask-traces.jsonl")) {
+        const t = (0, turn_recap_1.parseAskTrace)(raw);
+        if (t && t.session_id === sessionId)
+            bump(t.turn_index);
+    }
+    for (const c of (0, followthrough_1.parseMcpCalls)(readLog("mcp-calls.jsonl"))) {
+        if (c.session_id === sessionId)
+            bump(c.turn_index);
+    }
+    for (const r of (0, followthrough_1.parseReportCitations)(readLog("report-citations.jsonl"))) {
+        if (r.session_id === sessionId)
+            bump(r.turn_index);
+    }
+    return max;
+}
+async function runTurn(argv, deps = {}) {
+    const log = deps.log ?? ((l) => console.log(l));
+    const err = deps.err ?? ((l) => console.error(l));
+    let args;
+    try {
+        args = parseTurnArgs(argv);
+    }
+    catch (e) {
+        err(e.message);
+        return 2;
+    }
+    const env = deps.env ?? process.env;
+    const session = (args.session ?? env.CLAUDE_CODE_SESSION_ID ?? "").trim();
+    if (!session) {
+        err("No session id provided and no $CLAUDE_CODE_SESSION_ID env. " +
+            "Run `mla turn` inside a Claude Code session, or pass --session <sid>.");
+        return 1;
+    }
+    const readLog = deps.readLog ?? logs_1.readLogJsonl;
+    const turn = args.turn ?? latestTurnIndex(session, readLog);
+    if (turn === null) {
+        log(`No turns recorded for session ${session} yet.`);
+        return 0;
+    }
+    const compute = deps.compute ?? ((s, t) => (0, turn_recap_1.computeTurnRecap)(s, t, { readLog }));
+    const recap = compute(session, turn);
+    if (args.json) {
+        log(JSON.stringify(recap, null, 2));
+    }
+    else {
+        log((0, turn_recap_1.renderBlock)(recap));
+    }
+    return 0;
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,222 @@
+"use strict";
+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.runUninstall = runUninstall;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const config_1 = require("../lib/config");
+const unwire_1 = require("../lib/unwire");
+const flush_1 = require("./flush");
+function defaultConfirm(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const n = answer.trim().toLowerCase();
+            resolve(n === "y" || n === "yes");
+        });
+    });
+}
+function defaultChoose(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const n = answer.trim().toLowerCase();
+            if (n === "f" || n === "flush")
+                resolve("flush");
+            else if (n === "d" || n === "delete")
+                resolve("delete");
+            else
+                resolve("cancel");
+        });
+    });
+}
+async function runUninstall(argv, deps = {}) {
+    const log = deps.log ?? ((m) => console.log(m));
+    const errlog = deps.errlog ?? ((m) => console.error(m));
+    let dryRun = false;
+    let yes = false;
+    for (const a of argv) {
+        if (a === "--dry-run")
+            dryRun = true;
+        else if (a === "--yes" || a === "-y")
+            yes = true;
+        else {
+            errlog(`Unknown flag for \`mla uninstall\`: ${a}. Usage: mla uninstall [--dry-run] [--yes]`);
+            return 2;
+        }
+    }
+    const home = deps.home ?? config_1.HOME;
+    const settingsPath = deps.settingsPath ?? path.join(os.homedir(), ".claude", "settings.json");
+    const claudeJsonPath = deps.claudeJsonPath ?? path.join(os.homedir(), ".claude.json");
+    const skillDir = deps.skillDir ?? path.join(os.homedir(), ".claude", "skills", "mla");
+    const queueDir = deps.queueDir ?? config_1.QUEUE_DIR;
+    const isTTY = deps.isTTY ?? Boolean(process.stdin.isTTY);
+    const env = deps.env ?? process.env;
+    const countQueued = deps.countQueued ?? unwire_1.countQueuedSessions;
+    const countEvents = deps.countEvents ?? unwire_1.countQueuedEvents;
+    const homeExists = deps.homeExists ?? ((p) => fs.existsSync(p));
+    const skillExists = deps.skillExists ?? ((p) => fs.existsSync(p));
+    const resolveBinary = deps.resolveBinary ?? unwire_1.resolveMlaBinary;
+    const removeHooks = deps.removeHooks ?? unwire_1.removeMeetlessHooks;
+    const removeMcp = deps.removeMcp ?? unwire_1.removeMeetlessMcp;
+    const removeDir = deps.removeDir ?? unwire_1.removeDir;
+    const confirm = deps.confirm ?? defaultConfirm;
+    const choose = deps.choose ?? defaultChoose;
+    const flush = deps.flush ?? flush_1.runFlush;
+    const queued = countQueued(queueDir);
+    const events = countEvents(queueDir);
+    const { binPath, realPath } = resolveBinary(env);
+    // 1. Render the plan.
+    log("mla uninstall will remove the local Meetless footprint:");
+    log(`  - ${home}  (config, credentials, queue, hooks, logs, telemetry)`);
+    log(`  - the Meetless hook entries in ${settingsPath}`);
+    log(`  - the "meetless" MCP server in ${claudeJsonPath}`);
+    if (skillExists(skillDir))
+        log(`  - ${skillDir}  (the /mla skill)`);
+    log("");
+    log("Left in place on purpose:");
+    log("  - any of your own hooks or MCP servers (only Meetless's entries are removed)");
+    log("  - .meetless.json + the CLAUDE.md rule block in other repos (non-secret).");
+    log("    Remove those per repo with: rm .meetless.json  (and delete the");
+    log("    `BEGIN MEETLESS RULES` ... `END MEETLESS RULES` block from CLAUDE.md)");
+    log("");
+    if (dryRun) {
+        // Disclose un-flushed captured events the real run would put at risk, so the
+        // preview names what is lost by its honest magnitude (event count, not file
+        // count). Stay silent when no un-flushed events remain: a counted session
+        // file can be fully drained and hold nothing to lose.
+        if (events > 0) {
+            log(`Note: the local queue holds ${events} captured event(s) across ${queued} session(s) not yet flushed to the server.`);
+            log("The real run will offer to flush, delete, or cancel before anything is removed.");
+            log("");
+        }
+        // Preview the one manual step uninstall leaves behind, so --dry-run shows
+        // the complete footprint and never undersells what stays on disk.
+        log("After removal, one manual step remains: remove the `mla` binary yourself:");
+        for (const line of (0, unwire_1.detectBinaryRemovalHint)(binPath, realPath))
+            log(line);
+        log("");
+        log("(dry run: nothing was changed.)");
+        return 0;
+    }
+    // 2. Gate. Non-interactive requires --yes.
+    if (!yes && !isTTY) {
+        errlog("Refusing to uninstall non-interactively. Re-run with --yes to proceed (or --dry-run to preview).");
+        return 2;
+    }
+    // 3. Un-flushed-event safety (interactive only; --yes warns and proceeds).
+    // Gate on the event count, not the file count: drained-but-lingering session
+    // files carry nothing to lose, so they must not trigger a data-loss prompt.
+    if (events > 0) {
+        log(`Warning: the local queue holds ${events} captured event(s) across ${queued} session(s) not yet flushed to the server.`);
+        if (yes) {
+            log("Proceeding under --yes; this unflushed data will be deleted.");
+        }
+        else {
+            const choice = await choose("[f]lush now, [d]elete anyway, or [c]ancel? ");
+            if (choice === "cancel") {
+                log("Cancelled. Nothing was changed.");
+                return 0;
+            }
+            if (choice === "flush") {
+                log("Flushing queued sessions...");
+                const rc = await flush([]);
+                if (rc !== 0) {
+                    errlog("Flush did not complete cleanly. Cancelling uninstall so no data is lost. Resolve the flush, then re-run.");
+                    return 1;
+                }
+            }
+        }
+    }
+    // 4. Final confirmation (skipped under --yes).
+    if (!yes) {
+        const ok = await confirm("Remove the Meetless local install? [y/N] ");
+        if (!ok) {
+            log("Cancelled. Nothing was changed.");
+            return 0;
+        }
+    }
+    // 5. Execute. Strip wiring BEFORE deleting HOME. Each step best-effort.
+    let hadError = false;
+    const hooksRes = removeHooks(settingsPath);
+    if (hooksRes.changed) {
+        log(`Removed Meetless hooks (${hooksRes.removed.join(", ")}) from ${settingsPath}` +
+            (hooksRes.backupPath ? ` (backup: ${hooksRes.backupPath})` : ""));
+    }
+    else {
+        log(`No Meetless hooks found in ${settingsPath}.`);
+    }
+    const mcpRes = removeMcp(claudeJsonPath);
+    if (mcpRes.changed) {
+        log(`Removed the "meetless" MCP server from ${claudeJsonPath}` +
+            (mcpRes.backupPath ? ` (backup: ${mcpRes.backupPath})` : ""));
+    }
+    else {
+        log(`No "meetless" MCP server found in ${claudeJsonPath}.`);
+    }
+    if (skillExists(skillDir)) {
+        const r = removeDir(skillDir);
+        if (r.error) {
+            hadError = true;
+            errlog(`Could not remove ${skillDir}: ${r.error}`);
+        }
+        else {
+            log(`Removed ${skillDir}.`);
+        }
+    }
+    if (homeExists(home)) {
+        const r = removeDir(home);
+        if (r.error) {
+            hadError = true;
+            errlog(`Could not remove ${home}: ${r.error}`);
+        }
+        else {
+            log(`Removed ${home}.`);
+        }
+    }
+    else {
+        log(`${home} was already absent.`);
+    }
+    // 6. Binary: print, never self-delete.
+    log("");
+    log("Local state is gone. One step left, to remove the `mla` binary itself:");
+    for (const line of (0, unwire_1.detectBinaryRemovalHint)(binPath, realPath))
+        log(line);
+    return hadError ? 1 : 0;
+}

package/dist/commands/whoami.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWhoami = runWhoami;
+const config_1 = require("../lib/config");
+const http_1 = require("../lib/http");
+// Best-effort humanizer for an ISO expiry. Mirrors login.ts formatRemaining:
+// null for an unparseable/absent timestamp so callers degrade gracefully.
+function formatExpiry(iso) {
+    if (!iso)
+        return "unknown";
+    const ms = Date.parse(iso) - Date.now();
+    if (Number.isNaN(ms))
+        return "unknown";
+    if (ms <= 0)
+        return "expired";
+    const hours = Math.floor(ms / (60 * 60 * 1000));
+    if (hours < 48)
+        return `in ~${hours}h`;
+    return `in ~${Math.floor(hours / 24)}d`;
+}
+async function runWhoami(argv, deps = {}) {
+    if (argv.length > 0) {
+        console.error(`\`mla whoami\` takes no arguments (got: ${argv.join(" ")}).`);
+        return 2;
+    }
+    const log = deps.log ?? ((m) => console.log(m));
+    const getMeFn = deps.getMeFn ?? ((cfg) => (0, http_1.get)(cfg, "/internal/v1/auth/me"));
+    // `auth.mode: none` is also the shape of a box that never ran `mla init`.
+    if (!(0, config_1.configExists)()) {
+        log("Not configured (no cli-config.json).");
+        log("Run `mla init --control-token <T>` or `mla login` to get started.");
+        return 1;
+    }
+    let cfg;
+    try {
+        cfg = (0, config_1.readConfig)();
+    }
+    catch (e) {
+        console.error(e.message);
+        return 1;
+    }
+    if (cfg.auth.mode === "none") {
+        log("Not configured (auth.mode: none).");
+        log("Run `mla init --control-token <T>` or `mla login` to log in.");
+        return 1;
+    }
+    if (cfg.auth.mode === "shared-key") {
+        // A shared key authenticates AS the workspace's internal key; there is no
+        // user behind it. Print the mode + the folder/config workspace without a
+        // network call (the §6.6 contract: "does NOT call /auth/me").
+        log("auth.mode: shared-key (no user identity)");
+        log(`  Control:   ${cfg.controlUrl}`);
+        if (cfg.workspaceId) {
+            log(`  Workspace: ${cfg.workspaceId} (from cli-config.json)`);
+        }
+        else {
+            log("  Workspace: resolved per-folder from .meetless.json (run `mla workspace`)");
+        }
+        return 0;
+    }
+    // user-token: resolve live identity from control.
+    let me;
+    try {
+        me = await getMeFn(cfg);
+    }
+    catch (e) {
+        const err = e;
+        if (err.status === 401) {
+            // After T27's auto-refresh has tried and failed, a 401 means the session
+            // is gone (expired or revoked). Point the operator at re-login.
+            console.error("Your CLI session has expired or was revoked. Run `mla login`.");
+            return 1;
+        }
+        // Network failure, control down, or unexpected status. The cached identity
+        // is still useful, so print it with a clear "could not reach control" note
+        // rather than failing blind.
+        console.error(`Could not reach control to verify the session (${err.message}).`);
+        const who = cfg.auth.user.displayName || cfg.auth.user.id;
+        const email = cfg.auth.user.email ? ` <${cfg.auth.user.email}>` : "";
+        log(`Cached identity: ${who}${email} (role ${cfg.auth.user.role}, unverified).`);
+        return 1;
+    }
+    if (me.mode === "shared-key" || !me.user) {
+        // Should not happen for a user-token bearer, but stay honest if control
+        // reports shared-key (e.g. the token happened to equal INTERNAL_API_KEY).
+        log("auth.mode: shared-key (no user identity)");
+        return 0;
+    }
+    const email = me.user.email ? ` <${me.user.email}>` : "";
+    log(`Logged in as ${me.user.displayName}${email}.`);
+    log(`  User:      ${me.user.id}`);
+    log(`  Role:      ${me.user.role}`);
+    if (me.workspace) {
+        log(`  Workspace: ${me.workspace.name} (${me.workspace.slug})`);
+    }
+    if (me.sessionId) {
+        log(`  Session:   ${me.sessionId}`);
+    }
+    log(`  Access token expires ${formatExpiry(me.accessExpiresAt)}.`);
+    log(`  Refresh token expires ${formatExpiry(me.refreshExpiresAt)}.`);
+    return 0;
+}