negotium 0.3.0 → 0.3.2

package/dist/runtime/src/storage/decisions.ts

@@ -0,0 +1,231 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { logger } from "#platform/logger";
+import { sanitizeFileName } from "#security/sanitize";
+import { resolveStorageDataDir } from "#storage/storage-host";
+import type { AgentKind, DecisionSnapshot } from "#types";
+
+export type StoredDecision = DecisionSnapshot;
+
+export const DECISION_STATUS_VALUES = [
+  "proposed",
+  "accepted",
+  "executed",
+  "rejected",
+  "superseded",
+] as const;
+
+interface DecisionFileShape {
+  version: 1;
+  decisions: StoredDecision[];
+}
+
+function safeDecisionScopeKey(scopeKey: string): string {
+  const safe = sanitizeFileName(scopeKey);
+  if (!safe || safe === "." || safe === "..") {
+    throw new Error(`decisions: refusing unsafe scope key: ${scopeKey}`);
+  }
+  return safe;
+}
+
+export function decisionScopeKey(opts: { topicId?: string; session: string }): string {
+  return opts.topicId?.trim() || opts.session || "default";
+}
+
+export function getDecisionFilePath(userId: number | string, scopeKey: string): string {
+  void userId;
+  return join(resolveStorageDataDir(), "decisions", `${safeDecisionScopeKey(scopeKey)}.json`);
+}
+
+export function getDecisionGraphSvgPath(userId: number | string, scopeKey: string): string {
+  void userId;
+  return join(
+    resolveStorageDataDir(),
+    "decision-renders",
+    safeDecisionScopeKey(scopeKey),
+    "latest.svg",
+  );
+}
+
+export function writeDecisionGraphSvg(
+  userId: number | string,
+  scopeKey: string,
+  svg: string,
+): string {
+  const path = getDecisionGraphSvgPath(userId, scopeKey);
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, svg, "utf-8");
+  renameSync(tmp, path);
+  return path;
+}
+
+export function readDecisions(userId: number | string, scopeKey: string): StoredDecision[] {
+  const path = getDecisionFilePath(userId, scopeKey);
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as DecisionFileShape;
+    return Array.isArray(parsed?.decisions) ? parsed.decisions : [];
+  } catch (error) {
+    logger.warn({ err: error, path }, "decisions: failed to read decision store");
+    return [];
+  }
+}
+
+export function writeDecisions(
+  userId: number | string,
+  scopeKey: string,
+  decisions: StoredDecision[],
+): void {
+  const path = getDecisionFilePath(userId, scopeKey);
+  mkdirSync(dirname(path), { recursive: true });
+  const payload: DecisionFileShape = { version: 1, decisions };
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+
+export interface DecisionCreateInput {
+  action: string;
+  reasoning: string;
+  agent: AgentKind;
+  model?: string;
+  status?: StoredDecision["status"];
+  causedBy?: string[];
+  timestamp?: number;
+}
+
+export interface DecisionUpdateInput {
+  id: string;
+  action?: string;
+  reasoning?: string;
+  status?: StoredDecision["status"];
+  causedBy?: string[];
+}
+
+function nextDecisionId(decisions: StoredDecision[]): number {
+  let max = 0;
+  for (const decision of decisions) {
+    const id = Number(decision.id);
+    if (Number.isInteger(id) && id > max) max = id;
+  }
+  return max + 1;
+}
+
+function normalizedIds(ids: string[] | undefined): string[] | undefined {
+  if (!ids) return undefined;
+  const unique = [...new Set(ids.map((id) => id.trim()).filter(Boolean))];
+  return unique.length > 0 ? unique : undefined;
+}
+
+export function validateDecisionGraph(decisions: StoredDecision[]): void {
+  const ids = new Set(decisions.map((decision) => decision.id));
+  for (const decision of decisions) {
+    for (const upstream of decision.causedBy ?? []) {
+      if (!ids.has(upstream)) {
+        throw new Error(`Decision #${decision.id} references missing decision #${upstream}.`);
+      }
+      if (upstream === decision.id) {
+        throw new Error(`Decision #${decision.id} cannot cause itself.`);
+      }
+    }
+  }
+
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const byId = new Map(decisions.map((decision) => [decision.id, decision]));
+  const visit = (id: string): void => {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) throw new Error(`Decision graph contains a cycle at #${id}.`);
+    visiting.add(id);
+    for (const upstream of byId.get(id)?.causedBy ?? []) visit(upstream);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const id of ids) visit(id);
+}
+
+export function createDecisions(
+  decisions: StoredDecision[],
+  inputs: DecisionCreateInput[],
+): { decisions: StoredDecision[]; created: StoredDecision[] } {
+  const out = [...decisions];
+  const created: StoredDecision[] = [];
+  let id = nextDecisionId(out);
+  for (const input of inputs) {
+    const decision: StoredDecision = {
+      id: String(id++),
+      action: input.action.trim(),
+      reasoning: input.reasoning.trim(),
+      agent: input.agent,
+      status: input.status ?? "accepted",
+      timestamp: input.timestamp ?? Date.now(),
+      ...(input.model ? { model: input.model } : {}),
+      ...(normalizedIds(input.causedBy) ? { causedBy: normalizedIds(input.causedBy) } : {}),
+    };
+    out.push(decision);
+    created.push(decision);
+  }
+  validateDecisionGraph(out);
+  return { decisions: out, created };
+}
+
+export function updateDecisions(
+  decisions: StoredDecision[],
+  updates: DecisionUpdateInput[],
+): { decisions: StoredDecision[]; missing: string[] } {
+  const out = decisions.map((decision) => ({
+    ...decision,
+    ...(decision.causedBy ? { causedBy: [...decision.causedBy] } : {}),
+  }));
+  const byId = new Map(out.map((decision) => [decision.id, decision]));
+  const missing: string[] = [];
+  for (const update of updates) {
+    const decision = byId.get(update.id);
+    if (!decision) {
+      missing.push(update.id);
+      continue;
+    }
+    if (update.action !== undefined) decision.action = update.action.trim();
+    if (update.reasoning !== undefined) decision.reasoning = update.reasoning.trim();
+    if (update.status !== undefined) decision.status = update.status;
+    if (update.causedBy !== undefined) {
+      const ids = normalizedIds(update.causedBy);
+      if (ids) decision.causedBy = ids;
+      else delete decision.causedBy;
+    }
+  }
+  validateDecisionGraph(out);
+  return { decisions: out, missing };
+}
+
+export function deleteDecisions(
+  decisions: StoredDecision[],
+  opts: { ids?: string[]; all?: boolean },
+): { decisions: StoredDecision[]; removed: number } {
+  if (opts.all) return { decisions: [], removed: decisions.length };
+  const ids = new Set(opts.ids ?? []);
+  const kept = decisions
+    .filter((decision) => !ids.has(decision.id))
+    .map((decision) => {
+      const causedBy = decision.causedBy?.filter((id) => !ids.has(id));
+      const next = { ...decision };
+      if (causedBy && causedBy.length > 0) next.causedBy = causedBy;
+      else delete next.causedBy;
+      return next;
+    });
+  return { decisions: kept, removed: decisions.length - kept.length };
+}
+
+export function renderDecisionList(decisions: StoredDecision[]): string {
+  if (decisions.length === 0) return "Decisions (0 recorded)";
+  return [
+    `Decisions (${decisions.length} recorded)`,
+    ...decisions.map((decision) => {
+      const causes = decision.causedBy?.length
+        ? ` <- ${decision.causedBy.map((id) => `#${id}`).join(", ")}`
+        : "";
+      return `[${decision.status}] #${decision.id} ${decision.action}${causes}\n  ${decision.reasoning}`;
+    }),
+  ].join("\n");
+}

package/dist/runtime/src/storage/storage-public.ts

@@ -20,6 +20,8 @@ export * as askUserGates from "#storage/ask-user-gates";
 export * from "#storage/ask-user-gates";
 export * as conversations from "#storage/conversations";
 export * from "#storage/conversations";
+export * as decisions from "#storage/decisions";
+export * from "#storage/decisions";
 export type {
   ForumTopicInfo,
   TopicRow,

package/dist/runtime/src/types.ts

@@ -97,6 +97,19 @@ export interface TaskSnapshot {
   owner?: string;
 }
 
+/** One topic-scoped decision and its incoming causal edges. */
+export interface DecisionSnapshot {
+  id: string;
+  action: string;
+  reasoning: string;
+  agent: AgentKind;
+  model?: string;
+  status: "proposed" | "accepted" | "executed" | "rejected" | "superseded";
+  /** Upstream decision ids. Each entry forms a directed upstream -> this edge. */
+  causedBy?: string[];
+  timestamp: number;
+}
+
 export type UnifiedEvent =
   | {
       type: "user_message";

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.3.0";
+export const NEGOTIUM_VERSION = "0.3.2";

package/dist/runtime-helpers.js

@@ -535,7 +535,7 @@ var DM_WORKSPACE_DIR = resolve(STATE_DIR, "data", "dm");
 var SESSION_WORKSPACE_DIR = resolve(STATE_DIR, "data", "sessions");
 var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
 var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve(CLAUDE_EXECUTABLE_ENV) : undefined;
-var BROWSER_RS_VERSION = "v0.1.19";
+var BROWSER_RS_VERSION = "v0.1.21";
 var BROWSER_RS_MIN_SECURE_VERSION = "0.1.15";
 function versionAtLeast(actualVersion, minimumVersion) {
   const actual = actualVersion.split(".").map(Number);
@@ -605,6 +605,7 @@ var TSX_LOADER = createRequire(import.meta.url).resolve("tsx");
 var TSCONFIG_PATH = resolve(PROJECT_ROOT, "tsconfig.json");
 var SESSION_COMM_SERVER = resolve(PROJECT_ROOT, "src/mcp/session-comm/server.ts");
 var TASK_SERVER = resolve(PROJECT_ROOT, "src/mcp/task-server.ts");
+var DECISION_SERVER = resolve(PROJECT_ROOT, "src/mcp/decision-server.ts");
 var BROWSER_MCP_SSE_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/browser-sse-proxy-server.ts");
 var CANONICAL_MCP_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/canonical-proxy-server.ts");
 var WIKI_SERVER = resolve(PROJECT_ROOT, "src/mcp/wiki-server.ts");
@@ -1439,6 +1440,10 @@ function buildMermaidHtml(code, theme, scriptUrl = MERMAID_BROWSER_ASSET_RELATIV
     .controls button:focus-visible{outline:2px solid var(--celadon);outline-offset:1px}
     .zoom-value{min-width:46px;color:var(--graphite);font:500 11px/1 Geist,system-ui,sans-serif;text-align:center;font-variant-numeric:tabular-nums}
     .error{margin:0;white-space:pre-wrap;color:#7D2E2E;background:#FFF5F2;border:1px solid #E4B9B1;border-radius:6px;padding:14px;font:13px ui-monospace,SFMono-Regular,Menlo,monospace}
+    .failure{max-width:56ch;margin:0 auto}
+    .failure p{margin:0 0 12px;color:var(--graphite);font:14px/1.6 Geist,system-ui,sans-serif}
+    .failure details{color:var(--graphite);font:12px/1.5 Geist,system-ui,sans-serif}
+    .failure summary{cursor:pointer;padding:4px 0}
     @media(max-width:600px){.viewport{padding:54px 14px 18px}.controls{top:10px;right:10px}}
   </style>
 </head>
@@ -1453,11 +1458,58 @@ function buildMermaidHtml(code, theme, scriptUrl = MERMAID_BROWSER_ASSET_RELATIV
   <script data-otium-mermaid-runtime src="${safeScriptUrl}"></script>
   <script>
     (async () => {
+      // An unrendered document reports itself in more than one voice: Mermaid's
+      // own 0x0 guard, and the browser refusing geometry on a path that was
+      // never laid out. Both mean the same thing, so both are worth one retry
+      // and, if it still fails, the same explanation.
+      const unrendered = (error) => {
+        const message = String(error && error.message ? error.message : error);
+        return message.indexOf("not in render tree") !== -1 || message.indexOf("path is empty") !== -1;
+      };
       try {
       const runtime = globalThis.mermaid;
       if (!runtime) throw new Error("Mermaid renderer failed to load.");
       runtime.initialize({ startOnLoad: false, securityLevel: "strict", theme: ${safeTheme} });
-      await runtime.run({ querySelector: ".mermaid" });
+      const host = document.querySelector(".mermaid");
+      // Mermaid sizes every label by appending a probe <svg> to the body and
+      // reading getBBox(), and it throws "svg element not in render tree" the
+      // moment that comes back 0x0. That is what a hidden panel looks like from
+      // in here: the document exists but nothing is in the render tree, so the
+      // measurement has no geometry to report. Ask the same question Mermaid
+      // will ask, and only start once it has an answer.
+      const measurable = () => {
+        const probe = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+        const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
+        text.textContent = "M";
+        probe.appendChild(text);
+        document.body.appendChild(probe);
+        let box = { width: 0, height: 0 };
+        try { box = text.getBBox(); } catch (ignored) {}
+        probe.remove();
+        return box.width > 0 || box.height > 0;
+      };
+      // requestAnimationFrame is the right clock here: a hidden document stops
+      // being animated, so this waits without spinning and resumes on the frame
+      // the panel is shown. The cap counts rendered frames, not wall time.
+      const waitUntilMeasurable = async (maxFrames) => {
+        for (let frame = 0; frame < maxFrames; frame += 1) {
+          if (measurable()) return true;
+          await new Promise((next) => requestAnimationFrame(next));
+        }
+        return measurable();
+      };
+      await waitUntilMeasurable(600);
+      try {
+        await runtime.run({ querySelector: ".mermaid" });
+      } catch (firstAttempt) {
+        if (!unrendered(firstAttempt)) throw firstAttempt;
+        // The panel can be hidden again between the probe and the real measure.
+        // Clear the marker Mermaid leaves behind so the retry is not skipped as
+        // already done, then wait for the render tree once more.
+        host.removeAttribute("data-processed");
+        await waitUntilMeasurable(600);
+        await runtime.run({ querySelector: ".mermaid" });
+      }
       const viewport = document.querySelector(".viewport");
       const svg = document.querySelector(".mermaid svg");
       const value = document.querySelector(".zoom-value");
@@ -1484,7 +1536,22 @@ function buildMermaidHtml(code, theme, scriptUrl = MERMAID_BROWSER_ASSET_RELATIV
       applyScale(scale, false);
       } catch (error) {
         document.querySelector(".controls")?.remove();
-        document.querySelector(".viewport").innerHTML = '<pre class="error">' + String(error && error.message ? error.message : error).replace(/[&<>]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c])) + '</pre>';
+        const raw = String(error && error.message ? error.message : error);
+        const escape = (value) => value.replace(/[&<>]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));
+        // Mermaid aborts the whole render when it cannot place an edge label:
+        // cardinality markers ask for a point a fixed distance along the edge,
+        // and a relation laid out shorter than that walks off the end. Nothing
+        // is wrong with the diagram, so the raw message sends authors looking
+        // for a syntax error that does not exist. Say what actually moves it.
+        const note = raw.indexOf("Could not find a suitable point") !== -1
+          ? "Two nodes ended up too close together for Mermaid to fit a label on the edge between them. Renaming a node, adding another, or setting an explicit direction usually spreads the layout enough to render."
+          : unrendered(error)
+          ? "The panel stayed hidden long enough that there was never a laid-out page to measure the diagram against. Reopening the panel renders it."
+          : "This diagram could not be rendered.";
+        document.querySelector(".viewport").innerHTML =
+          '<div class="failure"><p>' + escape(note) +
+          '</p><details><summary>Technical detail</summary><pre class="error">' +
+          escape(raw) + '</pre></details></div>';
       }
     })();
   </script>
@@ -1596,4 +1663,4 @@ export {
   CLAUDE_EFFORT_VALUES
 };
 
-//# debugId=4D0763B626E155F864756E2164756E21
+//# debugId=002587304D7533BD64756E2164756E21