@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/session-scope.js

@@ -0,0 +1,451 @@
+import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
+import { hashText } from "./finding-identity.js";
+import { createGenerationSource } from "./generation-guard.js";
+import { logLatency } from "./latency-logger.js";
+import { getProcessSingleton } from "./process-singletons.js";
+import { DM_LENS_EVALUATION_ORDINAL } from "./startup-timing.js";
+import { SUCCESSOR_HANDOFF_TTL_MS } from "./session-lifecycle.js";
+export function sessionFencedFixedThisTurn(set, handle) {
+  const fixedThisTurn = {
+    ...set,
+    add: (fixedPath) => {
+      handle.guardedWrite(fixedPath, () => set.add(fixedPath));
+      return fixedThisTurn;
+    }
+  };
+  return fixedThisTurn;
+}
+const REGISTRY_FAMILY = "session-scope.registry";
+const REGISTRY_VERSION = 1;
+function carriedCounter(cell, field) {
+  const value = cell?.[field];
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function registry() {
+  let seed = { nextTicket: 0, orderTurn: 0 };
+  return getProcessSingleton(REGISTRY_FAMILY, REGISTRY_VERSION, () => seed, (previous) => {
+    seed = {
+      nextTicket: carriedCounter(previous, "nextTicket"),
+      orderTurn: carriedCounter(previous, "orderTurn")
+    };
+  });
+}
+const SESSION_START_ADMISSION_FAMILY = "session-scope.start-admission";
+const SESSION_START_ADMISSION_VERSION = 1;
+function sessionStartAdmission() {
+  return getProcessSingleton(SESSION_START_ADMISSION_FAMILY, SESSION_START_ADMISSION_VERSION, () => ({ deliveredEvents: new WeakSet }));
+}
+export function reserveSessionStart(event) {
+  const state = sessionStartAdmission();
+  if (state.deliveredEvents.has(event))
+    return false;
+  state.deliveredEvents.add(event);
+  return true;
+}
+const CAPTURED_SCOPE = Symbol.for("dm-lens.session-scope.captured.v1");
+
+class Scope {
+  scopeId;
+  role;
+  parentScopeId;
+  coordinatorId;
+  retiredReason;
+  cells = new Map;
+  life = createGenerationSource("runtime-session");
+  branch = createGenerationSource("session-branch");
+  constructor(args) {
+    this.scopeId = drawTicket();
+    this.role = args.role;
+    this.parentScopeId = args.parentScopeId;
+    this.coordinatorId = args.coordinatorId;
+  }
+  branchEpoch() {
+    return this.branch.current();
+  }
+  isLive() {
+    return this.retiredReason === undefined;
+  }
+  retiredBy() {
+    return this.retiredReason;
+  }
+  retire(reason) {
+    if (this.retiredReason !== undefined)
+      return;
+    this.retiredReason = reason ?? "shutdown";
+    this.life.bump();
+  }
+  moveBranch() {
+    this.branch.bump();
+  }
+  capture() {
+    const life = this.life.capture();
+    const branch = this.branch.capture();
+    return {
+      generation: this.scopeId,
+      scopeId: this.scopeId,
+      branchEpoch: branch.generation,
+      isCurrent: (level = "session") => life.isCurrent() && (level === "session" || branch.isCurrent()),
+      guardedWrite: (subject, write) => life.guardedWrite(subject, write),
+      [CAPTURED_SCOPE]: { scope: this, branch }
+    };
+  }
+}
+function drawTicket() {
+  const state = registry();
+  state.nextTicket += 1;
+  return state.nextTicket;
+}
+export function beginScope(args) {
+  return new Scope(args);
+}
+export function retireScope(scope, reason) {
+  const wasLive = scope.isLive();
+  scope.retire(reason);
+  if (wasLive && reason === "superseded")
+    logScopeTransition(scope, { transition: "end", reason });
+}
+export function moveBranch(scope) {
+  scope.moveBranch();
+}
+export function nextOrderTurn() {
+  const state = registry();
+  state.orderTurn += 1;
+  return state.orderTurn;
+}
+export function logScopeTransition(scope, args) {
+  logLatency({
+    type: "phase",
+    phase: "session_scope_transition",
+    filePath: args.cwd ?? "<dm-lens>",
+    durationMs: 0,
+    metadata: {
+      transition: args.transition,
+      reason: args.reason,
+      scopeId: scope.scopeId,
+      parentScopeId: scope.parentScopeId,
+      role: scope.role,
+      branchEpoch: scope.branchEpoch(),
+      sessionId: args.sessionId,
+      evaluationOrdinal: DM_LENS_EVALUATION_ORDINAL,
+      coordinatorId: scope.coordinatorId,
+      handoffSource: args.handoffSource,
+      ...args.detail
+    }
+  });
+}
+export function recordDroppedRead(handle, site, writeBranchEpoch) {
+  const captured = handle[CAPTURED_SCOPE];
+  if (!captured?.branch.isCurrent())
+    return;
+  if (writeBranchEpoch !== handle.branchEpoch)
+    return;
+  const reason = captured.scope.retiredBy();
+  incrementDegradationCount({
+    kind: "session-scope-read-dropped",
+    subject: `${reason}:${site}`,
+    reason: `a ${site} read-guard write of scope ${captured.scope.scopeId} was dropped after the scope retired (${reason}); its entry is still on its conversation's branch`
+  });
+}
+const SOURCES = {
+  startup: ["own-sidecar", "parent-sidecar"],
+  resume: ["own-sidecar", "parent-sidecar"],
+  fork: ["slot", "parent-sidecar"],
+  reload: ["slot", "own-sidecar"],
+  new: []
+};
+export function toStartReason(reason) {
+  return reason !== undefined && Object.hasOwn(SOURCES, reason) ? reason : "startup";
+}
+const sessionStores = new Map;
+export function defineSessionStore(spec) {
+  if (sessionStores.has(spec.name))
+    throw new Error(`session store ${spec.name} is declared twice`);
+  sessionStores.set(spec.name, spec);
+  return spec;
+}
+export function listSessionStores() {
+  return [...sessionStores.values()];
+}
+export function scopeCell(scope, key, init) {
+  const cells = scope.cells;
+  if (!cells.has(key) && init)
+    cells.set(key, init());
+  return cells.get(key);
+}
+export function snapshotSessionStores(scope) {
+  const snapshots = {};
+  for (const spec of sessionStores.values()) {
+    const payload = spec.snapshot(scope);
+    if (payload !== undefined)
+      snapshots[spec.name] = payload;
+  }
+  return snapshots;
+}
+const HANDOFF_FAMILY = "session-scope.handoff";
+const HANDOFF_VERSION = 2;
+function asManager(sessionManager) {
+  return typeof sessionManager === "object" && sessionManager !== null ? sessionManager : undefined;
+}
+function handoffSlot() {
+  return getProcessSingleton(HANDOFF_FAMILY, HANDOFF_VERSION, () => ({
+    handoff: undefined,
+    left: new WeakMap
+  }));
+}
+function describeKey(key) {
+  if (key === undefined)
+    return;
+  return typeof key === "number" ? `ticket:${key}` : `file:${hashText(key, 8)}`;
+}
+function ageOf(handoff) {
+  return handoff?.at === undefined ? undefined : Date.now() - handoff.at;
+}
+function logSlotOp(op, handoff, extra = {}) {
+  logLatency({
+    type: "phase",
+    phase: "session_handoff_slot",
+    filePath: "<dm-lens>",
+    durationMs: 0,
+    metadata: {
+      op,
+      reason: handoff?.reason,
+      keyHash: describeKey(handoff?.key),
+      storeNames: handoff && Object.keys(handoff.stores),
+      ageMs: ageOf(handoff),
+      ...extra
+    }
+  });
+}
+function activationCount(stores) {
+  const remembered = stores["lazy-tool-memory"];
+  if (!Array.isArray(remembered))
+    return 0;
+  let count = 0;
+  for (const name of remembered) {
+    if (typeof name === "string")
+      count += 1;
+  }
+  return count;
+}
+function retireExpiredHandoff(cell) {
+  const handoff = cell.handoff;
+  if (handoff?.at === undefined || Date.now() - handoff.at < SUCCESSOR_HANDOFF_TTL_MS)
+    return;
+  cell.handoff = undefined;
+  const droppedActivations = activationCount(handoff.stores);
+  logSlotOp("expired", handoff, { droppedActivations });
+  recordDegradationOnce({
+    kind: "session-scope-handoff-expired",
+    subject: handoff.reason,
+    reason: `a ${handoff.reason} hand-off exceeded ${SUCCESSOR_HANDOFF_TTL_MS}ms and was retired; dropped ${droppedActivations} activation(s)`,
+    metadata: { droppedActivations }
+  });
+}
+export function stashHandoff(scope, args) {
+  const reason = toStartReason(args.reason);
+  const cell = handoffSlot();
+  retireExpiredHandoff(cell);
+  if (!SOURCES[reason].includes("slot")) {
+    if (cell.handoff && (args.reason === undefined || args.reason === "quit"))
+      logSlotOp("unconsumed-at-exit", cell.handoff);
+    return false;
+  }
+  const manager = asManager(args.sessionManager);
+  if (manager !== undefined)
+    cell.left.set(manager, scope.scopeId);
+  const replaced = cell.handoff;
+  cell.handoff = {
+    reason,
+    key: args.targetSessionFile ?? args.sessionFile ?? scope.scopeId,
+    stores: snapshotSessionStores(scope),
+    at: Date.now()
+  };
+  logSlotOp(replaced ? "replaced" : "stashed", cell.handoff, {
+    ...replaced && {
+      replacedReason: replaced.reason,
+      replacedKeyHash: describeKey(replaced.key),
+      replacedAgeMs: ageOf(replaced)
+    }
+  });
+  return true;
+}
+function takeSlot(reason, key, by) {
+  const slot = handoffSlot();
+  retireExpiredHandoff(slot);
+  const handoff = slot.handoff;
+  if (!handoff)
+    return;
+  if (handoff.reason !== reason || handoff.key !== key) {
+    if (!handoff.mismatchLogged) {
+      handoff.mismatchLogged = true;
+      logSlotOp("key-mismatch-left", handoff, {
+        by,
+        askedReason: reason,
+        askedKeyHash: describeKey(key)
+      });
+    }
+    return;
+  }
+  slot.handoff = undefined;
+  logSlotOp("taken", handoff, { by });
+  return handoff;
+}
+export function takeHandoff(reason, key, by = "adopt") {
+  return takeSlot(reason, key, by)?.stores;
+}
+export function startKey(sessionFile, sessionManager) {
+  const manager = asManager(sessionManager);
+  return sessionFile ?? (manager && handoffSlot().left.get(manager));
+}
+export function successorStartKey(args) {
+  if (args.targetSessionFile !== undefined)
+    return args.targetSessionFile;
+  const reason = toStartReason(args.reason);
+  if (reason !== "reload" && reason !== "fork")
+    return;
+  const key = startKey(args.sessionFile, args.sessionManager);
+  const manager = asManager(args.sessionManager);
+  if (key !== undefined || manager === undefined)
+    return key;
+  const ticket = drawTicket();
+  handoffSlot().left.set(manager, ticket);
+  return ticket;
+}
+export function discardHandoff(args) {
+  const reason = toStartReason(args.reason);
+  if (!takeHandoff(reason, startKey(args.sessionFile, args.sessionManager), "discard"))
+    return false;
+  recordDegradationOnce({
+    kind: "session-scope-handoff-discarded",
+    subject: reason,
+    reason: `a demoted ${reason} start discarded the hand-off slot left for it, so a later start of its conversation cannot take it stale`
+  });
+  return true;
+}
+export function forwardHandoff(args) {
+  const reason = toStartReason(args.reason);
+  const startReason = toStartReason(args.startReason);
+  const key = startKey(args.sessionFile, args.sessionManager);
+  const taken = SOURCES[reason].includes("slot") ? takeSlot(startReason, key, "forward") : undefined;
+  const stores = taken?.stores;
+  if (taken) {
+    const adopted = {};
+    for (const [name, payload] of Object.entries(taken.stores))
+      if (sessionStores.get(name)?.policy[startReason] === "adopt")
+        adopted[name] = payload;
+    const forwarded = {
+      reason,
+      key: args.targetSessionFile ?? key,
+      stores: adopted,
+      ...taken.at !== undefined && { at: taken.at }
+    };
+    handoffSlot().handoff = forwarded;
+    logSlotOp("forwarded", forwarded);
+  }
+  const outcome = stores ? "forwarded" : "no-slot";
+  recordDegradationOnce({
+    kind: "session-scope-handoff-interrupted",
+    subject: startReason,
+    reason: `a ${reason} shutdown landed before its ${startReason} start adopted; it ${stores ? "handed on the slot left for that start" : "found no slot left for that start to hand on"} and stashed nothing of its own scope`,
+    metadata: { shutdownReason: reason, outcome }
+  });
+  return stores !== undefined;
+}
+function heldStoreNames(stores) {
+  return Object.entries(stores).flatMap(([name, payload]) => payload === undefined ? [] : [name]);
+}
+export async function adoptHandoff(scope, args) {
+  const reason = toStartReason(args.reason);
+  const slotted = takeSlot(reason, startKey(args.sessionFile, args.sessionManager), "adopt");
+  let source = "none";
+  let found;
+  const tried = [];
+  for (const candidate of SOURCES[reason]) {
+    let version;
+    let ageMs;
+    if (candidate === "slot") {
+      found = slotted && { stores: slotted.stores };
+      if (slotted)
+        ageMs = ageOf(slotted);
+    } else {
+      const sidecar = candidate === "own-sidecar" ? await args.loadOwnSidecar() : await args.loadParentSidecar();
+      found = sidecar;
+      version = sidecar?.migratedFrom ?? sidecar?.version;
+      if (sidecar)
+        ageMs = Date.now() - sidecar.savedAt;
+    }
+    tried.push({
+      source: candidate,
+      found: found !== undefined,
+      ...found && {
+        version,
+        ageMs,
+        storeNames: heldStoreNames(found.stores)
+      }
+    });
+    if (found) {
+      source = candidate;
+      break;
+    }
+  }
+  logLatency({
+    type: "phase",
+    phase: "session_handoff_adopt",
+    filePath: args.cwd,
+    durationMs: 0,
+    metadata: {
+      reason,
+      startKeyHash: describeKey(startKey(args.sessionFile, args.sessionManager)),
+      scopeId: scope.scopeId,
+      tried,
+      chosen: source
+    }
+  });
+  if (SOURCES[reason][0] === "slot" && source !== "slot")
+    recordDegradationOnce({
+      kind: "session-scope-handoff-missed",
+      subject: reason,
+      reason: `a ${reason} start found no hand-off slot keyed by its session file or its predecessor's ticket; it started from ${source}`
+    });
+  const summary = [];
+  for (const spec of sessionStores.values()) {
+    const action = spec.policy[reason];
+    if (action === "reset")
+      spec.reset?.(scope);
+    const payload = found?.stores[spec.name];
+    let carry;
+    if (action === "adopt") {
+      const restored = await spec.restore(scope, payload, {
+        reason,
+        source,
+        savedAt: found?.savedAt,
+        sessionManager: args.sessionManager,
+        cwd: args.cwd
+      });
+      if (restored)
+        carry = restored;
+    }
+    const label = action === "none" ? "skip" : action;
+    logLatency({
+      type: "phase",
+      phase: "session_store_action",
+      filePath: args.cwd,
+      durationMs: 0,
+      metadata: {
+        store: spec.name,
+        action: label,
+        reason,
+        source,
+        payloadPresent: payload !== undefined,
+        ...carry && {
+          itemsIn: carry.itemsIn,
+          itemsKept: carry.itemsKept,
+          itemsDropped: carry.itemsIn - carry.itemsKept
+        }
+      }
+    });
+    summary.push(carry ? `${spec.name} ${label} ${carry.itemsKept}/${carry.itemsIn}` : `${spec.name} ${label}`);
+  }
+  args.dbg?.(`session_start: stores from ${source} — ${summary.join(", ")}`);
+  return source;
+}

package/extensions/dm-lens/dist/clients/session-start-observability.js

@@ -0,0 +1,47 @@
+import { logLatency } from "./latency-logger.js";
+import { getProcessSingleton } from "./process-singletons.js";
+const BIND_ROLLUP_FAMILY = "concurrent-session-bind-rollup";
+const BIND_ROLLUP_VERSION = 1;
+function bindRollupCounts() {
+  return getProcessSingleton(BIND_ROLLUP_FAMILY, BIND_ROLLUP_VERSION, () => ({
+    "concurrent-secondary": 0,
+    "secondary-root": 0,
+    unclassified: 0
+  }));
+}
+function bindRollupKey(classification) {
+  return classification === "concurrent-secondary" || classification === "secondary-root" ? classification : "unclassified";
+}
+export function logConcurrentSessionBind(args) {
+  bindRollupCounts()[bindRollupKey(args.classification)] += 1;
+  logLatency({
+    type: "phase",
+    filePath: "<dm-lens>",
+    phase: "concurrent_session_bind",
+    durationMs: 0,
+    metadata: args
+  });
+}
+export function getConcurrentSessionBindRollupCounts() {
+  return { ...bindRollupCounts() };
+}
+export function emitConcurrentSessionBindRollupAtSessionEnd(cwd) {
+  const counts = bindRollupCounts();
+  const total = counts["concurrent-secondary"] + counts["secondary-root"] + counts.unclassified;
+  if (total === 0)
+    return;
+  logLatency({
+    type: "phase",
+    filePath: cwd,
+    phase: "concurrent_session_bind_rollup",
+    durationMs: 0,
+    metadata: { ...counts }
+  });
+  resetConcurrentSessionBindRollupCounts();
+}
+export function resetConcurrentSessionBindRollupCounts() {
+  const counts = bindRollupCounts();
+  counts["concurrent-secondary"] = 0;
+  counts["secondary-root"] = 0;
+  counts.unclassified = 0;
+}

package/extensions/dm-lens/dist/clients/session-state-store.js

@@ -0,0 +1,66 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { writeFileAtomicAsync } from "./atomic-write.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { readJsonCacheAsync } from "./json-cache-read.js";
+import { snapshotSessionStores } from "./session-scope.js";
+export const STATE_VERSION = 2;
+function fromDisk(parsed) {
+  const state = parsed;
+  if (state?.version === STATE_VERSION && typeof state.stores === "object" && state.stores !== null)
+    return state;
+  const v1 = parsed;
+  if (v1?.version !== 1 || !v1.widget)
+    return;
+  return {
+    version: STATE_VERSION,
+    sessionId: String(v1.sessionId),
+    savedAt: Number(v1.savedAt),
+    stores: { widget: v1.widget, "read-guard": v1.readGuard },
+    migratedFrom: 1
+  };
+}
+function sessionsDir(cwd) {
+  return path.join(getProjectDataDir(cwd), "sessions");
+}
+function sessionFilePath(cwd, sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 200);
+  return path.join(sessionsDir(cwd), `${safe}.json`);
+}
+export async function saveSessionState(cwd, sessionId, stores) {
+  if (!sessionId || !sessionId.trim())
+    return;
+  try {
+    const dir = sessionsDir(cwd);
+    await fs.mkdir(dir, { recursive: true });
+    const payload = {
+      version: STATE_VERSION,
+      sessionId,
+      savedAt: Date.now(),
+      stores
+    };
+    await writeFileAtomicAsync(sessionFilePath(cwd, sessionId), JSON.stringify(payload));
+  } catch {}
+}
+export function persistScope(cwd, sessionId, scope) {
+  saveSessionState(cwd, sessionId, snapshotSessionStores(scope));
+}
+export async function dropStaleFiles(widget, savedAt) {
+  const checked = await Promise.all(widget.files.map(async (file) => {
+    try {
+      const st = await fs.stat(file.filePath);
+      return st.mtimeMs <= savedAt + 1 ? file : undefined;
+    } catch {
+      return;
+    }
+  }));
+  return {
+    ...widget,
+    files: checked.filter((f) => f !== undefined)
+  };
+}
+export async function loadSessionState(cwd, sessionId) {
+  if (!sessionId || !sessionId.trim())
+    return;
+  return readJsonCacheAsync(sessionFilePath(cwd, sessionId), fromDisk);
+}

package/extensions/dm-lens/dist/clients/session-summary.js

@@ -0,0 +1,8 @@
+export function formatSlopScoreSummary(summary) {
+  if (summary.totalRuleDiagnostics === 0 || summary.totalKlocWritten <= 0) {
+    return "";
+  }
+  const topRules = summary.ruleCounts.slice(0, 3);
+  const detail = topRules.length > 0 ? "  (" + topRules.map((entry) => entry.ruleId + " ×" + entry.count).join(", ") + ")" : "";
+  return `Slop score: ${summary.scorePerKloc.toFixed(1)}/KLOC${detail}`;
+}

package/extensions/dm-lens/dist/clients/sessionstart-logger.js

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+export const SESSIONSTART_LOG_FILE = path.join(getGlobalDmLensLogDir(), "sessionstart.log");
+const writer = createNdjsonLogger({
+  filePath: SESSIONSTART_LOG_FILE,
+  maxBytes: getMaxLogSizeMB() * 1024 * 1024,
+  backupPath: `${SESSIONSTART_LOG_FILE}.1`
+});
+export function logSessionStart(message) {
+  if (isTestMode())
+    return;
+  writer.append(`[${new Date().toISOString()}] ${message}`);
+}
+export function flushSessionStartLog() {
+  return writer.flush();
+}
+export function flushSessionStartLogSync() {
+  writer.flushSync();
+}