@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/process-terminal.js

@@ -0,0 +1,269 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson, writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import {
+  SUBAGENT_LIFECYCLE_ARTIFACT_VERSION
+} from "../../shared/types.js";
+import { canonicalSessionId, inspectSessionLease } from "../shared/session-lease.js";
+import { releaseActiveRunIndex } from "./active-run-index.js";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function validProcessInstance(value, kind) {
+  if (!isRecord(value))
+    return false;
+  if (typeof value.processInstanceId !== "string" || value.processInstanceId.length === 0)
+    return false;
+  if (kind ? value.kind !== kind : value.kind !== "runner" && value.kind !== "dm-writer")
+    return false;
+  if (typeof value.closeObservedAt !== "number" || !Number.isFinite(value.closeObservedAt))
+    return false;
+  if (typeof value.exitCode !== "number" && value.exitCode !== null)
+    return false;
+  if (typeof value.signal !== "string" && value.signal !== null)
+    return false;
+  if (value.kind === "runner")
+    return value.attempt === undefined;
+  if (typeof value.attempt !== "number" || !Number.isInteger(value.attempt) || value.attempt < 0 || !isRecord(value.processTree))
+    return false;
+  if (value.processTree.state === "observed") {
+    return value.processTree.mechanism === "posix-process-group" && typeof value.processTree.processGroupId === "number" && Number.isInteger(value.processTree.processGroupId) && value.processTree.processGroupId > 0 && typeof value.processTree.verifiedAt === "number" && Number.isFinite(value.processTree.verifiedAt);
+  }
+  return value.processTree.state === "unknown" && ["unsupported-platform", "signal-failed", "verification-failed"].includes(String(value.processTree.reason)) && (value.processTree.diagnostic === undefined || typeof value.processTree.diagnostic === "string");
+}
+function validInstance(value) {
+  return validProcessInstance(value, "dm-writer");
+}
+export function processTerminalCandidatePath(asyncDir) {
+  return path.join(asyncDir, "process-terminal-candidate.json");
+}
+export function processTerminalPath(asyncDir) {
+  return path.join(asyncDir, "process-terminal.json");
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export function readProcessTerminalCandidate(asyncDir) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(processTerminalCandidatePath(asyncDir), "utf-8"));
+    if (!isRecord(raw) || raw.version !== 1 || typeof raw.runId !== "string" || typeof raw.runnerProcessInstanceId !== "string" || !isRecord(raw.writers)) {
+      throw new Error(`Invalid process-terminal candidate in '${asyncDir}'.`);
+    }
+    const writers = {};
+    for (const [index, entries] of Object.entries(raw.writers)) {
+      if (!Array.isArray(entries) || !entries.every(validInstance))
+        throw new Error(`Invalid writer process records for child '${index}'.`);
+      writers[index] = entries;
+    }
+    let expectedWriters;
+    if (raw.expectedWriters !== undefined) {
+      if (!isRecord(raw.expectedWriters))
+        throw new Error("Invalid expected writer process records.");
+      expectedWriters = {};
+      for (const [index, count] of Object.entries(raw.expectedWriters)) {
+        if (typeof count !== "number" || !Number.isInteger(count) || count < 0)
+          throw new Error(`Invalid expected writer count for child '${index}'.`);
+        expectedWriters[index] = count;
+      }
+    }
+    if (raw.sessionFile !== undefined && typeof raw.sessionFile !== "string")
+      throw new Error("Invalid process-terminal candidate sessionFile.");
+    if (raw.revivalLeaseToken !== undefined && typeof raw.revivalLeaseToken !== "string")
+      throw new Error("Invalid process-terminal candidate lease token.");
+    if (raw.revivalLeaseReleaseAcknowledged !== undefined && typeof raw.revivalLeaseReleaseAcknowledged !== "boolean")
+      throw new Error("Invalid process-terminal lease release acknowledgement.");
+    return {
+      version: 1,
+      runId: raw.runId,
+      runnerProcessInstanceId: raw.runnerProcessInstanceId,
+      writers,
+      ...expectedWriters ? { expectedWriters } : {},
+      ...typeof raw.sessionFile === "string" && raw.sessionFile ? { sessionFile: raw.sessionFile } : {},
+      ...typeof raw.revivalLeaseToken === "string" && raw.revivalLeaseToken ? { revivalLeaseToken: raw.revivalLeaseToken } : {},
+      ...typeof raw.revivalLeaseReleaseAcknowledged === "boolean" ? { revivalLeaseReleaseAcknowledged: raw.revivalLeaseReleaseAcknowledged } : {}
+    };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+export function writeProcessTerminalCandidate(asyncDir, candidate) {
+  writePrivateAtomicJson(processTerminalCandidatePath(asyncDir), candidate);
+}
+export function markProcessTerminalCandidateLeaseRelease(asyncDir, token, acknowledged) {
+  const candidate = readProcessTerminalCandidate(asyncDir);
+  if (!candidate || candidate.revivalLeaseToken !== token)
+    return;
+  writeProcessTerminalCandidate(asyncDir, { ...candidate, revivalLeaseReleaseAcknowledged: acknowledged });
+}
+function unknownProof(runId, runnerProcessInstanceId, reason, diagnostic) {
+  return { version: 1, state: "unknown", runId, runnerProcessInstanceId, reason, ...diagnostic ? { diagnostic } : {} };
+}
+function resumeDisposition(state, sessionFile) {
+  if (state === "stopped")
+    return "non-resumable";
+  if (state !== "complete" && state !== "completed" && state !== "failed" && state !== "paused")
+    return "unavailable";
+  return sessionFile && fs.existsSync(sessionFile) ? "resumable" : "unavailable";
+}
+function sessionProjection(candidate, lease) {
+  if (!candidate.sessionFile || lease.state !== "free")
+    return;
+  if (candidate.revivalLeaseToken && candidate.revivalLeaseReleaseAcknowledged !== true)
+    return;
+  return {
+    canonicalSessionId: canonicalSessionId(candidate.sessionFile),
+    leaseDisposition: candidate.revivalLeaseToken ? "released" : "not-held",
+    freeAtObservation: true,
+    ...candidate.revivalLeaseToken ? { canonicalSessionLeaseReleased: true } : {}
+  };
+}
+function validateProof(raw, asyncDir, fallback) {
+  if (!isRecord(raw) || raw.version !== 1 || !["pending", "observed", "unknown", "not-started"].includes(String(raw.state)) || typeof raw.runId !== "string" || !raw.runId || typeof raw.runnerProcessInstanceId !== "string" || !raw.runnerProcessInstanceId) {
+    throw new Error(`Invalid process-terminal proof in '${asyncDir}'.`);
+  }
+  if (fallback?.runId && raw.runId !== fallback.runId)
+    throw new Error(`Process-terminal proof in '${asyncDir}' belongs to run '${raw.runId}', expected '${fallback.runId}'.`);
+  if (fallback?.runnerProcessInstanceId && raw.runnerProcessInstanceId !== fallback.runnerProcessInstanceId)
+    throw new Error(`Process-terminal proof in '${asyncDir}' belongs to runner '${raw.runnerProcessInstanceId}', expected '${fallback.runnerProcessInstanceId}'.`);
+  if (raw.instances !== undefined && (!Array.isArray(raw.instances) || !raw.instances.every((entry) => validProcessInstance(entry)))) {
+    throw new Error(`Invalid process-terminal instances in '${asyncDir}'.`);
+  }
+  if (raw.state === "observed") {
+    if (typeof raw.observedAt !== "number" || !Number.isFinite(raw.observedAt))
+      throw new Error(`Observed process-terminal proof in '${asyncDir}' is missing observedAt.`);
+    if (!Array.isArray(raw.instances))
+      throw new Error(`Observed process-terminal proof in '${asyncDir}' is missing instances.`);
+    const runner = raw.instances.find((entry) => isRecord(entry) && entry.kind === "runner");
+    if (!validProcessInstance(runner, "runner") || runner.processInstanceId !== raw.runnerProcessInstanceId)
+      throw new Error(`Observed process-terminal proof in '${asyncDir}' has no matching runner instance.`);
+  }
+  if (raw.resumeDisposition !== undefined && !["resumable", "non-resumable", "unavailable"].includes(String(raw.resumeDisposition)))
+    throw new Error(`Invalid process-terminal resume disposition in '${asyncDir}'.`);
+  return true;
+}
+export function sanitizeProcessTerminal(value, fallback, label = "status") {
+  if (value === undefined)
+    return;
+  try {
+    validateProof(value, label, fallback);
+    return value;
+  } catch (error) {
+    return unknownProof(fallback.runId ?? label, fallback.runnerProcessInstanceId ?? "unknown", "proof-write-failed", errorMessage(error));
+  }
+}
+export function readProcessTerminal(asyncDir, fallback) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(processTerminalPath(asyncDir), "utf-8"));
+    validateProof(raw, asyncDir, fallback);
+    return raw;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    return unknownProof(fallback?.runId ?? path.basename(asyncDir), fallback?.runnerProcessInstanceId ?? "unknown", "proof-write-failed", errorMessage(error));
+  }
+}
+function stepProcessTerminalProof(proof, childIndex, state, records, resumeDispositionValue) {
+  const base = {
+    version: 1,
+    runId: proof.runId,
+    childIndex,
+    runnerProcessInstanceId: proof.runnerProcessInstanceId,
+    ...resumeDispositionValue ? { resumeDisposition: resumeDispositionValue } : {}
+  };
+  if (state === "observed") {
+    return { ...base, state, observedAt: proof.state === "observed" ? proof.observedAt : Date.now(), instances: records };
+  }
+  if (state === "unknown") {
+    return { ...base, state, reason: proof.state === "unknown" ? proof.reason : "writer-close-unverified" };
+  }
+  return { ...base, state };
+}
+function overlayStatus(asyncDir, proof, candidate) {
+  const statusPath = path.join(asyncDir, "status.json");
+  try {
+    const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+    status.processTerminal = proof;
+    if (status.steps) {
+      for (const [index, step] of status.steps.entries()) {
+        const records = candidate?.writers[String(index)] ?? [];
+        const expected = candidate?.expectedWriters?.[String(index)] ?? (records.length > 0 ? records.length : 0);
+        const stepState = expected === 0 ? "not-started" : proof.state === "observed" && records.length === expected ? "observed" : proof.state === "pending" ? "pending" : "unknown";
+        step.processTerminal = stepProcessTerminalProof(proof, index, stepState, records, resumeDisposition(step.status, step.sessionFile ?? candidate?.sessionFile));
+      }
+    }
+    writeAtomicJson(statusPath, status);
+  } catch {}
+}
+export function finalizeProcessTerminal(asyncDir, runId, runnerClose) {
+  const existing = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId: runnerClose.processInstanceId });
+  if (existing && fs.existsSync(processTerminalPath(asyncDir))) {
+    if (existing.state === "observed" && existing.runId === runId && existing.runnerProcessInstanceId === runnerClose.processInstanceId)
+      return existing;
+    if (existing.state === "unknown")
+      return existing;
+  }
+  let proof;
+  let candidateForOverlay;
+  try {
+    const candidate = readProcessTerminalCandidate(asyncDir);
+    candidateForOverlay = candidate;
+    if (!candidate)
+      proof = unknownProof(runId, runnerClose.processInstanceId, "runner-candidate-missing");
+    else if (candidate.runId !== runId || candidate.runnerProcessInstanceId !== runnerClose.processInstanceId)
+      proof = unknownProof(runId, runnerClose.processInstanceId, "runner-instance-mismatch");
+    else {
+      const allWriters = Object.values(candidate.writers).flat();
+      const status = (() => {
+        try {
+          return JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+        } catch {
+          return;
+        }
+      })();
+      const session = candidate.sessionFile ? inspectSessionLease(candidate.sessionFile) : undefined;
+      const writerEntries = Object.entries(candidate.writers);
+      const expectedWriters = candidate.expectedWriters ?? Object.fromEntries(writerEntries.map(([index, records]) => [index, records.length]));
+      const expectedEntries = Object.entries(expectedWriters);
+      const expectedIndexes = new Set(expectedEntries.map(([index]) => index));
+      const writerIndexes = new Set(writerEntries.map(([index]) => index));
+      const inconsistentWriters = writerEntries.some(([index, records]) => !expectedIndexes.has(index) || records.length !== expectedWriters[index]) || expectedEntries.some(([index, expected]) => !writerIndexes.has(index) && expected !== 0);
+      if (session && session.state !== "free") {
+        proof = unknownProof(runId, runnerClose.processInstanceId, session.state === "owned" ? "canonical-session-lease-active" : "canonical-session-unavailable");
+      } else if (candidate.revivalLeaseToken && candidate.revivalLeaseReleaseAcknowledged !== true) {
+        proof = unknownProof(runId, runnerClose.processInstanceId, "canonical-session-release-unverified");
+      } else if (inconsistentWriters || allWriters.length === 0 && expectedEntries.length === 0) {
+        proof = unknownProof(runId, runnerClose.processInstanceId, "writer-close-unverified");
+      } else if (allWriters.some((writer) => writer.kind === "dm-writer" && writer.processTree.state !== "observed")) {
+        proof = unknownProof(runId, runnerClose.processInstanceId, "process-tree-unverified");
+      } else {
+        const runner = { kind: "runner", ...runnerClose };
+        const canonicalSession = session && sessionProjection(candidate, session);
+        proof = {
+          version: 1,
+          state: "observed",
+          runId,
+          runnerProcessInstanceId: runnerClose.processInstanceId,
+          observedAt: runnerClose.closeObservedAt,
+          instances: [runner, ...allWriters],
+          resumeDisposition: resumeDisposition(status?.state, candidate.sessionFile ?? status?.sessionFile),
+          ...canonicalSession ? { canonicalSession } : {}
+        };
+      }
+    }
+  } catch (error) {
+    proof = unknownProof(runId, runnerClose.processInstanceId, "proof-write-failed", errorMessage(error));
+  }
+  let durable = false;
+  try {
+    writeAtomicJson(processTerminalPath(asyncDir), proof);
+    durable = true;
+    if (proof.state === "observed")
+      releaseActiveRunIndex(asyncDir);
+    overlayStatus(asyncDir, proof, candidateForOverlay);
+    fs.appendFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.run.process_terminal", lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, ts: Date.now(), runId, processTerminal: proof })}
+`, "utf-8");
+  } catch {}
+  return durable ? proof : unknownProof(runId, runnerClose.processInstanceId, "proof-write-failed", "Failed to persist process-terminal proof.");
+}

package/extensions/dm-subagents/src/runs/background/result-delivery-ownership.js

@@ -0,0 +1,34 @@
+const MAX_CLAIMED_PREDECESSOR_SESSIONS = 8;
+export function createResultDeliveryOwnership(state) {
+  const claimed = new Map;
+  const currentOwner = () => typeof state.completionOwnerId === "string" && state.completionOwnerId ? state.completionOwnerId : undefined;
+  return {
+    owns(sessionId, completionOwnerId) {
+      const owner = currentOwner();
+      if (!owner || completionOwnerId !== owner)
+        return false;
+      return sessionId === state.currentSessionId || claimed.get(sessionId) === owner;
+    },
+    claimedSessionIds() {
+      const owner = currentOwner();
+      if (!owner)
+        return [];
+      return [...claimed].flatMap(([sessionId, claimedOwner]) => claimedOwner === owner ? [sessionId] : []);
+    },
+    claimPredecessor(previousSessionFile, previousRuntimeSessionId) {
+      const owner = currentOwner();
+      if (!owner || !previousSessionFile || !previousRuntimeSessionId)
+        return false;
+      if (previousSessionFile !== previousRuntimeSessionId || state.currentSessionId !== previousRuntimeSessionId)
+        return false;
+      claimed.delete(previousRuntimeSessionId);
+      claimed.set(previousRuntimeSessionId, owner);
+      while (claimed.size > MAX_CLAIMED_PREDECESSOR_SESSIONS)
+        claimed.delete(claimed.keys().next().value);
+      return true;
+    },
+    clear() {
+      claimed.clear();
+    }
+  };
+}