u-foo 2.5.15 → 3.0.1

package/src/code/runtime/taskRun.js

@@ -0,0 +1,348 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+
+/**
+ * TaskRun registry — parent Task node identity vs runnable attempt.
+ *
+ * Scheduler owner: TaskLoop (`processTaskRun` / `resumePersistedTaskRuns`).
+ * Agent Loop may only issue control commands (start/cancel/complete) via CAS.
+ *
+ * Restart rules:
+ * - queued → remain queued (scheduler resumes)
+ * - running + phase waiting_model|executing_tools|planning → requeue to queued
+ * - cancelling → stay cancelling until cancel completes
+ * - terminal → never transition backward
+ */
+
+const TASK_RUN_STATUSES = Object.freeze([
+  "queued",
+  "running",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled",
+]);
+
+const TASK_RUN_PHASES = Object.freeze([
+  "initializing",
+  "planning",
+  "waiting_model",
+  "executing_tools",
+  "finalizing",
+]);
+
+const TERMINAL_TASK_RUN = new Set(["succeeded", "failed", "cancelled"]);
+
+/** Keep in sync with protocol/transitions.TASK_RUN_TRANSITIONS. */
+const TASK_RUN_TRANSITIONS = Object.freeze({
+  queued: Object.freeze(["running", "cancelled"]),
+  running: Object.freeze(["succeeded", "failed", "cancelling"]),
+  cancelling: Object.freeze(["cancelled", "failed"]),
+  succeeded: Object.freeze([]),
+  failed: Object.freeze([]),
+  cancelled: Object.freeze([]),
+});
+
+/** Default write-lease / heartbeat staleness (ms). */
+const DEFAULT_LEASE_STALE_MS = 30 * 60 * 1000;
+
+/** Extra recovery edge used only by recoverTaskRunsAfterRestart. */
+const RECOVERY_TRANSITIONS = Object.freeze({
+  running: Object.freeze(["queued"]),
+});
+
+function isAllowedTaskRunTransition(fromStatus = "", toStatus = "") {
+  const from = String(fromStatus || "").trim();
+  const to = String(toStatus || "").trim();
+  const allowed = TASK_RUN_TRANSITIONS[from];
+  if (!allowed) return false;
+  return allowed.includes(to);
+}
+function createTaskRunId() {
+  return `trun_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`;
+}
+
+function emptyTaskRunStore() {
+  return {
+    byId: {},
+    commandLog: {},
+    wakeupLog: {},
+  };
+}
+
+function ensureTaskRunStore(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.taskRuns || typeof state.taskRuns !== "object") {
+    state.taskRuns = emptyTaskRunStore();
+  }
+  if (!state.taskRuns.byId || typeof state.taskRuns.byId !== "object") {
+    state.taskRuns.byId = {};
+  }
+  if (!state.taskRuns.commandLog || typeof state.taskRuns.commandLog !== "object") {
+    state.taskRuns.commandLog = {};
+  }
+  if (!state.taskRuns.wakeupLog || typeof state.taskRuns.wakeupLog !== "object") {
+    state.taskRuns.wakeupLog = {};
+  }
+  return state.taskRuns;
+}
+
+function createTaskRun({
+  parentGraphId = "",
+  parentNodeId = "",
+  childGraphId = "",
+  attempt = 1,
+} = {}) {
+  const now = new Date().toISOString();
+  return {
+    id: createTaskRunId(),
+    parentGraphId: String(parentGraphId || "").trim(),
+    parentNodeId: String(parentNodeId || "").trim(),
+    childGraphId: String(childGraphId || "").trim(),
+    status: "queued",
+    phase: "initializing",
+    attempt: Number.isFinite(attempt) ? Math.max(1, Math.floor(attempt)) : 1,
+    ignoreUserPrompts: true,
+    cancelRequested: false,
+    result: null,
+    error: null,
+    changedFiles: [],
+    createdAt: now,
+    startedAt: "",
+    completedAt: "",
+    heartbeatAt: "",
+    lastWakeupId: "",
+  };
+}
+
+function getTaskRun(executionState = null, taskRunId = "") {
+  const store = ensureTaskRunStore(executionState);
+  const id = String(taskRunId || "").trim();
+  return id && store.byId[id] ? store.byId[id] : null;
+}
+
+function putTaskRun(executionState = null, taskRun = null) {
+  if (!taskRun || !taskRun.id) return null;
+  const store = ensureTaskRunStore(executionState);
+  store.byId[taskRun.id] = taskRun;
+  return taskRun;
+}
+
+function findActiveTaskRunForNode(executionState = null, parentNodeId = "") {
+  const store = ensureTaskRunStore(executionState);
+  const nodeId = String(parentNodeId || "").trim();
+  for (const run of Object.values(store.byId)) {
+    if (!run || run.parentNodeId !== nodeId) continue;
+    if (run.status === "queued" || run.status === "running" || run.status === "cancelling") {
+      return run;
+    }
+  }
+  return null;
+}
+
+function listActiveWritingTaskRuns(executionState = null) {
+  const store = ensureTaskRunStore(executionState);
+  return Object.values(store.byId).filter((run) => (
+    run
+    && (run.status === "queued" || run.status === "running" || run.status === "cancelling")
+  ));
+}
+
+function isTerminalTaskRun(run = null) {
+  return Boolean(run && TERMINAL_TASK_RUN.has(String(run.status || "")));
+}
+
+function touchTaskRunHeartbeat(executionState = null, taskRunId = "") {
+  const run = getTaskRun(executionState, taskRunId);
+  if (!run) return null;
+  run.heartbeatAt = new Date().toISOString();
+  putTaskRun(executionState, run);
+  return run;
+}
+
+function isTransitionAllowed(fromStatus, toStatus, { allowRecovery = false } = {}) {
+  if (fromStatus === toStatus) return true;
+  if (isAllowedTaskRunTransition(fromStatus, toStatus)) return true;
+  if (allowRecovery) {
+    const extra = RECOVERY_TRANSITIONS[fromStatus] || [];
+    return extra.includes(toStatus);
+  }
+  return false;
+}
+
+/**
+ * Compare-and-set status transition. Enforces allowed edges; terminal is final.
+ */
+function casTaskRunStatus(executionState = null, taskRunId = "", {
+  expectedStatus = "",
+  nextStatus = "",
+  phase = "",
+  result = null,
+  error = null,
+  changedFiles = null,
+  allowRecovery = false,
+} = {}) {
+  const run = getTaskRun(executionState, taskRunId);
+  if (!run) return { ok: false, code: "TASK_RUN_NOT_FOUND", run: null };
+  const expected = String(expectedStatus || "").trim();
+  if (expected && run.status !== expected) {
+    return {
+      ok: false,
+      code: "TASK_STATUS_CAS_FAILED",
+      run,
+      currentStatus: run.status,
+    };
+  }
+  if (TERMINAL_TASK_RUN.has(run.status)) {
+    return {
+      ok: false,
+      code: "TASK_ALREADY_TERMINAL",
+      run,
+      currentStatus: run.status,
+    };
+  }
+  const next = String(nextStatus || "").trim();
+  if (!TASK_RUN_STATUSES.includes(next)) {
+    return { ok: false, code: "INVALID_TASK_STATUS", run };
+  }
+  if (!isTransitionAllowed(run.status, next, { allowRecovery })) {
+    return {
+      ok: false,
+      code: "TASK_TRANSITION_FORBIDDEN",
+      run,
+      currentStatus: run.status,
+      nextStatus: next,
+      allowed: (TASK_RUN_TRANSITIONS[run.status] || []).slice(),
+    };
+  }
+  run.status = next;
+  if (phase && TASK_RUN_PHASES.includes(phase)) run.phase = phase;
+  if (result !== null) run.result = result;
+  if (error !== null) run.error = error;
+  if (Array.isArray(changedFiles)) run.changedFiles = changedFiles.map(String);
+  if (next === "running" && !run.startedAt) run.startedAt = new Date().toISOString();
+  if (TERMINAL_TASK_RUN.has(next)) {
+    run.completedAt = new Date().toISOString();
+    run.phase = "finalizing";
+  }
+  if (next === "cancelling") run.cancelRequested = true;
+  run.heartbeatAt = new Date().toISOString();
+  putTaskRun(executionState, run);
+  return { ok: true, run };
+}
+
+function cacheControlCommand(executionState = null, commandId = "", payload = {}) {
+  const id = String(commandId || "").trim();
+  if (!id) return;
+  const store = ensureTaskRunStore(executionState);
+  store.commandLog[id] = JSON.parse(JSON.stringify(payload));
+}
+
+function getCachedControlCommand(executionState = null, commandId = "") {
+  const id = String(commandId || "").trim();
+  if (!id) return null;
+  const store = ensureTaskRunStore(executionState);
+  return store.commandLog[id] ? JSON.parse(JSON.stringify(store.commandLog[id])) : null;
+}
+
+/**
+ * Deduplicate wakeups by wakeupId. Second delivery returns cached result.
+ */
+function beginWakeup(executionState = null, wakeupId = "", meta = {}) {
+  const id = String(wakeupId || "").trim();
+  if (!id) return { ok: true, fresh: true };
+  const store = ensureTaskRunStore(executionState);
+  const existing = store.wakeupLog[id];
+  if (existing && existing.status === "completed") {
+    return {
+      ok: true,
+      fresh: false,
+      idempotentReplay: true,
+      result: existing.result ? JSON.parse(JSON.stringify(existing.result)) : existing,
+    };
+  }
+  if (existing && existing.status === "started") {
+    return {
+      ok: true,
+      fresh: false,
+      idempotentReplay: true,
+      result: { status: "in_flight", wakeupId: id },
+    };
+  }
+  store.wakeupLog[id] = {
+    status: "started",
+    startedAt: new Date().toISOString(),
+    ...meta,
+  };
+  return { ok: true, fresh: true };
+}
+
+function completeWakeup(executionState = null, wakeupId = "", result = {}) {
+  const id = String(wakeupId || "").trim();
+  if (!id) return;
+  const store = ensureTaskRunStore(executionState);
+  store.wakeupLog[id] = {
+    ...(store.wakeupLog[id] || {}),
+    status: "completed",
+    completedAt: new Date().toISOString(),
+    result: JSON.parse(JSON.stringify(result || {})),
+  };
+}
+
+/**
+ * After process restart: requeue interrupted running runs; leave cancelling alone.
+ * Does not execute tools — caller should invoke processTaskRun separately.
+ */
+function recoverTaskRunsAfterRestart(executionState = null) {
+  const store = ensureTaskRunStore(executionState);
+  const recovered = [];
+  for (const run of Object.values(store.byId)) {
+    if (!run) continue;
+    if (run.status === "running") {
+      const phase = String(run.phase || "");
+      if (phase === "waiting_model" || phase === "executing_tools" || phase === "planning") {
+        const cas = casTaskRunStatus(executionState, run.id, {
+          expectedStatus: "running",
+          nextStatus: "queued",
+          phase: "initializing",
+          allowRecovery: true,
+        });
+        recovered.push({
+          taskRunId: run.id,
+          action: cas.ok ? "requeued" : "skip",
+          code: cas.ok ? "" : cas.code,
+        });
+      } else {
+        recovered.push({ taskRunId: run.id, action: "resume_running" });
+      }
+    } else if (run.status === "queued" || run.status === "cancelling") {
+      recovered.push({ taskRunId: run.id, action: `resume_${run.status}` });
+    }
+  }
+  return recovered;
+}
+
+module.exports = {
+  TASK_RUN_STATUSES,
+  TASK_RUN_PHASES,
+  TERMINAL_TASK_RUN,
+  TASK_RUN_TRANSITIONS,
+  DEFAULT_LEASE_STALE_MS,
+  createTaskRunId,
+  emptyTaskRunStore,
+  ensureTaskRunStore,
+  createTaskRun,
+  getTaskRun,
+  putTaskRun,
+  findActiveTaskRunForNode,
+  listActiveWritingTaskRuns,
+  isTerminalTaskRun,
+  touchTaskRunHeartbeat,
+  casTaskRunStatus,
+  cacheControlCommand,
+  getCachedControlCommand,
+  beginWakeup,
+  completeWakeup,
+  recoverTaskRunsAfterRestart,
+};

package/src/code/runtime/toolProvenance.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * Per-TaskRun tool provenance for changedFiles (not git diff attribution).
+ */
+
+function ensureProvenanceStore(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.toolProvenance || typeof state.toolProvenance !== "object") {
+    state.toolProvenance = { byTaskRunId: {} };
+  }
+  if (!state.toolProvenance.byTaskRunId || typeof state.toolProvenance.byTaskRunId !== "object") {
+    state.toolProvenance.byTaskRunId = {};
+  }
+  return state.toolProvenance;
+}
+
+function touchedPathsFromTool(tool = "", args = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  const paths = [];
+  if (name === "write" || name === "edit") {
+    const path = String(args && args.path || "").trim();
+    if (path) paths.push(path);
+  }
+  return paths;
+}
+
+function recordToolProvenance(executionState = null, {
+  taskRunId = "",
+  tool = "",
+  args = {},
+  graphId = "",
+  nodeId = "",
+} = {}) {
+  const id = String(taskRunId || "").trim();
+  if (!id) return [];
+  const store = ensureProvenanceStore(executionState);
+  if (!store.byTaskRunId[id]) {
+    store.byTaskRunId[id] = { paths: [], events: [] };
+  }
+  const bucket = store.byTaskRunId[id];
+  const paths = touchedPathsFromTool(tool, args);
+  for (const path of paths) {
+    if (!bucket.paths.includes(path)) bucket.paths.push(path);
+  }
+  bucket.events.push({
+    at: new Date().toISOString(),
+    tool: String(tool || ""),
+    graphId: String(graphId || ""),
+    nodeId: String(nodeId || ""),
+    paths,
+  });
+  // Cap event log
+  if (bucket.events.length > 200) bucket.events = bucket.events.slice(-200);
+  return paths;
+}
+
+function getProvenanceChangedFiles(executionState = null, taskRunId = "") {
+  const store = ensureProvenanceStore(executionState);
+  const id = String(taskRunId || "").trim();
+  const bucket = store.byTaskRunId[id];
+  return bucket && Array.isArray(bucket.paths) ? bucket.paths.slice() : [];
+}
+
+module.exports = {
+  ensureProvenanceStore,
+  touchedPathsFromTool,
+  recordToolProvenance,
+  getProvenanceChangedFiles,
+};

package/src/code/runtime/workspaceLease.js

@@ -0,0 +1,249 @@
+"use strict";
+
+/**
+ * Workspace write lease — up to MAX_CONCURRENT_WRITE_LEASES writing TaskRuns.
+ * Agent write/edit/side-effect bash rejected while any Task holds a write lease.
+ */
+
+const WRITE_TOOLS = new Set(["write", "edit", "bash"]);
+const MAX_CONCURRENT_WRITE_LEASES = 6;
+
+function emptyWorkspaceLease() {
+  return {
+    holders: [], // [{ kind: "task_run", taskRunId, acquiredAt }]
+    mode: "write",
+    // Legacy single-holder field; migrated in ensureWorkspaceLease.
+    holder: null,
+    acquiredAt: "",
+  };
+}
+
+function ensureWorkspaceLease(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.workspaceLease || typeof state.workspaceLease !== "object") {
+    state.workspaceLease = emptyWorkspaceLease();
+  }
+  normalizeHolders(state.workspaceLease);
+  return state.workspaceLease;
+}
+
+function normalizeHolders(lease = null) {
+  const next = lease && typeof lease === "object" ? lease : emptyWorkspaceLease();
+  if (!Array.isArray(next.holders)) next.holders = [];
+
+  // Migrate V1 single-holder shape.
+  if (next.holder && typeof next.holder === "object" && next.holder.taskRunId) {
+    const id = String(next.holder.taskRunId || "").trim();
+    if (id && !next.holders.some((h) => h && h.taskRunId === id)) {
+      next.holders.push({
+        kind: "task_run",
+        taskRunId: id,
+        acquiredAt: String(next.acquiredAt || new Date().toISOString()),
+      });
+    }
+    next.holder = null;
+  }
+
+  next.holders = next.holders
+    .filter((h) => h && h.kind === "task_run" && String(h.taskRunId || "").trim())
+    .map((h) => ({
+      kind: "task_run",
+      taskRunId: String(h.taskRunId).trim(),
+      acquiredAt: String(h.acquiredAt || ""),
+    }));
+
+  // Cap defensive (should not happen if acquire gates correctly).
+  if (next.holders.length > MAX_CONCURRENT_WRITE_LEASES) {
+    next.holders = next.holders.slice(0, MAX_CONCURRENT_WRITE_LEASES);
+  }
+  return next.holders;
+}
+
+function listWriteLeaseHolders(executionState = null) {
+  return normalizeHolders(ensureWorkspaceLease(executionState)).slice();
+}
+
+function countWriteLeases(executionState = null) {
+  return listWriteLeaseHolders(executionState).length;
+}
+
+function findWriteLeaseHolder(executionState = null, taskRunId = "") {
+  const id = String(taskRunId || "").trim();
+  if (!id) return null;
+  return listWriteLeaseHolders(executionState).find((h) => h.taskRunId === id) || null;
+}
+
+function canAcquireWriteLease(executionState = null, taskRunId = "") {
+  const id = String(taskRunId || "").trim();
+  if (!id) return { ok: false, code: "MISSING_TASK_RUN_ID" };
+  if (findWriteLeaseHolder(executionState, id)) {
+    return { ok: true, idempotent: true };
+  }
+  const count = countWriteLeases(executionState);
+  if (count >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      ok: false,
+      code: "MAX_CONCURRENT_TASKS",
+      max: MAX_CONCURRENT_WRITE_LEASES,
+      current: count,
+      holders: listWriteLeaseHolders(executionState),
+    };
+  }
+  return { ok: true, current: count, max: MAX_CONCURRENT_WRITE_LEASES };
+}
+
+function acquireTaskWriteLease(executionState = null, taskRunId = "") {
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const id = String(taskRunId || "").trim();
+  if (!id) {
+    return { ok: false, code: "MISSING_TASK_RUN_ID" };
+  }
+
+  const existing = holders.find((h) => h.taskRunId === id);
+  if (existing) {
+    return { ok: true, lease, holder: existing, idempotent: true };
+  }
+
+  if (holders.length >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      ok: false,
+      code: "MAX_CONCURRENT_TASKS",
+      max: MAX_CONCURRENT_WRITE_LEASES,
+      current: holders.length,
+      holders: holders.slice(),
+      message: `At most ${MAX_CONCURRENT_WRITE_LEASES} concurrent writing TaskRuns`,
+    };
+  }
+
+  const holder = {
+    kind: "task_run",
+    taskRunId: id,
+    acquiredAt: new Date().toISOString(),
+  };
+  holders.push(holder);
+  lease.holders = holders;
+  lease.mode = "write";
+  return { ok: true, lease, holder };
+}
+
+function releaseTaskWriteLease(executionState = null, taskRunId = "") {
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const id = String(taskRunId || "").trim();
+  if (!id) return { ok: true, lease };
+  lease.holders = holders.filter((h) => h.taskRunId !== id);
+  if (lease.holders.length === 0) {
+    lease.acquiredAt = "";
+  }
+  return { ok: true, lease };
+}
+
+function clearWorkspaceLease(executionState = null) {
+  const lease = ensureWorkspaceLease(executionState);
+  lease.holders = [];
+  lease.holder = null;
+  lease.acquiredAt = "";
+  return lease;
+}
+
+/**
+ * @param {string} tool
+ * @param {"agent_loop"|"task_loop"} originKind
+ * @param {string} [taskRunId]
+ */
+function checkWriteAllowed(executionState = null, {
+  tool = "",
+  originKind = "agent_loop",
+  taskRunId = "",
+} = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  if (!WRITE_TOOLS.has(name)) return { ok: true };
+
+  const holders = listWriteLeaseHolders(executionState);
+  if (holders.length === 0) return { ok: true };
+
+  if (originKind === "task_loop") {
+    const id = String(taskRunId || "").trim();
+    if (holders.some((h) => h.taskRunId === id)) {
+      return { ok: true };
+    }
+    return {
+      ok: false,
+      code: "WORKSPACE_WRITE_LEASE_HELD",
+      holders,
+      message: "This TaskRun does not hold a workspace write lease.",
+    };
+  }
+
+  // Agent loop cannot write while any task holds a lease.
+  return {
+    ok: false,
+    code: "WORKSPACE_WRITE_LEASE_HELD",
+    holders,
+    owner: holders[0] || null,
+    message: `${holders.length} active TaskRun(s) hold workspace write lease(s); cancel or wait before writing.`,
+  };
+}
+
+function hasActiveWriteLease(executionState = null) {
+  return countWriteLeases(executionState) > 0;
+}
+
+/**
+ * Release leases whose TaskRun is missing/terminal, or whose acquiredAt is older
+ * than maxAgeMs without an active non-terminal run heartbeat.
+ */
+function releaseStaleWriteLeases(executionState = null, {
+  maxAgeMs = require("./taskRun").DEFAULT_LEASE_STALE_MS,
+  nowMs = Date.now(),
+} = {}) {
+  const {
+    getTaskRun,
+    isTerminalTaskRun,
+  } = require("./taskRun");
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const released = [];
+  const kept = [];
+  const maxAge = Number.isFinite(maxAgeMs) ? Math.max(0, maxAgeMs) : 0;
+
+  for (const holder of holders) {
+    const run = getTaskRun(executionState, holder.taskRunId);
+    if (!run || isTerminalTaskRun(run)) {
+      released.push({ taskRunId: holder.taskRunId, reason: "terminal_or_missing" });
+      continue;
+    }
+    const acquired = Date.parse(String(holder.acquiredAt || ""));
+    if (maxAge > 0 && Number.isFinite(acquired) && (nowMs - acquired) > maxAge) {
+      const beat = Date.parse(String(run.heartbeatAt || run.startedAt || ""));
+      if (!Number.isFinite(beat) || (nowMs - beat) > maxAge) {
+        released.push({ taskRunId: holder.taskRunId, reason: "stale_heartbeat" });
+        continue;
+      }
+    }
+    kept.push(holder);
+  }
+
+  lease.holders = kept;
+  if (kept.length === 0) lease.acquiredAt = "";
+  return { ok: true, released, kept: kept.slice(), lease };
+}
+
+module.exports = {
+  WRITE_TOOLS,
+  MAX_CONCURRENT_WRITE_LEASES,
+  emptyWorkspaceLease,
+  ensureWorkspaceLease,
+  normalizeHolders,
+  listWriteLeaseHolders,
+  countWriteLeases,
+  findWriteLeaseHolder,
+  canAcquireWriteLease,
+  acquireTaskWriteLease,
+  releaseTaskWriteLease,
+  clearWorkspaceLease,
+  checkWriteAllowed,
+  hasActiveWriteLease,
+  releaseStaleWriteLeases,
+};

package/src/code/sessionStore.js

@@ -1,7 +1,6 @@
 const fs = require("fs");
 const path = require("path");
 const { randomUUID } = require("crypto");
-const { isContextV2Enabled } = require("./context/featureFlag");
 const {
   getTranscriptsDir,
   getTranscriptFilePath,
@@ -69,10 +68,10 @@ function normalizeContextPolicy(value = {}) {
 }
 
 function buildSessionSnapshot(input = {}) {
+  // Durable session fields vs projections: src/code/protocol/ownership.js
   const source = input && typeof input === "object" ? input : {};
   const sessionId = resolveSessionId(source.sessionId);
   const createdAt = String(source.createdAt || "").trim() || toIsoNow();
-  const useV2 = isContextV2Enabled() || Number(source.version) >= 2;
 
   const base = {
     sessionId,
@@ -84,14 +83,6 @@ function buildSessionSnapshot(input = {}) {
     updatedAt: toIsoNow(),
   };
 
-  if (!useV2) {
-    return {
-      version: 1,
-      ...base,
-      nlMessages: cloneMessages(source.nlMessages),
-    };
-  }
-
   return {
     version: 2,
     ...base,

package/src/code/skills/injection.js

@@ -195,4 +195,5 @@ module.exports = {
   readSkillBlock,
   persistSkillBodyArtifact,
   buildSkillInjections,
+  sanitizeSkillContent,
 };