clay-server 4.1.0-beta.4 → 4.1.0-beta.6

package/lib/project-full-access.js

@@ -0,0 +1,86 @@
+// Shared, transactional control for Clay-managed per-session Skip Permissions.
+
+function createFullAccessService(ctx) {
+  var sm = ctx.sm;
+  var transitions = new Map();
+
+  function serialize(session, action) {
+    var prior = transitions.get(session.localId) || Promise.resolve();
+    var next = prior.catch(function () {}).then(action);
+    transitions.set(session.localId, next);
+    return next.finally(function () {
+      if (transitions.get(session.localId) === next) transitions.delete(session.localId);
+    });
+  }
+
+  function snapshot(session) {
+    return {
+      permissionMode: session.permissionMode || null,
+      permissionModeBeforeFullAccess: session.permissionModeBeforeFullAccess || null,
+      enabled: session.permissionMode === "bypassPermissions",
+    };
+  }
+
+  function notify(session) {
+    if (typeof sm.sendToSession === "function") sm.sendToSession(session, { type: "session_full_access_changed", id: session.localId,
+      enabled: session.permissionMode === "bypassPermissions", permissionMode: session.permissionMode });
+  }
+
+  async function applyNativeMode(session, enabled) {
+    if (!session.queryInstance || typeof session.queryInstance.setPermissionMode !== "function") return;
+    // Clay's common permission callback remains the approval authority.
+    await session.queryInstance.setPermissionMode(enabled ? "default" : session.permissionMode);
+  }
+
+  async function applyEnabled(session, enabled) {
+    var previous = snapshot(session);
+    if (previous.enabled === !!enabled) return previous;
+    if (enabled) {
+      session.permissionModeBeforeFullAccess = session.permissionMode || sm.currentPermissionMode || "default";
+      session.permissionMode = "bypassPermissions";
+    } else {
+      session.permissionMode = session.permissionModeBeforeFullAccess || "default";
+      session.permissionModeBeforeFullAccess = null;
+    }
+    try {
+      await applyNativeMode(session, !!enabled);
+      sm.saveSessionFile(session);
+      sm.broadcastSessionList();
+      notify(session);
+      return previous;
+    } catch (error) {
+      session.permissionMode = previous.permissionMode;
+      session.permissionModeBeforeFullAccess = previous.permissionModeBeforeFullAccess;
+      throw error;
+    }
+  }
+
+  function setEnabled(session, enabled) {
+    return serialize(session, function () { return applyEnabled(session, enabled); });
+  }
+
+  async function applyRestore(session, prior) {
+    if (!prior) return;
+    var current = snapshot(session);
+    session.permissionMode = prior.permissionMode;
+    session.permissionModeBeforeFullAccess = prior.permissionModeBeforeFullAccess;
+    try {
+      await applyNativeMode(session, prior.enabled);
+      sm.saveSessionFile(session);
+      sm.broadcastSessionList();
+      notify(session);
+    } catch (error) {
+      session.permissionMode = current.permissionMode;
+      session.permissionModeBeforeFullAccess = current.permissionModeBeforeFullAccess;
+      throw error;
+    }
+  }
+
+  function restore(session, prior) {
+    return serialize(session, function () { return applyRestore(session, prior); });
+  }
+
+  return { restore: restore, setEnabled: setEnabled, snapshot: snapshot };
+}
+
+module.exports = { createFullAccessService: createFullAccessService };

package/lib/project-http.js

@@ -898,7 +898,9 @@ function attachHTTP(ctx) {
         }
         var sessionId = Number(body.sessionId);
         if (!Number.isInteger(sessionId)) sessionId = null;
-        var handler = getMcpBridgeHandler(sessionId, body.sessionOnly === true);
+        var queryGeneration = Number(body.queryGeneration);
+        if (!Number.isInteger(queryGeneration)) queryGeneration = null;
+        var handler = getMcpBridgeHandler(sessionId, body.sessionOnly === true, queryGeneration);
         if (!handler) {
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end('{"error":"MCP bridge handler unavailable"}');

package/lib/project-loop-interview.js

@@ -0,0 +1,163 @@
+var crypto = require("crypto");
+var driverEligibility = require("./session-driver-eligibility");
+var loopGuidance = require("./loop-guidance");
+
+var MAX_OBJECTIVE = 20000;
+var MAX_CRITERIA = 10;
+var MAX_CRITERION = 1000;
+
+function text(value, max) { return typeof value === "string" ? value.trim().substring(0, max) : ""; }
+function criteria(value) { return (Array.isArray(value) ? value : []).slice(0, MAX_CRITERIA).map(function (item) { return text(item, MAX_CRITERION); }).filter(Boolean); }
+function activeInterviewId(session) {
+  var history = Array.isArray(session && session.history) ? session.history : [];
+  var current = null;
+  for (var i = 0; i < history.length; i++) {
+    var entry = history[i];
+    if (entry && entry.source === "loop_interview") current = entry.interviewId || null;
+    if (entry && (entry.source === "loop_interview_cancel" || entry.source === "loop_interview_close") && entry.interviewId === current) current = null;
+  }
+  return current;
+}
+function brief(value) {
+  if (!value || typeof value !== "object") return null;
+  var objective = text(value.objective, MAX_OBJECTIVE);
+  var successCriteria = criteria(value.successCriteria);
+  if (!objective || successCriteria.length === 0) return null;
+  return { version: 1, id: text(value.id, 200) || crypto.randomUUID(), objective: objective,
+    successCriteria: successCriteria, maxContinuations: Math.max(1, Math.min(100, Math.floor(Number(value.maxContinuations) || 10))),
+    maxMinutes: Math.max(1, Math.min(1440, Math.floor(Number(value.maxMinutes) || 60))), createdAt: Number(value.createdAt) || Date.now() };
+}
+
+function attachLoopInterview(ctx) {
+  var sm = ctx.sm;
+  var sendTo = ctx.sendTo;
+  var autonomousRun = ctx.autonomousRun;
+  function eligible(session) { return !!(session && !ctx.isMate && (session.runtimeMode || session.mode) === "gui" && driverEligibility.isEligibleDriverSession(session) && !ctx.isDriverOperatedSession(session)); }
+  function runActive(session) { return !!(session && session.autonomousRun && ["armed", "running", "reviewing", "waiting-worker", "waiting-user", "paused"].indexOf(session.autonomousRun.state) !== -1); }
+  function hasInterview(session, requestId) {
+    var history = Array.isArray(session && session.history) ? session.history : [];
+    for (var i = history.length - 1; i >= 0; i--) if (history[i] && history[i].source === "loop_interview" && history[i].requestId === requestId) return true;
+    return false;
+  }
+  function currentInterview(session) {
+    return activeInterviewId(session);
+  }
+  function interviewActive(session) {
+    return !!currentInterview(session);
+  }
+  function startInterview(ws, msg) {
+    var session = ctx.getSessionForWs(ws);
+    var requestId = text(msg.requestId, 200);
+    var result = { type: "loop_interview_start_result", sessionId: session && session.localId || msg.sessionId || null, requestId: requestId, ok: false };
+    if (!session || !requestId || Number(msg.sessionId) !== Number(session.localId) || (ctx.canAccess && !ctx.canAccess(ws, session))) result.error = "This session is no longer available.";
+    else if (hasInterview(session, requestId)) { result.ok = true; result.duplicate = true; }
+    else if (!eligible(session)) result.error = "Loop interviews are available only in a Driver project chat.";
+    else if (runActive(session)) result.error = "Finish the active Loop run before starting another interview.";
+    else if (session.isProcessing || session._queryStarting) result.error = "Wait for the current task to finish before starting a Loop interview.";
+    else {
+      session.loopInterviewBrief = null;
+      var prompt = loopGuidance.interviewPrompt();
+      var interviewId = crypto.randomUUID();
+      var entry = { type: "user_message", text: "[Loop interview started]", source: "loop_interview", interviewId: interviewId, requestId: requestId, _ts: Date.now() };
+      session.history.push(entry);
+      sm.appendToSessionFile(session, entry);
+      sm.saveSessionFile(session);
+      publish(session);
+      ctx.sendToSession(session.localId, entry);
+      session.isProcessing = true;
+      ctx.onProcessingChanged();
+      ctx.sendToSession(session.localId, { type: "status", status: "processing" });
+      try {
+        var started = ctx.sdk.startQuery(session, prompt, null, ctx.ensureProjectAccessForSession(session));
+        ctx.sendTo(ws, Object.assign({}, result, { ok: true }));
+        Promise.resolve(started).catch(function (error) {
+          var stillCurrent = ctx.getSessionForWs(ws) === session && currentInterview(session) === interviewId && hasInterview(session, requestId);
+          if (!stillCurrent) return;
+          session.isProcessing = false;
+          ctx.onProcessingChanged();
+          ctx.sendToSession(session.localId, { type: "status", status: "idle" });
+          sm.saveSessionFile(session);
+          ctx.sendTo(ws, Object.assign({}, result, { ok: false, error: "Loop interview could not start: " + (error.message || error) }));
+        });
+        return true;
+      } catch (error) {
+        session.isProcessing = false;
+        ctx.onProcessingChanged();
+        ctx.sendToSession(session.localId, { type: "status", status: "idle" });
+        sm.saveSessionFile(session);
+        result.error = "Loop interview could not start: " + (error.message || error);
+      }
+    }
+    ctx.sendTo(ws, result);
+    return true;
+  }
+  function publish(session) { sm.sendToSession(session, { type: "loop_interview_brief", sessionId: session.localId, brief: session.loopInterviewBrief || null }); }
+  function propose(session, interviewId, args) {
+    if (!eligible(session) || runActive(session) || !interviewId || currentInterview(session) !== interviewId) return Promise.resolve({ content: [{ type: "text", text: JSON.stringify({ status: "rejected", reason: "propose_loop is stale or unavailable outside the current Driver Loop interview." }) }] });
+    var next = brief(args);
+    if (!next) return Promise.resolve({ content: [{ type: "text", text: JSON.stringify({ status: "rejected", reason: "Provide an objective and at least one success criterion." }) }] });
+    next.interviewId = interviewId;
+    session.loopInterviewBrief = next;
+    sm.saveSessionFile(session);
+    publish(session);
+    return Promise.resolve({ content: [{ type: "text", text: JSON.stringify({ status: "proposed", brief: next }) }] });
+  }
+  function getToolDefs(session) {
+    if (!eligible(session) || runActive(session) || !interviewActive(session) || session.loopInterviewBrief) return [];
+    var interviewId = currentInterview(session);
+    return [{ name: "propose_loop", description: "Draft a bounded Loop execution brief for human review. This never starts execution or changes permissions.", inputSchema: { type: "object", properties: {
+      objective: { type: "string" }, successCriteria: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 10 },
+      maxContinuations: { type: "integer", minimum: 1, maximum: 100 }, maxMinutes: { type: "integer", minimum: 1, maximum: 1440 }
+    }, required: ["objective", "successCriteria"], additionalProperties: false }, handler: function (args) { return propose(session, interviewId, args || {}); } }];
+  }
+  function handleMessage(ws, msg) {
+    if (msg.type === "loop_interview_state") {
+      var stateSession = ctx.getSessionForWs(ws);
+      if (stateSession && Number(msg.sessionId) === Number(stateSession.localId) && (!ctx.canAccess || ctx.canAccess(ws, stateSession))) publish(stateSession);
+      return true;
+    }
+    if (msg.type === "loop_interview_start") return startInterview(ws, msg);
+    if (["loop_interview_start_run", "loop_interview_edit", "loop_interview_cancel"].indexOf(msg.type) === -1) return false;
+    var session = ctx.getSessionForWs(ws);
+    if (!session || Number(msg.sessionId) !== Number(session.localId) || (ctx.canAccess && !ctx.canAccess(ws, session)) || !eligible(session)) {
+      if (msg.type === "loop_interview_start_run") sendTo(ws, { type: "loop_interview_start_run_result", ok: false, sessionId: session && session.localId || msg.sessionId || null, requestId: text(msg.requestId, 200), error: "This session is no longer available." });
+      return true;
+    }
+    if (msg.type === "loop_interview_cancel") {
+      if (session.loopInterviewBrief && (text(msg.proposalId, 200) !== session.loopInterviewBrief.id || Number(msg.version) !== Number(session.loopInterviewBrief.version))) return true;
+      var cancelEntry = { type: "loop_interview_cancel", source: "loop_interview_cancel", interviewId: currentInterview(session), _ts: Date.now() };
+      session.history.push(cancelEntry); sm.appendToSessionFile(session, cancelEntry);
+      session.loopInterviewBrief = null; sm.saveSessionFile(session); publish(session); return true;
+    }
+    if (msg.type === "loop_interview_edit") {
+      if (session.loopInterviewBrief && text(msg.proposalId, 200) === session.loopInterviewBrief.id && Number(msg.version) === Number(session.loopInterviewBrief.version) && session.loopInterviewBrief.interviewId === currentInterview(session)) {
+        var edited = brief(Object.assign({}, session.loopInterviewBrief, msg.brief || {}));
+        if (edited) { edited.interviewId = session.loopInterviewBrief.interviewId; edited.version = session.loopInterviewBrief.version + 1; session.loopInterviewBrief = edited; sm.saveSessionFile(session); publish(session); }
+      }
+      return true;
+    }
+    var proposal = session.loopInterviewBrief;
+    if (!proposal || proposal.interviewId !== currentInterview(session) || text(msg.proposalId, 200) !== proposal.id || Number(msg.version) !== Number(proposal.version)) {
+      sendTo(ws, { type: "loop_interview_start_run_result", ok: false, sessionId: session.localId, requestId: text(msg.requestId, 200), error: "This Loop brief is stale or no longer pending." });
+      return true;
+    }
+    autonomousRun.startApprovedBrief(ws, session, proposal, text(msg.requestId, 200), function () {
+      return !!(session.loopInterviewBrief && session.loopInterviewBrief.id === proposal.id && Number(session.loopInterviewBrief.version) === Number(proposal.version) && session.loopInterviewBrief.interviewId === currentInterview(session));
+    }).then(function (ok) {
+      if (ok && session.loopInterviewBrief && session.loopInterviewBrief.id === proposal.id) {
+        var closeEntry = { type: "loop_interview_close", source: "loop_interview_close", interviewId: proposal.interviewId, proposalId: proposal.id, proposalVersion: proposal.version, _ts: Date.now() };
+        session.history.push(closeEntry);
+        sm.appendToSessionFile(session, closeEntry);
+        session.loopInterviewBrief = null;
+        sm.saveSessionFile(session);
+        publish(session);
+      }
+    }).catch(function (error) {
+      sendTo(ws, { type: "loop_interview_start_run_result", ok: false, sessionId: session.localId, requestId: text(msg.requestId, 200), error: error.message || String(error) });
+    });
+    return true;
+  }
+  return { getToolDefs: getToolDefs, handleMessage: handleMessage };
+}
+
+module.exports = { attachLoopInterview: attachLoopInterview, brief: brief, activeInterviewId: activeInterviewId };

package/lib/project-loop.js

@@ -3,6 +3,10 @@ var path = require("path");
 var crypto = require("crypto");
 var { execFileSync } = require("child_process");
 var { createLoopRegistry } = require("./scheduler");
+var loopGuidance = require("./loop-guidance");
+var validateCron = require("./schedule-validation").validateCron;
+var validateScheduleRule = require("./schedule-rule").validateScheduleRule;
+var attachLoopDurableSchedule = require("./loop-durable-schedule").attachLoopDurableSchedule;
 
 /**
  * Attach loop engine to a project context.
@@ -62,7 +66,7 @@ function attachLoop(ctx) {
   var _loopUtils = require("./utils");
   var _loopDir = path.join(_loopConfig.CONFIG_DIR, "loops");
   var _loopEncodedCwd = _loopUtils.resolveEncodedFile(_loopDir, cwd, ".json");
-  var _loopStatePath = path.join(_loopDir, _loopEncodedCwd + ".json");
+  var _loopStatePath = ctx.loopStatePath || path.join(_loopDir, _loopEncodedCwd + ".json");
 
   function saveLoopState() {
     try {
@@ -269,18 +273,43 @@ function attachLoop(ctx) {
 
   // --- Loop Registry (unified one-off + scheduled) ---
   var activeRegistryId = null; // track which registry record triggered current loop
-  var pendingTriggers = []; // queue for deferred triggers when skipIfRunning=false
+  var durableSchedule = null;
+  function isMultiUser() { return typeof ctx.isMultiUser === "function" ? ctx.isMultiUser() : !!ctx.isMultiUser; }
+
+  function legacyRuntimeFor(session) {
+    var record = loopRegistry.getById(loopState.loopId);
+    var linuxUser = getLinuxUserForSession(session);
+    if (!isMultiUser()) return { ok: true, linuxUser: linuxUser };
+    if (!record || !record.ownerId || session.ownerId !== record.ownerId) return { ok: false, error: "The scheduled Loop owner changed before execution." };
+    if (ctx.authorizeScheduledRun && !ctx.authorizeScheduledRun(record)) return { ok: false, error: "The scheduled Loop owner is no longer authorized for this project." };
+    if (ctx.requiresLinuxUser && ctx.requiresLinuxUser() && !linuxUser) return { ok: false, error: "The scheduled Loop owner no longer has a valid OS identity." };
+    return { ok: true, linuxUser: linuxUser };
+  }
+
+  function rejectLegacyRuntime(session, error) {
+    var message = error || "The scheduled Loop execution identity is no longer valid.";
+    var entry = { type: "error", text: message };
+    session.isProcessing = false; session.singleTurn = false; if (session.loop) session.loop.active = false;
+    session.history.push(entry); sm.appendToSessionFile(session, entry); sm.saveSessionFile(session);
+    sendToSession(session.localId, entry); sendToSession(session.localId, { type: "status", status: "idle" }); send({ type: "loop_error", text: message }); finishLoop("error");
+  }
 
   function triggerFromQueue(record) {
-    // For schedule records, resolve the linked task to get loop files
+    if (record.createdViaScheduledTasks && ctx.authorizeScheduledRun && !ctx.authorizeScheduledRun(record)) {
+      console.error("[loop-registry] Scheduled task owner is no longer authorized: " + record.name);
+      return;
+    }
+    // Linked calendar schedules use their task's files. Standalone Scheduled Tasks own theirs.
     var loopFilesId = record.id;
     if (record.source === "schedule") {
-      if (!record.linkedTaskId) {
-        console.error("[loop-registry] Schedule has no linked task: " + record.name);
-        return;
+      var standaloneScheduledTask = record.createdViaScheduledTasks && record.mode === "simple" && !record.linkedTaskId;
+      if (!record.linkedTaskId && !standaloneScheduledTask) {
+        failScheduledDispatch("Schedule has no linked task: " + record.name);
+      }
+      if (record.linkedTaskId) {
+        loopFilesId = record.linkedTaskId;
+        console.log("[loop-registry] Schedule triggered: " + record.name + " -> linked task " + loopFilesId);
       }
-      loopFilesId = record.linkedTaskId;
-      console.log("[loop-registry] Schedule triggered: " + record.name + " -> linked task " + loopFilesId);
     }
 
     // Verify the loop directory and PROMPT.md exist
@@ -288,8 +317,7 @@ function attachLoop(ctx) {
     try {
       fs.accessSync(path.join(recDir, "PROMPT.md"));
     } catch (e) {
-      console.error("[loop-registry] PROMPT.md missing for " + loopFilesId);
-      return;
+      failScheduledDispatch("PROMPT.md is missing for " + loopFilesId + ".");
     }
     // Set the loopId to the schedule's own id (not the linked task) so sidebar groups correctly
     loopState.loopId = record.id;
@@ -304,28 +332,65 @@ function attachLoop(ctx) {
     startLoop({ maxIterations: record.maxIterations, name: record.name });
   }
 
+  function failScheduledDispatch(message) {
+    console.error("[loop-registry] " + message);
+    send({ type: "loop_error", text: message });
+    var error = new Error(message); error.code = "SCHEDULE_DISPATCH_FAILED"; throw error;
+  }
+
+  function usesPairExecution(record) { return !!(record && (record.createdViaScheduledTasks === true || record.source === "schedule")); }
+
   var loopRegistry = createLoopRegistry({
     cwd: cwd,
-    onTrigger: function (record) {
-      // Skip or queue trigger if a loop is already active
+    registryPath: ctx.loopRegistryPath,
+    canTrigger: function (record) {
+      if (!usesPairExecution(record)) return true;
+      return ctx.canExecuteScheduledTask ? ctx.canExecuteScheduledTask(record) : false;
+    },
+    prepareTrigger: function (record) {
+      if (!usesPairExecution(record)) return null;
+      return ctx.prepareScheduledTask ? ctx.prepareScheduledTask(record, "schedule") : { ok: false };
+    },
+    onTrigger: function (record, prepared) {
+      if (usesPairExecution(record)) {
+        if (prepared && (prepared.skipped || prepared.queued)) return;
+        var scheduledResult = ctx.executeScheduledTask && ctx.executeScheduledTask(record, "schedule", prepared);
+        if (!scheduledResult || !scheduledResult.ok) failScheduledDispatch("Pair execution did not start: " + (scheduledResult && scheduledResult.error || record.name));
+        return;
+      }
+      // A busy non-skipping occurrence remains queued in the durable scheduler.
       if (loopState.active || loopState.phase === "executing") {
         if (record.skipIfRunning !== false) {
           console.log("[loop-registry] Skipping trigger for " + record.name + " — loop already active (skipIfRunning)");
           return;
         }
-        console.log("[loop-registry] Loop active, queuing trigger for " + record.name);
-        pendingTriggers.push(record);
         return;
       }
 
       triggerFromQueue(record);
     },
     onChange: function () {
+      if (durableSchedule) durableSchedule.sync();
       send({ type: "loop_registry_updated", records: getHubSchedules() });
     },
   });
   loopRegistry.load();
-  loopRegistry.startTimer();
+  if (ctx.durableScheduler) {
+    durableSchedule = attachLoopDurableSchedule({
+      scheduler: ctx.durableScheduler,
+      registry: loopRegistry,
+      projectId: slug,
+      isMultiUser: ctx.isMultiUser,
+      authorize: function (record) {
+        if (!isMultiUser() && !usesPairExecution(record)) return true;
+        return !ctx.authorizeScheduledRun || ctx.authorizeScheduledRun(record);
+      },
+      canRun: function (record) {
+        if (usesPairExecution(record)) return ctx.canExecuteScheduledTask ? ctx.canExecuteScheduledTask(record) : false;
+        return !(record.skipIfRunning === false && (loopState.active || loopState.phase === "executing"));
+      },
+    });
+  } else loopRegistry.startTimer();
 
   // Wire loop info resolution for session list broadcasts
   sm.setResolveLoopInfo(function (loopId) {
@@ -412,8 +477,8 @@ function attachLoop(ctx) {
       return;
     }
 
-    var session = sm.createSession();
     var loopSource = loopRegistry.getById(loopState.loopId);
+    var session = sm.createSession({ ownerId: loopSource && loopSource.ownerId || null });
     var loopName = (loopState.wizardData && loopState.wizardData.name) || (loopSource && loopSource.name) || "";
     var loopSourceTag = (loopSource && loopSource.source) || null;
     var isRalphLoop = loopSourceTag === "ralph";
@@ -430,6 +495,8 @@ function attachLoop(ctx) {
       maxIterations: loopState.maxIterations,
       sessionId: session.localId,
     });
+    var coderRuntime = legacyRuntimeFor(session);
+    if (!coderRuntime.ok) { rejectLegacyRuntime(session, coderRuntime.error); return; }
 
     var coderCompleted = false;
     session.onQueryComplete = function(completedSession) {
@@ -508,7 +575,7 @@ function attachLoop(ctx) {
     session.acceptEditsAfterStart = true;
     session.singleTurn = true;
     if (loopState.settings) session.loopSettings = loopState.settings;
-    sdk.startQuery(session, loopState.promptText, undefined, getLinuxUserForSession(session));
+    sdk.startQuery(session, loopState.promptText, undefined, coderRuntime.linuxUser);
   }
 
   function runJudge() {
@@ -549,8 +616,8 @@ function attachLoop(ctx) {
       "- PASS: [brief explanation]\n" +
       "- FAIL: [brief explanation of what is still missing]";
 
-    var judgeSession = sm.createSession();
     var judgeSource = loopRegistry.getById(loopState.loopId);
+    var judgeSession = sm.createSession({ ownerId: judgeSource && judgeSource.ownerId || null });
     var judgeName = (loopState.wizardData && loopState.wizardData.name) || (judgeSource && judgeSource.name) || "";
     var judgeSourceTag = (judgeSource && judgeSource.source) || null;
     var isRalphJudge = judgeSourceTag === "ralph";
@@ -565,6 +632,8 @@ function attachLoop(ctx) {
       iteration: loopState.iteration,
       sessionId: judgeSession.localId,
     });
+    var judgeRuntime = legacyRuntimeFor(judgeSession);
+    if (!judgeRuntime.ok) { rejectLegacyRuntime(judgeSession, judgeRuntime.error); return; }
 
     var judgeCompleted = false;
     judgeSession.onQueryComplete = function(completedSession) {
@@ -625,7 +694,7 @@ function attachLoop(ctx) {
     judgeSession.acceptEditsAfterStart = true;
     judgeSession.singleTurn = true;
     if (loopState.settings) judgeSession.loopSettings = loopState.settings;
-    sdk.startQuery(judgeSession, judgePrompt, undefined, getLinuxUserForSession(judgeSession));
+    sdk.startQuery(judgeSession, judgePrompt, undefined, judgeRuntime.linuxUser);
   }
 
   function parseJudgeVerdict(session) {
@@ -710,14 +779,7 @@ function attachLoop(ctx) {
       });
     }
 
-    // Process next queued trigger if any
-    if (pendingTriggers.length > 0) {
-      var next = pendingTriggers.shift();
-      console.log("[loop-registry] Processing queued trigger: " + next.name);
-      setTimeout(function () {
-        triggerFromQueue(next);
-      }, 1000);
-    }
+    if (durableSchedule) durableSchedule.wake();
   }
 
   function resumeLoop() {
@@ -891,13 +953,7 @@ function attachLoop(ctx) {
           loopState.phase = "crafting";
           saveLoopState();
 
-          var judgeCraftPrompt = "Use the /clay-ralph skill to design ONLY a JUDGE.md for an existing Ralph Loop. " +
-            "The user has already provided PROMPT.md, so do NOT create or modify PROMPT.md. " +
-            "You MUST invoke the clay-ralph skill — do NOT execute the task yourself. " +
-            "Your job is to read the existing PROMPT.md and create a JUDGE.md " +
-            "that will evaluate whether the coder session completed the task successfully.\n\n" +
-            "## Task\n" + (wData.task || "") +
-            "\n\n## Loop Directory\n" + lDir;
+          var judgeCraftPrompt = loopGuidance.legacyCraftPrompt({ judgeOnly: true, task: wData.task, directory: lDir });
 
           var judgeCraftSession = sm.createSession();
           judgeCraftSession.title = (isRalphCraft ? "Ralph" : "Task") + (craftName ? " " + craftName : "") + " Crafting";
@@ -934,31 +990,9 @@ function attachLoop(ctx) {
         return true;
       }
 
-      // Default: "draft" mode — Clay crafts files via the clay-ralph skill
+      // Default: "draft" mode — Clay crafts legacy PROMPT.md/JUDGE.md files
       var _draftIsSimple = wData.loopMode === "simple";
-      var craftingPrompt;
-      if (_draftIsSimple) {
-        craftingPrompt = "Use the /clay-ralph skill to design a Ralph Loop for the following task. " +
-          "You MUST invoke the clay-ralph skill — do NOT execute the task yourself. " +
-          "This is a Simple Loop (no judge). Your job is to create ONLY a PROMPT.md file " +
-          "that a future autonomous session will execute. Do NOT create a JUDGE.md file.\n\n" +
-          "## Task\n" + (wData.task || "") +
-          "\n\n## Loop Directory\n" + lDir;
-      } else if (wData.judgeAuthor === "me") {
-        craftingPrompt = "Use the /clay-ralph skill to design a Ralph Loop for the following task. " +
-          "You MUST invoke the clay-ralph skill — do NOT execute the task yourself. " +
-          "The user will provide their own JUDGE.md, so create ONLY a PROMPT.md file " +
-          "that a future autonomous session will execute. Do NOT create a JUDGE.md file.\n\n" +
-          "## Task\n" + (wData.task || "") +
-          "\n\n## Loop Directory\n" + lDir;
-      } else {
-        craftingPrompt = "Use the /clay-ralph skill to design a Ralph Loop for the following task. " +
-          "You MUST invoke the clay-ralph skill — do NOT execute the task yourself. " +
-          "Your job is to interview me, then create PROMPT.md and JUDGE.md files " +
-          "that a future autonomous session will execute.\n\n" +
-          "## Task\n" + (wData.task || "") +
-          "\n\n## Loop Directory\n" + lDir;
-      }
+      var craftingPrompt = loopGuidance.legacyCraftPrompt({ simple: _draftIsSimple, userJudge: wData.judgeAuthor === "me", task: wData.task, directory: lDir });
 
       // Pre-write user-provided files before crafting starts
       if (wData.judgeText && wData.judgeAuthor === "me") {
@@ -1106,6 +1140,27 @@ function attachLoop(ctx) {
     // --- Schedule create (from calendar click) ---
     if (msg.type === "schedule_create") {
       var sData = msg.data || {};
+      var scheduleActor = ctx.getScheduleActor ? ctx.getScheduleActor(ws) : { ownerId: null, ownerName: null, sessionId: null };
+      if (!scheduleActor) {
+        sendTo(ws, { type: "loop_registry_error", text: "The schedule owner could not be verified." });
+        return true;
+      }
+      if (sData.cron) {
+        var scheduleCreateCron = validateCron(sData.cron);
+        if (!scheduleCreateCron.ok) {
+          sendTo(ws, { type: "loop_registry_error", text: scheduleCreateCron.error });
+          return true;
+        }
+        sData.cron = scheduleCreateCron.cron;
+      }
+      if (sData.scheduleRule) {
+        var scheduleCreateRule = validateScheduleRule(sData.scheduleRule);
+        if (!scheduleCreateRule.ok) {
+          sendTo(ws, { type: "loop_registry_error", text: scheduleCreateRule.error });
+          return true;
+        }
+        sData.scheduleRule = scheduleCreateRule.value;
+      }
       loopRegistry.register({
         name: sData.name || "Untitled",
         task: sData.name || "",
@@ -1122,6 +1177,11 @@ function attachLoop(ctx) {
         recurrenceEnd: sData.recurrenceEnd || null,
         skipIfRunning: sData.skipIfRunning !== undefined ? sData.skipIfRunning : true,
         intervalEnd: sData.intervalEnd || null,
+        scheduleRule: sData.scheduleRule || null,
+        ownerId: scheduleActor.ownerId,
+        ownerName: scheduleActor.ownerName,
+        sessionId: scheduleActor.sessionId,
+        createdViaScheduledTasks: true,
       });
       return true;
     }
@@ -1139,7 +1199,28 @@ function attachLoop(ctx) {
     }
 
     if (msg.type === "loop_registry_update") {
-      var updatedRec = loopRegistry.update(msg.id, msg.data || {});
+      if (msg.data && msg.data.cron !== undefined && msg.data.cron !== null) {
+        var scheduleUpdateCron = validateCron(msg.data.cron);
+        if (!scheduleUpdateCron.ok) {
+          sendTo(ws, { type: "loop_registry_error", text: scheduleUpdateCron.error });
+          return true;
+        }
+        msg.data.cron = scheduleUpdateCron.cron;
+      }
+      if (msg.data && msg.data.scheduleRule) {
+        var scheduleUpdateRule = validateScheduleRule(msg.data.scheduleRule);
+        if (!scheduleUpdateRule.ok) {
+          sendTo(ws, { type: "loop_registry_error", text: scheduleUpdateRule.error });
+          return true;
+        }
+        msg.data.scheduleRule = scheduleUpdateRule.value;
+      }
+      var registryUpdateData = Object.assign({}, msg.data || {});
+      delete registryUpdateData.ownerId;
+      delete registryUpdateData.ownerName;
+      delete registryUpdateData.sessionId;
+      delete registryUpdateData.createdViaScheduledTasks;
+      var updatedRec = loopRegistry.update(msg.id, registryUpdateData);
       if (!updatedRec) {
         sendTo(ws, { type: "loop_registry_error", text: "Record not found" });
       }
@@ -1197,15 +1278,20 @@ function attachLoop(ctx) {
 
     if (msg.type === "loop_registry_rerun") {
       // Re-run an existing job (one-off from library)
-      if (loopState.active || loopState.phase === "executing") {
-        sendTo(ws, { type: "loop_registry_error", text: "A loop is already running" });
-        return true;
-      }
       var rerunRec = loopRegistry.getById(msg.id);
       if (!rerunRec) {
         sendTo(ws, { type: "loop_registry_error", text: "Record not found" });
         return true;
       }
+      if (usesPairExecution(rerunRec)) {
+        var pairRun = ctx.executeScheduledTask && ctx.executeScheduledTask(rerunRec, "manual");
+        if (!pairRun || !pairRun.ok) sendTo(ws, { type: "loop_registry_error", text: pairRun && pairRun.error || "The scheduled pair could not start." });
+        return true;
+      }
+      if (loopState.active || loopState.phase === "executing") {
+        sendTo(ws, { type: "loop_registry_error", text: "A loop is already running" });
+        return true;
+      }
       var rerunDir = path.join(cwd, ".claude", "loops", rerunRec.id);
       try {
         fs.accessSync(path.join(rerunDir, "PROMPT.md"));
@@ -1297,7 +1383,7 @@ function attachLoop(ctx) {
     getSchedules: function () { return loopRegistry.getAll(); },
     importSchedule: function (data) { return loopRegistry.register(data); },
     removeSchedule: function (id) { return loopRegistry.remove(id); },
-    stopTimer: function () { loopRegistry.stopTimer(); },
+    stopTimer: function () { if (durableSchedule) durableSchedule.shutdown(); else loopRegistry.stopTimer(); },
   };
 }
 

package/lib/project-pair-autonomous-stop.js

@@ -0,0 +1,16 @@
+function stopAutonomousWork(session, roles, turnControl, taskControl, workerPermission) {
+  if (!roles) return false;
+  var runId = session.autonomousRun && session.autonomousRun.id;
+  var cancelled = taskControl.cancelAll(roles.worker, runId);
+  var owned = roles.worker._pairDelegation && roles.worker._pairDelegation.autonomousRunId === runId;
+  if (!owned && !cancelled) return true;
+  turnControl.markHumanStop(session);
+  if (!owned) return true;
+  taskControl.markInterruption(roles.worker, "user", "The Until complete run was stopped.");
+  workerPermission.cancelForSession(roles.worker, "The Until complete run was stopped.");
+  roles.worker.taskStopRequested = true;
+  if (roles.worker.abortController) roles.worker.abortController.abort();
+  return true;
+}
+
+module.exports = { stopAutonomousWork: stopAutonomousWork };