clay-server 4.1.0-beta.9 → 4.1.0

package/lib/project-logs-service.js

@@ -253,6 +253,11 @@ function attachProjectLogsService(ctx) {
 
   function createProjectBound(initial, revalidate) {
     var store = storeForStatus(initial.status);
+    var scheduledResultViewerId = initial.principal.userId || null;
+
+    function withScheduledResultViewer(args) {
+      return Object.assign({}, args || {}, { scheduledResultOwnerId: scheduledResultViewerId });
+    }
 
     // Identity, authorization, and the target store are all re-derived per
     // call. revalidate() re-checks exact session identity where there is one;
@@ -288,7 +293,15 @@ function attachProjectLogsService(ctx) {
 
     function scopedEntry(args) {
       var scope = currentScope();
-      return visibleEntry(live(), args && args.ref, scope.status, scope.worktreeOnly);
+      var entry = visibleEntry(live(), args && args.ref, scope.status, scope.worktreeOnly);
+      if (entry.scheduledResult && (entry.scheduledResult.ownerId || null) !== scheduledResultViewerId) throw new Error("Log entry not found.");
+      return entry;
+    }
+
+    function mutableEntry(args) {
+      var entry = scopedEntry(args);
+      if (entry.scheduledResult) throw new Error("Scheduled results are server-owned records.");
+      return entry;
     }
 
     function mutationContext() {
@@ -312,7 +325,7 @@ function attachProjectLogsService(ctx) {
       listLogs: function (args) {
         var scope = currentScope();
         var status = scope.status;
-        var options = scopedArgs(args, status, scope.worktreeOnly);
+        var options = withScheduledResultViewer(scopedArgs(args, status, scope.worktreeOnly));
         var result = live().list(options);
         result.contextMode = options.contextMode;
         result.currentChangeSetId = status.changeSetId || null;
@@ -322,7 +335,7 @@ function attachProjectLogsService(ctx) {
       searchLogs: function (args) {
         var scope = currentScope();
         var status = scope.status;
-        var options = scopedArgs(args, status, scope.worktreeOnly);
+        var options = withScheduledResultViewer(scopedArgs(args, status, scope.worktreeOnly));
         var result = live().search(options);
         result.contextMode = options.contextMode;
         result.currentChangeSetId = status.changeSetId || null;
@@ -334,18 +347,20 @@ function attachProjectLogsService(ctx) {
       },
       logHistory: function (args) { scopedEntry(args); return live().history(args && args.ref, args || {}); },
       commentLog: function (args) { scopedEntry(args); return live().comment(args && args.ref, args || {}, author(), mutationContext()); },
+      scheduledResultsState: function () { var scope = currentScope(); return live().unreadScheduledResults(scheduledResultViewerId, scopedArgs({}, scope.status, scope.worktreeOnly)); },
+      markScheduledResultRead: function (args) { var scope = currentScope(); scopedEntry(args); return live().markScheduledResultRead(args && args.ref, scheduledResultViewerId, scopedArgs({}, scope.status, scope.worktreeOnly)); },
       readLogRevision: function (args) { scopedEntry(args); return live().readRevision(args && args.ref, args && args.revision); },
       listLogFeedback: canonical ? function (args) {
         var scope = currentScope();
-        return live().feedback(scopedArgs(args, scope.status, scope.worktreeOnly));
+        return live().feedback(withScheduledResultViewer(scopedArgs(args, scope.status, scope.worktreeOnly)));
       } : driverOnly,
-      reviewLogComment: canonical ? function (args) { scopedEntry(args); return live().review(args && args.ref, args || {}, author(), mutationContext()); } : driverOnly,
+      reviewLogComment: canonical ? function (args) { if (args && args.action === "incorporate") mutableEntry(args); else scopedEntry(args); return live().review(args && args.ref, args || {}, author(), mutationContext()); } : driverOnly,
       revertLog: canonical
-        ? function (args) { scopedEntry(args); return live().revert(args && args.ref, args && args.revision, args && args.reason, author(), mutationContext()); }
+        ? function (args) { mutableEntry(args); return live().revert(args && args.ref, args && args.revision, args && args.reason, author(), mutationContext()); }
         : driverOnly,
       createLog: canonical ? function (args) { return live().create(args || {}, author(), mutationContext()); } : agentOnly,
-      updateLog: canonical ? function (args) { scopedEntry(args); return live().update(args && args.ref, args || {}, author(), mutationContext()); } : agentOnly,
-      linkLog: canonical ? function (args) { scopedEntry(args); return live().link(args && args.ref, args && args.links, author(), mutationContext()); } : agentOnly,
+      updateLog: canonical ? function (args) { mutableEntry(args); return live().update(args && args.ref, args || {}, author(), mutationContext()); } : agentOnly,
+      linkLog: canonical ? function (args) { mutableEntry(args); return live().link(args && args.ref, args && args.links, author(), mutationContext()); } : agentOnly,
       removeLog: canDelete ? function (args) {
         var current = revalidate();
         var project = projectFor(current.principal.projectSlug);
@@ -353,7 +368,7 @@ function attachProjectLogsService(ctx) {
         if (!project || !authorizedProject(current.principal, currentStatus)) {
           throw new Error("Project Logs are not available for this project.");
         }
-        visibleEntry(storeForStatus(currentStatus), args && args.ref, currentStatus, projectAuthorization(current.principal, currentStatus).worktreeOnly);
+        mutableEntry(args);
         if (current.principal.kind !== "session" && !ownsProject(current.principal, currentStatus)) ownerOnly();
         return storeForStatus(currentStatus).remove(args && args.ref, current.author, recordContext(currentStatus));
       } : ownerOnly,
@@ -367,6 +382,20 @@ function attachProjectLogsService(ctx) {
     return storeForStatus(projectStatus).setContextState(recordContext(projectStatus), status);
   }
 
+  // Trusted server lifecycle path. It is deliberately not part of any bound
+  // human or MCP write capability, so system results cannot be impersonated.
+  function recordScheduledResult(source) {
+    var data = source || {};
+    var project = projectFor(data.projectSlug);
+    if (!project) throw new Error("Project not found.");
+    var status = project.getStatus();
+    if (!status || status.isMate === true) throw new Error("Scheduled results require a project.");
+    if (isMultiUser()) {
+      if (!data.ownerId || !findUserById(data.ownerId)) throw new Error("Scheduled result owner is unavailable.");
+    }
+    return storeForStatus(status).createScheduledResult(data, recordContext(status));
+  }
+
   function createClayBound(revalidate) {
     function target(args) {
       var principal = revalidate();
@@ -374,14 +403,16 @@ function attachProjectLogsService(ctx) {
       if (!slug) throw new Error("An exact project slug is required.");
       var status = statusFor(principal, slug);
       var decision = projectAuthorization(principal, status);
-      return { store: storeForStatus(status), status: status, worktreeOnly: decision.worktreeOnly };
+      return { store: storeForStatus(status), status: status, worktreeOnly: decision.worktreeOnly, viewerId: principal.userId || null };
     }
 
     function targetEntry(args) {
       var selected = target(args);
+      var entry = visibleEntry(selected.store, args && args.ref, selected.status, selected.worktreeOnly);
+      if (entry.scheduledResult && (entry.scheduledResult.ownerId || null) !== selected.viewerId) throw new Error("Log entry not found.");
       return {
         selected: selected,
-        entry: visibleEntry(selected.store, args && args.ref, selected.status, selected.worktreeOnly),
+        entry: entry,
       };
     }
 
@@ -405,6 +436,7 @@ function attachProjectLogsService(ctx) {
         seenScopes.add(scopeKey);
         var entry = null;
         try { entry = visibleEntry(storeForStatus(status), ref, status, decision.worktreeOnly); } catch (e) { return; }
+        if (entry && entry.scheduledResult && (entry.scheduledResult.ownerId || null) !== (principal.userId || null)) return;
         if (!entry) return;
         var targetSlug = decision.worktreeOnly
           ? slug
@@ -425,11 +457,11 @@ function attachProjectLogsService(ctx) {
       author: null,
       listLogs: function (args) {
         var selected = target(args);
-        return selected.store.list(scopedArgs(args, selected.status, selected.worktreeOnly));
+        return selected.store.list(Object.assign({}, scopedArgs(args, selected.status, selected.worktreeOnly), { scheduledResultOwnerId: selected.viewerId }));
       },
       searchLogs: function (args) {
         var selected = target(args);
-        return selected.store.search(scopedArgs(args, selected.status, selected.worktreeOnly));
+        return selected.store.search(Object.assign({}, scopedArgs(args, selected.status, selected.worktreeOnly), { scheduledResultOwnerId: selected.viewerId }));
       },
       readLog: function (args) {
         return targetEntry(args).entry;
@@ -458,6 +490,7 @@ function attachProjectLogsService(ctx) {
     bindProjectSession: bindProjectSession,
     bindUser: bindUser,
     bindMate: bindMate,
+    recordScheduledResult: recordScheduledResult,
     setContextState: setContextState,
   };
 }

package/lib/project-logs-store.js

@@ -1,5 +1,4 @@
 // Project Logs projection over the Clay-wide knowledge record backend.
-
 var fs = require("fs");
 var path = require("path");
 var crypto = require("crypto");
@@ -12,6 +11,7 @@ var logsVersioning = require("./project-logs-versioning");
 var logsRoot = require("./project-logs-root");
 var logContext = require("./project-log-context");
 var contextState = require("./project-logs-context-state");
+var scheduledResultStore = require("./project-scheduled-result-store");
 
 var MAX_SUMMARY_CHARS = logsSchema.MAX_SUMMARY_CHARS;
 var MAX_COMMENT_CHARS = 4000;
@@ -34,7 +34,6 @@ var normalizeTags = logsSchema.normalizeTags;
 var normalizeLinks = logsSchema.normalizeLinks;
 
 var page = logsQuery.page;
-
 // Filters accept any well-formed category. An unknown but valid one matches
 // nothing, which is a real answer. A supplied malformed one is an error:
 // silently dropping it would widen the result set to everything the caller is
@@ -45,7 +44,6 @@ function validateKind(kind, fallback) {
   return logsSchema.normalizeCategory(kind);
 }
 
-
 function createProjectLogsStore(opts) {
   var options = opts || {};
   var root = options.root ? path.resolve(options.root) : logsRoot.resolveProjectRoot(options.cwd, options.runGit);
@@ -116,6 +114,7 @@ function createProjectLogsStore(opts) {
       deletedAt: history.deleted ? history.deleted.at : null,
       deletedBy: history.deleted ? history.deleted.author : null,
       context: logContext.normalizeRecordContext(originRecord && originRecord.context),
+      scheduledResult: scheduledResultStore.normalizeMetadata(originRecord && originRecord.scheduledResult),
     };
     if (entry.context.changeSetId) {
       var states = knownContextStates || contexts.states();
@@ -132,13 +131,14 @@ function createProjectLogsStore(opts) {
     return entry;
   }
 
-  function entries(includeDeleted) {
+  function entries(includeDeleted, scheduledResultOwnerId) {
     var out = [];
     var states = contexts.states();
     chains().forEach(function (chain, rootId) {
       var entry = fold(rootId, chain, states);
       if (!entry) return;
       if (entry.deleted && !includeDeleted) return;
+      if (!scheduledResultStore.visibleTo(entry.scheduledResult, scheduledResultOwnerId)) return;
       out.push(entry);
     });
     // Latest canonical update first, ref as a deterministic tie-break. Only a
@@ -157,12 +157,13 @@ function createProjectLogsStore(opts) {
     return found;
   }
 
-  function read(ref, includeDeleted) {
+  function read(ref, includeDeleted, scheduledResultOwnerId) {
     var located = findChain(ref);
     if (!located) return null;
     var entry = fold(located.rootId, located.chain);
     if (!entry) return null;
     if (entry.deleted && !includeDeleted) return null;
+    if (!scheduledResultStore.visibleTo(entry.scheduledResult, scheduledResultOwnerId)) return null;
     return entry;
   }
 
@@ -212,8 +213,7 @@ function createProjectLogsStore(opts) {
     return read(refFor(id), false);
   }
 
-  // Build the complete snapshot a revision will store, from the current state
-  // plus the requested changes. Every new canonical edit is self-contained.
+  // Build the complete snapshot a revision will store from current state.
   function nextSnapshot(current, validated, data) {
     var snapshot = logsSnapshot.cloneSnapshot(current);
     if (validated.category !== undefined) snapshot.category = validated.category;
@@ -251,7 +251,6 @@ function createProjectLogsStore(opts) {
   }
 
   // One append per canonical revision, always carrying a complete snapshot.
-  // Legacy field names ride along so an older build can still read the record.
   function appendRevision(rootId, op, snapshot, author, extra) {
     var record = {
       id: recordStore.newRecordId(),
@@ -275,9 +274,7 @@ function createProjectLogsStore(opts) {
     return record;
   }
 
-  // Human participation. Append-only for this slice: no edit, no delete, and
-  // never a canonical revision. The author is supplied by the authorization
-  // layer, never by the caller's payload.
+  // Human participation is append-only and never a canonical revision.
   function comment(ref, input, author, context) {
     var located = requireLive(ref);
     var data = input || {};
@@ -344,7 +341,7 @@ function createProjectLogsStore(opts) {
   function categories(options) {
     var seen = {};
     var out = [];
-    var live = entries(false);
+    var live = entries(false, options && options.scheduledResultOwnerId);
     for (var i = 0; i < live.length; i++) {
       if (!logsQuery.matchesContext(live[i], options || {})) continue;
       var value = live[i].category;
@@ -379,7 +376,7 @@ function createProjectLogsStore(opts) {
     var limit = Number(options2.limit);
     if (!Number.isFinite(limit)) limit = MAX_FEEDBACK_ITEMS;
     limit = Math.max(1, Math.min(MAX_FEEDBACK_ITEMS, Math.floor(limit)));
-    var live = entries(false);
+    var live = entries(false, options2.scheduledResultOwnerId);
     var out = [];
     var total = 0;
     for (var i = 0; i < live.length; i++) {
@@ -409,13 +406,13 @@ function createProjectLogsStore(opts) {
 
   function list(args) {
     var options2 = args || {};
-    var result = logsQuery.listEntries(entries(options2.includeDeleted === true), options2, cleanLine, validateKind);
+    var result = logsQuery.listEntries(entries(options2.includeDeleted === true, options2.scheduledResultOwnerId), options2, cleanLine, validateKind);
     result.categories = categories(options2);
     return result;
   }
 
   function search(args) {
-    var result = logsQuery.searchEntries(entries(false), args || {}, cleanLine, validateKind);
+    var result = logsQuery.searchEntries(entries(false, args && args.scheduledResultOwnerId), args || {}, cleanLine, validateKind);
     result.categories = categories(args || {});
     return result;
   }
@@ -457,6 +454,8 @@ function createProjectLogsStore(opts) {
     };
   }
 
+  var scheduledResults = scheduledResultStore.attachScheduledResultStore({ store: store, scopeId: scopeId, refFor: refFor, read: read, entries: entries, findChain: findChain, matchesContext: logsQuery.matchesContext });
+
   return {
     root: root,
     scopeId: scopeId,
@@ -477,6 +476,9 @@ function createProjectLogsStore(opts) {
     search: search,
     history: history,
     stats: stats,
+    createScheduledResult: scheduledResults.create,
+    unreadScheduledResults: scheduledResults.unread,
+    markScheduledResultRead: scheduledResults.markRead,
   };
 }
 

package/lib/project-logs.js

@@ -72,6 +72,8 @@ var HANDLED_TYPES = [
   "project_log_read",
   "project_log_comment",
   "project_log_delete",
+  "scheduled_task_result_mark_read",
+  "scheduled_task_result_open_session",
   // Retired human mutations. Still claimed so an older client gets an
   // explicit refusal rather than silence.
   "project_log_create",
@@ -155,6 +157,31 @@ function attachProjectLogs(ctx) {
     return service.bindUser({ projectSlug: slug, user: (ws && ws._clayUser) || null });
   }
 
+  function scheduledResultState(bound, autoFocus) {
+    var state = bound.scheduledResultsState();
+    return { type: "scheduled_task_results_state", unreadCount: state.count, newestUnreadRef: state.newestRef, autoFocus: autoFocus === true };
+  }
+
+  function sendScheduledResultState(ws) {
+    if (!ws || ws._clayPane) return false;
+    var bound = userBinding(ws);
+    if (!bound) return false;
+    try { sendTo(ws, scheduledResultState(bound, true)); return true; } catch (e) { return false; }
+  }
+
+  function broadcastScheduledResultState(sourceWs) {
+    var sourceUserId = sourceWs && sourceWs._clayUser ? sourceWs._clayUser.id : null;
+    var clients = getClients();
+    for (var client of clients) {
+      if (!client || client.readyState !== 1 || client._clayPane) continue;
+      var clientUserId = client._clayUser ? client._clayUser.id : null;
+      if (clientUserId !== sourceUserId) continue;
+      var bound = userBinding(client);
+      if (!bound) continue;
+      try { sendTo(client, scheduledResultState(bound)); } catch (e) {}
+    }
+  }
+
   // --- WebSocket surface -----------------------------------------------
 
   function fail(ws, requestId, message) {
@@ -253,6 +280,27 @@ function attachProjectLogs(ctx) {
         sendTo(ws, { type: "project_log_commented", requestId: requestId, entry: commented, reviewQueued: reviewQueued });
         return true;
       }
+
+      if (msg.type === "scheduled_task_result_mark_read") {
+        bound.markScheduledResultRead({ ref: msg.ref });
+        broadcastScheduledResultState(ws);
+        return true;
+      }
+
+      if (msg.type === "scheduled_task_result_open_session") {
+        var resultEntry = bound.readLog({ ref: msg.ref });
+        var resultMeta = resultEntry && resultEntry.scheduledResult;
+        if (!resultMeta) throw new Error("Scheduled result not found.");
+        var target = null;
+        sm.sessions.forEach(function (session) {
+          if (target || !session || session.sessionOriginId !== resultMeta.driverOriginId) return;
+          var marker = session.scheduledTaskRun;
+          if ((session.ownerId || null) === (resultMeta.ownerId || null) && marker && marker.role === "driver" && marker.runId === resultMeta.runId && marker.scheduleId === resultMeta.scheduleId) target = session;
+        });
+        if (!target) throw new Error("This scheduled session is no longer available.");
+        sendTo(ws, { type: "scheduled_task_result_session", requestId: requestId, ref: resultEntry.ref, sessionId: target.localId });
+        return true;
+      }
     } catch (e) {
       fail(ws, requestId, (e && e.message) || "Project Logs could not complete the request.");
       return true;
@@ -378,6 +426,26 @@ function attachProjectLogs(ctx) {
       "\n" + logsMcp.REVIEW_CONTRACT + pendingFeedbackSignal(session);
   }
 
+  function recordScheduledResult(data) {
+    if (!service || isMate) return null;
+    var result = service.recordScheduledResult(Object.assign({}, data || {}, { projectSlug: slug }));
+    if (!result || !result.entry || !result.created) return result;
+    var clients = getClients();
+    for (var client of clients) {
+      if (!client || client.readyState !== 1 || client._clayPane) continue;
+      if (result.entry.scheduledResult.ownerId && (!client._clayUser || client._clayUser.id !== result.entry.scheduledResult.ownerId)) continue;
+      var bound = userBinding(client);
+      if (!bound) continue;
+      try { bound.readLog({ ref: result.entry.ref }); } catch (e) { continue; }
+      sendTo(client, {
+        type: "scheduled_task_result_created", ref: result.entry.ref,
+        title: result.entry.title, summary: result.entry.summary,
+        outcome: result.entry.scheduledResult.outcome,
+      });
+    }
+    return result;
+  }
+
   return {
     handleLogsMessage: handleLogsMessage,
     createMcpServer: createMcpServer,
@@ -386,6 +454,8 @@ function attachProjectLogs(ctx) {
     getBridgeTools: getBridgeTools,
     callBridgeTool: callBridgeTool,
     getSystemPrompt: getSystemPrompt,
+    recordScheduledResult: recordScheduledResult,
+    sendScheduledResultState: sendScheduledResultState,
   };
 }
 

package/lib/project-loop.js

@@ -373,6 +373,7 @@ function attachLoop(ctx) {
       if (durableSchedule) durableSchedule.sync();
       send({ type: "loop_registry_updated", records: getHubSchedules() });
     },
+    onRunTerminal: ctx.onScheduledRunTerminal,
   });
   loopRegistry.load();
   if (ctx.durableScheduler) {

package/lib/project-notifications.js

@@ -67,7 +67,7 @@ var formatters = {
       type: "permission_request",
       title: data.title || "Permission requested",
       body: data.body || "",
-      meta: { requestId: data.requestId, toolName: data.toolName, toolInput: data.toolInput || null },
+      meta: { requestId: data.requestId, toolName: data.toolName, toolInput: data.toolInput || null, defaultToNo: data.defaultToNo === true, suppressAlwaysAllowRule: data.suppressAlwaysAllowRule === true },
     };
   },
 

package/lib/project-scheduled-result-store.js

@@ -0,0 +1,131 @@
+// Server-owned Scheduled Tasks results inside the Project Logs record stream.
+// This capability is never exposed through the human or agent write surfaces.
+
+var crypto = require("crypto");
+var recordStore = require("./knowledge-record-store");
+var logsSchema = require("./project-logs-schema");
+var logsSnapshot = require("./project-logs-snapshot");
+
+var ID_PATTERN = /^[A-Za-z0-9_-]{1,200}$/;
+var OUTCOMES = ["completed", "failed", "needs-input", "interrupted", "skipped-busy"];
+
+function clean(value, max) {
+  return logsSchema.cleanLine(typeof value === "string" ? value : "", max);
+}
+
+function normalizeMetadata(value) {
+  var source = value || {};
+  if (!ID_PATTERN.test(source.runId || "") || !ID_PATTERN.test(source.scheduleId || "")) return null;
+  if (OUTCOMES.indexOf(source.outcome) === -1) return null;
+  return {
+    runId: source.runId,
+    scheduleId: source.scheduleId,
+    outcome: source.outcome,
+    ownerId: source.ownerId ? clean(String(source.ownerId), 120) : null,
+    driverOriginId: clean(source.driverOriginId || "", 200) || null,
+    workerOriginId: clean(source.workerOriginId || "", 200) || null,
+    driverProviderSessionId: clean(source.driverProviderSessionId || "", 200) || null,
+    workerProviderSessionId: clean(source.workerProviderSessionId || "", 200) || null,
+    startedAt: Number(source.startedAt) || null,
+    finishedAt: Number(source.finishedAt) || null,
+  };
+}
+
+function visibleTo(metadata, viewerId) {
+  if (!metadata || viewerId === undefined) return true;
+  return (metadata.ownerId || null) === (viewerId || null);
+}
+
+function outcomeLabel(outcome) {
+  if (outcome === "completed") return "Completed";
+  if (outcome === "needs-input") return "Needs input";
+  if (outcome === "interrupted") return "Interrupted";
+  if (outcome === "skipped-busy") return "Skipped";
+  return "Failed";
+}
+
+function fallbackSummary(outcome) {
+  if (outcome === "completed") return "The scheduled task completed successfully.";
+  if (outcome === "needs-input") return "The scheduled task is waiting for user input or permission.";
+  if (outcome === "interrupted") return "The scheduled task was interrupted before completion.";
+  if (outcome === "skipped-busy") return "The scheduled occurrence was skipped because an earlier run was still active.";
+  return "The scheduled task failed.";
+}
+
+function rootId(scopeId, runId) {
+  var digest = crypto.createHash("sha256").update(scopeId + "\u0000scheduled-result\u0000" + runId).digest("base64url");
+  return "sresult-" + digest.substring(0, 24);
+}
+
+function attachScheduledResultStore(ctx) {
+  function resultRecord(runId) {
+    var records = ctx.store.all();
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].op === "create" && records[i].scheduledResult && records[i].scheduledResult.runId === runId) return records[i];
+    }
+    return null;
+  }
+
+  function create(input, context) {
+    var data = input || {};
+    var metadata = normalizeMetadata(data);
+    if (!metadata) throw new Error("Scheduled result identity is invalid.");
+    var existing = resultRecord(metadata.runId);
+    if (existing) return { entry: ctx.read(ctx.refFor(existing.rootId || existing.id), false), created: false };
+    var name = clean(data.name || "Scheduled task", 160) || "Scheduled task";
+    var reason = clean(data.summary || data.reason || "", 400);
+    var summary = reason || fallbackSummary(metadata.outcome);
+    var title = name + " · " + outcomeLabel(metadata.outcome);
+    var body = "## Scheduled result\n\n" + summary + "\n\n" +
+      "- Outcome: " + outcomeLabel(metadata.outcome) + "\n" +
+      "- Run: `" + metadata.runId + "`\n" +
+      (metadata.startedAt ? "- Started: " + new Date(metadata.startedAt).toISOString() + "\n" : "") +
+      (metadata.finishedAt ? "- Finished: " + new Date(metadata.finishedAt).toISOString() + "\n" : "");
+    var id = rootId(ctx.scopeId, metadata.runId);
+    var snapshot = logsSnapshot.cloneSnapshot({ category: "scheduled-result", priority: metadata.outcome === "failed" ? "important" : "normal", title: title, summary: summary, body: body, tags: ["scheduled-task", metadata.outcome], links: [] });
+    ctx.store.append({
+      id: id, rootId: id, op: "create", scope: ctx.scopeId,
+      kind: snapshot.category, priority: snapshot.priority, title: snapshot.title,
+      summary: snapshot.summary, body: snapshot.body, tags: snapshot.tags,
+      links: snapshot.links, snapshot: snapshot,
+      author: logsSchema.normalizeAuthor({ type: "system", displayName: "Scheduled Tasks" }),
+      context: context || null, scheduledResult: metadata, at: metadata.finishedAt || Date.now(),
+    });
+    return { entry: ctx.read(ctx.refFor(id), false), created: true };
+  }
+
+  function hasRead(root, readerId) {
+    var records = ctx.store.all();
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].rootId === root && records[i].op === "scheduled-result-read" && (records[i].readerId || null) === (readerId || null)) return true;
+    }
+    return false;
+  }
+
+  function unread(viewerId, options) {
+    var entries = ctx.entries(false, viewerId);
+    var refs = [];
+    for (var i = 0; i < entries.length; i++) {
+      if (!entries[i].scheduledResult) continue;
+      if (ctx.matchesContext && !ctx.matchesContext(entries[i], options || {})) continue;
+      var located = ctx.findChain(entries[i].ref);
+      if (located && !hasRead(located.rootId, viewerId)) refs.push(entries[i].ref);
+    }
+    return { count: refs.length, newestRef: refs.length ? refs[0] : null, refs: refs };
+  }
+
+  function markRead(ref, viewerId, options) {
+    var entry = ctx.read(ref, false, viewerId);
+    if (!entry || !entry.scheduledResult) throw new Error("Scheduled result not found.");
+    var located = ctx.findChain(ref);
+    if (!located) throw new Error("Scheduled result not found.");
+    if (!hasRead(located.rootId, viewerId)) {
+      ctx.store.append({ id: recordStore.newRecordId(), rootId: located.rootId, op: "scheduled-result-read", scope: ctx.scopeId, readerId: viewerId || null, at: Date.now() });
+    }
+    return unread(viewerId, options);
+  }
+
+  return { create: create, markRead: markRead, unread: unread };
+}
+
+module.exports = { attachScheduledResultStore: attachScheduledResultStore, normalizeMetadata: normalizeMetadata, visibleTo: visibleTo };

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

@@ -50,8 +50,9 @@ function attachScheduledTaskExecution(ctx) {
     var active = record.activeRun;
     var driver = sm.sessions.get(active.driverSessionId);
     var worker = sm.sessions.get(active.workerSessionId);
+    var finalSummary = clean(reason, 1000) || null;
     var saved = registry.completeRun(recordId, runId, {
-      outcome: outcome, reason: clean(reason, 1000) || null,
+      outcome: outcome, summary: finalSummary, reason: finalSummary,
       driverProviderSessionId: driver && driver.cliSessionId || active.driverProviderSessionId || null,
       workerProviderSessionId: worker && worker.cliSessionId || active.workerProviderSessionId || null,
     });
@@ -65,6 +66,37 @@ function attachScheduledTaskExecution(ctx) {
     return true;
   }
 
+  function recordTerminal(record, run, attempt) {
+    if (!record || !run || !run.runId || !run.outcome || typeof ctx.recordResult !== "function") return false;
+    try {
+      ctx.recordResult({
+        scheduleId: record.id, runId: run.runId, name: record.name || "Scheduled task",
+        ownerId: record.ownerId || null, outcome: run.outcome,
+        summary: run.summary || run.reason || null, startedAt: run.startedAt || null,
+        finishedAt: run.finishedAt || Date.now(), driverOriginId: run.driverOriginId || null,
+        workerOriginId: run.workerOriginId || null,
+        driverProviderSessionId: run.driverProviderSessionId || null,
+        workerProviderSessionId: run.workerProviderSessionId || null,
+      });
+      return true;
+    } catch (error) {
+      console.error("[scheduled-task] Failed to record result for " + run.runId + ":", error.message || error);
+      if (Number(attempt || 0) < 2) setTimeout(function () { recordTerminal(record, run, Number(attempt || 0) + 1); }, 1000);
+      return false;
+    }
+  }
+
+  function syncTerminalResults() {
+    var records = registry.getAll ? registry.getAll() : [];
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].createdViaScheduledTasks !== true && records[i].source !== "schedule") continue;
+      var runs = Array.isArray(records[i].runs) ? records[i].runs : [];
+      for (var j = 0; j < runs.length; j++) {
+        if (runs[j] && runs[j].runId && runs[j].outcome) recordTerminal(records[i], runs[j]);
+      }
+    }
+  }
+
   function failStart(recordId, runId, created, error, preDispatch) {
     if (preDispatch) rollbackPair(created);
     else if (created) {
@@ -110,6 +142,7 @@ function attachScheduledTaskExecution(ctx) {
         name: record.name || "Scheduled task",
         driver: record.execution.driver,
         worker: record.execution.worker,
+        hidden: true,
       });
       var runState = {
         status: "running", groupId: created.group.id,
@@ -230,7 +263,7 @@ function attachScheduledTaskExecution(ctx) {
     return driver ? stopForSession(driver, reason) : finish(record.id, record.activeRun.runId, "interrupted", reason, false);
   }
 
-  return { getToolDefs: getToolDefs, onPartnerResult: onPartnerResult, onTurnDone: onTurnDone, prepare: prepare, runnable: runnable, stopForSession: stopForSession, stopRecord: stopRecord, trigger: trigger };
+  return { getToolDefs: getToolDefs, onPartnerResult: onPartnerResult, onTurnDone: onTurnDone, prepare: prepare, recordTerminal: recordTerminal, runnable: runnable, stopForSession: stopForSession, stopRecord: stopRecord, syncTerminalResults: syncTerminalResults, trigger: trigger };
 }
 
 module.exports = { attachScheduledTaskExecution: attachScheduledTaskExecution, validRuntime: validRuntime };

package/lib/project-session-notes.js

@@ -1,5 +1,6 @@
 var sessionNotesMcp = require("./session-notes-mcp-server");
 var lifecycle = require("./notes-lifecycle");
+var driverEligibility = require("./session-driver-eligibility");
 
 var MAX_NOTE_TEXT_CHARS = 20000;
 var MAX_ACTIVE_NOTES = 20;
@@ -172,13 +173,19 @@ function attachSessionNotes(ctx) {
     return toolResult(publicNote(created));
   }
 
-  // A session may only act on notes it created. Ownership is checked against the
-  // note's recorded origin and the server-bound caller, never against anything
-  // in the arguments.
+  // Cross-session closure requires a live, authorized Project Driver.
+  // Reopening retains the existing creator-only permission.
   function ownedNote(args, caller, verb) {
+    var authorized = typeof ctx.canUseSession === "function" && ctx.canUseSession(caller);
+    if (ctx.canUseSession && !authorized) {
+      return { error: "this session no longer has access to project notes" };
+    }
     var note = findNote(nm.list() || [], args && args.id);
     if (!note) return { error: "note not found: " + ((args && args.id) || "unknown") };
-    if (!note.origin || note.origin.sessionId !== caller.localId) {
+    var driverCanClose = verb === "close" && !ctx.isMate &&
+      driverEligibility.isEligibleDriverSession(caller) &&
+      authorized;
+    if (!driverCanClose && (!note.origin || note.origin.sessionId !== caller.localId)) {
       return { error: "this session can only " + verb + " notes it created" };
     }
     return { note: note };