samagotchi 0.158.0 → 0.159.0

data/lib/samagotchi/session_access/contract.rb

@@ -26,7 +26,7 @@ module Samagotchi
       # bin/chi subcommands that act on this machine: never sessions. chi
       # remote (this machine's list of remotes) runs here under a remote too
       # (Dispatch); the others are refused there.
-      MACHINE = %w[bootstrap update models desktop memory bundle guardrails toolkit judgments remote home project].freeze
+      MACHINE = %w[bootstrap update models desktop memory bundle guardrails toolkit judgments remote home project schedule].freeze
 
       # "command", "command sub" or either with a flag (its long name) →
       # SUPPORTED or LOCAL_ONLY. A LOCAL_ONLY command or subcommand lists

data/lib/samagotchi/session_access/local.rb

@@ -11,6 +11,7 @@ require_relative "../parent_report"
 require_relative "../note_delivery"
 require_relative "../image_store"
 require_relative "../context_candidates"
+require_relative "../worker_inbound"
 require_relative "../context_sources"
 require_relative "../archive_store"
 require_relative "../session_chain"
@@ -24,6 +25,7 @@ require_relative "../participants"
 require_relative "../config"
 require_relative "../live_versions"
 require_relative "../grants"
+require_relative "../log"
 require_relative "../web/info_probe"
 require_relative "../web/public_url"
 require_relative "../web/link_codes"
@@ -314,6 +316,16 @@ module Samagotchi
         before, written = attached.location.locked(name) do
           [attached.location.snapshot(name).revision, attached.location.record_text(name, fetched)]
         end
+        if fetched.wake && before != written.revision && !target.project? && attached.location.session? &&
+           attached.source.scope == "session"
+          begin
+            subscription = attached.location.subscription(name)
+            recent_wake = context_wake_recent?(subscription)
+            SessionManager.wake_for_context(target.session_id, **dir) unless recent_wake || Config.get("context.wake") == false
+          rescue StandardError => e
+            Log.exception(:context, "context_push_wake_failed", e, sid: target.session_id, source: name)
+          end
+        end
         ContextPush.new(status: :pushed, before: before, revision: written.revision)
       end
 
@@ -513,6 +525,14 @@ module Samagotchi
       def state_dir! = @state_dir || Session.default_state_dir
       def session_dir(id) = Session.session_dir(id, state_dir: state_dir!)
 
+      def context_wake_recent?(subscription)
+        return false unless subscription.wakes_at
+
+        Time.now - Time.iso8601(subscription.wakes_at) < WorkerInbound::CONTEXT_WAKE_WINDOW
+      rescue ArgumentError
+        false
+      end
+
       def attached_to(target, shadowed: false)
         ContextSources.attached(target.session_id, project_root: target.project_root, state_dir: @state_dir,
                                                    shadowed: shadowed)

data/lib/samagotchi/session_manager/spawn.rb

@@ -155,23 +155,37 @@ module Samagotchi
       # @return [Symbol] :woken, or why not (:gone, :stopped, :archived,
       #   :scratch, :owned, :starting)
       def wake_for_report(session_id, state_dir: nil, forward: true)
-        sd = state_dir || Session.default_state_dir
-        return :gone unless Session.exist?(session_id, state_dir: sd)
-        return :owned if session_owner(session_id, state_dir: sd)
-        return :stopped if Session.stopped_marker?(session_id, state_dir: sd)
+        wake_existing_session(session_id, state_dir: state_dir || Session.default_state_dir, forward: forward,
+                              event: :delegate_woke_parent)
+      end
+
+      # A pushed context source asked for a wake: start an idle-exited
+      # session, but never clear a stop or forward an archived link.
+      # @return [Symbol] :woken, or why not (:gone, :stopped, :archived,
+      #   :scratch, :owned, :starting)
+      def wake_for_context(session_id, state_dir: nil)
+        wake_existing_session(session_id, state_dir: state_dir || Session.default_state_dir, forward: false,
+                              event: :context_woke_session)
+      end
 
-        if ArchiveStore.archived?(Session.session_dir(session_id, state_dir: sd))
-          following = forward && SessionChain.next_of(session_id, state_dir: sd)
-          return following ? wake_for_report(following, state_dir: sd, forward: false) : :archived
+      private def wake_existing_session(session_id, state_dir:, forward:, event:)
+        return :gone unless Session.exist?(session_id, state_dir: state_dir)
+        return :owned if session_owner(session_id, state_dir: state_dir)
+        return :stopped if Session.stopped_marker?(session_id, state_dir: state_dir)
+
+        if ArchiveStore.archived?(Session.session_dir(session_id, state_dir: state_dir))
+          following = forward && SessionChain.next_of(session_id, state_dir: state_dir)
+          return following ? wake_existing_session(following, state_dir: state_dir, forward: false, event: event) : :archived
         end
-        return :starting if StartingMarker.fresh?(session_id, state_dir: sd)
+        return :starting if StartingMarker.fresh?(session_id, state_dir: state_dir)
 
-        session = Session.load(session_id, state_dir: sd)
+        session = Session.load(session_id, state_dir: state_dir)
         return :stopped if session.status == Session::STATUS_STOPPED
         return :scratch if session.scratch
 
-        resume_session(session_id, state_dir: sd)
-        Log.info(:worker, "delegate_woke_parent", parent: session_id[0, 8])
+        resume_session(session_id, state_dir: state_dir)
+        details = event == :delegate_woke_parent ? { parent: session_id[0, 8] } : { sid: session_id[0, 8] }
+        Log.info(:worker, event, **details)
         :woken
       rescue OwnedByTUI
         :owned

data/lib/samagotchi/session_manager/worker_command.rb

@@ -3,8 +3,8 @@
 module Samagotchi
   class SessionManager
     # CROSS-VERSION CONTRACT: this boot string, the entry it names
-    # (run_session_loop(id, state_dir:), the forwarder below), the env keys
-    # spawn_options sets and the input/ file
+    # (WorkerBoot.run_session_loop(id, state_dir:)), the legacy forwarder
+    # below, the env keys spawn_options sets and the input/ file
     # format are read by a NEWER chi than the one writing them. Change them
     # only additively (spec/worker_contract_spec.rb).
     BOOT_FALLBACK_ENV = "SAMAGOTCHI_BOOT_FALLBACK"
@@ -28,9 +28,9 @@ module Samagotchi
 
     # WorkerCommand: the worker's command line and env (CROSS-VERSION
     # CONTRACT: spec/worker_contract_spec.rb); the worker process itself is
-    # WorkerBoot (worker_boot.rb), which only the forwarder (run_session_loop)
-    # loads, as a worker boots. Calls no other part. Meant to be loaded
-    # through samagotchi/session_manager.
+    # WorkerBoot (worker_boot.rb). The boot command loads it directly; the
+    # forwarder (run_session_loop) remains for older boot strings. Calls no
+    # other part. Meant to be loaded through samagotchi/session_manager.
     module WorkerCommandPart
       # Build the opts hash passed to Process.spawn for a forked worker. The
       # child inherits this process's ENV and reads config.yml itself (as it
@@ -94,13 +94,13 @@ module Samagotchi
         opts
       end
 
-      # The worker's entry, the one every boot string names (CROSS-VERSION
-      # CONTRACT: spec/worker_contract_spec.rb): it only forwards to
+      # The worker's legacy entry for boot strings written by older chi
+      # (CROSS-VERSION CONTRACT: spec/worker_contract_spec.rb): it forwards to
       # WorkerBoot.run_session_loop, which runs the worker process. Looked up
       # by name on purpose: a constant reference here would put SessionManager
       # back into one cycle with Worker, Engine and Bridge (the class map).
-      # REMOVE one release after the boot string switches (see
-      # ~/.claude/plans/arch-worker-boot.md).
+      # REMOVE in the next release: boot strings name WorkerBoot since this
+      # one (see ~/.claude/plans/arch-worker-boot.md).
       def run_session_loop(session_id, state_dir: nil, **)
         require_relative "../worker_boot"
         Samagotchi.const_get(:WorkerBoot).run_session_loop(session_id, state_dir: state_dir, **)
@@ -118,8 +118,8 @@ module Samagotchi
       # there) keeps the plain -I lib: a worktree's bin/chi spawns its own code.
       def worker_command(session_id, state_dir:, gem_spec: InstalledGem.spec,
                          home: ChiHome.current(gem_spec: gem_spec))
-        boot = "require 'samagotchi/session_manager'; " \
-               "Samagotchi::SessionManager.run_session_loop('#{session_id}', state_dir: #{state_dir.inspect})"
+        boot = "require 'samagotchi/worker_boot'; " \
+               "Samagotchi::WorkerBoot.run_session_loop('#{session_id}', state_dir: #{state_dir.inspect})"
         return [RbConfig.ruby, "-I", File.expand_path("../..", __dir__), "-e", boot] unless gem_spec
         return home_worker_command(session_id, state_dir: state_dir, gem_spec: gem_spec, home: home) if home
 
@@ -146,9 +146,9 @@ module Samagotchi
                    else
                      "gem 'samagotchi', '>= 0.a'"
                    end
-        home.boot_argv(run: "begin; #{activate}; require 'samagotchi/session_manager'; " \
+        home.boot_argv(run: "begin; #{activate}; require 'samagotchi/worker_boot'; " \
                              "#{HOME_BOOT_FAILED.sub("SID", session_id)}; end; " \
-                             "Samagotchi::SessionManager.run_session_loop('#{session_id}', state_dir: #{state_dir.inspect})")
+                             "Samagotchi::WorkerBoot.run_session_loop('#{session_id}', state_dir: #{state_dir.inspect})")
       end
     end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -242,6 +242,8 @@ module Samagotchi
         when "task"
           task = id.delete_prefix(ClientId::TASK_PREFIX)
           return "task #{Tools::TaskRecord.short_id(task)} finished" unless task.empty?
+        when "schedule"
+          return "schedule"
         end
 
         prefix = id[/\A[^:]*:/]

data/lib/samagotchi/tool_declarations.rb

@@ -303,6 +303,49 @@ module Samagotchi
           properties: {}
         }
       },
+      {
+        name: "schedule_task",
+        description: "Register a durable schedule for this session: a prompt that runs on a clock outside the worker " \
+                     "(chi schedule tick, run by cron, systemd or chi web's hub). Unlike register_reminder it needs no " \
+                     "live worker and never holds one up. Give exactly one of every, weekday+time or date.",
+        parameters: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "A short name for the schedule" },
+            prompt: { type: "string", description: "What each firing does (non-empty, at most 16 KiB)" },
+            every: { type: "string", description: "Interval: \"30m\", \"2h\", \"1d\" (UTC math: drifts an hour across a DST change)" },
+            weekday: { type: "integer", description: "1=Mon … 7=Sun, used with time" },
+            time: { type: "string", description: "HH:MM in the machine's local zone (with weekday)" },
+            date: { type: "string", description: "One local moment: 2026-11-20T09:00" },
+            mode: { type: "string", description: "chain (default): the next link of this session's chain. same: a queued turn in this session" },
+            keep_links: { type: "integer", description: "Chain links to keep (default 5; 0 keeps all)" }
+          },
+          required: ["prompt"]
+        }
+      },
+      {
+        name: "list_schedules",
+        description: "List the durable schedules of this chain (all: true for every schedule on this machine): id, mode, recurrence, next due and target.",
+        parameters: {
+          type: "object",
+          properties: {
+            include_disabled: { type: "boolean", description: "Include the disabled schedules and the fired one-offs" },
+            all: { type: "boolean", description: "Every schedule on this machine, not just this chain" }
+          }
+        }
+      },
+      {
+        name: "cancel_schedule",
+        description: "Cancel a durable schedule of this chain by its id, a unique prefix of it, or its title (all: true for one from another chain).",
+        parameters: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "The schedule's id or title" },
+            all: { type: "boolean", description: "Allow cancelling a schedule of another session's chain" }
+          },
+          required: ["name"]
+        }
+      },
       {
         name: "list_sessions",
         description: "List the other chi sessions of this project (newest first, up to 20): id, whether a worker runs it, its folder and last prompt; other projects: cwd \"/\". Use it to find the session send_note should go to.",

data/lib/samagotchi/tools/builtin_calls.rb

@@ -47,6 +47,8 @@ module Samagotchi
         "web_fetch" => { content: "url", fallback: :prefix_or_raw },
         "register_reminder" => { content: "name", fallback: :prefix_or_raw },
         "cancel_reminder" => { content: "name", fallback: :prefix_or_raw },
+        "schedule_task" => { content: "prompt", fallback: :prefix_or_raw },
+        "cancel_schedule" => { content: "name", fallback: :prefix_or_raw },
         "list_sessions" => { fallback: :prefix, fallback_key: "cwd" },
         "send_note" => { content: "text" },
         "context_read" => { content: "name", fallback: :prefix_or_raw },

data/lib/samagotchi/tools/builtins.rb

@@ -18,6 +18,9 @@ require_relative "web_fetch"
 require_relative "register_reminder"
 require_relative "cancel_reminder"
 require_relative "list_reminders"
+require_relative "schedule_task"
+require_relative "list_schedules"
+require_relative "cancel_schedule"
 require_relative "list_sessions"
 require_relative "send_note"
 require_relative "context_read"
@@ -54,6 +57,9 @@ module Samagotchi
         RegisterReminder,
         CancelReminder,
         ListReminders,
+        ScheduleTask,
+        ListSchedules,
+        CancelSchedule,
         ListSessions,
         SendNote,
         ContextRead,
@@ -103,6 +109,17 @@ module Samagotchi
         end,
         CancelReminder::NAME => ->(call, kctx) { CancelReminder.call(call[:content], reminder_store: kctx.reminder_store) },
         ListReminders::NAME => ->(call, kctx) { ListReminders.call(call[:content], reminder_store: kctx.reminder_store) },
+        ScheduleTask::NAME => lambda do |call, kctx|
+          ScheduleTask.call(call[:content], title: call[:title], prompt: call[:prompt], every: call[:every],
+                            weekday: call[:weekday], time: call[:time], date: call[:date], mode: call[:mode],
+                            keep_links: call[:keep_links], peers: kctx.peers)
+        end,
+        ListSchedules::NAME => lambda do |call, kctx|
+          ListSchedules.call(call[:content], include_disabled: call[:include_disabled], all: call[:all], peers: kctx.peers)
+        end,
+        CancelSchedule::NAME => lambda do |call, kctx|
+          CancelSchedule.call(call[:content], all: call[:all], peers: kctx.peers)
+        end,
         ListSessions::NAME => ->(call, kctx) { ListSessions.call(call[:content], peers: kctx.peers, cwd: call[:cwd]) },
         SendNote::NAME => ->(call, kctx) { SendNote.call(call[:content], session: call[:session], peers: kctx.peers) },
         ContextRead::NAME => lambda do |call, kctx|

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/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/version.rb

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

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_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