clay-server 4.1.0-beta.10 → 4.1.0-beta.12

package/lib/loop-registry-occurrence.js

@@ -38,6 +38,7 @@ function attachLoopRegistryOccurrence(ctx) {
     ctx.scheduledRuns.prepareRecord(rec, prepared);
     if (!ctx.save()) { recordRevision.restoreRecord(rec, previous); return { ok: false, error: ctx.lastSaveError() || "The occurrence reservation could not be stored." }; }
     ctx.changed();
+    if (prepared && prepared.skippedRun) ctx.scheduledRuns.notifyTerminal(rec, prepared.skippedRun);
     return { ok: true, value: prepared };
   }
 

package/lib/project-connection.js

@@ -77,6 +77,7 @@ function attachConnection(ctx) {
   var _loop = ctx._loop;
   var _mcp = ctx._mcp;
   var _notifications = ctx._notifications;
+  var _projectLogs = ctx._projectLogs;
   var _splitGroups = ctx._splitGroups;
   var _vendorLogin = ctx._vendorLogin;
   var hydrateImageRefs = ctx.hydrateImageRefs;
@@ -229,6 +230,7 @@ function attachConnection(ctx) {
     _loop.sendConnectionState(ws);
     if (_mcp) _mcp.sendConnectionState(ws);
     if (_notifications) _notifications.sendConnectionState(ws, sendTo);
+    if (_projectLogs) _projectLogs.sendScheduledResultState(ws);
 
     // Session list (filtered for access control). Uses the same mapper as
     // broadcastSessionList: a hand-rolled copy here silently drifts and

package/lib/project-logs-schema.js

@@ -196,7 +196,7 @@ function cleanLine(value, max) {
 
 function normalizeAuthor(author) {
   var source = author || {};
-  var type = source.type === "user" ? "user" : "session";
+  var type = source.type === "user" ? "user" : (source.type === "system" ? "system" : "session");
   return {
     type: type,
     userId: source.userId ? cleanLine(String(source.userId), 120) : null,

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

@@ -1422,6 +1422,9 @@ function createProjectContext(opts) {
     canExecuteScheduledTask: function (record) {
       return !!(_scheduledTaskExecution && _scheduledTaskExecution.runnable(record).ok);
     },
+    onScheduledRunTerminal: function (record, run) {
+      if (_scheduledTaskExecution) _scheduledTaskExecution.recordTerminal(record, run);
+    },
     onProcessingChanged: onProcessingChanged,
     hydrateImageRefs: hydrateImageRefs,
   });
@@ -1437,6 +1440,7 @@ function createProjectContext(opts) {
     getSdk: function () { return sdk; }, getLinuxUserForSession: getLinuxUserForSession,
     requiresLinuxUser: function () { return osUsers; },
     onProcessingChanged: onProcessingChanged,
+    recordResult: function (result) { return _projectLogs.recordScheduledResult(result); },
     authorize: function (record) {
       return authorizeStoredOwner(record, {
         usersModule: usersModule, osUsers: osUsers,
@@ -1446,6 +1450,7 @@ function createProjectContext(opts) {
       });
     },
   });
+  setTimeout(function () { _scheduledTaskExecution.syncTerminalResults(); }, 0);
 
   _scheduledTasks = attachScheduledTasks({
     cwd: cwd,
@@ -1940,6 +1945,7 @@ function createProjectContext(opts) {
     saveContextSources: saveContextSources,
     _email: _email,
     _notifications: _notifications,
+    _projectLogs: _projectLogs,
   });
 
   var _models = attachModels({

package/lib/public/app.js

@@ -381,6 +381,12 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     projectLogsCanDelete: false,
     projectLogsUnread: 0,
     projectLogsSeenRevisions: {},
+    scheduledResultUnread: 0,
+    scheduledResultAutoFocusHandled: false,
+    scheduledResultFocusRef: null,
+    scheduledResultPendingReadRef: null,
+    scheduledResultSeenRefs: {},
+    scheduledResultSessionRequestId: null,
     issuesOpen: false,
     issuesView: "list",
     issuesSelected: null,

package/lib/public/css/notifications-center.css

@@ -181,7 +181,7 @@
   margin-top: 8px;
 }
 .notif-banner-allow, .notif-banner-always, .notif-banner-deny, .notif-banner-goto,
-.notif-banner-tui-open, .notif-banner-tui-goto {
+.notif-banner-tui-open, .notif-banner-tui-goto, .notif-banner-result-open {
   padding: 4px 10px;
   border-radius: 6px;
   font-size: 11px;
@@ -191,11 +191,11 @@
   border: none;
   transition: opacity 0.15s, background 0.15s;
 }
-.notif-banner-tui-open {
+.notif-banner-tui-open, .notif-banner-result-open {
   background: var(--accent, #6c5ce7);
   color: #fff;
 }
-.notif-banner-tui-open:hover { opacity: 0.85; }
+.notif-banner-tui-open:hover, .notif-banner-result-open:hover { opacity: 0.85; }
 .notif-banner-tui-goto {
   background: var(--accent2);
   border: none;

package/lib/public/css/project-logs.css

@@ -196,3 +196,18 @@
   .project-log-row { padding: 14px 14px 13px; }
   .project-log-document { padding: 24px 18px 38px; }
 }
+.project-log-session-button {
+  align-self: flex-start;
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  margin: 0 0 16px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 7px 10px;
+  background: var(--bg-alt);
+  color: var(--text);
+  cursor: pointer;
+}
+
+.project-log-session-button:hover { border-color: var(--accent); }

package/lib/public/modules/app-messages.js

@@ -44,7 +44,7 @@ import { tuiModalHandleTermOutput, tuiModalHandleTermResized, tuiModalHandleTerm
 import { updateTerminalList, handleContextSourcesState, updateEmailAccountList, updateEmailUnreadCounts, handleEmailTestResult, handleEmailAddResult, handleEmailRemoveResult } from './context-sources.js';
 import { refreshEmailSettings } from './user-settings.js';
 import { handleNotesList, handleNoteCreated, handleNoteUpdated, handleNoteDeleted, handleNoteWritten } from './sticky-notes.js';
-import { handleProjectLogsState, handleProjectLogEntry, handleProjectLogCommented, handleProjectLogCommentReviewed, handleProjectLogDeleted, handleProjectLogUpdated, handleProjectLogsError } from './project-logs.js';
+import { handleProjectLogsState, handleProjectLogEntry, handleProjectLogCommented, handleProjectLogCommentReviewed, handleProjectLogDeleted, handleProjectLogUpdated, handleProjectLogsError, handleScheduledTaskResultsState, handleScheduledTaskResultCreated, handleScheduledTaskResultSession } from './project-logs.js';
 import { handleSkillInstalled, handleSkillUninstalled } from './skills.js';
 import { showRewindModal, onRewindComplete, setRewindMode, onRewindError, clearPendingRewindUuid, addRewindButton } from './rewind.js';
 import { checkAdminAccess } from './admin.js';
@@ -1664,6 +1664,18 @@ export function processMessage(msg) {
         handleProjectLogsError(msg);
         break;
 
+      case "scheduled_task_results_state":
+        handleScheduledTaskResultsState(msg);
+        break;
+
+      case "scheduled_task_result_created":
+        handleScheduledTaskResultCreated(msg);
+        break;
+
+      case "scheduled_task_result_session":
+        handleScheduledTaskResultSession(msg);
+        break;
+
       case "process_stats":
         updateStatusPanel(msg);
         updateSettingsStats(msg);

package/lib/public/modules/project-logs-render.js

@@ -45,6 +45,7 @@ function actorLabel(actor) {
 // only the account the session ran under.
 function authorLine(entry) {
   var actor = (entry && (entry.updatedBy || entry.createdBy)) || {};
+  if (actor.type === "system") return actor.displayName || "Scheduled Tasks";
   if (actor.type === "session") {
     return actor.vendor ? "Project Driver (" + vendorLabel(actor.vendor) + ")" : "Project Driver";
   }
@@ -363,7 +364,7 @@ export function renderDetail(detailEl, entry, handlers) {
     formatTime(entry.updatedAt || entry.createdAt),
   ].filter(Boolean).join(" · ");
   setText(header, ".project-log-byline", byline);
-  if (handlers && handlers.canDelete) {
+  if (handlers && handlers.canDelete && !entry.scheduledResult) {
     var deleteButton = document.createElement("button");
     deleteButton.type = "button";
     deleteButton.className = "project-log-delete-button";
@@ -373,6 +374,15 @@ export function renderDetail(detailEl, entry, handlers) {
   }
   article.appendChild(header);
 
+  if (entry.scheduledResult && entry.scheduledResult.driverOriginId && handlers && handlers.onOpenSession) {
+    var sessionButton = document.createElement("button");
+    sessionButton.type = "button";
+    sessionButton.className = "project-log-session-button";
+    sessionButton.innerHTML = '<i data-lucide="external-link"></i><span>View session</span>';
+    sessionButton.addEventListener("click", function () { handlers.onOpenSession(entry); });
+    article.appendChild(sessionButton);
+  }
+
   var markdown = document.createElement("div");
   markdown.className = "project-log-markdown md-content";
   markdown.innerHTML = renderMarkdown(entry.body || "");

package/lib/public/modules/project-logs.js

@@ -1,5 +1,4 @@
 // Project Logs — the project's ledger of agent-authored decisions and work.
-//
 // A bounded right-side workbench pane, like the document viewer and terminal.
 // Inside it there is one navigation stack rather than a master/detail split:
 // the list fills the pane, opening an entry replaces it with the full-pane
@@ -14,6 +13,9 @@ import { store } from './store.js';
 import { getWs } from './ws-ref.js';
 import { refreshIcons } from './icons.js';
 import { showToast } from './utils.js';
+import { showScheduledResultNotification } from './scheduled-result-notification.js';
+import * as scheduledResultClient from './scheduled-result-client.js';
+import { clearPendingScheduledResultRead, handleScheduledResultDisplayed, initScheduledResultDisplay, openScheduledResultSession } from './scheduled-result-display.js';
 import { closeScheduledTasks } from './scheduled-tasks.js';
 import { closeNotesBrowser } from './sticky-notes-browser.js';
 import { closeFileViewer } from './filebrowser.js';
@@ -35,7 +37,7 @@ var requestCounter = 0;
 function syncUnreadBadge() {
   var button = document.getElementById("project-logs-btn");
   if (!button) return;
-  var unread = store.get('projectLogsUnread') || 0;
+  var unread = (store.get('projectLogsUnread') || 0) + (store.get('scheduledResultUnread') || 0);
   button.classList.toggle("project-logs-unread", unread > 0);
   var badge = document.getElementById("project-logs-count");
   if (!badge) return;
@@ -164,10 +166,10 @@ function applyWindowState(wide, fullscreen) {
 }
 
 // --- Navigation stack ----------------------------------------------------
-
 function showList() {
   if (!panel) return;
   store.set({ projectLogsView: "list", projectLogsSelectedRef: null });
+  clearPendingScheduledResultRead();
   detailEl.classList.add("hidden");
   listEl.classList.remove("hidden");
   panel.querySelector("#project-logs-toolbar").classList.remove("hidden");
@@ -188,8 +190,10 @@ function showDetail(entry) {
   renderDetail(detailEl, entry, {
     onComment: submitComment,
     onDelete: openDeleteDialog,
+    onOpenSession: openScheduledResultSession,
     canDelete: store.get('projectLogsCanDelete') === true,
   });
+  handleScheduledResultDisplayed(entry);
 }
 
 function openDeleteDialog(entry) {
@@ -230,7 +234,6 @@ function confirmDelete() {
 }
 
 // --- Requests ------------------------------------------------------------
-
 function requestList() {
   var requestId = nextRequestId("list-logs");
   store.set({ projectLogsListRequestId: requestId });
@@ -288,8 +291,10 @@ export function initProjectLogs() {
     if (store.get('projectLogsOpen')) closeProjectLogs();
     else openProjectLogs();
   });
+  initScheduledResultDisplay();
   syncUnreadBadge();
   store.subscribe(function (state, previous) {
+    if (state.connected === false && previous.connected === true) store.set({ scheduledResultAutoFocusHandled: false });
     if (state.currentSlug === previous.currentSlug) return;
     closeProjectLogs();
     applyWindowState(false, false);
@@ -309,7 +314,13 @@ export function initProjectLogs() {
       projectLogsDeleteRequestId: null,
       projectLogsCanDelete: false,
       projectLogsUnread: 0,
-      projectLogsSeenRevisions: {}
+      projectLogsSeenRevisions: {},
+      scheduledResultUnread: 0,
+      scheduledResultAutoFocusHandled: false,
+      scheduledResultFocusRef: null,
+      scheduledResultPendingReadRef: null,
+      scheduledResultSeenRefs: {},
+      scheduledResultSessionRequestId: null,
     });
     syncUnreadBadge();
   });
@@ -384,11 +395,35 @@ export function handleProjectLogsState(msg) {
 
 export function handleProjectLogEntry(msg) {
   if (msg.requestId && msg.requestId !== store.get('projectLogsReadRequestId')) return;
-  if (!msg.entry) return;
+  if (!msg.entry || !store.get('projectLogsOpen')) return;
   store.set({ projectLogsCanDelete: msg.canDelete === true });
   showDetail(msg.entry);
 }
 
+export function handleScheduledTaskResultsState(msg) {
+  var transition = scheduledResultClient.scheduledResultStateTransition(store.snap(), msg);
+  store.set(transition.patch); syncUnreadBadge();
+  if (!transition.openRef) return false;
+  var opened = openProjectLog(transition.openRef);
+  if (!opened) store.set({ scheduledResultFocusRef: null });
+  return opened;
+}
+
+export function handleScheduledTaskResultCreated(msg) {
+  var patch = scheduledResultClient.scheduledResultCreatedTransition(store.snap(), msg);
+  if (!patch) return false;
+  store.set(patch); syncUnreadBadge();
+  showScheduledResultNotification(msg.title || "Scheduled task finished", msg.summary || "", function () { openProjectLog(msg.ref); });
+  return true;
+}
+
+export function handleScheduledTaskResultSession(msg) {
+  var sessionId = scheduledResultClient.scheduledResultSessionId(store.snap(), msg);
+  if (sessionId === null) return false;
+  store.set({ scheduledResultSessionRequestId: null });
+  return send({ type: "switch_session", id: sessionId });
+}
+
 export function handleProjectLogCommented(msg) {
   if (msg.requestId && msg.requestId !== store.get('projectLogsCommentRequestId')) return;
   if (!msg.entry) return;

package/lib/public/modules/scheduled-result-client.js

@@ -0,0 +1,33 @@
+// Pure Scheduled Tasks result-news decisions. The production controller owns
+// store, WebSocket, DOM, and peer-module calls directly.
+
+export function scheduledResultStateTransition(state, msg) {
+  var patch = { scheduledResultUnread: Number(msg.unreadCount) || 0 };
+  var openRef = null;
+  if (msg.autoFocus && msg.newestUnreadRef && !state.scheduledResultAutoFocusHandled) {
+    patch.scheduledResultAutoFocusHandled = true;
+    patch.scheduledResultFocusRef = msg.newestUnreadRef;
+    openRef = msg.newestUnreadRef;
+  }
+  return { patch: patch, openRef: openRef };
+}
+
+export function scheduledResultCreatedTransition(state, msg) {
+  if (!msg || !msg.ref || (state.scheduledResultSeenRefs || {})[msg.ref]) return null;
+  var seen = Object.assign({}, state.scheduledResultSeenRefs || {});
+  seen[msg.ref] = true;
+  return { scheduledResultSeenRefs: seen, scheduledResultUnread: (state.scheduledResultUnread || 0) + 1 };
+}
+
+export function shouldAcknowledgeScheduledResult(entry, state, visibilityState) {
+  return !!(entry && entry.scheduledResult && visibilityState !== "hidden" && state.projectLogsOpen && state.projectLogsView === "detail" && state.projectLogsSelectedRef === entry.ref);
+}
+
+export function shouldFocusScheduledResult(entry, state) {
+  return !!(entry && state.scheduledResultFocusRef === entry.ref);
+}
+
+export function scheduledResultSessionId(state, msg) {
+  if (msg.requestId && msg.requestId !== state.scheduledResultSessionRequestId) return null;
+  return typeof msg.sessionId === "number" ? msg.sessionId : null;
+}

package/lib/public/modules/scheduled-result-display.js

@@ -0,0 +1,50 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { showToast } from './utils.js';
+import { shouldAcknowledgeScheduledResult, shouldFocusScheduledResult } from './scheduled-result-client.js';
+
+function sendRead(ref) {
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) return false;
+  ws.send(JSON.stringify({ type: "scheduled_task_result_mark_read", ref: ref }));
+  return true;
+}
+
+var openRequestCounter = 0;
+export function openScheduledResultSession(entry) {
+  if (!entry || !entry.scheduledResult) return false;
+  openRequestCounter += 1;
+  var requestId = "open-scheduled-session-" + Date.now() + "-" + openRequestCounter;
+  store.set({ scheduledResultSessionRequestId: requestId });
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) { showToast("Reconnect to view this scheduled session.", "warn"); return false; }
+  ws.send(JSON.stringify({ type: "scheduled_task_result_open_session", requestId: requestId, ref: entry.ref })); return true;
+}
+
+function acknowledgeVisible() {
+  var ref = store.get('scheduledResultPendingReadRef');
+  if (!ref || document.visibilityState === "hidden") return;
+  store.set({ scheduledResultPendingReadRef: null });
+  var state = store.snap();
+  if (state.projectLogsOpen && state.projectLogsView === "detail" && state.projectLogsSelectedRef === ref) sendRead(ref);
+}
+
+export function clearPendingScheduledResultRead() {
+  store.set({ scheduledResultPendingReadRef: null });
+}
+
+export function handleScheduledResultDisplayed(entry) {
+  var state = store.snap();
+  if (shouldFocusScheduledResult(entry, state)) {
+    store.set({ scheduledResultFocusRef: null });
+    var heading = document.querySelector("#project-logs-detail .project-log-document h1");
+    if (heading) { heading.setAttribute("tabindex", "-1"); heading.focus(); }
+  }
+  if (shouldAcknowledgeScheduledResult(entry, store.snap(), document.visibilityState)) {
+    clearPendingScheduledResultRead(); sendRead(entry.ref);
+  } else if (entry && entry.scheduledResult && document.visibilityState === "hidden") store.set({ scheduledResultPendingReadRef: entry.ref });
+}
+
+export function initScheduledResultDisplay() {
+  document.addEventListener("visibilitychange", acknowledgeVisible);
+}

package/lib/public/modules/scheduled-result-notification.js

@@ -0,0 +1,31 @@
+import { refreshIcons, iconHtml } from './icons.js';
+import { escapeHtml } from './utils.js';
+
+function removeBanner(banner) {
+  if (!banner || !banner.parentNode) return;
+  banner.classList.remove("show");
+  setTimeout(function () { if (banner.parentNode) banner.remove(); }, 220);
+}
+
+export function showScheduledResultNotification(title, body, onOpen) {
+  var container = document.querySelector(".notif-banner-container");
+  if (!container) return false;
+  var banner = document.createElement("div");
+  banner.className = "notif-banner";
+  banner.innerHTML =
+    '<div class="notif-banner-icon">' + iconHtml("calendar-check") + '</div>' +
+    '<div class="notif-banner-body"><div class="notif-banner-project">SCHEDULED TASKS</div>' +
+      '<div class="notif-banner-title">' + escapeHtml(title || "Scheduled task finished") + '</div>' +
+      (body ? '<div class="notif-banner-text">' + escapeHtml(body) + '</div>' : '') +
+      '<div class="notif-banner-actions"><button class="notif-banner-result-open">View result</button></div></div>' +
+    '<button class="notif-banner-close" aria-label="Dismiss notification">' + iconHtml("x") + '</button>';
+  container.appendChild(banner);
+  refreshIcons(banner);
+  requestAnimationFrame(function () { banner.classList.add("show"); });
+  banner.querySelector(".notif-banner-result-open").addEventListener("click", function (event) {
+    event.stopPropagation(); removeBanner(banner); if (typeof onOpen === "function") onOpen();
+  });
+  banner.querySelector(".notif-banner-close").addEventListener("click", function (event) { event.stopPropagation(); removeBanner(banner); });
+  setTimeout(function () { removeBanner(banner); }, 8000);
+  return true;
+}

package/lib/public/modules/scheduled-task-presentation.js

@@ -0,0 +1,15 @@
+export function scheduledTaskExecutionLabel(record) {
+  if (record.activeRun) {
+    if (record.activeRun.status === "needs-input") return "Needs input";
+    if (record.activeRun.status === "waiting-worker") return "Waiting for Worker";
+    if (record.activeRun.status === "reviewing") return "Driver reviewing";
+    return "Running";
+  }
+  if (!record.execution) return "Needs setup";
+  if (record.readiness && record.readiness.ok === false) return "Unavailable";
+  return record.enabled === false ? "Paused" : "Active";
+}
+
+export function scheduledTaskOpenRunLabel(record) {
+  return record.activeRun && record.activeRun.status === "needs-input" ? "Open blocked run" : "Open run";
+}

package/lib/public/modules/scheduled-tasks.js

@@ -12,6 +12,7 @@ import { readExecutionRuntime, renderExecutionRuntime } from './scheduled-task-e
 import { openDefaultAi } from './default-ai.js';
 import { reconcileScheduledTaskEdit } from './scheduled-task-edit-state.js';
 import { editorFields, fillEditor, readEditor, serverEditorData, validateEditor, handleEditorScheduleChange } from './scheduled-task-form.js';
+import { scheduledTaskExecutionLabel, scheduledTaskOpenRunLabel } from './scheduled-task-presentation.js';
 
 export { isStrictCron, humanRecurrence } from './scheduled-task-recurrence.js';
 
@@ -56,18 +57,6 @@ function scheduleLabel(record) {
   return "No schedule";
 }
 
-function executionLabel(record) {
-  if (record.activeRun) {
-    if (record.activeRun.status === "needs-input") return "Needs input";
-    if (record.activeRun.status === "waiting-worker") return "Waiting for Worker";
-    if (record.activeRun.status === "reviewing") return "Driver reviewing";
-    return "Running";
-  }
-  if (!record.execution) return "Needs setup";
-  if (record.readiness && record.readiness.ok === false) return "Unavailable";
-  return record.enabled === false ? "Paused" : "Active";
-}
-
 function ensurePanel() {
   if (panel) return;
   var host = document.getElementById("main-panels");
@@ -185,7 +174,7 @@ function buildRow(record) {
   row.className = "scheduled-task-row" + (record.enabled === false ? " paused" : "");
   row.dataset.taskId = record.id;
   row.setAttribute("role", "listitem");
-  var stateLabel = executionLabel(record);
+  var stateLabel = scheduledTaskExecutionLabel(record);
   row.innerHTML =
     '<button class="scheduled-task-summary" type="button" data-action="expand" aria-expanded="' + (expandedId === record.id ? "true" : "false") + '">' +
       '<span class="scheduled-task-state-dot" aria-hidden="true"></span>' +
@@ -212,12 +201,12 @@ function buildRow(record) {
       detail.appendChild(instructions);
       var context = document.createElement("div");
       context.className = "scheduled-task-context";
-      var executionState = executionLabel(record);
+      var executionState = scheduledTaskExecutionLabel(record);
       context.textContent = (record.projectTitle || store.get('currentSlug') || "Project") + " · " + executionState + (record.execution ? " · Driver and Split Worker" : " · Choose execution pair in Edit");
       detail.appendChild(context);
       var actions = document.createElement("div");
       actions.className = "scheduled-task-actions";
-      actions.innerHTML = '<button type="button" data-action="edit">' + iconHtml("pencil") + 'Edit</button><button type="button" data-action="toggle">' + iconHtml(record.enabled === false ? "play" : "pause") + (record.enabled === false ? "Resume" : "Pause") + '</button><button type="button" data-action="run">' + iconHtml("zap") + 'Run now</button>' + (record.activeRun || record.latestRun ? '<button type="button" data-action="open-run">' + iconHtml("columns-2") + 'Open run</button>' : '') + '<button type="button" data-action="delete" class="danger">' + iconHtml("trash-2") + 'Delete</button>';
+      actions.innerHTML = '<button type="button" data-action="edit">' + iconHtml("pencil") + 'Edit</button><button type="button" data-action="toggle">' + iconHtml(record.enabled === false ? "play" : "pause") + (record.enabled === false ? "Resume" : "Pause") + '</button><button type="button" data-action="run">' + iconHtml("zap") + 'Run now</button>' + (record.activeRun || record.latestRun ? '<button type="button" data-action="open-run">' + iconHtml("columns-2") + scheduledTaskOpenRunLabel(record) + '</button>' : '') + '<button type="button" data-action="delete" class="danger">' + iconHtml("trash-2") + 'Delete</button>';
       detail.appendChild(actions);
     }
     row.appendChild(detail);

package/lib/scheduled-run-state.js

@@ -42,9 +42,11 @@ function createScheduledRunState(ctx) {
   }
 
   function complete(id, runId, result) {
-    return mutate(id, function (rec) {
+    var completed = null;
+    var saved = mutate(id, function (rec) {
       if (!rec.activeRun || rec.activeRun.runId !== runId) return false;
       var run = Object.assign({}, rec.activeRun, result || {}, { finishedAt: Date.now() });
+      completed = run;
       rec.lastRunAt = run.startedAt || Date.now();
       rec.lastRunResult = run.outcome || "failed";
       rec.runs = Array.isArray(rec.runs) ? rec.runs : [];
@@ -54,6 +56,8 @@ function createScheduledRunState(ctx) {
       rec.activeRun = null;
       return true;
     });
+    if (saved && completed && ctx.onTerminal) ctx.onTerminal(ctx.getRecord(id), completed);
+    return saved;
   }
 
   function recover(rec) {
@@ -81,7 +85,11 @@ function createScheduledRunState(ctx) {
     return true;
   }
 
-  return { begin: begin, complete: complete, prepareRecord: prepareRecord, recordLegacy: recordLegacy, recover: recover, update: update };
+  function notifyTerminal(rec, run) {
+    if (ctx.onTerminal && rec && run) ctx.onTerminal(rec, run);
+  }
+
+  return { begin: begin, complete: complete, notifyTerminal: notifyTerminal, prepareRecord: prepareRecord, recordLegacy: recordLegacy, recover: recover, update: update };
 }
 
 module.exports = { createScheduledRunState: createScheduledRunState };

package/lib/scheduler.js

@@ -36,6 +36,7 @@ function createLoopRegistry(opts) {
   var scheduledRuns = createScheduledRunState({
     getRecord: getById, save: save,
     onChange: function () { if (onChange) onChange(records); },
+    onTerminal: opts.onRunTerminal,
   });
   var durableOccurrence;
 

package/lib/session-pair-factory.js

@@ -235,12 +235,12 @@ function attachPairFactory(ctx) {
     var request = args || {};
     var driverRuntime = preflightRuntime(request.driver || {}, "claude");
     var workerRuntime = preflightRuntime(request.worker || {}, null);
-    var driver = sm.createSessionRaw({ ownerId: ownerId || null, vendor: driverRuntime.vendor, model: driverRuntime.model, effort: driverRuntime.effort });
+    var driver = sm.createSessionRaw({ ownerId: ownerId || null, vendor: driverRuntime.vendor, model: driverRuntime.model, effort: driverRuntime.effort, hidden: request.hidden === true });
     var worker = null;
     try {
       driver.title = request.name ? request.name + " · Driver" : "Scheduled task · Driver";
       if (driverRuntime.explicitEffort) driver.loopSettings = { effort: driverRuntime.effort };
-      worker = sm.createSessionRaw({ ownerId: ownerId || null, vendor: workerRuntime.vendor, model: workerRuntime.model, effort: workerRuntime.effort });
+      worker = sm.createSessionRaw({ ownerId: ownerId || null, vendor: workerRuntime.vendor, model: workerRuntime.model, effort: workerRuntime.effort, hidden: request.hidden === true });
       worker.title = request.name ? request.name + " · Split Worker" : "Scheduled task · Split Worker";
       if (workerRuntime.explicitEffort) worker.loopSettings = { effort: workerRuntime.effort };
       sessionProvenance.markWorker(driver, worker, sm.sessions);

package/lib/sessions.js

@@ -177,6 +177,7 @@ function createSessionManager(opts) {
       if (session.loopInterviewHandoff) metaObj.loopInterviewHandoff = session.loopInterviewHandoff;
       if (session.scheduledTaskDraft) metaObj.scheduledTaskDraft = session.scheduledTaskDraft;
       if (session.scheduledTaskRun) metaObj.scheduledTaskRun = session.scheduledTaskRun;
+      if (session.hidden) metaObj.hidden = true;
       metaObj.sessionVisibility = sessionVisibility.normalize(session.sessionVisibility);
       if (session.sessionVisibilityExplicit) metaObj.sessionVisibilityExplicit = true;
       if (session.bookmarked) metaObj.bookmarked = true;
@@ -338,6 +339,7 @@ function createSessionManager(opts) {
       session.loopInterviewHandoff = m.loopInterviewHandoff && typeof m.loopInterviewHandoff === "object" ? m.loopInterviewHandoff : null;
       session.scheduledTaskDraft = m.scheduledTaskDraft && typeof m.scheduledTaskDraft === "object" ? m.scheduledTaskDraft : null;
       session.scheduledTaskRun = m.scheduledTaskRun && typeof m.scheduledTaskRun === "object" ? m.scheduledTaskRun : null;
+      session.hidden = m.hidden === true || !!session.scheduledTaskRun;
       session.terminalId = null;
       session.runtimeMode = null;
       session.runtimeTerminalId = null;
@@ -664,6 +666,7 @@ function createSessionManager(opts) {
       loopInterviewHandoff: null,
       scheduledTaskDraft: null,
       scheduledTaskRun: null,
+      hidden: !!(sessionOpts && sessionOpts.hidden),
       terminalId: null,
       sessionOriginId: null,
     };
@@ -711,6 +714,7 @@ function createSessionManager(opts) {
       loopInterviewHandoff: null,
       scheduledTaskDraft: null,
       scheduledTaskRun: null,
+      hidden: !!(sessionOpts && sessionOpts.hidden),
       terminalId: null,
       sessionOriginId: null,
     };

package/lib/ws-schema.js

@@ -81,6 +81,11 @@ var schema = {
   "scheduled_task_update":    { direction: "c2s", handler: "lib/project-scheduled-tasks.js", description: "Update an exact schedule revision" },
   "scheduled_task_cancel":    { direction: "c2s", handler: "lib/project-scheduled-tasks.js", description: "Cancel the active schedule interview or draft" },
   "scheduled_task_action_result": { direction: "s2c", handler: "lib/public/modules/scheduled-tasks.js", description: "Correlated create or edit result" },
+  "scheduled_task_results_state": { direction: "s2c", handler: "lib/public/modules/project-logs.js", description: "Authorized per-user unread Scheduled Tasks result state" },
+  "scheduled_task_result_created": { direction: "s2c", handler: "lib/public/modules/project-logs.js", description: "Live terminal Scheduled Tasks result notification" },
+  "scheduled_task_result_mark_read": { direction: "c2s", handler: "lib/project-logs.js", description: "Mark an exact displayed scheduled result read for the current user" },
+  "scheduled_task_result_open_session": { direction: "c2s", handler: "lib/project-logs.js", description: "Resolve the hidden Driver for an authorized scheduled result" },
+  "scheduled_task_result_session": { direction: "s2c", handler: "lib/public/modules/project-logs.js", description: "Authorized hidden scheduled Driver navigation target" },
   "search_results":           { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Session title search results" },
   "search_content_results":   { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Full-text content search results" },
   "fork_complete":            { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Fork succeeded, includes new session ID" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.1.0-beta.10",
+  "version": "4.1.0-beta.12",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"
@@ -8,8 +8,6 @@
   "scripts": {
     "dev": "node bin/cli.js --dev",
     "test": "node --test --test-force-exit test/*.test.js",
-    "prepack": "npm pkg delete bin.clay-dev",
-    "postpack": "npm pkg set bin.clay-dev=./bin/cli.js",
     "semantic-release": "semantic-release"
   },
   "files": [