@meetless/mla 0.1.4

package/dist/commands/stats.js

@@ -0,0 +1,479 @@
+"use strict";
+// `mla stats` -- the usefulness-first local dashboard (spec §7). It reads the
+// append-only ~/.meetless/events.jsonl (INV-LOCAL-STATS-1: works with all remote
+// switches off) and answers "did mla help", not "did mla run". Every headline is
+// value; activity (commands run, KB size) is a --verbose footnote (Thesis B).
+//
+//   mla stats               this workspace, last 30 days (the ROI default window)
+//   mla stats evidence      the adoption join, focused (alias of `mla adoption`)
+//   mla stats --window 7d   configurable window
+//   mla stats --json        machine-readable
+//   mla stats --verbose     append the activity footnote
+//   mla stats --global      server-aggregated (handled in Phase 6 / T6.2)
+//
+// `mla stats evidence` and `mla adoption` route through the SAME runAdoption code
+// path (INV-ADOPTION-SOURCE-1: one join, two entry points), so the §10.5 parity
+// row holds by construction, not by a second implementation.
+//
+// The delayed-outcome trap (§7.4, INV-LOCAL-STATS-2): an inject is written
+// immediately but its outcome lands only once the window closes (3 turns or 15
+// minutes later). Rendering in between must count the inject in the denominator as
+// `pending`, never drop it and never silently call it ignored. We window-filter
+// the INJECTS (the denominator population) and attach each inject's outcome by
+// inject_id regardless of when the outcome was written, so an inject near the
+// window edge keeps its later verdict instead of being undercounted.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStatsArgs = parseStatsArgs;
+exports.buildDashboard = buildDashboard;
+exports.renderDashboard = renderDashboard;
+exports.renderGlobalDashboard = renderGlobalDashboard;
+exports.translateTurnAlias = translateTurnAlias;
+exports.runStats = runStats;
+const metrics_1 = require("../lib/analytics/metrics");
+const followthrough_1 = require("../lib/analytics/followthrough");
+const store_1 = require("../lib/analytics/store");
+const recorder_1 = require("../lib/analytics/recorder");
+const consent_1 = require("../lib/analytics/consent");
+const config_1 = require("../lib/config");
+const workspace_1 = require("../lib/workspace");
+const http_1 = require("../lib/http");
+const adoption_1 = require("./adoption");
+const turn_1 = require("./turn");
+const DEFAULT_WINDOW_DAYS = 30;
+// Parse `--window 7d` / `--window 30` (bare integer = days). Days only in v1; the
+// ROI report and §7.2 examples are all day-grained.
+function parseWindow(raw) {
+    if (raw === undefined)
+        throw new Error("--window requires a value (e.g. 7d, 30d, 30)");
+    const m = /^(\d+)(d)?$/.exec(raw.trim());
+    if (!m)
+        throw new Error(`--window must be a positive number of days (e.g. 7d, 30d). Got: ${raw}`);
+    const days = Number(m[1]);
+    if (!Number.isInteger(days) || days <= 0) {
+        throw new Error(`--window must be a positive number of days. Got: ${raw}`);
+    }
+    return { days, label: `${days}d` };
+}
+function parseStatsArgs(argv) {
+    const out = {
+        section: null,
+        windowDays: DEFAULT_WINDOW_DAYS,
+        windowLabel: `${DEFAULT_WINDOW_DAYS}d`,
+        json: false,
+        verbose: false,
+        global: false,
+        rest: [],
+    };
+    let i = 0;
+    // A leading bare token is the section selector. `evidence` is the only section
+    // in v1; once selected, the remaining argv belongs to that section's handler.
+    if (argv[i] !== undefined && !argv[i].startsWith("-")) {
+        const section = argv[i];
+        if (section !== "evidence") {
+            throw new Error(`Unknown \`mla stats\` section: ${section} (known: evidence)`);
+        }
+        out.section = "evidence";
+        out.rest = argv.slice(i + 1);
+        return out;
+    }
+    for (; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json")
+            out.json = true;
+        else if (a === "--verbose")
+            out.verbose = true;
+        else if (a === "--global")
+            out.global = true;
+        else if (a === "--window") {
+            const w = parseWindow(argv[++i]);
+            out.windowDays = w.days;
+            out.windowLabel = w.label;
+        }
+        else
+            throw new Error(`Unknown flag for \`mla stats\`: ${a}`);
+    }
+    return out;
+}
+function inWindow(iso, startMs, nowMs) {
+    const t = Date.parse(iso);
+    return Number.isFinite(t) && t >= startMs && t <= nowMs;
+}
+// Latest outcome per inject_id (highest outcome_version wins; ties keep the last
+// written). A recomputed outcome (bumped version) supersedes its predecessor.
+function latestOutcomes(events) {
+    const byInject = new Map();
+    for (const e of events) {
+        if (e.event_type !== "mla_evidence_outcome")
+            continue;
+        const o = e;
+        const prev = byInject.get(o.inject_id);
+        if (!prev || o.outcome_version >= prev.outcome_version)
+            byInject.set(o.inject_id, o);
+    }
+    return byInject;
+}
+function buildDashboard(events, windowDays, nowMs) {
+    const startMs = nowMs - windowDays * 24 * 60 * 60 * 1000;
+    // Window the inject population (the denominator). Outcomes are attached by id
+    // below, NOT window-filtered, so a late-closing window is not undercounted.
+    const injects = events.filter((e) => e.event_type === "mla_evidence_inject" && inWindow(e.created_at, startMs, nowMs));
+    const outcomes = latestOutcomes(events);
+    const metricInputs = injects.map((inj) => {
+        const o = outcomes.get(inj.inject_id);
+        return {
+            evidence_offered: inj.evidence_offered,
+            offered_source_ids: inj.offered_source_ids ?? [],
+            referenced: o?.referenced ?? false,
+            referenced_source_ids: o?.referenced_source_ids ?? [],
+            outcome: o?.outcome ?? "pending",
+        };
+    });
+    const evidence = (0, metrics_1.computeMetrics)(metricInputs);
+    // Section 2: contradictions caught (Phase 7 emits these; empty until then).
+    let contradictions_surfaced = 0;
+    let contradictions_acted_on = 0;
+    for (const e of events) {
+        if (e.event_type !== "mla_contradiction" || !inWindow(e.created_at, startMs, nowMs))
+            continue;
+        if (e.contradiction_surfaced)
+            contradictions_surfaced++;
+        if (e.contradiction_acted_on)
+            contradictions_acted_on++;
+    }
+    // Section 3: local governance signal (review decisions). The authoritative
+    // governed-change/propagation count is server-side (--global).
+    let review_decisions = 0;
+    for (const e of events) {
+        if (e.event_type === "mla_review_decision" && inWindow(e.created_at, startMs, nowMs))
+            review_decisions++;
+    }
+    // Section 4: coverage gaps by type, sorted by demand (most frequent first).
+    const gapCounts = new Map();
+    for (const e of events) {
+        if (e.event_type !== "mla_coverage_gap" || !inWindow(e.created_at, startMs, nowMs))
+            continue;
+        gapCounts.set(e.coverage_gap_type, (gapCounts.get(e.coverage_gap_type) ?? 0) + 1);
+    }
+    const coverage_gaps = Array.from(gapCounts.entries())
+        .map(([type, count]) => ({ type, count }))
+        .sort((a, b) => b.count - a.count || a.type.localeCompare(b.type));
+    const coverage_gaps_total = coverage_gaps.reduce((s, g) => s + g.count, 0);
+    // Section 5: load-bearing knowledge -- referenced source ids across the
+    // windowed injects' outcomes, counted by the same normId rule the join uses so
+    // "NT:foo.md" and "NT:foo" collapse. Local renders the id; remote never sees it.
+    const refCounts = new Map();
+    for (const inj of injects) {
+        const o = outcomes.get(inj.inject_id);
+        if (!o)
+            continue;
+        for (const id of o.referenced_source_ids ?? []) {
+            const key = (0, followthrough_1.normId)(id);
+            const prev = refCounts.get(key);
+            if (prev)
+                prev.count++;
+            else
+                refCounts.set(key, { id, count: 1 });
+        }
+    }
+    const load_bearing = Array.from(refCounts.values())
+        .map((r) => ({ source_id: r.id, reference_count: r.count }))
+        .sort((a, b) => b.reference_count - a.reference_count || a.source_id.localeCompare(b.source_id))
+        .slice(0, 5);
+    // Section 6: activity footnote (commands run by name).
+    const cmdCounts = new Map();
+    let commands_total = 0;
+    for (const e of events) {
+        if (e.event_type !== "mla_command" || !inWindow(e.created_at, startMs, nowMs))
+            continue;
+        commands_total++;
+        cmdCounts.set(e.command, (cmdCounts.get(e.command) ?? 0) + 1);
+    }
+    const commands_by_name = Array.from(cmdCounts.entries())
+        .map(([command, count]) => ({ command, count }))
+        .sort((a, b) => b.count - a.count || a.command.localeCompare(b.command));
+    return {
+        window: `${windowDays}d`,
+        window_days: windowDays,
+        generated_at: new Date(nowMs).toISOString(),
+        evidence,
+        injections: injects.length,
+        contradictions_surfaced,
+        contradictions_acted_on,
+        review_decisions,
+        coverage_gaps,
+        coverage_gaps_total,
+        load_bearing,
+        commands_total,
+        commands_by_name,
+    };
+}
+// --- render -----------------------------------------------------------------
+function pct(r) {
+    return r === null ? "n/a" : (r * 100).toFixed(0) + "%";
+}
+function renderDashboard(d, verbose) {
+    const m = d.evidence;
+    const lines = [];
+    lines.push(`mla usefulness, last ${d.window} (workspace-local):`);
+    lines.push("");
+    // 1. Evidence followthrough (headline).
+    lines.push("1. Evidence followthrough");
+    if (d.injections === 0) {
+        lines.push("   No evidence injections recorded in this window yet.");
+    }
+    else {
+        const pendingNote = m.pending > 0 ? `, ${m.pending} pending` : "";
+        lines.push(`   mla surfaced evidence in ${d.injections} injection(s) (${m.injects_offered} offered evidence${pendingNote}).`);
+        lines.push(`   Injection Utilization:    ${pct(m.injection_utilization)} (${m.injects_referenced}/${m.injects_offered} offered injects referenced)`);
+        lines.push(`   ${metrics_1.REFERENCE_PRECISION_V1_LABEL}:  ${pct(m.reference_precision_v1)} (${m.used}/${m.used + m.ignored} closed used vs ignored)`);
+        lines.push(`   Unknown Coverage:         ${pct(m.unknown_coverage)} (${m.unknown}/${m.closed_windows} closed windows unclassified)`);
+        lines.push(`   Evidence Item Utilization: ${pct(m.evidence_item_utilization)} (${m.distinct_referenced}/${m.distinct_offered} distinct docs)`);
+    }
+    lines.push("");
+    // 2. Caught before it shipped.
+    lines.push("2. Caught before it shipped");
+    if (d.contradictions_surfaced === 0) {
+        lines.push("   No contradictions or supersessions flagged in this window.");
+    }
+    else {
+        lines.push(`   mla flagged ${d.contradictions_surfaced} contradiction(s)/supersession(s); you acted on ${d.contradictions_acted_on}.`);
+    }
+    lines.push("");
+    // 3. Decisions governed (local proxy + pointer to the authoritative --global).
+    lines.push("3. Decisions governed");
+    lines.push(`   ${d.review_decisions} review decision(s) recorded locally.`);
+    lines.push("   For the authoritative governed-change and propagation count, run `mla stats --global`.");
+    lines.push("");
+    // 4. What mla could not help with (coverage gaps == the roadmap).
+    lines.push("4. Coverage gaps (the roadmap)");
+    if (d.coverage_gaps_total === 0) {
+        lines.push("   No coverage gaps recorded in this window.");
+    }
+    else {
+        lines.push(`   ${d.coverage_gaps_total} query/queries returned nothing useful, by type:`);
+        for (const g of d.coverage_gaps)
+            lines.push(`     ${g.type}: ${g.count}`);
+    }
+    lines.push("");
+    // 5. Load-bearing knowledge.
+    lines.push("5. Load-bearing knowledge");
+    if (d.load_bearing.length === 0) {
+        lines.push("   No referenced evidence recorded in this window.");
+    }
+    else {
+        lines.push("   Most-referenced evidence:");
+        for (const it of d.load_bearing)
+            lines.push(`     ${it.source_id} (x${it.reference_count})`);
+    }
+    // 6. Activity footnote (only under --verbose; never the lead).
+    if (verbose) {
+        lines.push("");
+        lines.push("Activity (footnote)");
+        lines.push(`   ${d.commands_total} command(s) run.`);
+        for (const c of d.commands_by_name)
+            lines.push(`     ${c.command}: ${c.count}`);
+    }
+    return lines.join("\n");
+}
+// The global dashboard. Same usefulness-first ordering as the local view, but only
+// the sections that have a permission-scoped, opaque-id-safe server counterpart:
+// evidence followthrough, the wedge (contradictions caught), decisions governed
+// (here AUTHORITATIVE, not a local proxy), and coverage gaps. Load-bearing
+// knowledge and the activity footnote are local-only (spec section 9, 7.3) and have
+// no global form, so they are intentionally absent rather than rendered empty.
+function renderGlobalDashboard(r) {
+    const m = r.evidence;
+    const lines = [];
+    const wsLabel = r.workspaces === 1 ? "1 workspace" : `${r.workspaces} workspaces`;
+    lines.push(`mla usefulness, last ${r.window_days}d (global: ${wsLabel} you can view):`);
+    lines.push("");
+    // 1. Evidence followthrough (headline).
+    lines.push("1. Evidence followthrough");
+    if (r.injections === 0) {
+        lines.push("   No evidence injections recorded in this window yet.");
+    }
+    else {
+        const pendingNote = m.pending > 0 ? `, ${m.pending} pending` : "";
+        lines.push(`   mla surfaced evidence in ${r.injections} injection(s) (${m.injects_offered} offered evidence${pendingNote}).`);
+        lines.push(`   Injection Utilization:    ${pct(m.injection_utilization)} (${m.injects_referenced}/${m.injects_offered} offered injects referenced)`);
+        lines.push(`   ${metrics_1.REFERENCE_PRECISION_V1_LABEL}:  ${pct(m.reference_precision_v1)} (${m.used}/${m.used + m.ignored} closed used vs ignored)`);
+        lines.push(`   Unknown Coverage:         ${pct(m.unknown_coverage)} (${m.unknown}/${m.closed_windows} closed windows unclassified)`);
+        lines.push(`   Evidence Item Utilization: ${pct(m.evidence_item_utilization)} (${m.distinct_referenced}/${m.distinct_offered} distinct docs)`);
+    }
+    lines.push("");
+    // 2. Caught before it shipped (the wedge).
+    lines.push("2. Caught before it shipped");
+    if (r.contradictions_surfaced === 0) {
+        lines.push("   No contradictions or supersessions flagged in this window.");
+    }
+    else {
+        lines.push(`   mla flagged ${r.contradictions_surfaced} contradiction(s)/supersession(s); acted on ${r.contradictions_acted_on}.`);
+    }
+    lines.push("");
+    // 3. Decisions governed (authoritative server count, not the local proxy).
+    lines.push("3. Decisions governed");
+    lines.push(`   ${r.review_decisions} review decision(s) recorded across your workspaces.`);
+    lines.push("");
+    // 4. Coverage gaps (the roadmap).
+    lines.push("4. Coverage gaps (the roadmap)");
+    if (r.coverage_gaps_total === 0) {
+        lines.push("   No coverage gaps recorded in this window.");
+    }
+    else {
+        lines.push(`   ${r.coverage_gaps_total} query/queries returned nothing useful, by type:`);
+        for (const g of r.coverage_gaps)
+            lines.push(`     ${g.type}: ${g.count}`);
+    }
+    return lines.join("\n");
+}
+// INV-GLOBAL-UNKNOWN-1: telemetry off AND nothing-synced are both "unknown", never
+// a misleading zero. Same human-facing message for both; in --json the machine gets
+// an explicit `available:false` with the reason so it cannot read it as activity=0.
+function emitGlobalUnavailable(reason, json) {
+    const message = "No remote telemetry available. Local stats are still available.";
+    if (json) {
+        console.log(JSON.stringify({ available: false, reason, message }, null, 2));
+    }
+    else {
+        console.log(message);
+    }
+}
+// Translate a `mla stats --turn [N]` argv into the `mla turn` argv: the value
+// after --turn (when number-shaped) becomes the positional turn index, and --json
+// / --session pass through. Window/verbose/global have no per-turn meaning and are
+// dropped (the alias is a convenience, not a second per-turn flag surface).
+function translateTurnAlias(argv) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--turn") {
+            const v = argv[i + 1];
+            if (v !== undefined && /^[0-9]+$/.test(v)) {
+                out.push(v);
+                i++;
+            }
+        }
+        else if (a === "--json") {
+            out.push("--json");
+        }
+        else if (a === "--session") {
+            const v = argv[++i];
+            if (v)
+                out.push("--session", v);
+        }
+    }
+    return out;
+}
+// T7.2: `mla stats` is a value-checking moment -- record that someone looked
+// (mla_stats_viewed answers "are people checking value"). The payload is the
+// closed scope/window only (no metrics, no PII). Best-effort and fail-soft:
+// analytics must never break a stats read. It only record()s into the buffer;
+// run context (run_id/trace_id) is ambient from bootstrap and the cli.ts finalize
+// flush ships it.
+function recordStatsViewed(args, deps) {
+    try {
+        const env = deps.env ?? process.env;
+        const record = deps.record ?? recorder_1.recordAnalyticsEvent;
+        const resolveWs = deps.resolveWorkspaceId ?? workspace_1.tryResolveWorkspaceId;
+        const nowMs = deps.nowMs ?? Date.now();
+        const payload = {
+            scope: args.global ? "global" : "local",
+            window: args.windowLabel,
+        };
+        const ctx = {
+            workspaceId: resolveWs(),
+            sessionId: (env.CLAUDE_CODE_SESSION_ID || "").trim() || null,
+            now: new Date(nowMs).toISOString(),
+        };
+        record(ctx, { eventType: "mla_stats_viewed", payload: payload }, env);
+    }
+    catch {
+        // fail-soft: a stats view must never be blocked by analytics.
+    }
+}
+async function runStats(argv, deps = {}) {
+    // `mla stats --turn [N]` is an alias for the per-turn recap (`mla turn`). It is
+    // intercepted before parseStatsArgs (which has no --turn flag) and delegated to
+    // the SAME handler, so the two entry points are one implementation, not two.
+    if (argv.includes("--turn")) {
+        return (deps.turn ?? turn_1.runTurn)(translateTurnAlias(argv));
+    }
+    let args;
+    try {
+        args = parseStatsArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    // T7.2: every successful `mla stats` view is a value-checking signal -- record
+    // it before dispatching so local / evidence / global all count uniformly.
+    recordStatsViewed(args, deps);
+    // `mla stats evidence` is the focused adoption join -- the SAME code path as
+    // `mla adoption` (INV-ADOPTION-SOURCE-1). One join, two entry points.
+    if (args.section === "evidence") {
+        return (deps.adoption ?? adoption_1.runAdoption)(args.rest);
+    }
+    // `--global` reads the control rollup read-model (spec section 10.4), not PostHog.
+    if (args.global) {
+        return runGlobalStats(args, deps);
+    }
+    const read = deps.read ?? store_1.readEvents;
+    const nowMs = deps.nowMs ?? Date.now();
+    const events = read();
+    const dashboard = buildDashboard(events, args.windowDays, nowMs);
+    if (args.json) {
+        console.log(JSON.stringify(dashboard, null, 2));
+    }
+    else {
+        console.log(renderDashboard(dashboard, args.verbose));
+    }
+    return 0;
+}
+// `mla stats --global`: authenticated server call to control's rollup read-model.
+// Reads the canonical, deduped, permission-scoped aggregate (NEVER PostHog), so the
+// global numbers are ACL-correct and cannot drift from the local definitions (the
+// server mirrors the same metric math). "Zero means no activity; telemetry-off
+// means unknown" -- both telemetry-off and nothing-synced print the unknown
+// message, never a zero (INV-GLOBAL-UNKNOWN-1).
+async function runGlobalStats(args, deps) {
+    const env = deps.env ?? process.env;
+    // Telemetry off -> unknown, not zero. No server call is made (and none could
+    // succeed: nothing has been synced).
+    if (!(0, consent_1.remoteAnalyticsEnabled)(env)) {
+        emitGlobalUnavailable("telemetry_off", args.json);
+        return 0;
+    }
+    let rollup;
+    try {
+        rollup = deps.fetchGlobal
+            ? await deps.fetchGlobal(args.windowDays)
+            : await fetchGlobalRollup(args.windowDays);
+    }
+    catch (e) {
+        // A reachability/auth failure is NOT "no activity"; surface it as an error
+        // (exit 1) so it is never silently read as a zero.
+        console.error(`mla stats --global could not reach control: ${e.message}`);
+        return 1;
+    }
+    // Nothing synced yet for any visible workspace -> unknown, not zero.
+    if (!rollup.has_any_events) {
+        emitGlobalUnavailable("no_synced_data", args.json);
+        return 0;
+    }
+    if (args.json) {
+        console.log(JSON.stringify(rollup, null, 2));
+    }
+    else {
+        console.log(renderGlobalDashboard(rollup));
+    }
+    return 0;
+}
+// The real control call. `get` auto-stamps the bearer, X-Trace-ID, and
+// X-Meetless-Actor (the actor the rollup endpoint resolves under INV-AUTH-1). The
+// rollup is cross-workspace by design, so we read the base config (readConfig), not
+// a workspace-bound one -- there is no single workspace to bind to.
+async function fetchGlobalRollup(periodDays) {
+    const cfg = (0, config_1.readConfig)();
+    return (0, http_1.get)(cfg, `/internal/v1/analytics/rollups?periodDays=${periodDays}`);
+}

package/dist/commands/status.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderStatus = renderStatus;
+exports.runStatus = runStatus;
+// src/commands/status.ts
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const cache_1 = require("../lib/scanner/cache");
+const workspace_1 = require("../lib/workspace");
+const config_1 = require("../lib/config");
+function renderStatus(view) {
+    const cache = (0, cache_1.readScanCache)(view.home, view.workspaceId);
+    if (!cache) {
+        return `Meetless is not activated for this repo. Run \`mla activate\`.`;
+    }
+    const rules = cache.directives.length;
+    const pending = cache.staleSignals.length;
+    // `?? 0` guards a pre-M1 on-disk cache that predates the agentMemoryRules field.
+    const advisory = cache.inventory.agentMemoryRules ?? 0;
+    const hooks = view.hooksInstalled ? "hooks installed" : "hooks NOT installed (run `mla rewire`)";
+    const lines = [
+        `Meetless is active for workspace ${view.workspaceId} (${hooks}).`,
+        `  ${plural(rules, "confirmed rule")} injected on every prompt.`,
+        `  ${plural(pending, "pending review item")} (mla context list).`,
+        `  inventory: ${cache.inventory.instructionFiles} instruction files, ` +
+            `${cache.inventory.decisionDocs} docs, ${cache.inventory.legacyNotes} notes.`,
+    ];
+    // Advisory agent-memory rules are machine_inferred and NOT injected (never must-follow);
+    // surface them only when present, so a fresh repo with none stays quiet (no spam).
+    if (advisory > 0) {
+        lines.push(`  ${plural(advisory, "advisory rule")} from agent memory (pending review; not injected).`);
+    }
+    return lines.join("\n");
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+// Thin wrapper kept for local readability; delegates to the shared resolver
+// in src/lib/workspace.ts (env override first, then .meetless.json marker walk).
+function resolveWorkspaceId() {
+    return (0, workspace_1.resolveWorkspaceIdWithEnv)();
+}
+function detectHooksInstalled() {
+    try {
+        return (0, node_fs_1.existsSync)((0, node_path_1.join)(config_1.HOOKS_DIR, "user-prompt-submit.sh"));
+    }
+    catch {
+        return false;
+    }
+}
+async function runStatus(_argv) {
+    const workspaceId = resolveWorkspaceId();
+    if (!workspaceId) {
+        console.log("Meetless is not activated for this repo. Run `mla activate`.");
+        return 0;
+    }
+    const hooksInstalled = detectHooksInstalled();
+    console.log(renderStatus({ home: (0, node_os_1.homedir)(), workspaceId, hooksInstalled }));
+    return 0;
+}