clay-server 4.1.0-beta.5 → 4.1.0-beta.7

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-message-delivery.js

@@ -29,7 +29,7 @@ function ensureRecordedMessages(session) {
   return recorded;
 }
 
-function createProjectMessageDelivery(sendTo) {
+function createProjectMessageDelivery(sendTo, projectSlug) {
   function inspect(ws, session, msg) {
     var clientMessageId = normalizeClientMessageId(msg && msg.clientMessageId);
     if (!clientMessageId) return { clientMessageId: null, ownerId: ownerKey(ws), duplicate: false };
@@ -48,11 +48,13 @@ function createProjectMessageDelivery(sendTo) {
     ensureRecordedMessages(session).set(deliveryKey(receipt.ownerId, receipt.clientMessageId), message);
   }
 
-  function acknowledge(ws, receipt, message) {
+  function acknowledge(ws, receipt, message, session) {
     if (!receipt || !receipt.clientMessageId) return;
     sendTo(ws, {
       type: "message_ack",
       clientMessageId: receipt.clientMessageId,
+      projectSlug: projectSlug || null,
+      sessionId: session ? session.localId : null,
       message: message || receipt.recordedMessage || null,
     });
   }

package/lib/project-models.js

@@ -1,4 +1,5 @@
 var yoke = require("./yoke");
+var defaultAiRuntime = require("./default-ai-runtime");
 
 function modelEntryValue(entry) {
   if (!entry) return "";
@@ -12,6 +13,17 @@ function modelEntryMatches(entry, value) {
   return entry.value === value || entry.id === value || entry.resolvedModel === value;
 }
 
+function modelsWithEffortMetadata(models, vendorInfo) {
+  var fallback = vendorInfo && Array.isArray(vendorInfo.effortLevels) ? vendorInfo.effortLevels : [];
+  return (models || []).map(function (model) {
+    if (typeof model === "string") {
+      return { value: model, displayName: model, supportedEffortLevels: fallback.slice() };
+    }
+    if (!model || Array.isArray(model.supportedEffortLevels)) return model;
+    return Object.assign({}, model, { supportedEffortLevels: fallback.slice() });
+  });
+}
+
 function normalizeCatalogModels(models) {
   var normalized = [];
   models = models || [];
@@ -64,8 +76,12 @@ function attachModels(ctx) {
   var serverPort = ctx.serverPort;
   var serverTls = ctx.serverTls;
   var serverAuthToken = ctx.serverAuthToken;
+  var resolveDefaultAi = ctx.resolveDefaultAi;
 
-  function getVendorAvailability() {
+  function getVendorAvailability(ws) {
+    if (sm.installedVendors === undefined && sdk && typeof sdk.refreshInstalledVendors === "function") {
+      sdk.refreshInstalledVendors(getLinuxUserForWs(ws));
+    }
     var available = (sm.availableVendors || []).slice();
     var installed = (sm.installedVendors || []).slice();
     var ids = available.slice();
@@ -160,8 +176,8 @@ function attachModels(ctx) {
       console.error("[project-models] model loading failed for " + vendor + ":", e.message || e);
     }
 
-    var vendorModels = (sm.modelsByVendor && sm.modelsByVendor[vendor]) || [];
     var vendorInfo = yoke.getVendorInfo(vendor);
+    var vendorModels = modelsWithEffortMetadata((sm.modelsByVendor && sm.modelsByVendor[vendor]) || [], vendorInfo);
     var displayName = vendorInfo ? vendorInfo.displayName : vendor;
     var status = vendorModels.length > 0 ? "ready" : (loadError ? "error" : "empty");
     var defaultModel = "";
@@ -191,11 +207,62 @@ function attachModels(ctx) {
       installedVendors: sm.installedVendors || [],
       status: status,
       error: errorText,
+      effortLevels: vendorInfo && Array.isArray(vendorInfo.effortLevels) ? vendorInfo.effortLevels.slice() : [],
     };
   }
 
   async function resolveConfiguredModel(ws, alias) {
-    var availability = getVendorAvailability();
+    if (typeof resolveDefaultAi === "function") {
+      var defaultSelection = await resolveDefaultAi(ws);
+      var normalizedAlias = alias === "fast" || alias === "deep" ? alias : "standard";
+      if (!defaultSelection || !defaultSelection.ready) {
+        return {
+          status: "error",
+          vendor: defaultSelection && defaultSelection.vendor || "",
+          vendorName: defaultSelection && defaultSelection.vendor || "",
+          model: "",
+          modelName: "",
+          alias: normalizedAlias,
+          effort: "",
+          error: defaultSelection && defaultSelection.error || "Default AI is unavailable.",
+        };
+      }
+      var selectedModel = defaultSelection.model;
+      var selectedName = defaultSelection.model;
+      if (normalizedAlias !== "standard") {
+        var selectedCatalog = await getVendorCatalog(ws, defaultSelection.vendor);
+        var aliasEntry = selectCatalogModel(selectedCatalog.models || [], defaultSelection.model, normalizedAlias);
+        if (!aliasEntry || selectedCatalog.status !== "ready") {
+          return {
+            status: "error",
+            vendor: defaultSelection.vendor,
+            vendorName: defaultSelection.vendor,
+            model: "",
+            modelName: "",
+            alias: normalizedAlias,
+            effort: defaultSelection.effort || "",
+            error: selectedCatalog.error || "The selected Default AI provider has no available model.",
+          };
+        }
+        selectedModel = aliasEntry.value;
+        selectedName = aliasEntry.displayName || selectedModel;
+        var aliasEffort = defaultAiRuntime.resolveEffort({ effort: defaultSelection.effort || "" }, aliasEntry.source, selectedCatalog);
+        if (!aliasEffort.ok) aliasEffort = defaultAiRuntime.resolveEffort(null, aliasEntry.source, selectedCatalog);
+        defaultSelection = Object.assign({}, defaultSelection, { effort: aliasEffort.effort || "" });
+      }
+      var selectedInfo = yoke.getVendorInfo(defaultSelection.vendor);
+      return {
+        status: "ready",
+        vendor: defaultSelection.vendor,
+        vendorName: selectedInfo && selectedInfo.displayName ? selectedInfo.displayName : defaultSelection.vendor,
+        alias: normalizedAlias,
+        model: selectedModel,
+        modelName: selectedName,
+        effort: defaultSelection.effort || "",
+        error: "",
+      };
+    }
+    var availability = getVendorAvailability(ws);
     var candidates = [];
     var preferredVendor = sm.defaultVendor || "";
     if (preferredVendor) candidates.push(preferredVendor);
@@ -341,5 +408,6 @@ module.exports = {
   modelEntryMatches: modelEntryMatches,
   modelEntryValue: modelEntryValue,
   normalizeCatalogModels: normalizeCatalogModels,
+  modelsWithEffortMetadata: modelsWithEffortMetadata,
   selectCatalogModel: selectCatalogModel,
 };

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 };

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

@@ -0,0 +1,18 @@
+function stopOwnedPair(session, roles, turnControl, taskControl, workerPermission, reason) {
+  if (!roles) return false;
+  turnControl.markHumanStop(session);
+  taskControl.cancelAll(roles.worker);
+  taskControl.markInterruption(roles.worker, "user", reason || "The human stopped this scheduled run.");
+  workerPermission.cancelForSession(roles.worker, reason || "The human stopped this scheduled run.");
+  var members = [roles.driver, roles.worker];
+  for (var i = 0; i < members.length; i++) {
+    members[i].taskStopRequested = true;
+    if (members[i].queryInstance && typeof members[i].queryInstance.close === "function") {
+      try { members[i].queryInstance.close(); } catch (e) {}
+    }
+    if (members[i].abortController) { try { members[i].abortController.abort(); } catch (e) {} }
+  }
+  return true;
+}
+
+module.exports = { stopOwnedPair: stopOwnedPair };

package/lib/project-pair-task-control.js

@@ -67,6 +67,7 @@ function attachPairTaskControl(ctx) {
       workerSessionId: worker.localId,
       driverSessionId: caller.localId,
       message: message,
+      autonomousRunId: caller.autonomousRun && caller.autonomousRun.id || null,
       createdAt: Date.now(),
       status: "running",
     };
@@ -118,6 +119,18 @@ function attachPairTaskControl(ctx) {
       return result({ status: "cancelled", taskId: task.taskId });
     } catch (err) { return result({ status: "rejected", taskId: args.taskId || null, reason: err.message || String(err) }); }
   }
+  function cancelAll(worker, autonomousRunId) {
+    var queue = queueFor(worker);
+    var cancelled = 0;
+    for (var i = 0; i < queue.length; i++) {
+      if (queue[i].status !== "queued" && queue[i].status !== "waiting_for_interrupt") continue;
+      if (autonomousRunId && queue[i].autonomousRunId !== autonomousRunId) continue;
+      queue[i].status = "cancelled";
+      queue[i].completedAt = Date.now();
+      cancelled++;
+    }
+    return cancelled;
+  }
   function markInterruption(worker, by, reason, targetTaskId) {
     var active = current(worker);
     worker._pairInterruption = {
@@ -258,7 +271,7 @@ function attachPairTaskControl(ctx) {
   function workerToolDefs(worker) {
     return [{ name: "report_partner_outcome", description: "Report structured, Worker-observed task outcome data. This does not claim Driver verification.", inputSchema: buildShape({ taskId: { type: "string" }, outcome: { type: "string" }, summary: { type: "string" }, changedFiles: { type: "array", items: { type: "string" } }, verifications: { type: "array", items: { type: "object" } }, unverified: { type: "array", items: { type: "string" } }, processes: { type: "array", items: { type: "string" } }, nextAction: { type: "string" } }, ["taskId", "outcome"]), handler: function (args) { return report(args || {}, worker); } }];
   }
-  return { begin: begin, cancel: cancel, complete: complete, drain: drain, driverToolDefs: driverToolDefs, ensureSystemInterruption: ensureSystemInterruption, inspect: inspect, markInterruption: markInterruption, queue: queue, replaceTask: replaceTask, resumeTask: resumeTask, status: status, workerToolDefs: workerToolDefs };
+  return { begin: begin, cancel: cancel, cancelAll: cancelAll, complete: complete, drain: drain, driverToolDefs: driverToolDefs, ensureSystemInterruption: ensureSystemInterruption, inspect: inspect, markInterruption: markInterruption, queue: queue, replaceTask: replaceTask, resumeTask: resumeTask, status: status, workerToolDefs: workerToolDefs };
 }
 
 module.exports = { attachPairTaskControl: attachPairTaskControl };