samagotchi 0.158.0 → 0.160.0

data/lib/samagotchi/tools/cancel_schedule.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Tools
+    # Cancel a durable schedule of this session's chain by its id, a unique
+    # prefix of it, or its title (docs/scheduling.md). A schedule of another
+    # session's chain is refused unless the call says `all: true`: `chi
+    # schedule cancel` is the machine-wide way.
+    class CancelSchedule
+      NAME = "cancel_schedule"
+
+      def self.name = NAME
+
+      def self.call(content, all: false, peers: nil)
+        # Required here, not at the top of the file: the kit does not pay
+        # for the session lifecycle until a schedule is actually used.
+        require_relative "../schedules"
+        name = content.to_s.strip
+        return "Error: cancel_schedule needs the schedule's id or title" if name.empty?
+
+        want_all = all == true || all.to_s.strip.casecmp?("true")
+        schedules = Schedules.new(state_dir: peers&.state_dir)
+        entry = schedules.lookup(name)
+        return "No schedule named #{name}." if entry.nil?
+
+        if want_all || peers&.session_id.nil?
+          schedules.cancel(name)
+          return "Cancelled #{entry.id} (#{entry.title || entry.recurrence_words})."
+        end
+
+        unless schedules.chain_of(peers.session_id).any? { |id| id == entry.anchor || id == entry.head }
+          return "Error: #{entry.id} belongs to another session's chain. " \
+                 "chi schedule cancel #{entry.id} cancels it, or say all: true if you meant it."
+        end
+
+        schedules.cancel(name)
+        "Cancelled #{entry.id} (#{entry.title || entry.recurrence_words})."
+      rescue StandardError => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/context_read.rb

@@ -51,8 +51,13 @@ module Samagotchi
         @own = ContextSources.session_location(peers.session_id, state_dir: @state_dir)
         # The Engine's PeerView knows the session's project; a plain Peers
         # (specs, a bare kernel) has only its folder.
-        root = peers.respond_to?(:project_root) ? peers.project_root : ProjectScope.root_for(peers.cwd)
-        @attached = ContextSources.attached(peers.session_id, project_root: root, state_dir: @state_dir)
+        root, id = if peers.respond_to?(:project_root)
+                     [peers.project_root, peers.project_id]
+                   else
+                     found = ProjectScope.project_for(peers.cwd)
+                     [found&.root, found&.id]
+                   end
+        @attached = ContextSources.attached(peers.session_id, project_root: root, project_id: id, state_dir: @state_dir)
         @max_chars = [max_chars.to_i, MIN_CHARS].max
         @now = now
         # The peer bundles' declared sources (PeerSources), through the

data/lib/samagotchi/tools/delegate.rb

@@ -13,6 +13,10 @@ require_relative "../child_reports"
 require_relative "../worker_link"
 
 module Samagotchi
+  # Loaded on the first task (a leaf; the bundle test kit's load budget,
+  # spec/samagotchi/testing/sandbox_spec.rb).
+  autoload :CommandIntake, File.expand_path("../command_intake", __dir__)
+
   # Loaded on first use: this autoload keeps SessionManager and its ~80
   # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("../session_manager", __dir__)
@@ -53,6 +57,9 @@ module Samagotchi
 
         task = content.to_s.strip
         return "Error: give the task, the child's first message" if task.empty?
+        # The child's intake takes no shell line from its parent: say so
+        # now, so the model rewrites the task (a /word one is the child's text).
+        return "Error: #{CommandIntake::REFUSED}" if CommandIntake.shell_line?(task)
 
         sd = peers.state_dir || Session.default_state_dir
         parent = Session.load(peers.session_id, state_dir: sd)
@@ -172,7 +179,8 @@ module Samagotchi
                                  parent_answers: parent.parent_answers)
         child = SessionManager.spawn_session(prompt: task, working_directory: folder,
                                              model_name: child_model(model, parent), memories: CHILD_MEMORIES,
-                                             parent_id: parent.id, delegate: true, setup: setup, state_dir: state_dir)
+                                             parent_id: parent.id, delegate: true, setup: setup, state_dir: state_dir,
+                                             client_id: ClientId.delegate(parent.id))
         DelegateWait.mark_started(parent.id, child, state_dir: state_dir)
         # The line for a task that names a worktree while the child runs in
         # the parent's folder (no cwd: given): the child still starts.
@@ -358,7 +366,7 @@ module Samagotchi
 
         # Only a reply after this delivery counts as the follow-up's.
         DelegateWait.mark_seen(parent.id, child, state_dir: state_dir)
-        delivered = SessionManager.deliver_turn(id, prompt: task, client_id: "#{ClientId::DELEGATE_PREFIX}#{parent.id[0, 8]}",
+        delivered = SessionManager.deliver_turn(id, prompt: task, client_id: ClientId.delegate(parent.id),
                                                     state_dir: state_dir)
         case delivered.status
         when :accepted

data/lib/samagotchi/tools/list_schedules.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Tools
+    # The durable schedules of this session's chain (docs/scheduling.md): id,
+    # mode, recurrence, next due and target. Another session's schedules are
+    # out of reach unless the call says `all: true`; `chi schedule list` is the
+    # machine-wide view. Schedules is required inside the call, so the testing
+    # kit does not pay for the session lifecycle at load time.
+    class ListSchedules
+      NAME = "list_schedules"
+
+      def self.name = NAME
+
+      def self.call(_content, include_disabled: false, all: false, peers: nil)
+        # Required here, not at the top of the file: the kit does not pay
+        # for the session lifecycle until a schedule is actually used.
+        require_relative "../schedules"
+        wanted = include_disabled == true || include_disabled.to_s.strip.casecmp?("true")
+        want_all = all == true || all.to_s.strip.casecmp?("true")
+        schedules = Samagotchi::Schedules.new(state_dir: peers&.state_dir)
+
+        scoped = !want_all && peers&.session_id
+        entries = scoped ? schedules.for_chain(peers.session_id, include_disabled: wanted) : schedules.entries(include_disabled: wanted)
+
+        if entries.empty?
+          scoped ? "No schedules in this session's chain. `chi schedule list` shows every schedule on this machine." : "No schedules."
+        else
+          lines = entries.map do |entry|
+            flags = []
+            flags << "skips #{entry.skips} of #{entry.max_skips}" if entry.skips.positive?
+            flags << "disabled after #{entry.failures} failures" unless entry.enabled
+            "#{entry.id}  #{entry.target_words}  #{entry.recurrence_words}  next #{entry.next_due}  #{flags.join(", ")}".rstrip
+          end
+          lines << "These are this session's chain only; `chi schedule list` shows every schedule on this machine." if scoped
+          lines.join("\n")
+        end
+      rescue StandardError => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/schedule_task.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Tools
+    # Register a durable schedule for this session (docs/scheduling.md): a
+    # prompt that runs on a clock, out of the worker's memory, until it is
+    # cancelled. The default mode is `chain`: each firing is the next link of
+    # this session's chain, so a long-running routine keeps a fresh context.
+    # Unlike register_reminder, a schedule needs no live worker — a tick run by
+    # cron (or chi web's hub) wakes one — and it never holds an idle worker up.
+    class ScheduleTask
+      NAME = "schedule_task"
+
+      def self.name = NAME
+
+      def self.call(content, title: nil, prompt: nil, every: nil, weekday: nil, time: nil, date: nil,
+                    mode: nil, keep_links: nil, peers: nil)
+        # Required here, not at the top of the file: the kit does not pay
+        # for the session lifecycle until a schedule is actually used.
+        require_relative "../schedules"
+        return "Error: this session's id is not known here" unless peers&.session_id
+
+        prompt = content.to_s if prompt.to_s.strip.empty?
+        schedules = Schedules.new(state_dir: peers.state_dir)
+        entry = schedules.add(
+          target: peers.session_id, prompt: prompt, title: title,
+          recurrence: Schedules.recurrence(every: every, weekday: weekday, time: time, date: date),
+          mode: mode.nil? || mode.to_s.strip.empty? ? Schedules::CHAIN : mode.to_s.strip,
+          keep_links: keep_links
+        )
+        "Scheduled #{entry.id}: #{entry.target_words} · #{entry.recurrence_words} · next #{entry.next_due}. " \
+        "It fires outside this worker (chi schedule tick, run by cron or chi web's hub); " \
+        "chi schedule list and cancel_schedule show and stop it."
+      rescue Schedules::Usage, Session::NotFound, Session::AmbiguousId => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/samagotchi/turn_stages/context_judge.rb

@@ -89,7 +89,8 @@ module Samagotchi
       def pass(session, texts, phase:, state_dir:, recorder:)
         return if session.id.nil? || session.scratch
 
-        rows = ContextCandidates.with_status(session.id, project_root: session.project_root, state_dir: state_dir)
+        rows = ContextCandidates.with_status(session.id, project_root: session.project_root,
+                                                         project_id: session.project_id, state_dir: state_dir)
         return if rows.empty?
 
         log = ContextCandidatesLog.log_for(state_dir)
@@ -134,6 +135,7 @@ module Samagotchi
       def choice(session, log, settings, state_dir)
         session_id = session.id
         project_root = session.project_root
+        project_id = session.project_id
         show = lambda do |**card|
           current = @current_session.call
           next nil unless current.nil? || current.id == session_id
@@ -146,6 +148,7 @@ module Samagotchi
         end
         lambda do |job, fields|
           ContextCandidateChoice.after_judged(job: job, fields: fields, settings: settings, project_root: project_root,
+                                              project_id: project_id,
                                               state_dir: state_dir, log: log, show_card: show)
         end
       end
@@ -156,12 +159,9 @@ module Samagotchi
       def parent_attached(session, state_dir)
         return nil unless session.delegate? && session.parent_id
 
-        parent_root = if Session.exist?(session.parent_id, state_dir: state_dir)
-                        Session.load(session.parent_id, state_dir: state_dir).project_root
-                      else
-                        session.project_root
-                      end
-        ContextSources.attached(session.parent_id, project_root: parent_root, state_dir: state_dir)
+        parent = Session.exist?(session.parent_id, state_dir: state_dir) ? Session.load(session.parent_id, state_dir: state_dir) : session
+        ContextSources.attached(session.parent_id, project_root: parent.project_root, project_id: parent.project_id,
+                                                   state_dir: state_dir)
                       .map { |attached| attached.source.title || attached.name }
       rescue StandardError => e
         Log.warn(:context, "context_parent_attached_failed", error: e.class.name, msg: e.message.to_s[0, 200])

data/lib/samagotchi/update_command.rb

@@ -356,7 +356,7 @@ module Samagotchi
       notes = file_notes(row, update.name, update.to || update.from, update.merged, update.behind, update.trash_copy, earlier: earlier)
       case update.status
       when :would_update, :updated
-        notes = [adds(update.adds), *notes, replaced(update.replaced), *update.kept_own, update.note].compact
+        notes = [adds(update.added_files), adds(update.adds), *notes, replaced(update.replaced), *update.kept_own, update.note].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
       when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note, update.manifest].compact, changed: Array(update.merged).any?)
       when :skipped then skipped(row, [update.note, *notes].join("; "))
@@ -522,7 +522,7 @@ module Samagotchi
       row
     end
 
-    # A profile's new members: "+ btw".
+    # New memory files or profile members: "+ file".
     def adds(members)
       members.nil? || members.empty? ? nil : "+ #{members.join(", ")}"
     end

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.158.0"
+  VERSION = "0.160.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -1030,7 +1030,7 @@ module Samagotchi
 
         # One normal form for the decision, the mkdir and the realpath (a `..` after a symlink would differ).
         dir = File.expand_path(dir)
-        outcome = ProjectInit.call(dir, home: home)
+        outcome = ProjectInit.call(dir, home: home, state_dir: default_state_dir)
         return error_response(422, outcome.reason.to_s, outcome.message) if outcome.kind == :refused
 
         if outcome.kind == :git
@@ -1455,7 +1455,8 @@ module Samagotchi
         body = { session_id: id, sources: rows, can_add_url: ContextProviders.any? }
         # The candidates too, for chi context ls (no UI shows them yet).
         if full
-          body[:candidates] = ContextCandidates.with_status(id, project_root: session.project_root, state_dir: default_state_dir)
+          body[:candidates] = ContextCandidates.with_status(id, project_root: session.project_root, project_id: session.project_id,
+                                                            state_dir: default_state_dir)
                                                .map { |candidate, status| candidate.to_h.merge("name" => candidate.name, "status" => status) }
         end
         json_response(200, body)
@@ -1573,8 +1574,8 @@ module Samagotchi
       end
 
       def attached_context(session, shadowed: false)
-        ContextSources.attached(session.id, project_root: session.project_root, state_dir: default_state_dir,
-                                            shadowed: shadowed)
+        ContextSources.attached(session.id, project_root: session.project_root, project_id: session.project_id,
+                                            state_dir: default_state_dir, shadowed: shadowed)
       end
 
       # @return [ContextSources::Attached, nil]

data/lib/samagotchi/web/public/chains.js

@@ -128,10 +128,21 @@ export function chainLinks(list, id, nexts = nextsOf(list), byId = new Map(list.
   return links;
 }
 
+// Whether the chain's oldest link the page holds still names a link it does
+// not: a schedule's prune (docs/scheduling.md, keep_links) or a delete. The
+// walk stops there, so every count comes from the surviving root, and the page
+// says "earlier links pruned" rather than linking to a session that is gone.
+export function linksPruned(links, byId) {
+  const root = links[0];
+  return !!root?.continues && !byId.has(root.continues);
+}
+
 // The session page's neighbours of +id+: {prev, next}, each {id, session}
-// or null. +continues+: the open session's own `continues`, when the list
-// may not have caught up with it. A previous link the list doesn't hold
-// (deleted) is null: its link would open a not-found page.
+// or null, and +pruned+: the session's own `continues` names a link the list
+// does not hold (a schedule pruned it, or it was deleted). +continues+: the
+// open session's own `continues`, when the list may not have caught up with it.
+// A previous link the list doesn't hold is null: its link would open a
+// not-found page.
 export function chainNeighbours(list, id, { continues = null } = {}) {
   const self = list.find((s) => s.id === id);
   const prevId = self?.continues || continues || null;
@@ -139,7 +150,7 @@ export function chainNeighbours(list, id, { continues = null } = {}) {
   const prev = prevSession ? { id: prevId, session: prevSession } : null;
   const nextSession = nextsOf(list).get(id) || null;
   const next = nextSession ? { id: nextSession.id, session: nextSession } : null;
-  return { prev, next };
+  return { prev, next, pruned: !!prevId && !prevSession };
 }
 
 const pad = (n) => String(n).padStart(2, "0");
@@ -188,14 +199,22 @@ export function foldChains(fams, all, { fold = true } = {}) {
   let changed = false;
   for (const f of fams) {
     const links = chainLinks(all, f.head.id, nexts, byId);
+    const pruned = linksPruned(links, byId);
     if (links.length < 2) {
-      out.push(f);
+      // A chain pruned to one link is still a chain: its card carries the chip
+      // and the popover says what is behind it.
+      if (pruned) {
+        changed = true;
+        out.push({ ...f, chain: { links, at: 0, folded: fold, pruned } });
+      } else {
+        out.push(f);
+      }
       continue;
     }
     changed = true;
     const at = links.findIndex((s) => s.id === f.head.id);
     if (fold && links.slice(at + 1).some((s) => heads.has(s.id))) continue;
-    out.push({ ...f, chain: { links, at, folded: fold } });
+    out.push({ ...f, chain: { links, at, folded: fold, pruned } });
   }
   return changed ? out : fams;
 }
@@ -233,7 +252,8 @@ export function chainChipTemplate(f, { open = false } = {}) {
   const text = n === links.length ? `#${n}` : `#${n} of ${links.length}`;
   const earlier = at;
   const later = links.length - 1 - at;
-  const parts = [earlier ? `${earlier} earlier ${earlier === 1 ? "link" : "links"}` : "", later ? `${later} later` : ""].filter(Boolean);
+  const parts = [earlier ? `${earlier} earlier ${earlier === 1 ? "link" : "links"}` : "", later ? `${later} later` : "",
+    f.chain.pruned ? "earlier links pruned" : ""].filter(Boolean);
   const title = `Session chain: link ${n} of ${links.length} (${parts.join(", ")}); open the list`;
   const liveT = live ? html`<span class="cc-live"> · <span class="live-dot" aria-hidden="true"></span>${live} live</span>` : nothing;
   const waitingT = waiting ? html` · <span class="cc-waiting">${waiting} waiting</span>` : nothing;
@@ -275,7 +295,11 @@ export function chainRowsTemplate(f, { activeId = null, now = Date.now() } = {})
       date ? html`<span class=${date.length > 10 ? "cr-date timed" : "cr-date"}>${date}</span>` : nothing}<span class="fr-preview">${rowTitle(s, headTitle, byId)}</span>${
       rowBadgesTemplate(waiting, stopped, s.status)}${s.archived ? archivedBadge : nothing}</button></div>`;
   });
-  return html`<div class="family-rows chain-rows" role="list">${rows}</div>`;
+  const prunedRow = f?.chain?.pruned
+    ? html`<div class="chain-row chain-pruned" role="listitem"><span class="cr-n" aria-hidden="true">↩</span>
+      <span class="fr-preview">earlier links pruned</span></div>`
+    : nothing;
+  return html`<div class="family-rows chain-rows" role="list">${rows}${prunedRow}</div>`;
 }
 
 // What the page does with a refused continue (POST /api/sessions

data/lib/samagotchi/web/public/index.html

@@ -1384,7 +1384,7 @@ body.has-session.composer-folded #infoBar{border-top-color:transparent}
   /* One run: the groups' chips are the meta's. */
   #infoBar .meta .bar-group{display:contents}
   #infoBar .meta .bar-sep{display:none}
-  #infoBar .meta :is(.tools-chip,.notes-chip,.mem-chip,.ws-chip,.chain-link,.parent,.children-chip,.participants-chip,.dir,.ctx,.speed,.session-time,.worker-badge){display:none}
+  #infoBar .meta :is(.tools-chip,.notes-chip,.mem-chip,.ws-chip,.chain-link,.chain-pruned,.parent,.children-chip,.participants-chip,.dir,.ctx,.speed,.session-time,.worker-badge){display:none}
   #infoBar .info-actions{display:none}
   #infoBar .meta .status+.model{flex:0 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis}
   /* ⚙ alone, the start page's dot when the session set its own (its values in the tooltip and accessible name). */
@@ -1577,6 +1577,9 @@ body.no-glass :is(#familyPop,#chainPop){background:var(--bg-panel);-webkit-backd
 .chain-row .cr-date{font-family:ui-monospace,monospace;font-size:11px;color:var(--text-muted);white-space:nowrap;font-variant-numeric:tabular-nums}
 /* A row with its time (chainStamp): every row's date as wide, so the previews line up. */
 .chain-rows:has(.cr-date.timed) .cr-date{min-width:16ch}
+/* A chain pruned by a schedule (docs/scheduling.md): the popover's last line and the info bar say the earlier links are gone. */
+.chain-row.chain-pruned,.chain-row.chain-pruned .cr-n{color:var(--text-muted)}
+#infoBar .meta .chain-pruned{font-family:ui-monospace,monospace;font-size:11px;color:var(--text-muted);white-space:nowrap}
 /* The session page's links to the previous and the next link of its chain. */
 #infoBar .meta a.chain-link{text-decoration:none;font-family:ui-monospace,monospace;white-space:nowrap;color:var(--accent)}
 @media(hover:hover){#infoBar .meta a.chain-link:hover{background:var(--accent-bg)}}

data/lib/samagotchi/web/public/info_bar.js

@@ -98,10 +98,11 @@ export function infoBarHtml(bar) {
   if (!bar) return nothing;
   const memories = bar.memories || [];
   const setup = html`<button type="button" class="id" title=${`Session id ${bar.id}: click to copy it`}>${String(bar.id).slice(0, 8)}</button><span class=${bar.status ? `status ${bar.status}` : "status"}><span>${bar.status || ""}</span></span><span class=${`model${bar.model.mismatch ? " served-mismatch" : ""}`} title=${bar.model.title}>${bar.model.text}</span>${settingsChip(bar.settings)}${toolkitChip(bar.toolkit)}${bar.notes ? html`<span class="model notes-chip" title=${bar.notes.title}>${bar.notes.text}</span>` : nothing}${bar.workingSet ? workingSetChipTemplate(bar.workingSet.chip) : memories.length ? html`<span class="model mem-chip" title=${memChipTitle(memories)}>${memChipText(memories)}</span>` : nothing}`;
-  const related = !!(bar.chain?.prev || bar.chain?.next || bar.parent || bar.kids || bar.participants);
-  // The parent reads "↑ <short id>"; its title says "delegated by …".
+  const related = !!(bar.chain?.prev || bar.chain?.next || bar.chain?.pruned || bar.parent || bar.kids || bar.participants);
+  // A chain pruned by a schedule (docs/scheduling.md): the link before this one
+  // is gone, so there is nothing to link to — the bar says so instead.
   const relations = related
-    ? html`<span class="bar-sep" aria-hidden="true"></span><span class="bar-group relations">${bar.chain?.prev ? chainLinkTemplate(bar.chain.prev, PREV, "The previous link of this chain") : nothing}${bar.chain?.next ? chainLinkTemplate(bar.chain.next, NEXT, "The next link of this chain") : nothing}${bar.parent ? html`<a class="model parent" href=${sessionHash(bar.parent.id)} title=${bar.parent.title}>↑ ${String(bar.parent.id).slice(0, 8)}</a>` : nothing}${kidsTemplate(bar.kids)}${participantsChip(bar.participants)}</span>`
+    ? html`<span class="bar-sep" aria-hidden="true"></span><span class="bar-group relations">${bar.chain?.prev ? chainLinkTemplate(bar.chain.prev, PREV, "The previous link of this chain") : nothing}${bar.chain?.pruned && !bar.chain?.prev ? html`<span class="model chain-pruned" title="The links before this one were pruned by a schedule">↩ earlier links pruned</span>` : nothing}${bar.chain?.next ? chainLinkTemplate(bar.chain.next, NEXT, "The next link of this chain") : nothing}${bar.parent ? html`<a class="model parent" href=${sessionHash(bar.parent.id)} title=${bar.parent.title}>↑ ${String(bar.parent.id).slice(0, 8)}</a>` : nothing}${kidsTemplate(bar.kids)}${participantsChip(bar.participants)}</span>`
     : nothing;
   const telemetry = html`<span class="dir" title=${bar.dir || ""}><bdi>${bar.dir || ""}</bdi></span><span class="model ctx" title=${bar.ctx.tip}>${bar.ctx.text}</span>${bar.speed ? html`<span class=${`model speed${bar.speed.empty ? " empty" : ""}`} title=${bar.speed.tip}>${bar.speed.text}</span>` : nothing}<span class=${`model session-time${bar.clock ? "" : " empty"}`} title=${bar.clock ? "This session's time: its turns, and the running one" : "This session's time: no turn yet"}>${bar.clock || CLOCK_NONE}</span>${workerBadgeTemplate(bar.worker)}`;
   return html`<div class="meta"><span class="bar-group setup">${setup}</span>${relations}<span class="bar-sep" aria-hidden="true"></span><span class="bar-group telemetry">${telemetry}</span></div>`;

data/lib/samagotchi/web/public/turn_events.js

@@ -133,6 +133,9 @@ const CONTEXT_CLIENT = "context:";
 // A turn chi ran because a background task the session started finished
 // unseen: task:<task id> (the Worker's finish wake).
 const TASK_CLIENT = "task:";
+// A durable schedule's firing (chi schedule, the schedule tools):
+// system:schedule:<schedule id>.
+const SCHEDULE_CLIENT = "system:schedule:";
 
 // A task id as people read it: the random part a task_create id ends with
 // (it starts with the time), else its first 8 chars (TaskRecord.short_id).
@@ -149,6 +152,7 @@ export function clientLabel(clientId) {
   const id = String(clientId);
   if (id.startsWith(CONTEXT_CLIENT) && id.length > CONTEXT_CLIENT.length) return `context ${id.slice(CONTEXT_CLIENT.length)} changed`;
   if (id.startsWith(TASK_CLIENT) && id.length > TASK_CLIENT.length) return `task ${shortTaskId(id.slice(TASK_CLIENT.length))} finished`;
+  if (id.startsWith(SCHEDULE_CLIENT)) return "schedule";
   const colon = id.indexOf(":");
   return CLIENT_LABELS[id] || (colon >= 0 && CLIENT_LABELS[id.slice(0, colon + 1)]) || AUTOMATIC_LABEL;
 }

data/lib/samagotchi/web/session_access_routes.rb

@@ -101,7 +101,7 @@ module Samagotchi
           brief: true,
           session: { id: session.id, status: session.status, title: session.title,
                      display_title: session.display_title, project_root: session.project_root,
-                     working_directory: session.working_directory, model_name: session.model_name,
+                     project_id: session.project_id, working_directory: session.working_directory, model_name: session.model_name,
                      model_typed: session.model_typed, parent_answers: session.parent_answers,
                      owner: owner&.kind },
           pending_question: session.pending_question&.to_file
@@ -492,8 +492,8 @@ module Samagotchi
       # @raise [ArgumentError] no such session
       def context_target(id)
         session = session_access.show(id)
-        ContextCommand::Target.new(session_id: id, project_root: session.project_root, cwd: session.working_directory,
-                                   label: id[0, 8])
+        ContextCommand::Target.new(session_id: id, project_root: session.project_root, project_id: session.project_id,
+                                   cwd: session.working_directory, label: id[0, 8])
       end
     end
   end

data/lib/samagotchi/web/session_hub.rb

@@ -6,6 +6,7 @@ require "time"
 
 require_relative "../session"
 require_relative "../session_manager"
+require_relative "../schedules"
 require_relative "../bridge_client"
 require_relative "../worker_link"
 require_relative "../config"
@@ -105,6 +106,7 @@ module Samagotchi
         @dir_mtime = nil    # the state dir's mtime at the last glob
         @root_cache = {}    # folder → project root, for sessions saved before project_root
         @next_full_probe = nil
+        @next_schedule_tick = nil
         @wakeup = Queue.new # stop wakes the tick thread out of its sleep
         @thread = nil
         @stopped = false
@@ -148,6 +150,8 @@ module Samagotchi
             check_installed
           end
         end
+        # Outside the projection's lock: a firing can wait for a recap.
+        schedule_tick
         nil
       end
 
@@ -314,6 +318,22 @@ module Samagotchi
         nil
       end
 
+      # chi web can be the scheduler when the user opts in (schedule.auto_tick):
+      # the same tick cron runs, gated by schedule.tick_interval_minutes and
+      # sharing schedules.lock, so cron and the hub never both fire.
+      def schedule_tick
+        return unless Config.get("schedule.auto_tick")
+
+        now = @now.call
+        return if @next_schedule_tick && now < @next_schedule_tick
+
+        @next_schedule_tick = now + (Samagotchi::Schedules.tick_interval_minutes * 60)
+        Samagotchi::Schedules.new(state_dir: @state_dir).tick
+      rescue StandardError => e
+        Log.warn(:web, "schedule_tick_failed", error: e.class.name, msg: e.message)
+        nil
+      end
+
       # A change (the first look too, unless it finds nothing) is a `chi`
       # event: chi web's terminal line and the open tabs hear it.
       def check_installed

data/lib/samagotchi/worker.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "securerandom"
 
 require_relative "client_id"
+require_relative "command_intake"
 require_relative "config"
 require_relative "engine"
 require_relative "guardrails/parent_policy"
@@ -338,7 +339,7 @@ module Samagotchi
                                         predecessor: @session.continues)
       # Its attached context's notes (ContextSources).
       @context_absorber = ContextAbsorber.new(session_id: @session_id, state_dir: @state_dir,
-                                              project_root: @session.project_root,
+                                              project_root: @session.project_root, project_id: @session.project_id,
                                               peer_sources: @engine.peer_sources, peer_turns: -> { @wakes.peer_turns })
       # What comes in between turns, and how each kind is saved.
       @inbound = WorkerInbound.new(session: @session, state_dir: @state_dir, session_dir: @session_dir, engine: @engine,
@@ -374,7 +375,9 @@ module Samagotchi
                              # chi web's Stop asks about these before TERMed-ing
                              # the worker (its own holds routes).
                              on_holds: -> { @idle_exit&.stoppable_holds },
-                             on_holds_stop: -> { @hold_stop&.stop_all })
+                             on_holds_stop: -> { @hold_stop&.stop_all },
+                             # `chi schedule tick` asks this before firing.
+                             on_activity: method(:activity_snapshot))
       # What failed to load and what plugins showed as they loaded, now that
       # a UI can be there (a late one gets them in the snapshot).
       @engine.announce_load_events!
@@ -410,12 +413,12 @@ module Samagotchi
     #   there is no live SSE or in-process cancel/answer).
     # @param on_input [#call, nil] called after the Bridge queues a turn
     def start_bridge(engine:, state_dir:, session_id:, on_input: nil, on_command: nil, on_exit_request: nil,
-                     exit_discards: nil, exit_stopped: nil, on_holds: nil, on_holds_stop: nil)
+                     exit_discards: nil, exit_stopped: nil, on_holds: nil, on_holds_stop: nil, on_activity: nil)
       require_relative "bridge"
       Samagotchi::Bridge.new(
         engine: engine, state_dir: state_dir, session_id: session_id, input_format: SessionInbox::INPUT_FORMAT,
         on_input: on_input, on_command: on_command, on_exit_request: on_exit_request, exit_discards: exit_discards,
-        exit_stopped: exit_stopped, on_holds: on_holds, on_holds_stop: on_holds_stop
+        exit_stopped: exit_stopped, on_holds: on_holds, on_holds_stop: on_holds_stop, on_activity: on_activity
       ).start
     rescue StandardError => e
       Log.error(:bridge, "start_failed", echo: "Bridge: failed to start for session #{session_id}: #{e.class}: #{e.message}", sid: session_id, error: e.class.name)
@@ -426,6 +429,22 @@ module Samagotchi
       Degrade.call(:config, "idle_exit_minutes_unreadable") { Samagotchi::Config.get("session.idle_exit_minutes") }
     end
 
+    # What this worker is busy with right now, for GET /activity: the same
+    # signals WorkerIdleExit#hold reads. A schedule never holds a worker up,
+    # so +reminders+ and +tasks_holding+ are reported for the log but are not a
+    # reason for a tick to skip a firing.
+    # @return [Hash]
+    def activity_snapshot
+      {
+        turn_running: @engine.turn_running?,
+        input_pending: input_pending?,
+        awaiting_continue: @turn_flow.awaiting_continue?,
+        open_streams: @bridge&.open_streams.to_i,
+        reminders: @engine.reminder_store&.any? ? 1 : 0,
+        tasks_holding: Degrade.call(:worker, "activity_tasks_unreadable") { @task_wakes&.watch&.holding&.size.to_i }
+      }
+    end
+
     # The delegate children of this session that are running a turn or have
     # a live worker. ChildrenStatus.of scans the session files; this runs on
     # an exit request, not every pass.
@@ -450,8 +469,8 @@ module Samagotchi
       # Attached context's commands, in the background; a new text wakes
       # the loop to absorb it. Not activity: the idle exit stops it.
       @context_poller = ContextPoller.new(session_id: @session_id, state_dir: @state_dir,
-                                          project_root: @session.project_root, cwd: @session.working_directory,
-                                          on_change: -> { @waker.wake }).start
+                                          project_root: @session.project_root, project_id: @session.project_id,
+                                          cwd: @session.working_directory, on_change: -> { @waker.wake }).start
       @scratch_watch = start_scratch_watch if @session.scratch
     end
 
@@ -741,14 +760,15 @@ module Samagotchi
     end
 
     # The first prompt (spawn_session's): a delegate child's task, which is
-    # its parent's although no client sent it. Its turn carries the id
-    # spawn_session gave it, so a wait for it (--new --wait) names it.
+    # its parent's. Its turn carries the id spawn_session gave it, so a
+    # wait for it (--new --wait) names it, and its sender
+    # (WorkerInbound#initial_origin).
     # A Verify fresh child's is a Verify turn on its claim (its verdict is
     # recorded and forwarded to the parent).
     def run_initial_prompt(prompt)
       @initial_turn = true
       fresh = @session.verify_fresh
-      run_prompt(WorkerInbound::Prompt.new(text: prompt, origin: TurnOrigin.new(enqueued_id: @session.first_turn_id),
+      run_prompt(WorkerInbound::Prompt.new(text: prompt, origin: @inbound.initial_origin,
                                            anchors: { verify: fresh&.anchor }))
     ensure
       @initial_turn = false
@@ -1033,9 +1053,9 @@ module Samagotchi
                kept: "Its note stays for the user's next message.", mark: task_wake)
     end
 
-    # The idle loop's sleep: the fallback tick, or less while reports wait
-    # out the start grace.
-    def idle_wait = @wakes.idle_wait(@poll_interval) { wake_state == :due }
+    # The idle loop's sleep: the fallback tick, or less while reports or
+    # attached-context wakes wait out the start grace.
+    def idle_wait = @wakes.idle_wait(@poll_interval) { wake_state == :due || @inbound.context_wake_waiting? }
 
     # The wake budget is spent: the parent's UIs hear once that reports
     # wait for the next message.
@@ -1197,6 +1217,8 @@ module Samagotchi
     #   the cards and notices it showed, held: they follow its command_ran,
     #   as its output
     def run_command_line(command)
+      return [shell_refused(command), []] if CommandIntake.refused?(command.line, command.client_id)
+
       @engine.holding_announcements do
         command_result(command) do
           @commands.run(command.line, confirm: confirm?(command), as_parent: as_parent?(command), user_ui: user_ui?(command))
@@ -1204,6 +1226,14 @@ module Samagotchi
       end
     end
 
+    # A shell line from a sender that may not run one (CommandIntake: a
+    # delegate's task, a schedule's prompt, a plugin's message): not run,
+    # its command_ran an error with the one refusal text.
+    def shell_refused(command)
+      Log.warn(:worker, "shell_line_refused", client_id: command.client_id)
+      SessionCommands::Result.new(status: :error, output: CommandIntake::REFUSED, changed: [])
+    end
+
     # Whether +command+ asks before a costly /thinking or /reasoning-history
     # change (CacheConfirm): only a person at a web tab or a TUI sees the
     # question; chi send, a delegate, a plugin and a card's action apply it.