labgate 0.5.37 → 0.5.38

package/dist/mcp-bundles/results-mcp.bundle.mjs

@@ -2979,7 +2979,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -3006,7 +3006,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3581,55 +3581,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative, options, skipNormalization) {
+    function resolveComponent(base, relative2, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative = parse3(serialize(relative, options), options);
+        relative2 = parse3(serialize(relative2, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative.scheme) {
-        target.scheme = relative.scheme;
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (!options.tolerant && relative2.scheme) {
+        target.scheme = relative2.scheme;
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
-          target.userinfo = relative.userinfo;
-          target.host = relative.host;
-          target.port = relative.port;
-          target.path = removeDotSegments(relative.path || "");
-          target.query = relative.query;
+        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
+          target.userinfo = relative2.userinfo;
+          target.host = relative2.host;
+          target.port = relative2.port;
+          target.path = removeDotSegments(relative2.path || "");
+          target.query = relative2.query;
         } else {
-          if (!relative.path) {
+          if (!relative2.path) {
             target.path = base.path;
-            if (relative.query !== void 0) {
-              target.query = relative.query;
+            if (relative2.query !== void 0) {
+              target.query = relative2.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative.path[0] === "/") {
-              target.path = removeDotSegments(relative.path);
+            if (relative2.path[0] === "/") {
+              target.path = removeDotSegments(relative2.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative.path;
+                target.path = "/" + relative2.path;
               } else if (!base.path) {
-                target.path = relative.path;
+                target.path = relative2.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative.query;
+            target.query = relative2.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3637,7 +3637,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative.fragment;
+      target.fragment = relative2.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -3808,7 +3808,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -27964,7 +27964,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error48) {
@@ -27981,7 +27981,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error48) => {
         reject(error48);
       };
@@ -28059,7 +28059,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error48) {
           reject(error48);
@@ -28320,12 +28320,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -29284,7 +29284,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -29927,17 +29927,24 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
 };
 
+// src/lib/results-mcp.ts
+import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, isAbsolute, relative, resolve } from "path";
+import { createHash } from "crypto";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
 // src/lib/results-store.ts
 import { randomUUID } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
@@ -29947,6 +29954,100 @@ import { dirname, join as join2 } from "path";
 import { readFileSync, existsSync, chmodSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  runtime: "auto",
+  // Default sandbox image: includes python3 + basic build tools (git/make/g++).
+  // Note: pip/venv are not included by default in Debian; users may still need a
+  // custom image for richer Python workflows.
+  image: "docker.io/library/node:20-bookworm",
+  session_timeout_hours: 8,
+  filesystem: {
+    extra_paths: [],
+    blocked_patterns: [
+      "**/.ssh",
+      "**/.gnupg",
+      "**/.aws",
+      "**/.config/gcloud",
+      "**/.azure",
+      "**/.env",
+      "**/.netrc",
+      "**/.git-credentials",
+      "**/*.pem",
+      "**/*.key",
+      "**/id_rsa*",
+      "**/id_ed25519*",
+      "**/credentials*",
+      "**/secrets*"
+    ]
+  },
+  datasets: [],
+  commands: {
+    blacklist: [
+      "mount",
+      "umount",
+      "mkfs",
+      "reboot",
+      "shutdown"
+    ]
+  },
+  network: {
+    mode: "host",
+    allowed_domains: [
+      "api.anthropic.com",
+      "api.openai.com",
+      "pypi.org",
+      "files.pythonhosted.org",
+      "conda.anaconda.org",
+      "registry.npmjs.org",
+      "github.com"
+    ]
+  },
+  slurm: {
+    enabled: true,
+    poll_interval_seconds: 5,
+    sacct_lookback_hours: 24,
+    mcp_server: true
+  },
+  audit: {
+    enabled: true,
+    log_dir: "~/.labgate/logs"
+  },
+  plugins: {
+    files: true,
+    datasets: false,
+    results: false,
+    charting: true,
+    molecular: true,
+    genomics: true,
+    phylogenetics: true,
+    network: true,
+    slurm: true,
+    explorer: true,
+    automation: false
+  },
+  automation: {
+    model: "claude-sonnet-4-5-20250929",
+    system_prompt: "You are an automation assistant helping guide a coding agent. When the agent asks a question or waits for input, provide a concise, helpful response based on the context.",
+    trigger_patterns: [
+      "\\?\\s*$",
+      "^>\\s*$",
+      "Do you want to proceed",
+      "Press Enter to continue",
+      "Y/n\\]?\\s*$"
+    ],
+    context_lines: 100,
+    delay_ms: 3e3,
+    max_turns: 20,
+    max_tokens: 1024
+  },
+  headless: {
+    claude_run_with_allowed_permissions: true,
+    continuation_in_other_terminals: true,
+    git_integration: false
+  }
+};
+var KNOWN_PLUGIN_IDS = Object.freeze(Object.keys(DEFAULT_CONFIG.plugins));
+var KNOWN_PLUGIN_ID_SET = new Set(KNOWN_PLUGIN_IDS);
 var LABGATE_DIR = process.env.LABGATE_DIR ?? join(homedir(), ".labgate");
 var PRIVATE_DIR_MODE = 448;
 var PRIVATE_FILE_MODE = 384;
@@ -29995,6 +30096,10 @@ function sanitizeSource(value) {
   if (!/^[a-z0-9._-]+$/.test(source)) return "unknown";
   return source;
 }
+function sanitizeBoolean(value, fallback = false) {
+  if (typeof value === "boolean") return value;
+  return fallback;
+}
 function sanitizeStringArray(value, maxItemLen, maxItems) {
   if (!Array.isArray(value)) return [];
   const out = [];
@@ -30023,6 +30128,139 @@ function sanitizeMetadata(value) {
   }
   return Object.keys(out).length > 0 ? out : null;
 }
+function sanitizePositiveInt(value, fallback, min, max) {
+  if (!Number.isFinite(value)) return fallback;
+  const intVal = Math.floor(value);
+  return Math.min(max, Math.max(min, intVal));
+}
+function sanitizeScriptKind(value) {
+  const normalized = sanitizeString(value, 16).toLowerCase();
+  if (normalized === "bash") return "bash";
+  if (normalized === "python") return "python";
+  if (normalized === "slurm") return "slurm";
+  return "other";
+}
+function sanitizeReproStrategy(value) {
+  const normalized = sanitizeString(value, 16).toLowerCase();
+  if (normalized === "precomputed") return "precomputed";
+  return "run";
+}
+function sanitizeExecutionStatus(value) {
+  const normalized = sanitizeString(value, 24).toLowerCase();
+  if (normalized === "succeeded") return "succeeded";
+  if (normalized === "failed") return "failed";
+  if (normalized === "submitted") return "submitted";
+  if (normalized === "precomputed") return "precomputed";
+  return "not_run";
+}
+function sanitizeReproExecution(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "object" || Array.isArray(value)) return null;
+  const src = value;
+  return {
+    status: sanitizeExecutionStatus(src.status),
+    command: sanitizeNullableString(src.command, 4096),
+    ran_at: sanitizeNullableString(src.ran_at, 64),
+    duration_ms: src.duration_ms === null || src.duration_ms === void 0 ? null : sanitizePositiveInt(src.duration_ms, 0, 0, 7 * 24 * 60 * 60 * 1e3),
+    exit_code: src.exit_code === null || src.exit_code === void 0 ? null : sanitizePositiveInt(src.exit_code, 0, 0, 65535),
+    signal: sanitizeNullableString(src.signal, 64),
+    stdout_tail: sanitizeNullableString(src.stdout_tail, 2e4),
+    stderr_tail: sanitizeNullableString(src.stderr_tail, 2e4),
+    slurm_job_id: sanitizeNullableString(src.slurm_job_id, 128)
+  };
+}
+function sanitizeReproducibility(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "object" || Array.isArray(value)) return null;
+  const src = value;
+  return {
+    script_path: sanitizeNullableString(src.script_path, 4096),
+    script_kind: sanitizeScriptKind(src.script_kind),
+    script_sha256: sanitizeNullableString(src.script_sha256, 128),
+    input_files: sanitizeStringArray(src.input_files, 4096, 500),
+    runtime: sanitizeNullableString(src.runtime, 2048),
+    requirements: sanitizeStringArray(src.requirements, 512, 200),
+    strategy: sanitizeReproStrategy(src.strategy),
+    precomputed_reason: sanitizeNullableString(src.precomputed_reason, 4e3),
+    execution: sanitizeReproExecution(src.execution)
+  };
+}
+function mergeReproExecutionPatch(current, patch) {
+  if (patch === void 0) return current;
+  if (patch === null) return null;
+  if (typeof patch !== "object" || Array.isArray(patch)) return current;
+  const src = patch;
+  const merged = { ...current || {} };
+  const fields = [
+    "status",
+    "command",
+    "ran_at",
+    "duration_ms",
+    "exit_code",
+    "signal",
+    "stdout_tail",
+    "stderr_tail",
+    "slurm_job_id"
+  ];
+  for (const field of fields) {
+    if (Object.prototype.hasOwnProperty.call(src, field)) {
+      merged[field] = src[field];
+    }
+  }
+  return sanitizeReproExecution(merged);
+}
+function mergeReproducibilityPatch(current, patch) {
+  if (patch === void 0) return current;
+  if (patch === null) return null;
+  if (typeof patch !== "object" || Array.isArray(patch)) return current;
+  const src = patch;
+  const merged = { ...current || {} };
+  const fields = [
+    "script_path",
+    "script_kind",
+    "script_sha256",
+    "input_files",
+    "runtime",
+    "requirements",
+    "strategy",
+    "precomputed_reason"
+  ];
+  for (const field of fields) {
+    if (Object.prototype.hasOwnProperty.call(src, field)) {
+      merged[field] = src[field];
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(src, "execution")) {
+    merged.execution = mergeReproExecutionPatch(current?.execution || null, src.execution);
+  } else if (current?.execution !== void 0) {
+    merged.execution = current.execution;
+  }
+  return sanitizeReproducibility(merged);
+}
+function normalizeLineageId(value, fallback) {
+  const lineage = sanitizeString(value, 128);
+  return lineage || fallback;
+}
+function sanitizeDerivedIdComponent(value) {
+  const cleaned = value.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-/, "").replace(/-$/, "");
+  return cleaned || "result";
+}
+function formatVersionLabel(version2) {
+  return `v${String(version2).padStart(2, "0")}`;
+}
+function deriveVersionedResultId(lineageId, version2, existing) {
+  const base = sanitizeDerivedIdComponent(sanitizeString(lineageId, 112) || "result");
+  const stemRaw = `${base}-${formatVersionLabel(version2)}`;
+  const stem = stemRaw.length > 128 ? stemRaw.slice(0, 128) : stemRaw;
+  let candidate = stem;
+  let suffix = 2;
+  while (existing.has(candidate)) {
+    const extra = `-${suffix}`;
+    candidate = `${stem.slice(0, Math.max(1, 128 - extra.length))}${extra}`;
+    suffix += 1;
+  }
+  return candidate;
+}
 function clampInt(value, fallback, min, max) {
   if (!Number.isFinite(value)) return fallback;
   return Math.min(max, Math.max(min, Math.floor(value)));
@@ -30030,18 +30268,36 @@ function clampInt(value, fallback, min, max) {
 function buildSearchText(result) {
   return [
     result.id,
+    result.lineage_id,
+    `v${result.version}`,
     result.title,
     result.summary,
     result.details || "",
     result.source,
+    result.starred ? "starred" : "",
+    result.previous_result_id || "",
     result.session_id || "",
     result.workdir || "",
     result.tags.join(" "),
-    result.artifacts.join(" ")
+    result.artifacts.join(" "),
+    result.reproducibility?.script_path || "",
+    result.reproducibility?.script_kind || "",
+    result.reproducibility?.runtime || "",
+    result.reproducibility?.input_files.join(" ") || "",
+    result.reproducibility?.requirements.join(" ") || "",
+    result.reproducibility?.strategy || "",
+    result.reproducibility?.precomputed_reason || "",
+    result.reproducibility?.execution?.command || "",
+    result.reproducibility?.execution?.stdout_tail || "",
+    result.reproducibility?.execution?.stderr_tail || "",
+    result.reproducibility?.execution?.slurm_job_id || ""
   ].join("\n").toLowerCase();
 }
-function sortByUpdatedDesc(items) {
-  return [...items].sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+function sortByPriority(items) {
+  return [...items].sort((a, b) => {
+    if (a.starred !== b.starred) return (b.starred ? 1 : 0) - (a.starred ? 1 : 0);
+    return b.updated_at.localeCompare(a.updated_at);
+  });
 }
 function countParsedResults(raw) {
   try {
@@ -30069,7 +30325,9 @@ var ResultsStore = class {
     const search = sanitizeString(opts?.search, 256).toLowerCase();
     const source = sanitizeString(opts?.source, 64).toLowerCase();
     const tag = sanitizeString(opts?.tag, 64).toLowerCase();
-    let rows = sortByUpdatedDesc(this.readFile().results);
+    const lineage = sanitizeString(opts?.lineage, 128);
+    const starred = typeof opts?.starred === "boolean" ? opts.starred : void 0;
+    let rows = sortByPriority(this.readFile().results);
     if (search) {
       rows = rows.filter((r) => buildSearchText(r).includes(search));
     }
@@ -30079,6 +30337,12 @@ var ResultsStore = class {
     if (tag) {
       rows = rows.filter((r) => r.tags.some((t) => t.toLowerCase() === tag));
     }
+    if (lineage) {
+      rows = rows.filter((r) => r.lineage_id === lineage);
+    }
+    if (starred !== void 0) {
+      rows = rows.filter((r) => r.starred === starred);
+    }
     const total = rows.length;
     rows = rows.slice(safeOffset, safeOffset + safeLimit);
     return { results: rows, total };
@@ -30088,14 +30352,74 @@ var ResultsStore = class {
     if (!normalized) return null;
     return this.readFile().results.find((r) => r.id === normalized) || null;
   }
+  listResultVersions(idOrLineage) {
+    const normalized = sanitizeString(idOrLineage, 128);
+    if (!normalized) return [];
+    const rows = this.readFile().results;
+    const byId = rows.find((r) => r.id === normalized) || null;
+    const lineage = byId ? byId.lineage_id : normalized;
+    return rows.filter((r) => r.lineage_id === lineage).sort((a, b) => {
+      if (a.version !== b.version) return b.version - a.version;
+      return b.updated_at.localeCompare(a.updated_at);
+    });
+  }
   createResult(input) {
-    const title = sanitizeString(input.title, 240);
-    if (!title) throw new Error("title is required");
     const file2 = this.readFile();
-    const id = sanitizeString(input.id, 128) || randomUUID();
+    const existingIds = new Set(file2.results.map((r) => r.id));
+    let title = sanitizeString(input.title, 240);
+    let lineageId = sanitizeString(input.lineage_id, 128);
+    let version2 = sanitizePositiveInt(input.version, 1, 1, 1e4);
+    let previousResultId = sanitizeNullableString(input.previous_result_id, 128);
+    const versionOf = sanitizeString(input.version_of, 128);
+    if (versionOf) {
+      const base = file2.results.find((r) => r.id === versionOf);
+      if (!base) throw new Error(`version_of result not found: ${versionOf}`);
+      lineageId = base.lineage_id;
+      const lineageRows = file2.results.filter((r) => r.lineage_id === lineageId);
+      const latest = lineageRows.sort((a, b) => {
+        if (a.version !== b.version) return b.version - a.version;
+        return b.updated_at.localeCompare(a.updated_at);
+      })[0] || base;
+      version2 = latest.version + 1;
+      previousResultId = latest.id;
+      if (!title) title = base.title;
+    }
+    if (!title) throw new Error("title is required");
+    if (lineageId) {
+      const lineageRows = file2.results.filter((r) => r.lineage_id === lineageId);
+      if (lineageRows.length > 0) {
+        const latest = lineageRows.sort((a, b) => {
+          if (a.version !== b.version) return b.version - a.version;
+          return b.updated_at.localeCompare(a.updated_at);
+        })[0];
+        const hasVersionConflict = lineageRows.some((r) => r.version === version2);
+        if ((input.version === void 0 || input.version === null) && (!versionOf || hasVersionConflict)) {
+          version2 = (latest?.version || 0) + 1;
+          if (!previousResultId && latest) previousResultId = latest.id;
+        } else if (hasVersionConflict) {
+          throw new Error(`version ${version2} already exists for lineage ${lineageId}`);
+        }
+      }
+    }
+    let id = sanitizeString(input.id, 128);
+    if (!id) {
+      if (versionOf) {
+        const nextLineage = lineageId || randomUUID();
+        id = deriveVersionedResultId(nextLineage, version2, existingIds);
+      } else {
+        id = randomUUID();
+      }
+    }
     if (file2.results.some((r) => r.id === id)) {
       throw new Error(`Result id already exists: ${id}`);
     }
+    const effectiveLineageId = normalizeLineageId(lineageId, id);
+    if (file2.results.some((r) => r.lineage_id === effectiveLineageId && r.version === version2)) {
+      throw new Error(`version ${version2} already exists for lineage ${effectiveLineageId}`);
+    }
+    if (previousResultId && previousResultId === id) {
+      throw new Error("previous_result_id cannot equal result id");
+    }
     const ts = nowIso();
     const created = {
       id,
@@ -30103,11 +30427,16 @@ var ResultsStore = class {
       summary: sanitizeString(input.summary, 1e3),
       details: sanitizeNullableString(input.details, 2e4),
       source: sanitizeSource(input.source),
+      starred: sanitizeBoolean(input.starred, false),
       session_id: sanitizeNullableString(input.session_id, 128),
       workdir: sanitizeNullableString(input.workdir, 4096),
+      lineage_id: effectiveLineageId,
+      version: version2,
+      previous_result_id: sanitizeNullableString(previousResultId, 128),
       tags: sanitizeStringArray(input.tags, 64, 50),
       artifacts: sanitizeStringArray(input.artifacts, 4096, 100),
       metadata: sanitizeMetadata(input.metadata),
+      reproducibility: sanitizeReproducibility(input.reproducibility),
       created_at: ts,
       updated_at: ts
     };
@@ -30153,6 +30482,13 @@ var ResultsStore = class {
         changed = true;
       }
     }
+    if (patch.starred !== void 0) {
+      const starred = sanitizeBoolean(patch.starred, false);
+      if (starred !== next.starred) {
+        next.starred = starred;
+        changed = true;
+      }
+    }
     if (patch.session_id !== void 0) {
       const sessionId = sanitizeNullableString(patch.session_id, 128);
       if (sessionId !== next.session_id) {
@@ -30167,6 +30503,28 @@ var ResultsStore = class {
         changed = true;
       }
     }
+    if (patch.lineage_id !== void 0) {
+      const lineageId = sanitizeString(patch.lineage_id, 128);
+      if (!lineageId) throw new Error("lineage_id cannot be empty");
+      if (lineageId !== next.lineage_id) {
+        next.lineage_id = lineageId;
+        changed = true;
+      }
+    }
+    if (patch.version !== void 0) {
+      const version2 = sanitizePositiveInt(patch.version, next.version, 1, 1e4);
+      if (version2 !== next.version) {
+        next.version = version2;
+        changed = true;
+      }
+    }
+    if (patch.previous_result_id !== void 0) {
+      const previousResultId = sanitizeNullableString(patch.previous_result_id, 128);
+      if (previousResultId !== next.previous_result_id) {
+        next.previous_result_id = previousResultId;
+        changed = true;
+      }
+    }
     if (patch.tags !== void 0) {
       const tags = sanitizeStringArray(patch.tags, 64, 50);
       if (JSON.stringify(tags) !== JSON.stringify(next.tags)) {
@@ -30188,7 +30546,20 @@ var ResultsStore = class {
         changed = true;
       }
     }
+    if (patch.reproducibility !== void 0) {
+      const reproducibility = mergeReproducibilityPatch(next.reproducibility, patch.reproducibility);
+      if (JSON.stringify(reproducibility) !== JSON.stringify(next.reproducibility)) {
+        next.reproducibility = reproducibility;
+        changed = true;
+      }
+    }
     if (!changed) return current;
+    if (next.previous_result_id && next.previous_result_id === next.id) {
+      throw new Error("previous_result_id cannot equal result id");
+    }
+    if (file2.results.some((r, i) => i !== idx && r.lineage_id === next.lineage_id && r.version === next.version)) {
+      throw new Error(`version ${next.version} already exists for lineage ${next.lineage_id}`);
+    }
     next.updated_at = nowIso();
     file2.results[idx] = next;
     this.writeFile(file2);
@@ -30271,11 +30642,16 @@ var ResultsStore = class {
           summary: sanitizeString(r.summary, 1e3),
           details: sanitizeNullableString(r.details, 2e4),
           source: sanitizeSource(r.source),
+          starred: sanitizeBoolean(r.starred, false),
           session_id: sanitizeNullableString(r.session_id, 128),
           workdir: sanitizeNullableString(r.workdir, 4096),
+          lineage_id: normalizeLineageId(r.lineage_id, id),
+          version: sanitizePositiveInt(r.version, 1, 1, 1e4),
+          previous_result_id: sanitizeNullableString(r.previous_result_id, 128),
           tags: sanitizeStringArray(r.tags, 64, 50),
           artifacts: sanitizeStringArray(r.artifacts, 4096, 100),
           metadata: sanitizeMetadata(r.metadata),
+          reproducibility: sanitizeReproducibility(r.reproducibility),
           created_at: created,
           updated_at: updated
         };
@@ -30322,6 +30698,9 @@ var ResultsStore = class {
 };
 
 // src/lib/results-mcp.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_REPRO_TIMEOUT_SECONDS = 120;
+var MAX_REPRO_OUTPUT_CHARS = 2e4;
 function clampInt2(value, fallback, min, max) {
   if (!Number.isFinite(value)) return fallback;
   return Math.min(max, Math.max(min, Math.floor(value)));
@@ -30361,6 +30740,193 @@ function parseDbPathFromArgs(args) {
   }
   return dbPath;
 }
+function trimTail(value, maxLen = MAX_REPRO_OUTPUT_CHARS) {
+  let text = null;
+  if (typeof value === "string") {
+    text = value;
+  } else if (Buffer.isBuffer(value)) {
+    text = value.toString("utf-8");
+  } else if (value !== void 0 && value !== null) {
+    text = String(value);
+  }
+  if (text === null) return null;
+  if (text.length <= maxLen) return text;
+  return text.slice(text.length - maxLen);
+}
+function isPathInside(rootPath, targetPath) {
+  const rel = relative(rootPath, targetPath);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function buildAllowedRoots(input) {
+  const roots = [
+    input.executionWorkdir ? resolve(input.executionWorkdir) : "",
+    input.workdir ? resolve(input.workdir) : "",
+    resolve(process.cwd())
+  ].filter(Boolean);
+  return [...new Set(roots)];
+}
+function ensurePathAllowed(path, allowedRoots) {
+  const allowed = allowedRoots.some((root) => isPathInside(root, path));
+  if (allowed) return;
+  throw new Error(
+    `Script path "${path}" is outside allowed roots: ${allowedRoots.join(", ")}. Set workdir/working_directory or use a path inside your workspace.`
+  );
+}
+function ensureScriptOnDisk(scriptPath, allowedRoots, scriptContent) {
+  const resolvedPath = resolve(String(scriptPath || "").trim());
+  if (!resolvedPath) {
+    throw new Error("reproducibility.script_path is required.");
+  }
+  ensurePathAllowed(resolvedPath, allowedRoots);
+  if (typeof scriptContent === "string") {
+    mkdirSync2(dirname2(resolvedPath), { recursive: true });
+    const normalized = scriptContent.endsWith("\n") ? scriptContent : `${scriptContent}
+`;
+    writeFileSync2(resolvedPath, normalized, "utf-8");
+    try {
+      chmodSync2(resolvedPath, 493);
+    } catch {
+    }
+  }
+  if (!existsSync3(resolvedPath)) {
+    throw new Error(`Reproducibility script not found: ${resolvedPath}`);
+  }
+  const raw = readFileSync3(resolvedPath);
+  const scriptSha256 = createHash("sha256").update(raw).digest("hex");
+  return { scriptPath: resolvedPath, scriptSha256 };
+}
+function parseSlurmJobId(text) {
+  const match = text.match(/Submitted batch job\s+([0-9]+)/i);
+  return match?.[1] || null;
+}
+function makeDefaultExecution(strategy, runNow) {
+  if (String(strategy || "").toLowerCase() === "precomputed") {
+    return { status: "precomputed" };
+  }
+  if (runNow === false) return { status: "not_run" };
+  return { status: "not_run" };
+}
+async function executeLocalReproScript(input) {
+  const cwd = input.workdir ? resolve(input.workdir) : dirname2(input.scriptPath);
+  const timeoutMs = clampInt2(input.timeoutSeconds, DEFAULT_REPRO_TIMEOUT_SECONDS, 10, 86400) * 1e3;
+  const start = Date.now();
+  const scriptKind = String(input.scriptKind || "").toLowerCase();
+  const useCustomCommand = typeof input.commandOverride === "string" && input.commandOverride.trim().length > 0;
+  const displayCommand = useCustomCommand ? input.commandOverride.trim() : scriptKind === "python" ? `python3 ${input.scriptPath}` : `bash ${input.scriptPath}`;
+  try {
+    if (useCustomCommand) {
+      const ok2 = await execFileAsync("bash", ["-lc", input.commandOverride.trim()], {
+        cwd,
+        timeout: timeoutMs,
+        maxBuffer: 5 * 1024 * 1024
+      });
+      return {
+        status: "succeeded",
+        command: displayCommand,
+        ran_at: new Date(start).toISOString(),
+        duration_ms: Date.now() - start,
+        exit_code: 0,
+        signal: null,
+        stdout_tail: trimTail(ok2.stdout),
+        stderr_tail: trimTail(ok2.stderr),
+        slurm_job_id: null
+      };
+    }
+    if (scriptKind === "python") {
+      const ok2 = await execFileAsync("python3", [input.scriptPath], {
+        cwd,
+        timeout: timeoutMs,
+        maxBuffer: 5 * 1024 * 1024
+      });
+      return {
+        status: "succeeded",
+        command: displayCommand,
+        ran_at: new Date(start).toISOString(),
+        duration_ms: Date.now() - start,
+        exit_code: 0,
+        signal: null,
+        stdout_tail: trimTail(ok2.stdout),
+        stderr_tail: trimTail(ok2.stderr),
+        slurm_job_id: null
+      };
+    }
+    const ok = await execFileAsync("bash", [input.scriptPath], {
+      cwd,
+      timeout: timeoutMs,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    return {
+      status: "succeeded",
+      command: displayCommand,
+      ran_at: new Date(start).toISOString(),
+      duration_ms: Date.now() - start,
+      exit_code: 0,
+      signal: null,
+      stdout_tail: trimTail(ok.stdout),
+      stderr_tail: trimTail(ok.stderr),
+      slurm_job_id: null
+    };
+  } catch (err) {
+    const code = typeof err?.code === "number" ? err.code : null;
+    const signal = typeof err?.signal === "string" ? err.signal : null;
+    return {
+      status: "failed",
+      command: displayCommand,
+      ran_at: new Date(start).toISOString(),
+      duration_ms: Date.now() - start,
+      exit_code: code,
+      signal,
+      stdout_tail: trimTail(err?.stdout),
+      stderr_tail: trimTail(err?.stderr || err?.message),
+      slurm_job_id: null
+    };
+  }
+}
+async function executeSlurmReproScript(input) {
+  const cwd = input.workdir ? resolve(input.workdir) : dirname2(input.scriptPath);
+  const timeoutMs = clampInt2(input.timeoutSeconds, DEFAULT_REPRO_TIMEOUT_SECONDS, 10, 86400) * 1e3;
+  const start = Date.now();
+  const useCustomCommand = typeof input.commandOverride === "string" && input.commandOverride.trim().length > 0;
+  const displayCommand = useCustomCommand ? input.commandOverride.trim() : `sbatch ${input.scriptPath}`;
+  try {
+    const ok = useCustomCommand ? await execFileAsync("bash", ["-lc", input.commandOverride.trim()], {
+      cwd,
+      timeout: timeoutMs,
+      maxBuffer: 5 * 1024 * 1024
+    }) : await execFileAsync("sbatch", [input.scriptPath], {
+      cwd,
+      timeout: timeoutMs,
+      maxBuffer: 5 * 1024 * 1024
+    });
+    const combined = `${ok.stdout || ""}
+${ok.stderr || ""}`;
+    return {
+      status: "submitted",
+      command: displayCommand,
+      ran_at: new Date(start).toISOString(),
+      duration_ms: Date.now() - start,
+      exit_code: 0,
+      signal: null,
+      stdout_tail: trimTail(ok.stdout),
+      stderr_tail: trimTail(ok.stderr),
+      slurm_job_id: parseSlurmJobId(combined)
+    };
+  } catch (err) {
+    const code = typeof err?.code === "number" ? err.code : null;
+    const signal = typeof err?.signal === "string" ? err.signal : null;
+    return {
+      status: "failed",
+      command: displayCommand,
+      ran_at: new Date(start).toISOString(),
+      duration_ms: Date.now() - start,
+      exit_code: code,
+      signal,
+      stdout_tail: trimTail(err?.stdout),
+      stderr_tail: trimTail(err?.stderr || err?.message),
+      slurm_job_id: null
+    };
+  }
+}
 async function main(args = process.argv.slice(2)) {
   const dbPath = parseDbPathFromArgs(args);
   const store = dbPath ? new ResultsStore(dbPath) : new ResultsStore();
@@ -30376,6 +30942,36 @@ async function main(args = process.argv.slice(2)) {
       instructions: "LabGate results registry. Use these tools to record important findings, retrieve previously recorded outcomes, and keep results structured for later review."
     }
   );
+  const reproducibilityExecutionSchema = external_exports3.object({
+    status: external_exports3.enum(["not_run", "succeeded", "failed", "submitted", "precomputed"]).optional(),
+    command: external_exports3.string().nullable().optional(),
+    ran_at: external_exports3.string().nullable().optional(),
+    duration_ms: external_exports3.number().int().min(0).nullable().optional(),
+    exit_code: external_exports3.number().int().nullable().optional(),
+    signal: external_exports3.string().nullable().optional(),
+    stdout_tail: external_exports3.string().nullable().optional(),
+    stderr_tail: external_exports3.string().nullable().optional(),
+    slurm_job_id: external_exports3.string().nullable().optional()
+  });
+  const reproducibilitySchema = external_exports3.object({
+    script_path: external_exports3.string().nullable().optional(),
+    script_kind: external_exports3.enum(["bash", "python", "slurm", "other"]).optional(),
+    script_sha256: external_exports3.string().nullable().optional(),
+    input_files: external_exports3.array(external_exports3.string()).optional(),
+    runtime: external_exports3.string().nullable().optional(),
+    requirements: external_exports3.array(external_exports3.string()).optional(),
+    strategy: external_exports3.enum(["run", "precomputed"]).optional(),
+    precomputed_reason: external_exports3.string().nullable().optional(),
+    execution: reproducibilityExecutionSchema.nullable().optional()
+  });
+  const reproducibilityRegistrationSchema = reproducibilitySchema.extend({
+    script_path: external_exports3.string().describe("Path to the script that reproduces this result"),
+    script_content: external_exports3.string().optional().describe("Optional script body to write at script_path"),
+    run_now: external_exports3.boolean().optional().default(true).describe("Execute or submit the script immediately"),
+    timeout_seconds: external_exports3.number().int().min(10).max(86400).optional().default(DEFAULT_REPRO_TIMEOUT_SECONDS),
+    command_override: external_exports3.string().optional().describe("Optional shell command used instead of the default runner"),
+    working_directory: external_exports3.string().nullable().optional().describe("Working directory used for execution/submission")
+  });
   server.registerTool(
     "list_results",
     {
@@ -30385,17 +30981,21 @@ async function main(args = process.argv.slice(2)) {
         search: external_exports3.string().optional().describe("Search text across title, summary, details, tags, and metadata"),
         tag: external_exports3.string().optional().describe("Filter by exact tag"),
         source: external_exports3.string().optional().describe("Filter by source (e.g. claude, codex)"),
+        lineage: external_exports3.string().optional().describe("Filter by lineage id (all versions of a result thread)"),
+        starred: external_exports3.boolean().optional().describe("Filter by starred status"),
         limit: external_exports3.number().int().min(1).max(500).optional().default(50).describe("Maximum results to return"),
         offset: external_exports3.number().int().min(0).optional().default(0).describe("Offset for pagination")
       }
     },
-    async ({ search, tag, source, limit, offset }) => {
+    async ({ search, tag, source, lineage, starred, limit, offset }) => {
       const safeLimit = clampInt2(limit, 50, 1, 500);
       const safeOffset = clampInt2(offset, 0, 0, 1e5);
       const listed = store.listResults({
         search: search || void 0,
         tag: tag || void 0,
         source: source || void 0,
+        lineage: lineage || void 0,
+        starred: typeof starred === "boolean" ? starred : void 0,
         limit: safeLimit,
         offset: safeOffset
       });
@@ -30414,29 +31014,60 @@ async function main(args = process.argv.slice(2)) {
       title: "Register Result",
       description: "Register a new structured result (finding/outcome) so it can be reviewed later in the LabGate UI.",
       inputSchema: {
+        id: external_exports3.string().optional().describe("Optional explicit id (normally auto-generated)"),
         title: external_exports3.string().describe("Short title of the result"),
         summary: external_exports3.string().optional().describe("One-line summary"),
         details: external_exports3.string().nullable().optional().describe("Long-form details"),
         source: external_exports3.string().optional().default("claude").describe("Result source label, e.g. claude or codex"),
+        starred: external_exports3.boolean().optional().default(false).describe("Whether the result is starred for quick access"),
         session_id: external_exports3.string().nullable().optional().describe("Optional LabGate session id"),
         workdir: external_exports3.string().nullable().optional().describe("Optional work directory path"),
+        lineage_id: external_exports3.string().optional().describe("Optional lineage id used to group versioned results"),
+        version: external_exports3.number().int().min(1).optional().describe("Explicit version number within the lineage"),
+        previous_result_id: external_exports3.string().nullable().optional().describe("Optional previous version id in this lineage"),
+        version_of: external_exports3.string().optional().describe("Create a next version based on an existing result id"),
         tags: external_exports3.array(external_exports3.string()).optional().describe("Tags for filtering"),
         artifacts: external_exports3.array(external_exports3.string()).optional().describe("Related file paths or artifact references"),
-        metadata: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable().optional().describe("Optional flat metadata map")
+        metadata: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable().optional().describe("Optional flat metadata map"),
+        reproducibility: reproducibilitySchema.nullable().optional().describe("Reproducibility specification for this result")
       }
     },
-    async ({ title, summary, details, source, session_id, workdir, tags, artifacts, metadata }) => {
+    async ({
+      id,
+      title,
+      summary,
+      details,
+      source,
+      starred,
+      session_id,
+      workdir,
+      lineage_id,
+      version: version2,
+      previous_result_id,
+      version_of,
+      tags,
+      artifacts,
+      metadata,
+      reproducibility
+    }) => {
       try {
         const created = store.createResult({
+          id,
           title,
           summary,
           details: details === void 0 ? null : details,
           source,
+          starred,
           session_id,
           workdir,
+          lineage_id,
+          version: version2,
+          previous_result_id,
+          version_of,
           tags,
           artifacts,
-          metadata
+          metadata,
+          reproducibility
         });
         return asText(`Result "${created.title}" recorded with id ${created.id}.`);
       } catch (err) {
@@ -30444,6 +31075,125 @@ async function main(args = process.argv.slice(2)) {
       }
     }
   );
+  server.registerTool(
+    "register_reproducible_result",
+    {
+      title: "Register Reproducible Result",
+      description: "Register a result with reproducibility guarantees: script path/hash, explicit inputs/requirements, and optional immediate execution (or SLURM submission).",
+      inputSchema: {
+        id: external_exports3.string().optional().describe("Optional explicit id (normally auto-generated)"),
+        title: external_exports3.string().describe("Short title of the result"),
+        summary: external_exports3.string().optional().describe("One-line summary"),
+        details: external_exports3.string().nullable().optional().describe("Long-form details"),
+        source: external_exports3.string().optional().default("claude").describe("Result source label, e.g. claude or codex"),
+        starred: external_exports3.boolean().optional().default(false).describe("Whether the result is starred for quick access"),
+        session_id: external_exports3.string().nullable().optional().describe("Optional LabGate session id"),
+        workdir: external_exports3.string().nullable().optional().describe("Optional result workdir (also default run cwd)"),
+        lineage_id: external_exports3.string().optional().describe("Optional lineage id used to group versioned results"),
+        version: external_exports3.number().int().min(1).optional().describe("Explicit version number within the lineage"),
+        previous_result_id: external_exports3.string().nullable().optional().describe("Optional previous version id in this lineage"),
+        version_of: external_exports3.string().optional().describe("Create a next version based on an existing result id"),
+        tags: external_exports3.array(external_exports3.string()).optional().describe("Tags for filtering"),
+        artifacts: external_exports3.array(external_exports3.string()).optional().describe("Related file paths or artifact references"),
+        metadata: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable().optional().describe("Optional flat metadata map"),
+        reproducibility: reproducibilityRegistrationSchema
+      }
+    },
+    async ({
+      id,
+      title,
+      summary,
+      details,
+      source,
+      starred,
+      session_id,
+      workdir,
+      lineage_id,
+      version: version2,
+      previous_result_id,
+      version_of,
+      tags,
+      artifacts,
+      metadata,
+      reproducibility
+    }) => {
+      try {
+        const repro = reproducibility || {};
+        const executionWorkdir = typeof repro.working_directory === "string" && repro.working_directory.trim() ? String(repro.working_directory) : null;
+        const allowedRoots = buildAllowedRoots({
+          workdir: typeof workdir === "string" ? workdir : null,
+          executionWorkdir
+        });
+        const scriptSpec = ensureScriptOnDisk(
+          String(repro.script_path || ""),
+          allowedRoots,
+          typeof repro.script_content === "string" ? repro.script_content : void 0
+        );
+        const strategy = String(repro.strategy || "run").toLowerCase() === "precomputed" ? "precomputed" : "run";
+        const runNow = repro.run_now === void 0 ? true : !!repro.run_now;
+        const scriptKind = String(repro.script_kind || "bash").toLowerCase();
+        const timeoutSeconds = clampInt2(
+          typeof repro.timeout_seconds === "number" ? repro.timeout_seconds : void 0,
+          DEFAULT_REPRO_TIMEOUT_SECONDS,
+          10,
+          86400
+        );
+        const commandOverride = typeof repro.command_override === "string" ? repro.command_override : void 0;
+        const runCwd = executionWorkdir && executionWorkdir.trim() || typeof workdir === "string" && workdir.trim() || null;
+        let execution = makeDefaultExecution(strategy, runNow);
+        if (strategy !== "precomputed" && runNow) {
+          execution = scriptKind === "slurm" ? await executeSlurmReproScript({
+            scriptPath: scriptSpec.scriptPath,
+            timeoutSeconds,
+            workdir: runCwd,
+            commandOverride
+          }) : await executeLocalReproScript({
+            scriptPath: scriptSpec.scriptPath,
+            scriptKind,
+            timeoutSeconds,
+            workdir: runCwd,
+            commandOverride
+          });
+        }
+        const reproducibilityPayload = {
+          script_path: scriptSpec.scriptPath,
+          script_kind: scriptKind,
+          script_sha256: scriptSpec.scriptSha256,
+          input_files: Array.isArray(repro.input_files) ? repro.input_files : void 0,
+          runtime: typeof repro.runtime === "string" ? repro.runtime : null,
+          requirements: Array.isArray(repro.requirements) ? repro.requirements : void 0,
+          strategy,
+          precomputed_reason: typeof repro.precomputed_reason === "string" ? repro.precomputed_reason : null,
+          execution
+        };
+        const created = store.createResult({
+          id,
+          title,
+          summary,
+          details: details === void 0 ? null : details,
+          source,
+          starred,
+          session_id,
+          workdir,
+          lineage_id,
+          version: version2,
+          previous_result_id,
+          version_of,
+          tags,
+          artifacts,
+          metadata,
+          reproducibility: reproducibilityPayload
+        });
+        return asJson({
+          ok: true,
+          result: created,
+          reproducibility_execution: created.reproducibility?.execution || null
+        });
+      } catch (err) {
+        return asError(`Failed to register reproducible result: ${err.message}`);
+      }
+    }
+  );
   server.registerTool(
     "get_result",
     {
@@ -30461,6 +31211,27 @@ async function main(args = process.argv.slice(2)) {
       return asJson(result);
     }
   );
+  server.registerTool(
+    "list_result_versions",
+    {
+      title: "List Result Versions",
+      description: "List all versions in a result lineage. Accepts either a result id or a lineage id.",
+      inputSchema: {
+        id_or_lineage: external_exports3.string().describe("Result id or lineage id")
+      }
+    },
+    async ({ id_or_lineage }) => {
+      const versions = store.listResultVersions(id_or_lineage);
+      if (versions.length === 0) {
+        return asError(`No versions found for "${id_or_lineage}".`);
+      }
+      return asJson({
+        lineage_id: versions[0].lineage_id,
+        count: versions.length,
+        versions
+      });
+    }
+  );
   server.registerTool(
     "update_result",
     {
@@ -30472,15 +31243,36 @@ async function main(args = process.argv.slice(2)) {
         summary: external_exports3.string().optional().describe("New summary"),
         details: external_exports3.string().nullable().optional().describe("New details, null clears"),
         source: external_exports3.string().optional().describe("New source"),
+        starred: external_exports3.boolean().optional().describe("Set whether this result is starred"),
         session_id: external_exports3.string().nullable().optional().describe("New session id, null clears"),
         workdir: external_exports3.string().nullable().optional().describe("New workdir, null clears"),
+        lineage_id: external_exports3.string().optional().describe("Set lineage id"),
+        version: external_exports3.number().int().min(1).optional().describe("Set version number"),
+        previous_result_id: external_exports3.string().nullable().optional().describe("Set previous version id"),
         tags: external_exports3.array(external_exports3.string()).optional().describe("Replace tags"),
         artifacts: external_exports3.array(external_exports3.string()).optional().describe("Replace artifacts"),
-        metadata: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable().optional().describe("Replace metadata, null clears")
+        metadata: external_exports3.record(external_exports3.string(), external_exports3.unknown()).nullable().optional().describe("Replace metadata, null clears"),
+        reproducibility: reproducibilitySchema.nullable().optional().describe("Replace reproducibility metadata, null clears")
       }
     },
-    async ({ id, title, summary, details, source, session_id, workdir, tags, artifacts, metadata }) => {
-      const hasPatch = title !== void 0 || summary !== void 0 || details !== void 0 || source !== void 0 || session_id !== void 0 || workdir !== void 0 || tags !== void 0 || artifacts !== void 0 || metadata !== void 0;
+    async ({
+      id,
+      title,
+      summary,
+      details,
+      source,
+      starred,
+      session_id,
+      workdir,
+      lineage_id,
+      version: version2,
+      previous_result_id,
+      tags,
+      artifacts,
+      metadata,
+      reproducibility
+    }) => {
+      const hasPatch = title !== void 0 || summary !== void 0 || details !== void 0 || source !== void 0 || starred !== void 0 || session_id !== void 0 || workdir !== void 0 || lineage_id !== void 0 || version2 !== void 0 || previous_result_id !== void 0 || tags !== void 0 || artifacts !== void 0 || metadata !== void 0 || reproducibility !== void 0;
       if (!hasPatch) {
         return asError("No update fields provided.");
       }
@@ -30490,11 +31282,16 @@ async function main(args = process.argv.slice(2)) {
           summary,
           details,
           source,
+          starred,
           session_id,
           workdir,
+          lineage_id,
+          version: version2,
+          previous_result_id,
           tags,
           artifacts,
-          metadata
+          metadata,
+          reproducibility
         });
         if (!updated) {
           return asError(`Result "${id}" not found.`);