@meetless/mla 0.1.4

package/dist/commands/workspace.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWorkspace = runWorkspace;
+const config_1 = require("../lib/config");
+const http_1 = require("../lib/http");
+const workspace_1 = require("../lib/workspace");
+// `mla workspace` (folder = workspace, T1.3 / T3.2,
+// notes/20260604-folder-equals-workspace-binding-design.md)
+//
+// Repurposed for the folder-binding model. The workspace a directory runs under
+// is no longer a machine-global cli-config pointer; it is resolved from the
+// nearest `.meetless.json` marker, walking UP from cwd (nearest-wins, mirroring
+// how Claude Code resolves CLAUDE.md). So:
+//
+//   mla workspace            show the workspace bound to this folder + health
+//   mla workspace show       (alias for the above)
+//   mla workspace use <id>   REMOVED. Hard error pointing at `mla activate`.
+//
+// `use` used to rewrite the global cli-config `workspaceId`, which is no longer
+// a workspace source. Switching workspaces is now "cd to (or activate) the
+// folder bound to that workspace", not flipping one machine-global pointer. We
+// fail loud rather than silently no-op so muscle memory gets corrected, not
+// swallowed.
+// Loads machine credentials (controlUrl, controlToken, actor) from
+// cli-config.json. NOTE: cli-config no longer carries the workspaceId (T1.1);
+// the workspace is resolved from the folder marker, not here. This only fetches
+// the creds the server probe needs.
+function loadConfigOrExplain() {
+    if (!(0, config_1.configExists)()) {
+        console.error(`cli-config.json not found at ${config_1.CFG_PATH}. Run 'mla init --control-token <token>' first.`);
+        return 2;
+    }
+    try {
+        return (0, config_1.readConfig)();
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+}
+// `mla workspace show`: resolve the folder's workspace binding from the nearest
+// marker and report its health.
+//
+// Pure-local states (not activated, stale marker) never touch the network. A
+// healthy binding is corroborated against control so a marker pointing at a
+// deleted / inaccessible workspace reads as a precise, actionable state here
+// rather than an opaque 401/403/404 later mid-capture. The server probe is
+// best-effort: control being down must NOT mask the local binding (which is
+// printed first, before the probe).
+async function runWorkspaceShow() {
+    const loaded = loadConfigOrExplain();
+    if (typeof loaded === "number")
+        return loaded;
+    const cfg = loaded;
+    let ctx;
+    try {
+        ctx = (0, workspace_1.resolveWorkspaceContext)();
+    }
+    catch (e) {
+        if (e instanceof workspace_1.NotActivatedError) {
+            console.log("No workspace is bound to this folder.");
+            console.log("  Run 'mla activate' here to bind (or create) one.");
+            console.log("  Meetless resolves the workspace from the nearest .meetless.json, " +
+                "walking up from the current directory.");
+            return 0;
+        }
+        if (e instanceof workspace_1.MarkerMissingWorkspaceIdError) {
+            console.log(`Stale binding: ${e.markerPath} has no usable workspaceId.`);
+            console.log("  Run 'mla activate --repair' to re-stamp the marker.");
+            return 0;
+        }
+        throw e;
+    }
+    // Healthy local binding. Print it FIRST so the answer is always visible even
+    // when the server probe below is offline.
+    const nameSuffix = ctx.workspaceName ? ` (${ctx.workspaceName})` : "";
+    console.log(`Workspace: ${ctx.workspaceId}${nameSuffix}`);
+    console.log(`  Bound by ${ctx.markerPath}`);
+    // Corroborate against control. The marker is local truth for "which id"; only
+    // the server knows whether that id still exists and is reachable.
+    try {
+        await (0, http_1.get)(cfg, `/internal/v1/workspaces/me?workspaceId=${encodeURIComponent(ctx.workspaceId)}`, 5000);
+        console.log("  Status: active (exists and reachable).");
+        return 0;
+    }
+    catch (e) {
+        const err = e;
+        if (err.status === 404) {
+            console.log(`  Status: this repo is bound to ${ctx.workspaceId}, but the ` +
+                `workspace does not exist or is inaccessible.`);
+            console.log("  Options: 'mla activate --repair' or 'mla deactivate'.");
+            return 0;
+        }
+        // 401/403: shared internal bearer rejected, or (post-T1.4, when the CLI
+        // sends X-Meetless-Actor) the caller is not a member. Today's shared key
+        // does not 403 on non-membership, so this branch is forward-compatible.
+        if (err.status === 401 || err.status === 403) {
+            console.log(`  Status: this repo is bound to ${ctx.workspaceId}, but your token ` +
+                `is not a member. Ask a workspace owner to add you.`);
+            return 0;
+        }
+        // Network error / control down / unexpected status: never fail the report.
+        console.log(`  Status: could not verify with control (${err.status ?? "offline"}). ` +
+            `The local binding above still applies.`);
+        return 0;
+    }
+}
+// `mla workspace use <id>` is removed (T3.2). It rewrote the global cli-config
+// workspaceId, which is no longer a workspace source under folder = workspace.
+// Hard-error with a pointer to the replacement verb instead of silently doing
+// nothing, so existing muscle memory / scripts get a clear migration signal.
+function runWorkspaceUseRemoved() {
+    console.error("`mla workspace use` has been removed. Workspaces are now bound per folder " +
+        "by a .meetless.json marker, not a global cli-config pointer.");
+    console.error("  To switch workspace: cd to the folder bound to it, or run 'mla activate' " +
+        "in this folder to bind (or create) a workspace here.");
+    return 2;
+}
+async function runWorkspace(argv) {
+    const [sub] = argv;
+    if (sub === undefined || sub === "show") {
+        return runWorkspaceShow();
+    }
+    if (sub === "use") {
+        return runWorkspaceUseRemoved();
+    }
+    console.error(`Unknown workspace subcommand: ${sub}. Usage: mla workspace [show] ` +
+        `(use 'mla activate' / 'mla deactivate' to change the binding).`);
+    return 2;
+}

package/dist/hooks-template/ce0-post-tool-use.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# ce0-post-tool-use.sh: Claude Code PostToolUse hook for the CE0
+# evidence-consultation measurement harness (RECORD_ONLY; proposal §4.1).
+#
+# Scope (registered by wire.ts MANAGED_HOOK_SCRIPTS on PostToolUse with matcher
+# "mcp__meetless__"): fires after a meetless MCP tool call. It hands the raw
+# PostToolUse stdin to `mla _internal evidence-capture`, which records the FACT of
+# a governed-memory pull (retrieve_knowledge / kb_doc_detail / query) as a
+# ConsultationAttempt under the live turn's identity; any other tool is a no-op in
+# the subcommand. It then ALWAYS emits the empty `{}` pass-through body and exits 0.
+#
+# The matcher is the prefix `mcp__meetless__`, NOT the catch-all used by the
+# load-bearing post-tool-use.sh: this hook only needs the governed pulls, so it
+# does not spawn `mla` on every unrelated tool. The subcommand filters precisely to
+# the three governed pulls as a backstop.
+#
+# Deliberately self-contained (does NOT source common.sh), like pre-tool-use.sh.
+# No `set -e`: every step is best-effort and must leave a clean exit-0 pass-through.
+
+INPUT="$(cat 2>/dev/null || true)"
+
+CFG="${MEETLESS_HOME:-$HOME/.meetless}/cli-config.json"
+MLA_PATH="$(jq -r '.mlaPath // empty' "$CFG" 2>/dev/null || true)"
+if [[ -z "${MLA_PATH:-}" || ! -x "$MLA_PATH" ]]; then
+  MLA_PATH="$(command -v mla 2>/dev/null || true)"
+fi
+
+# Best-effort record. stdout discarded, stderr silenced, failure swallowed.
+if [[ -n "${MLA_PATH:-}" && -x "$MLA_PATH" ]]; then
+  printf '%s' "$INPUT" | "$MLA_PATH" _internal evidence-capture >/dev/null 2>&1 || true
+fi
+
+printf '{}'
+exit 0

package/dist/hooks-template/ce0-session-start.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# ce0-session-start.sh: Claude Code SessionStart hook for the CE0
+# evidence-consultation measurement harness (RECORD_ONLY; proposal §4.1, §6.4).
+#
+# Scope (registered by wire.ts MANAGED_HOOK_SCRIPTS on SessionStart, no matcher =
+# every session start): gives the offline §6.4 telemetry projection an AUTOMATIC
+# caller. The two denominator events that back precision/recall,
+# memory_requirement_assessed (one per assessment) and evidence_obligation_finalized
+# (one per FINALIZED obligation), are NOT emitted live by the turn hooks; they are
+# projected from the CE0 store by the `mla evidence ce0-emit-telemetry` sweep. Before
+# this hook that sweep only ran when a human typed it, so the denominator never
+# flowed from passive dogfood. Here it runs once at the top of each session, projecting
+# the prior session's accumulated rows.
+#
+# The sweep is IDEMPOTENT two ways (a deterministic event_id dedupes on the remote
+# sink, and a local skip-set of already-logged event_ids avoids re-appending lines),
+# so running it on every session start re-projects nothing already projected. Its
+# LOCAL projection into ~/.meetless/events.jsonl is synchronous and happens BEFORE the
+# best-effort network flush, so even if this hook is killed at its bounded timeout the
+# denominator events are already landed locally and the regular flush forwards them.
+#
+# Unlike the other three ce0-*.sh hooks (pure local SQLite, no network) this one ends
+# in a network flush, which is why MANAGED_HOOK_SCRIPTS gives it a timeout. It still
+# ALWAYS emits the empty `{}` SessionStart body and exits 0: CE0 is measurement only,
+# so this hook can never inject additionalContext, block, or change the session.
+#
+# Deliberately self-contained (does NOT source common.sh), like pre-tool-use.sh. No
+# `set -e`: every step is best-effort and must leave a clean exit-0 pass-through.
+
+# SessionStart delivers a small JSON payload on stdin; the sweep does not consume it
+# (it reads the CE0 store, not the hook input), but we drain stdin so the producer is
+# never left writing to a closed pipe.
+cat >/dev/null 2>&1 || true
+
+CFG="${MEETLESS_HOME:-$HOME/.meetless}/cli-config.json"
+MLA_PATH="$(jq -r '.mlaPath // empty' "$CFG" 2>/dev/null || true)"
+if [[ -z "${MLA_PATH:-}" || ! -x "$MLA_PATH" ]]; then
+  MLA_PATH="$(command -v mla 2>/dev/null || true)"
+fi
+
+# Best-effort sweep. stdout (the sweep's `{emitted, skipped}` JSON summary) is
+# discarded, stderr silenced, any failure swallowed so the hook never blocks a session.
+if [[ -n "${MLA_PATH:-}" && -x "$MLA_PATH" ]]; then
+  "$MLA_PATH" evidence ce0-emit-telemetry >/dev/null 2>&1 || true
+fi
+
+# The ONLY thing this hook ever writes to stdout: the empty no-decision body.
+printf '{}'
+exit 0

package/dist/hooks-template/ce0-stop.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# ce0-stop.sh: Claude Code Stop hook for the CE0 evidence-consultation measurement
+# harness (RECORD_ONLY; proposal §4.1).
+#
+# Scope (registered by wire.ts MANAGED_HOOK_SCRIPTS on Stop, no matcher): fires
+# when the turn ends. It hands the raw Stop stdin to `mla _internal evidence-stop`,
+# which on the FIRST Stop of a turn freezes the obligation's eligibility boundary
+# at the high-water consultation token; a later Stop is an idempotent no-op. It then
+# ALWAYS emits the empty `{}` pass-through body and exits 0, so the hook can never
+# block or re-open a turn.
+#
+# Deliberately self-contained (does NOT source common.sh), like pre-tool-use.sh.
+# No `set -e`: every step is best-effort and must leave a clean exit-0 pass-through.
+
+INPUT="$(cat 2>/dev/null || true)"
+
+CFG="${MEETLESS_HOME:-$HOME/.meetless}/cli-config.json"
+MLA_PATH="$(jq -r '.mlaPath // empty' "$CFG" 2>/dev/null || true)"
+if [[ -z "${MLA_PATH:-}" || ! -x "$MLA_PATH" ]]; then
+  MLA_PATH="$(command -v mla 2>/dev/null || true)"
+fi
+
+# Best-effort record. stdout discarded, stderr silenced, failure swallowed.
+if [[ -n "${MLA_PATH:-}" && -x "$MLA_PATH" ]]; then
+  printf '%s' "$INPUT" | "$MLA_PATH" _internal evidence-stop >/dev/null 2>&1 || true
+fi
+
+printf '{}'
+exit 0

package/dist/hooks-template/ce0-user-prompt-submit.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# ce0-user-prompt-submit.sh: Claude Code UserPromptSubmit hook for the CE0
+# evidence-consultation measurement harness (RECORD_ONLY; proposal §4.1).
+#
+# Scope (registered by wire.ts MANAGED_HOOK_SCRIPTS on UserPromptSubmit, no
+# matcher = every prompt): fires once at the top of each turn. It hands the raw
+# UserPromptSubmit stdin to `mla _internal evidence-turn-open`, which classifies
+# the turn's memory requirement, persists the assessment, and (only for a REQUIRED
+# turn) opens the turn's TurnRuleObligation. It then ALWAYS emits the empty `{}`
+# pass-through body and exits 0, so wiring this hook can never inject context or
+# change a turn. CE0 is measurement only; injection is a CE2 concern.
+#
+# Deliberately self-contained (does NOT source common.sh), exactly like
+# pre-tool-use.sh: the activation gate is the subcommand's own workspace
+# resolution, not a shell-side .meetless.json walk. No `set -e`: every step is
+# best-effort, and a missing `mla` or a failed lookup must still leave a clean
+# exit-0 pass-through, never a non-zero (blocking) exit.
+
+INPUT="$(cat 2>/dev/null || true)"
+
+# Resolve the absolute mla path the same way pre-tool-use.sh does (install-time
+# path in cli-config.json, then PATH fallback).
+CFG="${MEETLESS_HOME:-$HOME/.meetless}/cli-config.json"
+MLA_PATH="$(jq -r '.mlaPath // empty' "$CFG" 2>/dev/null || true)"
+if [[ -z "${MLA_PATH:-}" || ! -x "$MLA_PATH" ]]; then
+  MLA_PATH="$(command -v mla 2>/dev/null || true)"
+fi
+
+# Best-effort record. stdout is discarded (the hook decision is the hardcoded `{}`
+# below); stderr is silenced; any failure is swallowed so the hook never blocks a
+# turn. The subcommand persists its assessment + obligation out-of-band.
+if [[ -n "${MLA_PATH:-}" && -x "$MLA_PATH" ]]; then
+  printf '%s' "$INPUT" | "$MLA_PATH" _internal evidence-turn-open >/dev/null 2>&1 || true
+fi
+
+# The ONLY thing this hook ever writes to stdout: the empty no-decision body.
+printf '{}'
+exit 0