mover-os 4.7.8 → 4.7.10

package/src/dashboard/lib/state-core/start-close.js

@@ -0,0 +1,162 @@
+"use strict";
+
+// start-close.js — CORE-LOOP PHASE 2b (SCHEMA-SPEC v0.2 section 3, owner
+// default #4). The two verbs the whole loop collapses into, as LIBRARY
+// functions only: nothing here is wired to a workflow, hook, or server
+// route yet. Wiring comes after the owner inspects the migration manifest.
+//
+//   start(vaultRoot, ...)  = reap orphaned sessions from before, write
+//                            session.started, and (optionally) inventory
+//                            today's plan (plan.observed + plan.ticked from
+//                            the note's checkboxes). No other side effects.
+//   close(vaultRoot, ...)  = write the session's gathered facts +
+//                            session.closed, then rebuild and write the four
+//                            projection files beside the legacy ones.
+//
+// Projections are rebuildable, never hand-edited (spec section 2), so
+// writeProjections overwrites them wholesale on every Close. The file bytes
+// use the SAME assembly as dryrun.js's manifest (projectionFileText), so a
+// Close over an unchanged log at the same clock reading reproduces the
+// migration's bytes exactly — tested in state-core-startclose.test.mjs.
+
+const fs = require("fs");
+const path = require("path");
+const events = require("./events");
+const { appendEvent, readEvents, acquireLock } = require("./event-log");
+
+// A session younger than this is NEVER reaped by another Start's sweep:
+// terra attack 5 reproduced session B (started 1ms after A) reaping live
+// session A. The grace window makes parallel sessions safe without a
+// liveness lease; a genuinely crashed session is reaped by the first Start
+// that runs after the window. Wiring may later pass real liveness (agent
+// pids) to tighten this.
+const DEFAULT_REAP_GRACE_MS = 24 * 3600 * 1000;
+const { rebuildProjections } = require("./projections");
+const { projectionFileText, PROJECTION_NAMES, STATE_DIR, LOG_NAME } = require("./dryrun");
+const { backfillDailyTasks } = require("./backfill");
+
+function logPathFor(vaultRoot) {
+  return path.join(vaultRoot, STATE_DIR, LOG_NAME);
+}
+
+// Rebuilds from the log and overwrites the four projection files. Holds the
+// log's advisory lock across the read-reduce-write so a concurrent append
+// cannot land between the rebuild and the file writes (terra attack 6
+// reproduced a stored projection with a stale watermark that way), and each
+// file goes through a same-dir temp+rename so a crash never leaves a
+// half-written projection. Returns the rebuild result.
+function writeProjections(vaultRoot, { now, lockWaitMs } = {}) {
+  const nowMs = typeof now === "number" ? now : Date.now();
+  const logPath = logPathFor(vaultRoot);
+  const lock = acquireLock(logPath, lockWaitMs != null ? { lockWaitMs } : {});
+  try {
+    const rebuilt = rebuildProjections(logPath, { now: () => nowMs });
+    const watermark = { id: rebuilt.body.throughEventId, ts: rebuilt.body.throughEventTs };
+    for (const [kind, name] of Object.entries(PROJECTION_NAMES)) {
+      const dest = path.join(vaultRoot, STATE_DIR, name);
+      const tmp = `${dest}.tmp-${process.pid}`;
+      fs.writeFileSync(tmp, projectionFileText(kind, rebuilt.body[kind], watermark, rebuilt.body.eventCount, nowMs), "utf8");
+      fs.renameSync(tmp, dest);
+    }
+    return rebuilt;
+  } finally {
+    lock.release();
+  }
+}
+
+// Start = session.started + orphan sweep + (optional) plan inventory.
+// The sweep runs BEFORE this session's own started event is appended, so a
+// session can never reap itself. planNote is today's Daily Note content:
+// its checkboxes become the honest denominator (plan.observed) plus a
+// plan.ticked for boxes already [x] — both dedupe on identical re-runs, so
+// a double Start is harmless.
+// One TOTAL wall-clock budget across a whole start()/close() call (sol #8
+// partial refutation 2: lockWaitMs bounded each acquisition, but a call
+// performs one acquisition per orphan/fact, so a hook child had no single
+// deadline). Returns append options for the NEXT acquisition: the per-append
+// wait shrinks to the remaining budget; when the budget is spent it throws,
+// and the caller's partial work stands (appends are individually atomic and
+// deduped, so the next session's Start/Close catches up losslessly).
+function budgetedOpts(deadlineAt, lockWaitMs) {
+  if (deadlineAt == null) return lockWaitMs != null ? { lockWaitMs } : {};
+  const remaining = deadlineAt - Date.now();
+  if (remaining <= 0) throw new Error("start-close: total budget exhausted (partial work stands; the next session catches up)");
+  return { lockWaitMs: lockWaitMs != null ? Math.min(lockWaitMs, remaining) : remaining };
+}
+
+function start(vaultRoot, { agent, project, focus, sessionId, planNote, now, reapGraceMs, lockWaitMs, totalBudgetMs } = {}) {
+  const nowMs = typeof now === "number" ? now : Date.now();
+  const graceMs = typeof reapGraceMs === "number" ? reapGraceMs : DEFAULT_REAP_GRACE_MS;
+  const logPath = logPathFor(vaultRoot);
+  // lockWaitMs bounds EACH append's wait for a contended lock (terra wiring
+  // finding 5); totalBudgetMs bounds the WHOLE call (sol #8 refutation 2).
+  // The deadline is real wall clock, never the caller's logical `now`.
+  const deadlineAt = typeof totalBudgetMs === "number" ? Date.now() + totalBudgetMs : null;
+
+  const { events: existing } = readEvents(logPath);
+  // Only sessions older than the grace window are treated as crashed; a
+  // parallel session that started recently is LIVE, not an orphan.
+  const orphans = events.findOrphanSessions(existing).filter((o) => nowMs - o.ts > graceMs);
+  let reaped = 0;
+  for (const orphan of orphans) {
+    const r = appendEvent(logPath, events.reapSession(orphan, { ts: nowMs }), budgetedOpts(deadlineAt, lockWaitMs));
+    if (r.appended) reaped += 1;
+  }
+
+  const startedPayload = { agent, project };
+  if (sessionId) startedPayload.sessionId = sessionId;
+  if (focus) startedPayload.focus = focus;
+  const started = events.sessionStarted(startedPayload, { ts: nowMs });
+  appendEvent(logPath, started, budgetedOpts(deadlineAt, lockWaitMs));
+
+  let planEvents = 0;
+  const skipped = [];
+  if (planNote && typeof planNote.text === "string") {
+    const r = backfillDailyTasks(planNote.text, {
+      noteDate: planNote.noteDate,
+      relPath: planNote.relPath || `Dailies/${planNote.noteDate}.md`,
+    });
+    for (const e of r.events) {
+      if (appendEvent(logPath, e, budgetedOpts(deadlineAt, lockWaitMs)).appended) planEvents += 1;
+    }
+    skipped.push(...r.skipped);
+  }
+
+  return { sessionId: started.payload.sessionId, reaped, planEvents, skipped };
+}
+
+// Close = the session's gathered facts + session.closed + projection
+// rebuild. `facts` are prebuilt envelopes (events.js constructors) — Close
+// appends them verbatim; duplicates dedupe by key, so retrying a crashed
+// Close never double-counts.
+function close(vaultRoot, { sessionId, agent, project, summary, mins, dateKey, facts = [], now, lockWaitMs, totalBudgetMs } = {}) {
+  const nowMs = typeof now === "number" ? now : Date.now();
+  const logPath = logPathFor(vaultRoot);
+  const deadlineAt = typeof totalBudgetMs === "number" ? Date.now() + totalBudgetMs : null;
+  const appendOpts = () => budgetedOpts(deadlineAt, lockWaitMs);
+
+  let appended = 0;
+  let duplicates = 0;
+  for (const fact of facts) {
+    const r = appendEvent(logPath, fact, appendOpts());
+    if (r.appended) appended += 1;
+    else if (r.duplicate) duplicates += 1;
+  }
+
+  const closedPayload = { sessionId, agent, project, summary };
+  if (typeof mins === "number") closedPayload.mins = mins;
+  // Vault-zone policy (SCHEMA-SPEC v0.2.7): live wiring passes the
+  // product-local day; events.sessionClosed validates the shape.
+  if (dateKey !== undefined) closedPayload.dateKey = dateKey;
+  const r = appendEvent(logPath, events.sessionClosed(closedPayload, { ts: nowMs }), appendOpts());
+  if (r.appended) appended += 1;
+  else if (r.duplicate) duplicates += 1;
+
+  // The projection rebuild is the one step that must not be skipped mid-call:
+  // it gets whatever budget remains (or the per-lock default when unbudgeted).
+  const rebuildOpts = appendOpts();
+  const rebuilt = writeProjections(vaultRoot, { now: nowMs, lockWaitMs: rebuildOpts.lockWaitMs });
+  return { appended, duplicates, hash: rebuilt.hash, eventCount: rebuilt.body.eventCount };
+}
+
+module.exports = { start, close, writeProjections, logPathFor };

package/src/dashboard/lib/state-core/trial.js

@@ -0,0 +1,96 @@
+"use strict";
+
+// trial.js — CORE-LOOP TRIAL MODE (SCHEMA-SPEC v0.2 section 2): "If a
+// projection disagrees with its legacy sibling during the trial, the
+// DASHBOARD shows the legacy value and logs the delta — discrepancies
+// surface, never silently switch."
+//
+// Scope discipline: only pairs with IDENTICAL semantics are compared.
+// Overrides qualify (pattern-manifest override_history and override.logged
+// events share one source since the migration). Streak deliberately does
+// NOT: the legacy streak counts Daily-Note-existence days, the projection
+// counts session.closed days — different definitions, and logging their
+// disagreement would be false-equivalence noise, not signal. When more
+// event writers land (override capture at Close), this file grows pairs.
+//
+// The delta log is the honest gap meter: today nothing writes
+// override.logged forward, so `legacy - events` is exactly the wiring
+// backlog. Watching it shrink to zero across releases IS the trial.
+
+const fs = require("fs");
+const path = require("path");
+
+const STATE_DIR = path.join("02_Areas", "Engine", "State");
+const LOG_NAME = "events.jsonl";
+const DELTA_NAME = "trial-deltas.jsonl";
+const MAX_DELTA_BYTES = 512 * 1024; // rotate once, keep the tail honest
+
+// Compares override counts. Returns null when the vault is unmigrated
+// (beside-mode: no State dir means no trial), else a comparison record.
+function checkOverrides({ vault, manifestOverrideCount }) {
+  const logPath = path.join(vault, STATE_DIR, LOG_NAME);
+  if (!fs.existsSync(logPath)) return null;
+  const { readEvents } = require("./event-log");
+  const { events } = readEvents(logPath);
+  const eventCount = events.filter((e) => e.type === "override.logged").length;
+  const legacy = Number.isFinite(manifestOverrideCount) ? manifestOverrideCount : 0;
+  return {
+    kind: "overrides",
+    legacy,
+    events: eventCount,
+    agrees: legacy === eventCount,
+  };
+}
+
+// Appends a record when the state MOVES: a new disagreement, a change in a
+// standing disagreement, or a disagreement RESOLVING back to agreement (sol
+// #7 partial refutation: returning on agrees left the last durable record
+// claiming an open gap forever — the resolution is exactly the event the
+// 14-day zero-delta switch criterion needs on the record). Standing states,
+// agreeing or not, never re-log: the dashboard rebuilds often and spam
+// would bury real movement.
+function recordDelta(vault, record, { now } = {}) {
+  if (!record) return { logged: false, reason: "unmigrated" };
+  const deltaPath = path.join(vault, STATE_DIR, DELTA_NAME);
+  try {
+    let last = null;
+    if (fs.existsSync(deltaPath)) {
+      const stat = fs.statSync(deltaPath);
+      if (stat.size > MAX_DELTA_BYTES) {
+        fs.renameSync(deltaPath, deltaPath + ".1"); // one rotation, oldest history discarded
+      }
+      const lines = fs.readFileSync(deltaPath, "utf8").trim().split("\n").filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const parsed = JSON.parse(lines[i]);
+          if (parsed.kind === record.kind) { last = parsed; break; }
+        } catch { continue; }
+      }
+    }
+    if (record.agrees) {
+      // Agreement is durable news only when it RESOLVES a recorded gap.
+      if (!last || last.agrees) return { logged: false, reason: "agrees (no open gap on record)" };
+    } else if (last && !last.agrees && last.legacy === record.legacy && last.events === record.events) {
+      return { logged: false, reason: "unchanged since last record" };
+    }
+    const entry = { ts: typeof now === "number" ? now : Date.now(), ...record };
+    fs.appendFileSync(deltaPath, JSON.stringify(entry) + "\n", "utf8");
+    return { logged: true };
+  } catch (e) {
+    return { logged: false, reason: `delta log write failed: ${e.message}` };
+  }
+}
+
+// One-call convenience for the build path: best-effort, never throws.
+function runTrial({ vault, manifestOverrideCount }) {
+  try {
+    const overrides = checkOverrides({ vault, manifestOverrideCount });
+    if (!overrides) return { available: false, reason: "vault not migrated" };
+    const logged = recordDelta(vault, overrides);
+    return { available: true, pairs: [overrides], logged: logged.logged };
+  } catch (e) {
+    return { available: false, reason: e.message };
+  }
+}
+
+module.exports = { checkOverrides, recordDelta, runTrial, DELTA_NAME };

package/src/dashboard/lib/strategy-parser.js

@@ -37,6 +37,9 @@ function parseStrategy(vault) {
   out.primeObjective = out.fields.prime_objective || null;
   out.stretchTarget = out.fields.stretch_target || null;
   out.currentState = out.fields.current_state || null;
+  // The input commitment (daily quota) is SEPARATE from the Single Test (the
+  // outcome bet). The hero renders the bet; Today renders the commitment.
+  out.commitment = out.fields.commitment || null;
 
   // Single Test extraction — V4 uses **Mid-term Milestone:**, older versions
   // used **Single Test:** / **The Bet:**. Try V4 first, fall back to legacy

package/src/dashboard/lib/suggested-now.js

@@ -156,8 +156,8 @@ function computeSuggestions(input, options = {}) {
     return [{
       workflow: strategyWritten ? "/morning" : "/setup",
       reason: strategyWritten
-        ? "Your Engine is built but no day is on the record yet. /morning starts the first one."
-        : "Nothing is on the record yet. /setup builds your Identity, Strategy, and Goals, the Engine everything here runs on.",
+        ? "Your record is set up but no day is on it yet. /morning starts the first one."
+        : "Nothing is on the record yet. /setup builds your Identity, Strategy, and Goals, the files everything here runs on.",
       score: 100,
       urgency: "INFO",
       signal: "freshVault",

package/src/dashboard/lib/transcript-parser.js

@@ -60,6 +60,20 @@ function deriveProject(dirName) {
   return dirName.replace(/^-+/, "").replace(/-/g, " ").trim();
 }
 
+function projectFromCwd(cwd) {
+  const parts = String(cwd || "").split(/[\\/]01_Projects[\\/]/);
+  if (parts.length < 2) return null;
+  const project = parts[1].split(/[\\/]/)[0];
+  return project ? project.trim() : null;
+}
+
+function isBootstrapText(text) {
+  const s = String(text || "").trim();
+  return /^# AGENTS\.md instructions\b/i.test(s) ||
+    /^<environment_context\b/i.test(s) ||
+    /^<hook_prompt\b/i.test(s);
+}
+
 function detectAgent(dirName) {
   const d = dirName.toLowerCase();
   if (d.includes("gemini") || d.includes("antigravity")) return "gemini";
@@ -160,6 +174,9 @@ function parseTranscript(file, opts = {}) {
     const errors = [];
     const decisions = [];
     let firstTs = null, lastTs = null;
+    let detectedProject = opts.project || null;
+    let detectedAgent = opts.agent || null;
+    let detectedSessionId = opts.sessionId || null;
     // C1 — workflow attribution. currentCommand = the most recent slash-command seen; on each
     // error we snapshot it into lastCommand so a digest carries WHICH workflow was running when
     // things broke. Self-improvement (GEPA/§5.5) reads this to name the workflow to fix.
@@ -189,25 +206,48 @@ function parseTranscript(file, opts = {}) {
       // partial writes). `null.message` below would throw UNCAUGHT in this readline handler and kill
       // an entire backfill (rl.on("error") only catches stream errors, not handler throws). Skip it.
       if (!obj || typeof obj !== "object" || Array.isArray(obj)) return;
-      const msg = obj.message || obj;
+
+      // Codex rollout transcripts begin with session_meta and then wrap messages in
+      // {type:"response_item", payload:{type:"message", ...}}. Capture the cwd here because
+      // Codex stores rollouts under date folders, so the transcript path cannot identify the project.
+      if (obj.type === "session_meta" && obj.payload && typeof obj.payload === "object") {
+        detectedSessionId = detectedSessionId || obj.payload.session_id || obj.payload.id || null;
+        detectedProject = detectedProject || projectFromCwd(obj.payload.cwd);
+        if (/codex/i.test(String(obj.payload.originator || obj.payload.source || ""))) detectedAgent = "codex";
+        const metaTs = obj.timestamp || obj.payload.timestamp || "";
+        if (metaTs) { if (!firstTs) firstTs = metaTs; lastTs = metaTs; }
+        return;
+      }
+
+      const isCodexMessage = obj.type === "response_item" && obj.payload && obj.payload.type === "message";
+      const msg = isCodexMessage ? obj.payload : (obj.message || obj);
       const role = msg.role || obj.type || "";
       const ts = obj.timestamp || obj.created_at || msg.timestamp || "";
       if (ts) { if (!firstTs) firstTs = ts; lastTs = ts; }
-      const content = msg.content;
+      const content = isCodexMessage && Array.isArray(msg.content)
+        ? msg.content.map((c) => c && (c.type === "input_text" || c.type === "output_text")
+          ? { ...c, type: "text" }
+          : c)
+        : msg.content;
+
+      if (role === "user" && Array.isArray(content)) {
+        const textBlocks = content.filter((c) => c && c.type === "text" && c.text);
+        if (textBlocks.length && textBlocks.every((c) => isBootstrapText(c.text))) return;
+      }
 
       if (role === "user") {
         turns.user++;
         if (typeof content === "string") {
           const cmd = detectCommand(content); // scan even <command-name> turns (not pushed as prose)
           if (cmd) currentCommand = cmd;
-          if (!content.startsWith("<")) push(content);
+          if (!content.startsWith("<") && !isBootstrapText(content)) push(content);
         } else if (Array.isArray(content)) {
           for (const c of content) {
             if (!c) continue;
             if (c.type === "text" && c.text) {
               const cmd = detectCommand(c.text);
               if (cmd) currentCommand = cmd;
-              if (!c.text.startsWith("<")) push(c.text);
+              if (!c.text.startsWith("<") && !isBootstrapText(c.text)) push(c.text);
             }
             if (c.type === "tool_result" && c.is_error) {
               if (currentCommand) lastCommand = currentCommand; // attribute this error to its workflow
@@ -277,9 +317,9 @@ function parseTranscript(file, opts = {}) {
       }
       resolve({
         file,
-        sessionId: opts.sessionId || path.basename(file).replace(/\.jsonl$/, ""),
-        project: opts.project || null,
-        agent: opts.agent || null,
+        sessionId: detectedSessionId || path.basename(file).replace(/\.jsonl$/, ""),
+        project: detectedProject,
+        agent: detectedAgent || (path.basename(file).startsWith("rollout-") ? "codex" : null),
         firstTs, lastTs,
         durationMin: clampDuration(firstTs, lastTs),
         turns,
@@ -307,7 +347,7 @@ function parseTranscript(file, opts = {}) {
 
 function dedupe(a) { return [...new Set(a)]; }
 
-module.exports = { enumerateSessions, parseTranscript, deriveProject, extractCommitSubject, DEFAULT_PROJECTS_DIR };
+module.exports = { enumerateSessions, parseTranscript, deriveProject, projectFromCwd, extractCommitSubject, DEFAULT_PROJECTS_DIR };
 
 // ── CLI (standalone testing) ──
 if (require.main === module) {