clay-server 5.1.1-beta.1 → 5.2.0-beta.10

package/lib/project-scheduled-messages.js

@@ -15,31 +15,37 @@ function attachProjectScheduledMessages(ctx) {
   var now = ctx.now || Date.now;
   var unregister = null;
   var stopped = false;
-  function findSession(cliSessionId) {
+  function sessionIdentity(session) {
+    if (!session) return null;
+    if (ctx.isMate) return session.sessionOriginId || session._sessionRecordId || session.cliSessionId || null;
+    return session.cliSessionId || null;
+  }
+  function findSession(targetId) {
     var found = null;
     sm.sessions.forEach(function (session) {
-      if (!found && session.cliSessionId === cliSessionId) found = session;
+      if (!found && (sessionIdentity(session) === targetId || (ctx.isMate &&
+          (session.cliSessionId === targetId || session._sessionRecordId === targetId)))) found = session;
     });
     return found;
   }
   function latestJob(session) {
-    if (!scheduler || !session || !session.cliSessionId) return null;
+    if (!scheduler || !session || !sessionIdentity(session)) return null;
     var jobs = scheduler.listJobs();
     for (var i = jobs.length - 1; i >= 0; i--) {
-      if (jobs[i].type === type && jobs[i].projectId === slug && jobs[i].target && jobs[i].target.id === session.cliSessionId) return jobs[i];
+      if (jobs[i].type === type && jobs[i].projectId === slug && jobs[i].target && findSession(jobs[i].target.id) === session) return jobs[i];
     }
     return null;
   }
   function pendingJob(session) {
-    if (!scheduler || !session || !session.cliSessionId) return null;
+    if (!scheduler || !session || !sessionIdentity(session)) return null;
     if (session.scheduledMessage && session.scheduledMessage.jobId) {
       var direct = scheduler.getJob(session.scheduledMessage.jobId);
-      if (direct && direct.state === "queued") return direct;
+      if (direct && direct.state === "queued" && !direct.payload.mateScheduleId) return direct;
     }
     var jobs = scheduler.listJobs();
     for (var i = jobs.length - 1; i >= 0; i--) {
-      if (jobs[i].type === type && jobs[i].projectId === slug && jobs[i].state === "queued" &&
-          jobs[i].target && jobs[i].target.id === session.cliSessionId) return jobs[i];
+      if (jobs[i].type === type && jobs[i].projectId === slug && jobs[i].state === "queued" && !jobs[i].payload.mateScheduleId &&
+          jobs[i].target && findSession(jobs[i].target.id) === session) return jobs[i];
     }
     return null;
   }
@@ -53,30 +59,10 @@ function attachProjectScheduledMessages(ctx) {
       scheduledAt: job.payload.scheduledAt,
     };
   }
-  function queueActor(actorId) {
-    return users.isMultiUser() ? users.findUserById(actorId) : { id: "default" };
-  }
-  function queueItemForJob(session, job, actorId) {
-    if (!pendingMessageQueue || !session || !job) return null;
-    var actor = queueActor(actorId || (job.payload && job.payload.actorId));
-    var items = pendingMessageQueue.list(session, actor);
-    for (var i = 0; i < items.length; i++) {
-      if (items[i].schedule && items[i].schedule.jobId === job.id && items[i].schedule.revision === job.payload.revision) return items[i];
-    }
-    return null;
-  }
-  function validateQueueControl(session, job, actorId, correlation, requireQueueRevision) {
-    if (!pendingMessageQueue) return null;
-    if (requireQueueRevision && (!correlation || correlation.queueRevision == null || Number(correlation.queueRevision) !== pendingMessageQueue.getRevision())) {
-      throw new Error("The scheduled-message queue is stale.");
-    }
-    var actor = queueActor(actorId || (job.payload && job.payload.actorId));
-    var item = queueItemForJob(session, job, actorId);
-    if (!item || item.actorId !== actor.id || ["cancelled", "consumed", "failed"].indexOf(item.state) >= 0) {
-      throw new Error("The scheduled queue item is no longer available.");
-    }
-    return item;
-  }
+  var queue = require('./project-scheduled-message-queue').attachScheduledMessageQueue({ users: users, pendingMessageQueue: pendingMessageQueue });
+  var queueActor = queue.actor;
+  var queueItemForJob = queue.item;
+  var validateQueueControl = queue.validate;
   function sendState(session, targetWs, sendFn) {
     var job = pendingJob(session);
     session.scheduledMessage = projection(job, queueItemForJob(session, job, job && job.payload && job.payload.actorId));
@@ -106,11 +92,13 @@ function attachProjectScheduledMessages(ctx) {
   function authorize(session, actorId) {
     if (!session || session.destroying) throw new Error("The session is no longer available.");
     if (sm.sessions.get(session.localId) !== session) throw new Error("The session is no longer live.");
-    if (!session.cliSessionId) throw new Error("This session has no persistent provider identity yet.");
+    if (!sessionIdentity(session)) throw new Error(ctx.isMate ? "This Mate has no persistent server identity yet." : "This session has no persistent provider identity yet.");
     if (session.mode === "tui" || session.runtimeMode === "tui" || sessionProvenance.isWorker(session) ||
         (ctx.isDriverOperatedSession && ctx.isDriverOperatedSession(session))) {
       throw new Error("Scheduled messages are available only for ordinary project chat sessions.");
     }
+    if (ctx.isMate && (session._mcpForeignInput || session.sessionVisibility === "shared" || session.mateCreationMode ||
+        (session.history || []).some(function (entry) { return entry.type === "user_message" && entry.from && entry.from !== (session.ownerId || "default"); }))) throw new Error("Foreign input cannot authorize private Mate schedules.");
     if (!users.isMultiUser()) return LOCAL_OWNER;
     if (!actorId || !users.findUserById(actorId)) throw new Error("The scheduling user no longer exists.");
     var access = ctx.getProjectAccess();
@@ -123,26 +111,33 @@ function attachProjectScheduledMessages(ctx) {
     }
     return ownerId;
   }
-  function buildSpec(session, text, resetsAt, actorId, revision) {
+  function buildSpec(session, text, resetsAt, actorId, revision, options) {
+    options = options || {};
     var timestamp = now();
-    var runAt = resetsAt <= timestamp ? timestamp + 5000 : resetsAt + 60000;
+    var runAt = options.exact === true ? resetsAt : (resetsAt <= timestamp ? timestamp + 5000 : resetsAt + 60000);
     var ownerId = authorize(session, actorId);
     return {
       type: type,
-      idempotencyKey: "project-message:" + slug + ":" + session.cliSessionId + ":" + revision,
+      idempotencyKey: "project-message:" + slug + ":" + sessionIdentity(session) + ":" + revision,
       ownerId: ownerId,
       projectId: slug,
-      target: { kind: "project-session", id: session.cliSessionId },
+      target: { kind: "project-session", id: sessionIdentity(session) },
       payload: {
         text: text,
         hasAttachments: false,
         queueAdmissionRequired: true,
-        cliSessionId: session.cliSessionId,
+        cliSessionId: session.cliSessionId || null,
+        sessionIdentity: sessionIdentity(session),
         actorId: actorId || LOCAL_OWNER,
         sessionOwnerId: ownerId,
         revision: revision,
         requestedResetsAt: resetsAt,
         scheduledAt: timestamp,
+        scheduleRule: options.scheduleRule || null,
+        mateScheduleId: options.mateScheduleId || null,
+        logicalScheduleId: options.logicalScheduleId || options.mateScheduleId || null,
+        logicalRevision: options.logicalRevision || null,
+        occurrence: Number(options.occurrence || 0),
       },
       runAt: runAt,
     };
@@ -151,12 +146,12 @@ function attachProjectScheduledMessages(ctx) {
     if (!scheduler || !session || !requestId) return [];
     var jobs = scheduler.listJobs();
     return jobs.filter(function (job) {
-      return job.type === type && job.projectId === slug && job.target && job.target.id === session.cliSessionId &&
+      return job.type === type && job.projectId === slug && job.target && findSession(job.target.id) === session &&
         job.payload && job.payload.admissionRequestId === requestId && job.payload.actorId === actorId;
     });
   }
   function requestIdempotencyKey(session, actorId, requestId) {
-    var base = "project-message:" + slug + ":" + session.cliSessionId + ":actor:" + actorId + ":request:" + requestId;
+    var base = "project-message:" + slug + ":" + sessionIdentity(session) + ":actor:" + actorId + ":request:" + requestId;
     var jobs = requestJobs(session, actorId, requestId);
     var retryCount = 0;
     for (var i = 0; i < jobs.length; i++) if (jobs[i].state === "cancelled" && jobs[i].cancelledReason === "queue_admission_failed") retryCount++;
@@ -176,8 +171,7 @@ function attachProjectScheduledMessages(ctx) {
       scheduledMessage: job ? projection(job, queueItemForJob(session, job, actorId)) : null,
     });
   }
-
-  function schedule(session, text, resetsAt, actorUser, targetWs, attachments, requestId, transportAccountId) {
+  function schedule(session, text, resetsAt, actorUser, targetWs, attachments, requestId, transportAccountId, options) {
     var actorId = users.isMultiUser() ? (actorUser && actorUser.id) : LOCAL_OWNER;
     if (!scheduler || stopped) {
       sendAdmissionResult(targetWs, session, actorId, requestId, null, "Scheduled messages are temporarily unavailable.", transportAccountId);
@@ -198,7 +192,7 @@ function attachProjectScheduledMessages(ctx) {
       sendAdmissionResult(targetWs, session, actorId, requestId, null, "Invalid schedule request identifier.", transportAccountId);
       return null;
     }
-    if (typeof text !== "string" || (!text.trim() && !images.length && !pastes.length) || !isFinite(Number(resetsAt))) {
+    if (typeof text !== "string" || (!text.trim() && !images.length && !pastes.length) || !isFinite(Number(resetsAt)) || (options && options.exact === true && Number(resetsAt) <= now())) {
       sendAdmissionResult(targetWs, session, actorId, requestId, null, "A valid scheduled message and reset time are required.", transportAccountId);
       visibleError(session, targetWs, "A valid scheduled message and reset time are required.");
       return null;
@@ -219,7 +213,7 @@ function attachProjectScheduledMessages(ctx) {
         return prior;
       }
       var revision = makeRevision();
-      var spec = buildSpec(session, text, Number(resetsAt), actorId, revision);
+      var spec = buildSpec(session, text, Number(resetsAt), actorId, revision, options);
       if (requestId) {
         spec.idempotencyKey = requestIdempotencyKey(session, actorId, requestId);
         spec.payload.admissionRequestId = requestId;
@@ -227,6 +221,7 @@ function attachProjectScheduledMessages(ctx) {
       }
       spec.payload.hasAttachments = images.length > 0 || pastes.length > 0;
       var current = pendingJob(session);
+      if (options && options.mateScheduleId) current = null;
       if (current && requestId && (!current.payload || current.payload.admissionRequestId !== requestId)) {
         throw new Error("Another scheduled message is already pending.");
       }
@@ -239,7 +234,7 @@ function attachProjectScheduledMessages(ctx) {
           images: images,
           pastes: pastes,
           clientMessageId: requestId ? "scheduled-request-" + requestId : "scheduled-" + job.id,
-          schedule: { jobId: job.id, revision: job.payload.revision, notBefore: job.runAt, ready: false },
+          schedule: { jobId: job.id, revision: job.payload.revision, notBefore: job.runAt, ready: false, logicalScheduleId: job.payload.logicalScheduleId || null, logicalRevision: job.payload.logicalRevision || null },
         }, queueActor(actorId));
         if (!queuedScheduled.ok) {
           if (current) {
@@ -262,18 +257,18 @@ function attachProjectScheduledMessages(ctx) {
       return null;
     }
   }
-
   function requireCorrelation(job, correlation, targetWs) {
     if (!targetWs) return;
     if (!correlation || correlation.jobId !== job.id || correlation.revision !== job.payload.revision || correlation.queueRevision == null || !pendingMessageQueue || Number(correlation.queueRevision) !== pendingMessageQueue.getRevision()) {
       throw new Error("The scheduled-message control is stale.");
     }
   }
-
   function cancel(session, actorUser, targetWs, reason, correlation) {
     try {
       authorize(session, users.isMultiUser() ? (actorUser && actorUser.id) : LOCAL_OWNER);
-      var job = pendingJob(session) || latestJob(session);
+      var job = correlation && correlation.jobId ? scheduler.getJob(correlation.jobId) : (pendingJob(session) || latestJob(session));
+      if (job && (job.projectId !== slug || job.type !== type || !job.target || findSession(job.target.id) !== session || job.ownerId !== ownerFor(session) ||
+          (correlation && correlation.revision !== job.payload.revision))) throw new Error("The scheduled-message control is stale.");
       if (!job) return false;
       requireCorrelation(job, correlation, targetWs);
       if (pendingMessageQueue) validateQueueControl(session, job, actorUser && actorUser.id, correlation, !!targetWs);
@@ -291,7 +286,6 @@ function attachProjectScheduledMessages(ctx) {
       return false;
     }
   }
-
   function sendNow(session, actorUser, targetWs, correlation) {
     try {
       authorize(session, users.isMultiUser() ? (actorUser && actorUser.id) : LOCAL_OWNER);
@@ -310,7 +304,7 @@ function attachProjectScheduledMessages(ctx) {
           images: existing ? existing.message.images : undefined,
           pastes: existing ? existing.message.pastes : undefined,
           clientMessageId: existing ? existing.clientMessageId : "scheduled-" + updated.id,
-          schedule: { jobId: updated.id, revision: updated.payload.revision, notBefore: updated.runAt, ready: false },
+          schedule: { jobId: updated.id, revision: updated.payload.revision, notBefore: updated.runAt, ready: false, logicalScheduleId: updated.payload.logicalScheduleId || null, logicalRevision: updated.payload.logicalRevision || null },
         }, queueActor(actorUser && actorUser.id));
         if (!queued.ok) {
           try { scheduler.replaceQueued(job.id, job); }
@@ -326,14 +320,16 @@ function attachProjectScheduledMessages(ctx) {
       return false;
     }
   }
-
   function canRun(job) {
     var session = findSession(job.target && job.target.id);
     if (!session) return true;
     return !session.isProcessing && !session._queryStarting;
   }
-
   function failJob(session, job, error, processingOwner) {
+    if (session && job.payload.mateScheduleId && ctx.mateLifecycle) {
+      try { ctx.mateLifecycle().failed(session, job, error); }
+      catch (saveError) { console.error("[mate-schedules] Failed to persist dispatch failure:", saveError.message); }
+    }
     var ownsProcessing = session && processingOwner && session._scheduledMessageProcessing === processingOwner &&
       session._queryGeneration === processingOwner.queryGeneration &&
       session.queryInstance === processingOwner.queryInstance && !session._queryStarting;
@@ -358,6 +354,7 @@ function attachProjectScheduledMessages(ctx) {
     try {
       if (!session) throw new Error("The scheduled session was deleted.");
       var ownerId = authorize(session, job.payload.actorId);
+      if (job.payload.mateScheduleId && ctx.mateLifecycle && !ctx.mateLifecycle().current(session, job)) throw new Error("The Mate schedule is no longer active.");
       if (ownerId !== job.ownerId || ownerId !== job.payload.sessionOwnerId) throw new Error("The session owner changed.");
       if (ctx.osUsers) {
         var owner = users.findUserById(job.ownerId);
@@ -378,7 +375,7 @@ function attachProjectScheduledMessages(ctx) {
       if (!ensured && job.payload.queueAdmissionRequired === true) throw new Error("Scheduled queue item is missing; refusing to recreate message payload.");
       if (!ensured) ensured = pendingMessageQueue.upsertScheduled(session, {
         type: "message", text: job.payload.text, clientMessageId: "scheduled-" + job.id,
-        schedule: { jobId: job.id, revision: job.payload.revision, notBefore: job.runAt, ready: false },
+        schedule: { jobId: job.id, revision: job.payload.revision, notBefore: job.runAt, ready: false, logicalScheduleId: job.payload.logicalScheduleId || null, logicalRevision: job.payload.logicalRevision || null },
       }, queueActor(job.payload.actorId));
       if (!ensured || ensured.ok === false) throw new Error(ensured.error || "Scheduled queue handoff could not be prepared.");
       var released = pendingMessageQueue.releaseScheduled(session, job.id, job.payload.revision);
@@ -390,7 +387,6 @@ function attachProjectScheduledMessages(ctx) {
       throw error;
     }
   }
-
   function onQueueConsumed(item) {
     if (!item || !item.schedule || !scheduler) return false;
     var job = scheduler.getJob(item.schedule.jobId);
@@ -401,10 +397,10 @@ function attachProjectScheduledMessages(ctx) {
       session.rateLimitAutoContinuePending = false;
     }
     sm.sendAndRecord(session, { type: "scheduled_message_sent", jobId: job.id, revision: item.schedule.revision });
+    if (job.payload && job.payload.mateScheduleId && ctx.mateLifecycle) ctx.mateLifecycle().consumed(session, job);
     sm.broadcastSessionList();
     return true;
   }
-
   function onQueueCancelled(item) {
     if (!item || !item.schedule || !scheduler) return false;
     var job = scheduler.getJob(item.schedule.jobId);
@@ -412,6 +408,7 @@ function attachProjectScheduledMessages(ctx) {
       try { scheduler.cancel(job.id, "cancelled_by_user"); } catch (error) {}
     }
     var session = job && job.target ? findSession(job.target.id) : null;
+    if (session && job.payload.mateScheduleId && ctx.mateLifecycle) ctx.mateLifecycle().cancelled(session, job);
     if (session && session.scheduledMessage && session.scheduledMessage.jobId === item.schedule.jobId) {
       session.scheduledMessage = null;
       session.rateLimitAutoContinuePending = false;
@@ -419,17 +416,16 @@ function attachProjectScheduledMessages(ctx) {
     }
     return true;
   }
-
   function authorizePending(item, session) {
     if (!item || !item.schedule || !scheduler || !session) return true;
     var job = scheduler.getJob(item.schedule.jobId);
     var expectedActorId = users.isMultiUser() ? job && job.payload && job.payload.actorId : "default";
-    if (!job || ["running", "completed", "interrupted"].indexOf(job.state) < 0 || !job.target || job.target.id !== session.cliSessionId ||
+    if (!job || ["running", "completed", "interrupted"].indexOf(job.state) < 0 || !job.target || findSession(job.target.id) !== session ||
         !job.payload || job.projectId !== slug || job.payload.revision !== item.schedule.revision || item.actorId !== expectedActorId ||
         job.ownerId !== job.payload.sessionOwnerId) return false;
+    if (job.payload.mateScheduleId && ctx.mateLifecycle && !ctx.mateLifecycle().current(session, job)) return false;
     try { return authorize(session, job.payload.actorId) === job.ownerId; } catch (error) { return false; }
   }
-
   function rehydrate() {
     sm.sessions.forEach(function (session) {
       var pending = pendingJob(session);
@@ -437,12 +433,12 @@ function attachProjectScheduledMessages(ctx) {
       if (!pendingMessageQueue) return;
       var jobs = scheduler.listJobs();
       for (var i = 0; i < jobs.length; i++) {
-        if (jobs[i].type !== type || jobs[i].projectId !== slug || !jobs[i].target || jobs[i].target.id !== session.cliSessionId) continue;
+        if (jobs[i].type !== type || jobs[i].projectId !== slug || !jobs[i].target || findSession(jobs[i].target.id) !== session) continue;
         var actor = users.isMultiUser() ? users.findUserById(jobs[i].payload.actorId) : { id: "default" };
         if (jobs[i].state === "queued" && !queueItemForJob(session, jobs[i], jobs[i].payload.actorId)) {
-          if (jobs[i].payload.queueAdmissionRequired !== true) pendingMessageQueue.upsertScheduled(session, {
+          if (jobs[i].payload.queueAdmissionRequired !== true || (jobs[i].payload.mateScheduleId && ctx.mateLifecycle && ctx.mateLifecycle().current(session, jobs[i]))) pendingMessageQueue.upsertScheduled(session, {
             type: "message", text: jobs[i].payload.text, clientMessageId: "scheduled-" + jobs[i].id,
-            schedule: { jobId: jobs[i].id, revision: jobs[i].payload.revision, notBefore: jobs[i].runAt, ready: false },
+            schedule: { jobId: jobs[i].id, revision: jobs[i].payload.revision, notBefore: jobs[i].runAt, ready: false, logicalScheduleId: jobs[i].payload.logicalScheduleId || null, logicalRevision: jobs[i].payload.logicalRevision || null },
           }, actor);
         }
         else if (["interrupted", "completed"].indexOf(jobs[i].state) >= 0) {
@@ -455,19 +451,19 @@ function attachProjectScheduledMessages(ctx) {
       }
     });
   }
-
   function deleted(localId, session) {
-    var job = pendingJob(session);
-    if (!job) return;
-    try { scheduler.cancel(job.id, "session_deleted"); } catch (error) {}
+    if (!session) return;
+    scheduler.listJobs().forEach(function (job) {
+      if (job.type === type && job.state === "queued" && job.target && [sessionIdentity(session), session.cliSessionId, session._sessionRecordId].indexOf(job.target.id) >= 0) {
+        try { scheduler.cancel(job.id, "session_deleted"); } catch (error) {}
+      }
+    });
     session.scheduledMessage = null;
   }
-
   function notify() {
     if (!scheduler || stopped) return;
     try { scheduler.tick(); } catch (error) {}
   }
-
   function shutdown() {
     stopped = true;
     if (unregister) unregister();
@@ -476,7 +472,7 @@ function attachProjectScheduledMessages(ctx) {
 
   if (scheduler) {
     unregister = scheduler.registerHandler(type, dispatch, { canRun: canRun });
-    rehydrate();
+    if (!ctx.deferRehydrate) rehydrate();
     sm.addOnSessionDeleted(deleted);
     sm.addOnSessionViewed(function (session, targetWs, sendFn) { sendState(session, targetWs, sendFn); });
   }
@@ -491,6 +487,9 @@ function attachProjectScheduledMessages(ctx) {
     shutdown: shutdown,
     handlerType: type,
     authorizePending: authorizePending,
+    authorize: authorize,
+    identity: sessionIdentity,
+    queueItem: queueItemForJob,
     onQueueConsumed: onQueueConsumed,
     onQueueCancelled: onQueueCancelled,
   };

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

@@ -0,0 +1,83 @@
+var crypto = require('crypto');
+var authority = require('./canonical-clay-scheduling-authority');
+var validation = require('./schedule-validation');
+function attachScheduledTaskControl(ctx) {
+  var drafts = new Map();
+  function current(session, token) {
+    var actor = authority.validate(token, ctx.slug, session);
+    if (!ctx.available(session)) throw new Error('Scheduled Tasks requires an eligible owned project Driver session.');
+    if (ctx.validateOwnerIdentity) ctx.validateOwnerIdentity(session);
+    return actor;
+  }
+  function read(session, op, token) {
+    var actor = current(session, token);
+    if (op.action === 'list') return { records: ctx.records.list(session).filter(function (item) { return !ctx.multiUser() || item.ownerId === actor.userId; }), timezone: ctx.timezone };
+    var result = ctx.records.read(session, op.id);
+    if (!result.ok) throw new Error(result.error);
+    if (ctx.multiUser() && result.record.ownerId !== actor.userId) throw new Error('This task belongs to another owner or requires workbench ownership setup.');
+    return result;
+  }
+  function snapshot(session, op, token) {
+    current(session, token);
+    return op.action === 'propose' ? { draft: session.scheduledTaskDraft || null, interviewId: ctx.interviewId(session) } : read(session, { id: op.id }, token).record;
+  }
+  function prepare(session, op, token, requestId) {
+    current(session, token);
+    if (ctx.interviewId(session) || session.scheduledTaskDraft) throw new Error('Finish or cancel this Driver schedule draft before proposing another.');
+    var checked = validation.validateScheduledTaskInput(op.data);
+    if (!checked.ok || !checked.value.execution) throw new Error(checked.error || 'Choose Driver and Split Worker runtimes.');
+    ctx.preflight(checked.value.execution.driver, null, true); ctx.preflight(checked.value.execution.worker, null, true);
+    current(session, token);
+    var begun = ctx.beginManual(session, requestId);
+    if (!begun.ok) throw new Error(begun.error);
+    var prior = session.scheduledTaskDraft;
+    var draft = Object.assign({}, prior, checked.value, { canonicalScheduling: true, version: Number(prior.version || 0) + 1 });
+    session.scheduledTaskDraft = draft;
+    if (ctx.sm.saveSessionFile(session) !== true) { session.scheduledTaskDraft = prior; throw new Error('The canonical schedule proposal could not be saved.'); }
+    if (drafts.size >= 100) drafts.delete(drafts.keys().next().value);
+    drafts.set(draft.id, { session: session, token: token });
+    ctx.publish(session, { open: true });
+    return { status: 'proposed', persisted: true, proposalId: draft.id, version: draft.version, interviewId: draft.interviewId, sessionId: session.localId, guidance: 'The task has not been created. Open this selected Driver Scheduled Tasks workbench and use its final Create task control. No execution has started.' };
+  }
+  function actorForDraft(session, draft) {
+    if (!draft.canonicalScheduling) return null;
+    var grant = drafts.get(draft.id);
+    if (!grant || grant.session !== session) throw new Error('This canonical schedule proposal needs a fresh live Clay query after reload.');
+    return current(session, grant.token);
+  }
+  function apply(session, op, token, requestId) {
+    var actor = current(session, token);
+    if (op.action === 'propose') return prepare(session, op, token, requestId);
+    var selected = read(session, op, token).record;
+    if (selected.revision !== op.revision) throw new Error('Scheduled task revision changed.');
+    if (!selected.ownerId && ctx.multiUser()) throw new Error('Claim legacy task ownership through the existing workbench first.');
+    var record = ctx.registry.getById(op.id), result;
+    current(session, token);
+    if (op.action === 'update') {
+      result = ctx.records.update(session, op.id, op.revision, op.data, actor);
+      if (!result.ok) throw new Error(result.error);
+      ctx.publishRecord(session, result.record);
+      return { status: 'completed', persisted: true, record: result.record };
+    }
+    if (op.action === 'run') {
+      result = ctx.execution.trigger(record, 'canonical-clay');
+      if (!result.ok) return { status: 'failed', persisted: 'unknown', error: result.error, result: result };
+      return { status: 'queued', persisted: true, result: result, guidance: 'The existing scheduled-task executor dispatched its Driver. Task completion requires its normal Worker and outcome reporting.' };
+    }
+    if (op.action === 'cancel') {
+      var running = !!record.activeRun;
+      if (running && !ctx.execution.stopRecord(record, 'The owner cancelled this scheduled task through Clay.')) throw new Error('The active scheduled run could not be stopped; task retained.');
+      current(session, token);
+      if (!ctx.registry.remove(record.id)) throw new Error('The scheduled task could not be cancelled.');
+      return { status: 'completed', persisted: true, removed: true, runStopRequested: running };
+    }
+    var enabled = op.action === 'resume';
+    result = ctx.registry.update(record.id, { enabled: enabled, updatedBy: actor });
+    if (!result) throw new Error('The scheduled task state could not be saved.');
+    ctx.publishRecord(session, ctx.records.read(session, op.id).record);
+    return { status: 'completed', persisted: true, enabled: enabled };
+  }
+  return { authorize: current, read: read, snapshot: snapshot, apply: apply, actorForDraft: actorForDraft,
+    creationId: function (draft) { return 'loop_clay_' + crypto.createHash('sha256').update(draft.id).digest('hex').slice(0, 32); } };
+}
+module.exports = { attachScheduledTaskControl: attachScheduledTaskControl };

package/lib/project-scheduled-tasks.js

@@ -313,13 +313,19 @@ function attachScheduledTasks(ctx) {
         ctx.preflightRuntime(checked.value.execution.worker, null, true);
       } catch (runtimeError) { return { ok: false, error: runtimeError.message || String(runtimeError) }; }
     }
-    var recordId = "loop_" + Date.now() + "_" + crypto.randomBytes(3).toString("hex");
+    var canonicalActor;
+    try { canonicalActor = productControl.actorForDraft(session, draft); } catch (error) { return { ok: false, error: error.message }; }
+    var recordId = draft.canonicalScheduling ? productControl.creationId(draft) : "loop_" + Date.now() + "_" + crypto.randomBytes(3).toString("hex");
+    var creationKey = crypto.createHash('sha256').update(JSON.stringify(checked.value)).digest('hex');
+    var existing = draft.canonicalScheduling && registry.getById(recordId);
+    if (existing) return existing.creationFingerprint === creationKey ? { ok: true, duplicate: true, recordId: existing.id } : { ok: false, error: 'This schedule proposal already created a different reviewed task.' };
     var saved;
     try {
       var actor = owner(ws);
       if (session.ownerId && actor.id !== session.ownerId) return { ok: false, error: "The schedule owner does not match this Driver session." };
       createTaskFiles(recordId, checked.value);
       saved = registry.register(Object.assign({}, checked.value, {
+        createdBy: canonicalActor, updatedBy: canonicalActor, creationFingerprint: creationKey,
         id: recordId, task: checked.value.instructions, prompt: checked.value.instructions, enabled: true,
         mode: "simple", source: checked.value.cron ? null : "schedule", ownerId: actor.id, ownerName: actor.name, sessionId: session.localId, createdViaScheduledTasks: true,
       }));
@@ -475,7 +481,12 @@ function attachScheduledTasks(ctx) {
     return allowed(ws, session) && available(session);
   }
 
-  return { getToolDefs: getToolDefs, getSystemPrompt: getSystemPrompt, handleMessage: handleMessage, activeInterviewId: activeInterviewId, canStartInterview: canStartInterview, canCreateInterview: canCreateInterview };
+  var productControl = require('./project-scheduled-task-control').attachScheduledTaskControl({
+    slug: ctx.projectSlug, sm: sm, available: available, records: records, registry: registry, execution: ctx.scheduledExecution,
+    validateOwnerIdentity: ctx.validateOwnerIdentity, multiUser: function () { return !!(ctx.usersModule && ctx.usersModule.isMultiUser()); }, preflight: ctx.preflightRuntime, timezone: schedulerTimeZone,
+    beginManual: beginManual, interviewId: activeInterviewId, publish: publish, publishRecord: publishRecord,
+  });
+  return { productControl: productControl, getToolDefs: getToolDefs, getSystemPrompt: getSystemPrompt, handleMessage: handleMessage, activeInterviewId: activeInterviewId, canStartInterview: canStartInterview, canCreateInterview: canCreateInterview };
 }
 
 module.exports = { attachScheduledTasks: attachScheduledTasks, activeInterviewId: activeInterviewId, interviewPrompt: interviewPrompt, authorizeStoredOwner: authorizeStoredOwner };

package/lib/project-scheduling-access.js

@@ -0,0 +1,10 @@
+function attachSchedulingAccess(ctx) {
+  function ownerIdentity(session) {
+    if (!ctx.osUsers) return null;
+    var username = ctx.getLinuxUser(session), identity = username && ctx.resolveLinuxUser(username);
+    if (!identity) throw new Error('The schedule owner no longer has a valid mapped OS identity.');
+    return identity;
+  }
+  return { ownerIdentity: ownerIdentity };
+}
+module.exports = { attachSchedulingAccess: attachSchedulingAccess };

package/lib/project-server-settings.js

@@ -13,6 +13,7 @@ function handleServerSettings(ctx, ws, msg) {
     var id = ws._clayUser && ws._clayUser.id;
     var user = id && ctx.usersModule.findUserById(id);
     if (!user || user.role !== 'admin') { reply({ ok: false, error: 'Administrator access required.' }); return true; }
+    if (msg.type === 'set_pin') { reply({ ok: false, error: 'Server PIN is unavailable while account authentication is enabled. Manage account credentials in Personal settings or Users.' }); return true; }
   }
   var value = msg[entry.field];
   if (entry.valid ? !entry.valid(value) : typeof value !== 'boolean') { reply({ ok: false, error: 'Invalid setting value.' }); return true; }

package/lib/project-session-actions.js

@@ -0,0 +1,65 @@
+var yoke = require("./yoke");
+var permissionModes = require("./session-permission-mode");
+
+// Shared session effects. Callers authorize the exact live session before entry.
+function attachSessionActions(ctx) {
+  var sm = ctx.sm;
+  function exact(session) {
+    if (!session || sm.sessions.get(session.localId) !== session) throw new Error("Session was deleted or replaced.");
+  }
+  function rename(session, title) {
+    exact(session);
+    var previous = { title: session.title, titleProvisional: session.titleProvisional, titleAutoGenerated: session.titleAutoGenerated, titleManuallySet: session.titleManuallySet };
+    session.title = title;
+    session.titleProvisional = false;
+    session.titleAutoGenerated = false;
+    session.titleManuallySet = true;
+    try { if (sm.saveSessionFile(session) === false) throw new Error("Could not save session title."); }
+    catch (error) { Object.assign(session, previous); throw error; }
+    sm.notifySessionRenamed(session.localId);
+    sm.broadcastSessionList();
+    var adapter = ctx.adapters && ctx.adapters[session.vendor] || ctx.adapter;
+    if (session.cliSessionId && adapter && adapter.renameSession) {
+      Promise.resolve(adapter.renameSession(session.cliSessionId, title, { dir: ctx.cwd, linuxUser: ctx.getLinuxUserForSession && ctx.getLinuxUserForSession(session) || undefined })).catch(function (error) {
+        console.error("[session-actions] Provider title sync failed:", error.message);
+      });
+    }
+    return { title: title };
+  }
+  function stop(session, actor) {
+    exact(session);
+    if (ctx.autonomousRun && session.autonomousRun) ctx.autonomousRun.finish(session, "stopped", "Stopped by the user.");
+    if (typeof ctx.sdk.cancelResponseRecovery === "function") ctx.sdk.cancelResponseRecovery(session);
+    session._pendingMessageDrainPaused = true;
+    if (ctx.onPendingQueuePause) ctx.onPendingQueuePause(session, actor || null);
+    if (!session.isProcessing && !session._queryStarting && !session._responseRecoveryStopPending) return { status: "completed", queuePaused: true };
+    if (ctx.onHumanPairStop) ctx.onHumanPairStop(session);
+    session.taskStopRequested = true;
+    if (session.abortController) session.abortController.abort();
+    return { status: "queued", queuePaused: true, detail: "Stop requested; runtime completion is still pending." };
+  }
+  async function effort(session, value, revalidate) {
+    exact(session);
+    var vendor = session.vendor || sm.defaultVendor || "claude";
+    if (yoke.clampEffort(vendor, value) !== value) throw new Error("This effort level is not supported by the selected vendor.");
+    var result = await ctx.sdk.setEffort(session, value, revalidate ? { revalidate: revalidate } : undefined);
+    if (revalidate) return result;
+    sm.sendToSession(session, { type: "config_state", sessionId: session.localId, vendor: vendor, effort: value, model: session.model || ((sm.defaultModelByVendor || {})[vendor]) || "", mode: session.permissionMode || sm.currentPermissionMode || "default", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+    return { effort: value };
+  }
+  async function permission(session, value, requestId, revalidate) {
+    exact(session);
+    if ((session.runtimeMode || session.mode || "gui") !== "gui" || ctx.isDriverOperatedSession && ctx.isDriverOperatedSession(session)) throw new Error("Permissions require a GUI Driver session.");
+    if (ctx.dangerouslySkipPermissions) throw new Error("Skip permissions is forced by the server setting.");
+    var valid = permissionModes.validate(session, value, sm.defaultVendor);
+    if (!valid.ok) throw new Error(valid.error);
+    if (session.permissionMode === "bypassPermissions" && valid.mode !== "bypassPermissions" && ctx.autonomousRun) await ctx.autonomousRun.stopForPermissionChange(session);
+    var result = await ctx.fullAccessService.setMode(session, valid.mode, revalidate ? { revalidate: revalidate } : undefined);
+    if (revalidate) return result;
+    var state = permissionModes.clientState(session, sm.currentPermissionMode, sm.defaultVendor);
+    sm.sendToSession(session, Object.assign({ type: "config_state", sessionId: session.localId, vendor: session.vendor || sm.defaultVendor || "claude", mode: state.requestedPermissionMode, permissionRequestId: requestId || null, effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] }, state));
+    return state;
+  }
+  return { rename: rename, stop: stop, effort: effort, permission: permission };
+}
+module.exports = { attachSessionActions: attachSessionActions };

package/lib/project-session-delete.js

@@ -97,6 +97,13 @@ function attachSessionDelete(ctx) {
     sm.deleteSessionsBulk(plan.ids, ws);
   }
 
+  function executeOwnedDeletion(plan) {
+    if (!plan || !plan.ok || !plan.ids.length) throw new Error("No exact deletion plan.");
+    releaseRuntime(plan.ids);
+    plan.ids.forEach(function (id) { sm.deleteSessionQuiet(id); });
+    sm.broadcastSessionList();
+  }
+
   function bulkDeleteSessions(ws, msg) {
     if (!Array.isArray(msg.sessionIds) || msg.sessionIds.length === 0) return;
     if (!hasDeletePermission(ws)) return refuse(ws, "You do not have permission to delete sessions");
@@ -113,7 +120,7 @@ function attachSessionDelete(ctx) {
     executeDeletion(ws, scope);
   }
 
-  return { deleteSession: deleteSession, bulkDeleteSessions: bulkDeleteSessions, planDeletion: planDeletion, executeDeletion: executeDeletion, hasDeletePermission: hasDeletePermission };
+  return { deleteSession: deleteSession, bulkDeleteSessions: bulkDeleteSessions, planDeletion: planDeletion, executeDeletion: executeDeletion, executeOwnedDeletion: executeOwnedDeletion, hasDeletePermission: hasDeletePermission };
 }
 
 module.exports = { attachSessionDelete: attachSessionDelete, resolveDeletionScope: resolveDeletionScope };