@meetless/mla 0.1.4 → 0.1.6

package/dist/commands/pilot.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReport = renderReport;
+exports.runPilot = runPilot;
+// `mla pilot` -- the pilot value-signal surface (memo
+// notes/20260624-mla-new-user-value-and-brownfield-proof.md §6 Phase 3).
+//
+//   mla pilot feedback --point <p> --verdict <v> [--prevented-mistake] [--sampled] [--json]
+//       Record ONE explicit human verdict at a natural point. This is the pilot's
+//       primary value signal (the four hypotheses are scored from these), captured
+//       only at decision moments -- a reviewed candidate, a SAMPLED injection, a
+//       fired alert, a blocked tool call -- never on every injection (memo lines
+//       551-554). Appended to the same local events.jsonl as every other signal.
+//
+//   mla pilot report [--window <Nd>] [--json]
+//       The "simple report" half of the memo's "store raw events and generate a
+//       simple report/export; do NOT build a dashboard first" (line 553). Folds the
+//       local events into the four hypotheses. No server, no dashboard.
+//
+//   mla pilot export [--window <Nd>] [--out <path>]
+//       The "export" half: dump the raw pilot-feedback events (the genuinely-new
+//       signal) as JSONL for offline analysis or to hand to An. The full raw stream
+//       is always ~/.meetless/events.jsonl; this is the focused pilot subset.
+//
+//   mla pilot sample-check --inject-id <id> [--n <N>]
+//       Consult the deterministic 1-in-N sampling gate (the honest mechanism behind
+//       "sampled occasionally"). A predicate command: exit 0 = sample this injection,
+//       exit 1 = skip it, exit 2 = usage error. A hook gates a feedback prompt on it.
+//
+// Every payload is enums/ids/booleans only (INV-POSTHOG-PII-1); no statement text,
+// path, or query is ever recorded. The command is fail-soft on the record path: a
+// pilot verdict must never break because analytics had a disk hiccup.
+const node_fs_1 = require("node:fs");
+const pilot_1 = require("../lib/analytics/pilot");
+const envelope_1 = require("../lib/analytics/envelope");
+const recorder_1 = require("../lib/analytics/recorder");
+const store_1 = require("../lib/analytics/store");
+const workspace_1 = require("../lib/workspace");
+const DEFAULT_WINDOW_DAYS = 30;
+// --- shared parsing ---------------------------------------------------------
+// Parse `--window 7d` / `--window 30` (bare integer = days). Same grammar as
+// `mla stats` so the two value surfaces read identically.
+function parseWindowDays(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;
+}
+function parseFeedbackArgs(argv) {
+    let point;
+    let verdict;
+    let preventedMistake = false;
+    let sampled = false;
+    let json = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--point")
+            point = argv[++i];
+        else if (a === "--verdict")
+            verdict = argv[++i];
+        else if (a === "--prevented-mistake")
+            preventedMistake = true;
+        else if (a === "--sampled")
+            sampled = true;
+        else if (a === "--json")
+            json = true;
+        else
+            throw new Error(`Unknown flag for \`mla pilot feedback\`: ${a}`);
+    }
+    if (!point)
+        throw new Error("--point is required (one of: " + envelope_1.PILOT_FEEDBACK_POINTS.join(", ") + ")");
+    if (!verdict)
+        throw new Error("--verdict is required (one of: " + envelope_1.PILOT_FEEDBACK_VERDICTS.join(", ") + ")");
+    // The point/verdict pairing + the prevented_mistake constraint are enforced by
+    // validatePilotFeedback (called inside buildPilotFeedbackEvent); here we only
+    // confirm the values are in the closed enums so the cast is sound.
+    if (!envelope_1.PILOT_FEEDBACK_POINTS.includes(point)) {
+        throw new Error(`unknown --point "${point}" (expected one of: ${envelope_1.PILOT_FEEDBACK_POINTS.join(", ")})`);
+    }
+    if (!envelope_1.PILOT_FEEDBACK_VERDICTS.includes(verdict)) {
+        throw new Error(`unknown --verdict "${verdict}" (expected one of: ${envelope_1.PILOT_FEEDBACK_VERDICTS.join(", ")})`);
+    }
+    return {
+        point: point,
+        verdict: verdict,
+        preventedMistake,
+        sampled,
+        json,
+    };
+}
+function runFeedback(argv, deps) {
+    let args;
+    try {
+        args = parseFeedbackArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const input = {
+        point: args.point,
+        verdict: args.verdict,
+        preventedMistake: args.preventedMistake,
+        sampled: args.sampled,
+    };
+    // Build first: this validates the point/verdict pairing and the prevented_mistake
+    // tag. A bad combination is a usage error (exit 2), refused BEFORE anything is
+    // written -- not a recorded malformed event.
+    let recordInput;
+    try {
+        recordInput = (0, pilot_1.buildPilotFeedbackEvent)(input);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    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 ctx = {
+        workspaceId: resolveWs(),
+        sessionId: (env.CLAUDE_CODE_SESSION_ID || "").trim() || null,
+        now: new Date(nowMs).toISOString(),
+    };
+    let ev;
+    try {
+        ev = record(ctx, recordInput, env);
+    }
+    catch {
+        // Fail-soft: a verdict must never be blocked by an analytics I/O fault. We
+        // still report it as recorded-intent so the operator is not left guessing.
+        if (args.json) {
+            console.log(JSON.stringify({ recorded: false, point: args.point, verdict: args.verdict }, null, 2));
+        }
+        else {
+            console.error("warning: pilot feedback could not be persisted (analytics I/O error); continuing.");
+        }
+        return 0;
+    }
+    const feedbackId = ev.feedback_id ?? null;
+    if (args.json) {
+        console.log(JSON.stringify({
+            recorded: true,
+            feedback_id: feedbackId,
+            point: args.point,
+            verdict: args.verdict,
+            prevented_mistake: args.preventedMistake,
+            sampled: args.sampled,
+        }, null, 2));
+    }
+    else {
+        const tag = args.preventedMistake ? " (prevented a mistake)" : "";
+        console.log(`Recorded pilot feedback: ${args.point} -> ${args.verdict}${tag}.`);
+    }
+    return 0;
+}
+function parseReportArgs(argv) {
+    const out = { windowDays: DEFAULT_WINDOW_DAYS, json: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json")
+            out.json = true;
+        else if (a === "--window")
+            out.windowDays = parseWindowDays(argv[++i]);
+        else
+            throw new Error(`Unknown flag for \`mla pilot report\`: ${a}`);
+    }
+    return out;
+}
+function pct(r) {
+    return r === null ? "n/a" : (r * 100).toFixed(0) + "%";
+}
+function dur(ms) {
+    if (ms === null)
+        return "n/a";
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = Math.round(ms / 1000);
+    if (s < 90)
+        return `${s}s`;
+    const m = Math.round(s / 60);
+    if (m < 90)
+        return `${m}m`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h}h`;
+    return `${Math.round(h / 24)}d`;
+}
+function renderReport(r) {
+    const L = [];
+    L.push(`mla pilot report, last ${r.window_days}d (workspace-local):`);
+    L.push("");
+    // H1.
+    const o = r.onboarding;
+    L.push("1. Onboarding discovers useful knowledge");
+    L.push(`   Candidates: ${o.candidate_accept} accepted, ${o.candidate_reject} rejected (acceptance ${pct(o.acceptance_rate)}).`);
+    L.push(`   Review-flow corroboration: ${o.review_accept} accepted, ${o.review_reject} rejected.`);
+    L.push(`   Time to first useful item: ${dur(o.time_to_first_useful_ms)}.`);
+    L.push("");
+    // H2.
+    const inj = r.injection;
+    L.push("2. Injected context is useful, not noisy");
+    L.push(`   Verdicts: ${inj.useful} useful, ${inj.noise} noise, ${inj.uncertain} uncertain (usefulness ${pct(inj.usefulness_rate)}).`);
+    L.push(`   Sampled ${inj.sampled_feedback_count} of ${inj.total_injects} injection(s) (${pct(inj.feedback_coverage_rate)} coverage -- we did NOT prompt on every injection).`);
+    L.push("");
+    // H3.
+    const co = r.coordination;
+    L.push("3. mla catches genuine coordination errors");
+    L.push(`   Alerts: ${co.alert_confirmed} confirmed, ${co.alert_disposed} disposed, ${co.alert_uncertain} uncertain (confirmation ${pct(co.confirmation_rate)}).`);
+    L.push(`   Prevented mistakes (tagged): ${co.prevented_mistakes}.`);
+    L.push(`   Denies: ${co.deny_correct} correct, ${co.deny_incorrect} incorrect (annoyance ${pct(co.deny_annoyance_rate)}).`);
+    L.push(`   Contradiction corroboration: ${co.contradictions_surfaced} surfaced, ${co.contradictions_acted_on} acted on.`);
+    L.push("");
+    // H4.
+    const ret = r.retention;
+    L.push("4. Value persists beyond novelty");
+    L.push(`   First seen: ${ret.first_seen ?? "n/a"}. Last seen: ${ret.last_seen ?? "n/a"}.`);
+    L.push(`   Active days: ${ret.active_days}. Used after 7d: ${ret.used_after_7d ? "yes" : "no"}. Used after 14d: ${ret.used_after_14d ? "yes" : "no"}.`);
+    return L.join("\n");
+}
+function runReport(argv, deps) {
+    let args;
+    try {
+        args = parseReportArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const read = deps.read ?? store_1.readEvents;
+    const nowMs = deps.nowMs ?? Date.now();
+    const opts = { windowDays: args.windowDays, nowMs };
+    const report = (0, pilot_1.aggregatePilot)(read(deps.env), opts);
+    if (args.json) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(renderReport(report));
+    }
+    return 0;
+}
+function parseExportArgs(argv) {
+    const out = { windowDays: DEFAULT_WINDOW_DAYS, out: null };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--out")
+            out.out = argv[++i] ?? null;
+        else if (a === "--window")
+            out.windowDays = parseWindowDays(argv[++i]);
+        else
+            throw new Error(`Unknown flag for \`mla pilot export\`: ${a}`);
+    }
+    if (out.out !== null && out.out.trim().length === 0) {
+        throw new Error("--out requires a file path");
+    }
+    return out;
+}
+function runExport(argv, deps) {
+    let args;
+    try {
+        args = parseExportArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const read = deps.read ?? store_1.readEvents;
+    const nowMs = deps.nowMs ?? Date.now();
+    const startMs = nowMs - args.windowDays * 24 * 60 * 60 * 1000;
+    // Export the genuinely-new pilot-feedback signal, windowed. The full raw stream
+    // is always events.jsonl; this is the focused subset a recipient can recompute
+    // the report from without seeing every command/inject event.
+    const lines = [];
+    for (const ev of read(deps.env)) {
+        if (ev.event_type !== "mla_pilot_feedback")
+            continue;
+        const t = Date.parse(ev.created_at);
+        if (!Number.isFinite(t) || t < startMs)
+            continue;
+        lines.push(JSON.stringify(ev));
+    }
+    const payload = lines.length > 0 ? lines.join("\n") + "\n" : "";
+    if (args.out) {
+        const writeFile = deps.writeFile ?? ((p, d) => (0, node_fs_1.writeFileSync)(p, d, "utf8"));
+        try {
+            writeFile(args.out, payload);
+        }
+        catch (e) {
+            console.error(`mla pilot export could not write ${args.out}: ${e.message}`);
+            return 1;
+        }
+        console.log(`Exported ${lines.length} pilot feedback event(s) to ${args.out}.`);
+    }
+    else {
+        // Raw JSONL to stdout: no trailing message so it pipes cleanly.
+        if (payload)
+            process.stdout.write(payload);
+    }
+    return 0;
+}
+function parseSampleCheckArgs(argv, env) {
+    let injectId;
+    let n;
+    let json = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--inject-id")
+            injectId = argv[++i];
+        else if (a === "--n") {
+            const raw = argv[++i];
+            const parsed = Number(raw);
+            if (!Number.isFinite(parsed) || parsed < 0 || !Number.isInteger(parsed)) {
+                throw new Error(`--n must be a non-negative integer. Got: ${raw}`);
+            }
+            n = parsed;
+        }
+        else if (a === "--json")
+            json = true;
+        else
+            throw new Error(`Unknown flag for \`mla pilot sample-check\`: ${a}`);
+    }
+    if (!injectId)
+        throw new Error("--inject-id is required");
+    return { injectId, n: n ?? (0, pilot_1.injectionSampleN)(env), json };
+}
+function runSampleCheck(argv, deps) {
+    const env = deps.env ?? process.env;
+    let args;
+    try {
+        args = parseSampleCheckArgs(argv, env);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const sample = (0, pilot_1.shouldSampleInjection)(args.injectId, args.n);
+    if (args.json) {
+        console.log(JSON.stringify({ inject_id: args.injectId, n: args.n, sample }, null, 2));
+    }
+    else {
+        console.log(sample ? "sample" : "skip");
+    }
+    // Predicate exit contract (documented in help): 0 = sample, 1 = skip. A hook
+    // branches on this to decide whether to surface a feedback prompt for the inject.
+    return sample ? 0 : 1;
+}
+// --- entry point ------------------------------------------------------------
+const PILOT_USAGE = "Usage:\n" +
+    "  mla pilot feedback --point <candidate|injection|alert|deny> --verdict <v> [--prevented-mistake] [--sampled] [--json]\n" +
+    "  mla pilot report [--window <Nd>] [--json]\n" +
+    "  mla pilot export [--window <Nd>] [--out <path>]\n" +
+    "  mla pilot sample-check --inject-id <id> [--n <N>] [--json]   (exit 0 = sample, 1 = skip)\n" +
+    "\n" +
+    "Verdicts by point: candidate -> accept|reject; injection -> useful|noise|uncertain;\n" +
+    "alert -> confirmed|disposed|uncertain; deny -> correct|incorrect.\n" +
+    `Injection sampling default: 1 in ${pilot_1.DEFAULT_INJECTION_SAMPLE_N} (override with MEETLESS_PILOT_INJECTION_SAMPLE_N or --n).`;
+async function runPilot(argv, deps = {}) {
+    const [sub, ...rest] = argv;
+    switch (sub) {
+        case "feedback":
+            return runFeedback(rest, deps);
+        case "report":
+            return runReport(rest, deps);
+        case "export":
+            return runExport(rest, deps);
+        case "sample-check":
+            return runSampleCheck(rest, deps);
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(PILOT_USAGE);
+            return sub === undefined ? 2 : 0;
+        default:
+            console.error(`Unknown \`mla pilot\` subcommand: ${sub}\n\n${PILOT_USAGE}`);
+            return 2;
+    }
+}

package/dist/lib/agent-memory-capture/binding.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBindingStore = readBindingStore;
+exports.writeBindingStore = writeBindingStore;
+exports.canonicalizeDir = canonicalizeDir;
+exports.enableBinding = enableBinding;
+exports.disableBinding = disableBinding;
+exports.listBindings = listBindings;
+exports.listEnabledBindings = listEnabledBindings;
+// src/lib/agent-memory-capture/binding.ts
+//
+// The local capture-binding registry (§3). One binding per canonical memory
+// directory (its realpath is the identity key). Reactivation of the same
+// directory + workspace REUSES the bindingId; disable preserves it; never
+// deletes it. The synthetic source path embeds the bindingId, so a regenerated
+// id would fork one physical file into duplicate server sources.
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const paths_1 = require("./paths");
+function emptyStore() {
+    return { version: 1, bindings: [] };
+}
+function readBindingStore(home = config_1.HOME) {
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)((0, paths_1.bindingsPath)(home), "utf8");
+    }
+    catch {
+        return emptyStore();
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.bindings))
+            return emptyStore();
+        return { version: 1, bindings: parsed.bindings };
+    }
+    catch {
+        return emptyStore();
+    }
+}
+function writeBindingStore(store, home = config_1.HOME) {
+    const dest = (0, paths_1.bindingsPath)(home);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(dest), { recursive: true });
+    const tmp = `${dest}.${process.pid}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+    (0, node_fs_1.renameSync)(tmp, dest);
+}
+// Resolve a directory to its canonical realpath. Returns null when the path does
+// not resolve (missing dir): the caller surfaces an actionable diagnostic
+// rather than persisting an unverifiable binding.
+function canonicalizeDir(dir) {
+    try {
+        return (0, node_fs_1.realpathSync)(dir);
+    }
+    catch {
+        return null;
+    }
+}
+// Enable (or reactivate) capture for a directory + workspace. Reuses the
+// bindingId when one already exists for the same canonical directory. A request
+// to bind a directory already bound to a DIFFERENT workspace is a
+// MEMORY-WORKSPACE-1 conflict: refuse and report (the caller disables nothing
+// silently; one directory binds exactly one workspace).
+function enableBinding(rawDir, workspaceId, nowIso, home = config_1.HOME) {
+    const memoryDir = canonicalizeDir(rawDir);
+    if (!memoryDir)
+        return { ok: false, reason: "unresolved-dir" };
+    const store = readBindingStore(home);
+    const existing = store.bindings.find((b) => b.memoryDir === memoryDir);
+    if (existing && existing.workspaceId !== workspaceId) {
+        return {
+            ok: false,
+            reason: "workspace-conflict",
+            conflictWorkspaceId: existing.workspaceId,
+        };
+    }
+    if (existing) {
+        const reactivated = !existing.enabled;
+        existing.enabled = true;
+        // Preserve bindingId and consentedAt; the binding is the same one.
+        writeBindingStore(store, home);
+        return { ok: true, binding: existing, reactivated };
+    }
+    const binding = {
+        bindingId: (0, node_crypto_1.randomUUID)(),
+        memoryDir,
+        workspaceId,
+        enabled: true,
+        consentedAt: nowIso,
+    };
+    store.bindings.push(binding);
+    writeBindingStore(store, home);
+    return { ok: true, binding, reactivated: false };
+}
+// Disable a binding for a directory. Preserves the bindingId so a later
+// reactivation keeps the same synthetic source identity. Returns the binding if
+// one was found.
+function disableBinding(rawDir, home = config_1.HOME) {
+    const memoryDir = canonicalizeDir(rawDir) ?? rawDir;
+    const store = readBindingStore(home);
+    const binding = store.bindings.find((b) => b.memoryDir === memoryDir);
+    if (!binding)
+        return null;
+    binding.enabled = false;
+    writeBindingStore(store, home);
+    return binding;
+}
+function listBindings(home = config_1.HOME) {
+    return readBindingStore(home).bindings;
+}
+function listEnabledBindings(home = config_1.HOME) {
+    return readBindingStore(home).bindings.filter((b) => b.enabled);
+}

package/dist/lib/agent-memory-capture/classify.js

@@ -0,0 +1,68 @@
+"use strict";
+// src/lib/agent-memory-capture/classify.ts
+//
+// Eligibility is decided by frontmatter `metadata.type`, NEVER by filename
+// (notes/20260626-agent-memory-auto-capture-proposal.md §1, §4). MVP captures
+// `project` only; `user`/`feedback`/`reference` are skipped. The existing
+// scanner/frontmatter.ts parser is intentionally flat (scalar `key: value`
+// only) and does not descend into the nested `metadata:` block, so this module
+// extracts `metadata.type` itself.
+//
+// "Malformed frontmatter" (an opened `---` fence that never closes) is a
+// distinct outcome from "no project type": the former routes to a processing
+// failure (do not upload, do not retire, retry when corrected), the latter to
+// ineligible/reclassified. Keep them separate.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyMemory = classifyMemory;
+exports.isCapturable = isCapturable;
+function stripScalar(v) {
+    let s = v.trim();
+    if (s.length >= 2 && ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'")))) {
+        s = s.slice(1, -1);
+    }
+    return s.trim().toLowerCase();
+}
+function classifyMemory(text) {
+    if (!text.startsWith("---\n")) {
+        return { type: null, hasFrontmatter: false, malformed: false };
+    }
+    const end = text.indexOf("\n---", 4);
+    if (end === -1) {
+        // Opened but never closed: a real structural defect, not just "no type".
+        return { type: null, hasFrontmatter: true, malformed: true };
+    }
+    const block = text.slice(4, end);
+    const lines = block.split("\n");
+    let type = null;
+    let inMetadata = false;
+    for (const line of lines) {
+        // Enter the nested metadata: block.
+        if (/^metadata:\s*$/.test(line)) {
+            inMetadata = true;
+            continue;
+        }
+        // A new top-level key (no leading whitespace, ends the metadata block).
+        if (inMetadata && /^\S/.test(line)) {
+            inMetadata = false;
+        }
+        // metadata.type (indented under metadata:).
+        if (inMetadata) {
+            const m = /^\s+type:\s*(\S.*?)\s*$/.exec(line);
+            if (m) {
+                type = stripScalar(m[1]);
+                break;
+            }
+            continue;
+        }
+        // Fallback: a top-level `type:` (defensive; the corpus nests it).
+        const top = /^type:\s*(\S.*?)\s*$/.exec(line);
+        if (top && type === null) {
+            type = stripScalar(top[1]);
+        }
+    }
+    return { type, hasFrontmatter: true, malformed: false };
+}
+// MVP captures `project` only.
+function isCapturable(c) {
+    return c.type === "project";
+}

package/dist/lib/agent-memory-capture/collector.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendDecisions = appendDecisions;
+exports.runDryRunCollector = runDryRunCollector;
+// src/lib/agent-memory-capture/collector.ts
+//
+// Orchestrates one dry-run collection pass across all enabled bindings: take the
+// per-binding lock (skip if a live collector holds it), run the exact-byte
+// pipeline, append only the ACTIONABLE decisions to a metadata-only JSONL, and
+// release the lock. Uploads nothing (Phase 1).
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const lock_1 = require("./lock");
+const binding_1 = require("./binding");
+const pipeline_1 = require("./pipeline");
+const paths_1 = require("./paths");
+// Append the actionable decisions for one binding to its JSONL. Metadata only:
+// each line is {sourceId, relativePath, hash, bytes, decision, reason,
+// secretRuleIds, observedAt}. NEVER raw content. Unchanged/skipped no-ops are
+// dropped so the log does not grow without bound.
+function appendDecisions(bindingId, records, home = config_1.HOME) {
+    const actionable = records.filter((r) => (0, pipeline_1.isActionable)(r.decision));
+    if (actionable.length === 0)
+        return 0;
+    const dest = (0, paths_1.decisionLogPath)(bindingId, home);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(dest), { recursive: true });
+    const lines = actionable.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    (0, node_fs_1.appendFileSync)(dest, lines, { mode: 0o600 });
+    return actionable.length;
+}
+function runForBinding(binding, deps) {
+    const home = deps.home ?? config_1.HOME;
+    const lock = (0, lock_1.acquireBindingLock)(binding.bindingId, deps.nowIso, home);
+    if (!lock) {
+        return { bindingId: binding.bindingId, summary: null, locked: false, appended: 0 };
+    }
+    try {
+        const summary = (0, pipeline_1.collectOnce)(binding, deps);
+        const appended = appendDecisions(binding.bindingId, summary.records, home);
+        return { bindingId: binding.bindingId, summary, locked: true, appended };
+    }
+    finally {
+        lock.release();
+    }
+}
+// Run a dry-run pass over every enabled binding. Fail-soft per binding: one
+// binding's error never aborts the others.
+function runDryRunCollector(opts) {
+    const home = opts.home ?? config_1.HOME;
+    const bindings = (0, binding_1.listEnabledBindings)(home);
+    const deps = {
+        nowIso: opts.nowIso,
+        home,
+        ...(opts.scan ? { scan: opts.scan } : {}),
+        ...(opts.scannerVersion ? { scannerVersion: opts.scannerVersion } : {}),
+        ...(opts.scannerMode ? { scannerMode: opts.scannerMode } : {}),
+    };
+    const out = [];
+    for (const b of bindings) {
+        try {
+            out.push(runForBinding(b, deps));
+        }
+        catch {
+            out.push({ bindingId: b.bindingId, summary: null, locked: false, appended: 0 });
+        }
+    }
+    return out;
+}