openmausbot 0.1.84 → 0.1.86

package/dist-server/server/decision-log.js

@@ -15,44 +15,88 @@
 // credentials included), and fire-and-forget — an audit log must never
 // take down the decision it is auditing.
 //
+// Layout and retention follow the usage ledger: one file per UTC month under
+// <data>/decisions/YYYY-MM.ndjson, and a month file is deleted only once the
+// whole month is older than the retention window (default 180 days, config
+// `decisions.retentionDays` or OMB_DECISION_RETENTION_DAYS), so at least that
+// much history is always kept. Older servers wrote one decisions.ndjson that
+// rotated to .1 at 4 MB; both are still read, never written, and removed by
+// the same window once their last row is older than it.
+//
 // Deliberately NOT covered: ask_bot peer-approval cards. They never cross
 // the runtime bus (peer-approval.ts appends its cards straight to the
 // store), so wiring them here would mean a second, parallel tap — a
 // separate change if it earns its keep.
-import { readFileSync } from "node:fs";
-import { appendFile, rename, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { readdirSync, readFileSync } from "node:fs";
+import { appendFile, mkdir, readdir, stat, unlink } from "node:fs/promises";
+import { basename, join } from "node:path";
 import { redactSecrets } from "./redact.js";
-const FILE_NAME = "decisions.ndjson";
-// Rotation is logrotate at its simplest: when the live file crosses the cap
-// it becomes `.1` (clobbering the previous `.1`) and a fresh file starts.
-// Total disk is bounded at ~2× the cap; at a few hundred bytes per row that
-// is years of human-scale approvals, and anything fancier — dated segments,
-// compression — is more machinery than an audit trail this size warrants.
-const MAX_BYTES = 4 * 1024 * 1024;
+import { csvCell } from "./usage-ledger.js";
+const DIR = "decisions";
+const LEGACY_FILE = "decisions.ndjson";
+const MONTH_FILE = /^(\d{4})-(\d{2})\.ndjson$/;
+const DAY_MS = 24 * 60 * 60_000;
+const PRUNE_EVERY_MS = 60 * 60_000;
+export const DEFAULT_DECISION_RETENTION_DAYS = 180;
+export const MAX_DECISION_RETENTION_DAYS = 3650;
 const writeQueues = new Map();
-async function writeDecision(dataDir, row, maxBytes) {
-    const file = join(dataDir, FILE_NAME);
-    try {
-        if ((await stat(file)).size >= maxBytes)
-            await rename(file, `${file}.1`);
-    }
-    catch {
-        /* no live file yet — nothing to rotate */
+const lastPrune = new Map();
+let retentionDays = () => DEFAULT_DECISION_RETENTION_DAYS;
+/** The server binds its configured window once; see decisionRetentionDays. */
+export function bindDecisionRetention(provider) {
+    retentionDays = provider;
+}
+/** The window in force now. The admin activity log (admin-activity.ts)
+ * keeps its months for the same time, so one setting covers both. */
+export function boundRetentionDays() {
+    return retentionDays();
+}
+/** The retention window in days: OMB_DECISION_RETENTION_DAYS when it is a
+ * whole number in range, else the configured value, else 180. */
+export function decisionRetentionDays(configured, env = process.env) {
+    const fromEnv = env.OMB_DECISION_RETENTION_DAYS?.trim();
+    const parsed = fromEnv ? Number(fromEnv) : NaN;
+    if (Number.isInteger(parsed) && parsed >= 1 && parsed <= MAX_DECISION_RETENTION_DAYS)
+        return parsed;
+    if (typeof configured === "number" && Number.isInteger(configured) && configured >= 1 && configured <= MAX_DECISION_RETENTION_DAYS)
+        return configured;
+    return DEFAULT_DECISION_RETENTION_DAYS;
+}
+const actorScope = new AsyncLocalStorage();
+/** Run `work` as a person's card answer: every `source: "user"` row it
+ * writes names `actor`, without each resolver having to thread it through. */
+export function withDecisionActor(actor, work) {
+    return actorScope.run(actor, work);
+}
+function monthKey(at) {
+    return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+export function decisionFileFor(dataDir, at) {
+    return join(dataDir, DIR, `${monthKey(at)}.ndjson`);
+}
+async function writeDecision(dataDir, record) {
+    const at = new Date(record.at);
+    await mkdir(join(dataDir, DIR), { recursive: true, mode: 0o700 });
+    await appendFile(decisionFileFor(dataDir, at), JSON.stringify(record) + "\n", { mode: 0o600 });
+    if (at.getTime() - (lastPrune.get(dataDir) ?? 0) >= PRUNE_EVERY_MS) {
+        lastPrune.set(dataDir, at.getTime());
+        await pruneDecisions(dataDir, retentionDays(), at);
     }
-    const record = redactSecrets({ at: new Date().toISOString(), ...row });
-    await appendFile(file, JSON.stringify(record) + "\n", { mode: 0o600 });
 }
 /** Append one decision row. Fire-and-forget, mirroring the event bus tee:
  * the fold that calls this is delivering approvals and cards, and a full
  * disk must not turn into denied tools. */
-export function appendDecision(dataDir, row, opts) {
+export function appendDecision(dataDir, row) {
+    const actor = row.actor ?? (row.source === "user" ? actorScope.getStore() : undefined);
+    // Redact now, not when the queue drains: the row is what was true at the
+    // moment of the decision.
+    const record = redactSecrets({ at: new Date().toISOString(), ...row, ...(actor ? { actor } : {}) });
     const previous = writeQueues.get(dataDir) ?? Promise.resolve();
-    // Serialize stat → optional rotate → append for each directory. Without
-    // this queue two simultaneous approvals can both rotate, overwrite .1,
-    // or append out of decision order.
+    // Serialize appends (and the occasional prune) per directory, so two
+    // simultaneous approvals keep their decision order.
     const queued = previous
-        .then(() => writeDecision(dataDir, row, opts?.maxBytes ?? MAX_BYTES))
+        .then(() => writeDecision(dataDir, record))
         .catch(() => {
         /* logging must never take down the fold */
     });
@@ -67,40 +111,157 @@ export function appendDecision(dataDir, row, opts) {
 export async function flushDecisionLog(dataDir) {
     await writeQueues.get(dataDir);
 }
+/** Delete what the window no longer covers: a month file once the first
+ * instant after its month is at or before `now - days`, a legacy file once
+ * its last write is. Returns the names removed. Never throws. */
+export async function pruneDecisions(dataDir, days, now = new Date()) {
+    const cutoff = now.getTime() - days * DAY_MS;
+    const removed = await pruneMonthFiles(join(dataDir, DIR), days, now);
+    for (const name of [`${LEGACY_FILE}.1`, LEGACY_FILE]) {
+        try {
+            if ((await stat(join(dataDir, name))).mtimeMs > cutoff)
+                continue;
+            await unlink(join(dataDir, name));
+            removed.push(name);
+        }
+        catch {
+            /* absent */
+        }
+    }
+    return removed;
+}
+/** Delete the `YYYY-MM.ndjson` files in `dir` whose whole month is at or
+ * before `now - days`. Returns the names removed. Never throws. Shared with
+ * the admin activity log. */
+export async function pruneMonthFiles(dir, days, now = new Date()) {
+    const cutoff = now.getTime() - days * DAY_MS;
+    const removed = [];
+    let names = [];
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        /* nothing written in the new layout yet */
+    }
+    for (const name of names) {
+        const match = MONTH_FILE.exec(name);
+        if (!match || Date.UTC(Number(match[1]), Number(match[2]), 1) > cutoff)
+            continue;
+        try {
+            await unlink(join(dir, name));
+            removed.push(name);
+        }
+        catch {
+            /* already gone, or not ours to remove */
+        }
+    }
+    return removed;
+}
 const isDecisionRow = (value) => typeof value === "object" &&
     value !== null &&
     typeof value.at === "string" &&
     typeof value.threadId === "string" &&
     typeof value.decision === "string" &&
     typeof value.source === "string";
-/** The newest `limit` rows, oldest first — the same order the inspector
- * uses for thread events. Reads `.1` before the live file so a request
- * right after a rotation still sees history instead of a nearly empty
- * log; whole-file reads are fine here because rotation caps both files,
- * unlike the unbounded per-thread event logs that need a tail walk. */
-export function readDecisions(dataDir, limit) {
-    const file = join(dataDir, FILE_NAME);
+function readRows(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return [];
+    }
     const rows = [];
-    for (const path of [`${file}.1`, file]) {
-        let text;
+    for (const line of text.split("\n")) {
+        if (!line)
+            continue;
         try {
-            text = readFileSync(path, "utf8");
+            const value = JSON.parse(line);
+            if (isDecisionRow(value))
+                rows.push(value);
         }
         catch {
-            continue;
+            /* a line torn mid-write — skip the fragment, keep the rest */
         }
-        for (const line of text.split("\n")) {
-            if (!line)
-                continue;
-            try {
-                const value = JSON.parse(line);
-                if (isDecisionRow(value))
-                    rows.push(value);
-            }
-            catch {
-                /* a line torn mid-write — skip the fragment, keep the rest */
-            }
+    }
+    return rows;
+}
+/** Every file that may hold rows, oldest first: the legacy pair (which only
+ * ever holds rows older than any month file), then the months in order. */
+function sources(dataDir) {
+    let months = [];
+    try {
+        months = readdirSync(join(dataDir, DIR)).filter((name) => MONTH_FILE.test(name)).sort();
+    }
+    catch {
+        /* no month files yet */
+    }
+    return [join(dataDir, `${LEGACY_FILE}.1`), join(dataDir, LEGACY_FILE), ...months.map((name) => join(dataDir, DIR, name))];
+}
+/** The newest `limit` rows, oldest first — the same order the inspector
+ * uses for thread events. Reads month files newest first and stops once it
+ * has enough, so a long history costs no more than the page asked for. */
+export function readDecisions(dataDir, limit) {
+    const files = sources(dataDir);
+    const chunks = [];
+    let count = 0;
+    for (let index = files.length - 1; index >= 0 && count < limit; index -= 1) {
+        const rows = readRows(files[index]);
+        chunks.unshift(rows);
+        count += rows.length;
+    }
+    return chunks.flat().slice(-limit);
+}
+/** Every row whose time falls inside the range, oldest first. */
+export function readDecisionRange(dataDir, range) {
+    const from = range.from.getTime();
+    const to = range.to.getTime();
+    const first = monthKey(range.from);
+    const last = monthKey(range.to);
+    const rows = [];
+    for (const file of sources(dataDir)) {
+        // Month files outside the range are skipped unread; legacy files have no month.
+        const month = MONTH_FILE.exec(basename(file));
+        if (month && (`${month[1]}-${month[2]}` < first || `${month[1]}-${month[2]}` > last))
+            continue;
+        for (const row of readRows(file)) {
+            const at = Date.parse(row.at);
+            if (at >= from && at <= to)
+                rows.push(row);
         }
     }
-    return rows.slice(-limit);
+    return rows;
+}
+export function actorLabel(actor) {
+    if (!actor)
+        return "";
+    if (actor.kind === "loopback")
+        return "This computer";
+    if (actor.kind === "worker")
+        return "Local service";
+    return actor.email ?? actor.label;
+}
+/** One line per decision, spreadsheet-ready. Cells go through the usage
+ * CSV's formula neutralising, and every row through redaction again, so an
+ * export never carries more than the log itself may. */
+export function decisionsCsv(rows) {
+    const header = ["time", "decision", "source", "bot", "tool", "summary", "rule", "unattended", "answered_by", "thread", "request"];
+    const lines = [header.join(",")];
+    for (const raw of rows) {
+        const row = redactSecrets(raw);
+        lines.push([
+            row.at,
+            row.decision,
+            row.source,
+            row.botName || row.botId || "",
+            row.tool ?? "",
+            row.summary ?? "",
+            row.rule ?? "",
+            row.unattended ? "yes" : "",
+            actorLabel(row.actor),
+            row.threadId,
+            row.requestId ?? "",
+        ].map(csvCell).join(","));
+    }
+    return lines.join("\n") + "\n";
 }

package/dist-server/server/default-model-selection.js

@@ -1,10 +1,14 @@
+const claudeFirst = (instances) => instances.find((instance) => instance.driverKind === "claudeAgent") ?? instances[0];
 /** A saved choice is intentional: an unavailable provider or removed model
  * sends new bots to setup instead of silently changing their provider. */
-export function selectDefaultModelSelection(instances, preferred) {
+export function selectDefaultModelSelection(instances, preferred, context = {}) {
     if (preferred) {
         const instance = instances.find((candidate) => candidate.instanceId === preferred.instanceId);
         if (instance?.snapshot.state !== "available" ||
             instance.snapshot.authenticated === false ||
+            // An organisation that disallows the saved engine makes it unusable,
+            // exactly like an unavailable one: setup, never another provider.
+            context.refusal?.(instance) !== undefined ||
             (preferred.variant !== undefined && !instance.capabilities?.modelVariants) ||
             !(instance.models.default === preferred.model || instance.models.options.some((model) => model.id === preferred.model))) {
             return { instanceId: "", model: "" };
@@ -16,7 +20,20 @@ export function selectDefaultModelSelection(instances, preferred) {
             delete selection.effort;
         return selection;
     }
-    const available = instances.filter((instance) => instance.snapshot.state === "available");
-    const pick = available.find((instance) => instance.driverKind === "claudeAgent") ?? available[0];
+    // The organisation's policy is inert (no refusal) unless this desktop is enrolled.
+    const available = instances.filter((instance) => instance.snapshot.state === "available" && context.refusal?.(instance) === undefined);
+    const company = context.company;
+    let pick;
+    if (company && instances.some((instance) => company(instance.instanceId))) {
+        // Enrolled: an installed but signed-out personal Claude would send every
+        // new bot to setup although a Company model can run. Prefer instances that
+        // can run a turn now; a working personal engine still wins, so billing
+        // stays the person's explicit choice.
+        const ready = available.filter((instance) => instance.access === "custom" || instance.snapshot.authenticated !== false);
+        pick = claudeFirst(ready.filter((instance) => !company(instance.instanceId))) ?? claudeFirst(ready) ?? claudeFirst(available);
+    }
+    else {
+        pick = claudeFirst(available);
+    }
     return { instanceId: pick?.instanceId ?? "", model: pick?.models.default ?? "" };
 }

package/dist-server/server/delegations.js

@@ -642,17 +642,19 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     await runTarget(item.toBotId, prefixed, item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId);
     return "dispatched";
 }
-/** "Is the target free to take this handoff right now?" What "busy" means
- * depends on where the turn will run: a classic delegation lands in the
- * target's active thread, so it needs the bot to be idle; a fresh-thread
- * handoff needs only a free slot. This is the single free/busy test shared
- * by the expiry decision in `processOne` and the hold decision below, so
- * the two can never disagree about whether a handoff could have been
- * delivered right now. */
+/** "Is the target free to take this handoff right now?" Both shapes ask for
+ * a free capacity slot, never whole-bot idleness: a classic delegation lands
+ * in the target's standing thread and applies the same admission startTurn
+ * uses for a direct turn there, while a fresh-thread handoff needs any free
+ * slot. This is the single free/busy test shared by the expiry decision in
+ * `processOne` and the hold decision below, so the two can never disagree
+ * about whether a handoff could have been delivered right now. */
 function targetCanTakeTurn(bus, target, item) {
     return item.targetThreadId
         ? (bus.threadSlotFree ? bus.threadSlotFree(target.id) : !target.busy)
-        : !target.busy;
+        : bus.canAdmitDirectTurn
+            ? bus.canAdmitDirectTurn(target.id, target.threadId)
+            : !target.busy;
 }
 /** A busy target holds the handoff. Neither counts busy periods — the only
  * bound is DELEGATION_TTL_MS, checked in processOne before this runs (using
@@ -724,7 +726,7 @@ function sourceThreadBelongsToBot(store, botId, threadId) {
  * have moved either bot, or narrowed the sender's peers, in between. */
 function dropIfUnreachable(bus, sender, target, sourceThreadId, item) {
     const sectionsDiffer = !canAccessTeam(sender, target.section);
-    if (!sectionsDiffer && !target.hidden && peerAllowed(sender, target.id))
+    if (!sectionsDiffer && !target.hidden && peerAllowed(sender, target))
         return false;
     const reason = sectionsDiffer
         ? "bots now belong to different sections"

package/dist-server/server/digest.js

@@ -0,0 +1,130 @@
+/** Evidence is observed, not inferred from a provider's brand. In particular,
+ * OpenAI-compatible and Grok turns now expose structured tool activity too. */
+export function coverageForDriver(_driverKind, fullResults = false, observedTools = false) {
+    return fullResults ? "full" : observedTools ? "preview" : "none";
+}
+/** True when every tool row of the turn carries a delivered (untruncated)
+ * result — what a PostToolUse hook gives us — so the digest may claim
+ * "full" evidence. One preview-only row means the turn is "preview". */
+export function toolEvidence(activities, turnId) {
+    const rows = activities.filter((m) => m.kind === "activity" && m.tool?.itemId && m.turnId === turnId);
+    return rows.length > 0 && rows.every((m) => m.tool?.fullResult === true);
+}
+export const MAX_TOOLS = 8;
+export const MAX_FILES = 20;
+export const MAX_MEMORY = 20;
+export const REPLY_CHARS = 200;
+export const RENDER_BYTES = 1_500;
+export function buildTurnDigest(input) {
+    const byName = new Map();
+    for (const m of input.activities) {
+        if (m.kind !== "activity" || !m.tool?.itemId || m.turnId !== input.turnId)
+            continue;
+        const entry = byName.get(m.tool.name) ?? { name: fitBytes(m.tool.name, 160), count: 0, failed: 0 };
+        entry.count += 1;
+        if (m.tool.ok === false)
+            entry.failed += 1;
+        if (entry.sample === undefined && m.tool.summary)
+            entry.sample = fitBytes(m.tool.summary.replace(/\s+/g, " "), 300);
+        byName.set(m.tool.name, entry);
+    }
+    // busiest first; ties keep first-seen order (Map preserves insertion)
+    const ranked = [...byName.values()].sort((a, b) => b.count - a.count);
+    const tools = ranked.slice(0, MAX_TOOLS);
+    const toolsDropped = ranked.length - tools.length;
+    const memory = input.memory.slice(0, MAX_MEMORY).map((row) => ({
+        path: fitBytes(row.path, 512),
+        kind: (row.kind === "edited" ? "updated" : row.kind),
+    }));
+    const digest = {
+        turnId: input.turnId,
+        botId: input.botId,
+        threadId: input.threadId,
+        at: input.at,
+        durationMs: input.durationMs,
+        tools,
+        toolCalls: ranked.reduce((sum, tool) => sum + tool.count, 0),
+        ...(toolsDropped > 0 ? { toolsDropped } : {}),
+        ...(input.files ? { files: boundFiles(input.files) } : {}),
+        memory,
+        ...(input.memory.length > memory.length ? { memoryDropped: input.memory.length - memory.length } : {}),
+        reply: firstSentence(input.reply),
+        ...(input.usage ? { usage: input.usage } : {}),
+        hookCoverage: input.hookCoverage,
+    };
+    return digest;
+}
+function boundFiles(files) {
+    let budget = MAX_FILES;
+    let truncated = files.truncated ?? 0;
+    const take = (list) => {
+        const kept = list.slice(0, Math.max(0, budget)).map(path => fitBytes(path, 512));
+        truncated += list.length - kept.length;
+        budget -= kept.length;
+        return kept;
+    };
+    const changed = take(files.changed);
+    const added = take(files.added);
+    const deleted = take(files.deleted);
+    return { changed, added, deleted, ...(truncated > 0 ? { truncated } : {}) };
+}
+function firstSentence(reply) {
+    const flat = reply.replace(/\s+/g, " ").trim();
+    const end = flat.search(/[.!?](\s|$)/);
+    const sentence = end === -1 ? flat : flat.slice(0, end + 1);
+    return sentence.slice(0, REPLY_CHARS);
+}
+/** The transcript row's text: one paragraph, FTS-indexed, ≤ RENDER_BYTES. */
+export function renderDigest(d) {
+    const parts = ["[digest]"];
+    if (d.tools.length) {
+        const tools = d.tools.map((t) => `${t.name} ×${t.count}${t.failed ? ` (${t.failed} failed)` : ""}`).join(", ");
+        parts.push(`tools: ${tools}${d.toolsDropped ? ` +${d.toolsDropped} more` : ""}${d.hookCoverage === "preview" ? " (from tool previews)" : ""}`);
+    }
+    else if (d.hookCoverage === "none") {
+        parts.push("no tool activity observed in this turn");
+    }
+    else {
+        parts.push("no tool calls");
+    }
+    if (d.files) {
+        const files = [];
+        if (d.files.changed.length)
+            files.push(`changed ${d.files.changed.join(", ")}`);
+        if (d.files.added.length)
+            files.push(`added ${d.files.added.join(", ")}`);
+        if (d.files.deleted.length)
+            files.push(`deleted ${d.files.deleted.join(", ")}`);
+        if (d.files.truncated)
+            files.push(`+${d.files.truncated} more paths`);
+        parts.push(files.length ? `files: ${files.join("; ")}` : "files: none changed");
+    }
+    if (d.memory.length)
+        parts.push(`memory: ${d.memory.map((m) => `${m.kind} ${m.path}`).join(", ")}`);
+    if (d.memoryDropped)
+        parts.push(`+${d.memoryDropped} more memory changes`);
+    if (d.reply)
+        parts.push(`reply: ${d.reply}`);
+    return fitBytes(parts.join(" · "), RENDER_BYTES);
+}
+/** One bracketed line for a context rebuild — never multi-line, so it sits
+ * in a transcript replay or a room window like any other speaker line. */
+export function digestPromptLine(d, botName) {
+    const body = renderDigest(d).replace(/^\[digest\]\s*/, "").replace(/\s+/g, " ").trim();
+    return `[What ${botName} did in an earlier turn: ${body}]`;
+}
+/** Trim to a byte budget on a character boundary, marking the cut. */
+function fitBytes(text, max) {
+    if (Buffer.byteLength(text, "utf8") <= max)
+        return text;
+    const marker = " […]";
+    let out = "";
+    let bytes = Buffer.byteLength(marker);
+    for (const character of text) {
+        bytes += Buffer.byteLength(character);
+        if (bytes > max)
+            break;
+        out += character;
+    }
+    return out + marker;
+}