samagotchi 0.47.0 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31cacb8f3d63a915a92684dcac667920837f96675f9c4256e3962cbfd95df5ef
-  data.tar.gz: 29668be85fcc4178f470f15d8f2a1d1745cccb2a4e0391649ef85f8b5a5ad9bd
+  metadata.gz: b751e52e486a5e301e85e8dd0557b9786fc240d59becf71152eaee6b97c2176e
+  data.tar.gz: 1be48dc0d3898135b44b56bab594ee4af910669512b584c6d408536ed14f47bb
 SHA512:
-  metadata.gz: e4c46bb7eee9e046679b9d4ca15540b17f6b1e15f92756c3c55d7733fb8d313b3e5b12b5077027950dc7f1671d46a11d6aaac1aa72ce3d4668475e87aa0ebea3
-  data.tar.gz: 86e41f7cd8fe707cc8ad6914a72ce183b824f86d6bbc4c953a356ff9d5709776e49c0b254734f2e675061de8d26c2c66bfcd538fe9d8f28f5f4d7d727b7decbc
+  metadata.gz: 0b3d59478632ccee06384d6844b7a7e5d21dcc0e90042056d305a4763272f0ed1b1d0e9c7559fe7296915bc07c62148417883ad7084c18c488bd5d522f1e7f72
+  data.tar.gz: 726ae060c0f5f0b0c9238b24aa15601431b0648e297cba8709e9943f1e257da447009bea82b669178c859080ed79d2a25dc60ccc805b429f95bf0e7b0ba36839

data/CHANGELOG.md

@@ -8,6 +8,22 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.48.0] - 2026-10-09
+
+### Changed
+
+- Continuing a session moves its open delegates to the new link instead of refusing: running, waiting, live or with
+  an unreported reply, at any depth below. They stay unarchived, fold under the new link, and their reports (one
+  each, none lost or repeated) reach it; each gets a note naming its new parent. Only a delegate on an older chi's
+  worker (restart it) or open in a chi REPL still refuses the continue. See
+  [docs/sessions.md](docs/sessions.md#session-chains).
+  - Web: the continue toast counts the delegates that moved (`1 open delegate moved`); `POST /api/sessions` with
+    `continues` answers `moved: [ids]`.
+  - CLI: `chi send --new --continues` prints `started (continues 3fa2c1d0; 2 delegates moved)`.
+
+Update with `chi update` (no bundle changed), then restart `chi web`. A delegate whose worker started on an older
+chi refuses to move until it is restarted.
+
 ## [0.47.0] - 2026-10-09
 
 ### Added
@@ -2215,7 +2231,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.47.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.48.0...HEAD
+[0.48.0]: https://github.com/dm1try/samagotchi/compare/v0.47.0...v0.48.0
 [0.47.0]: https://github.com/dm1try/samagotchi/compare/v0.46.1...v0.47.0
 [0.46.1]: https://github.com/dm1try/samagotchi/compare/v0.46.0...v0.46.1
 [0.46.0]: https://github.com/dm1try/samagotchi/compare/v0.45.0...v0.46.0

data/docs/sessions.md

@@ -182,7 +182,7 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
 - Exit codes with `--wait`: 0 answered; 3 the turn waits for an answer from you (a question, a hook's question, a guardrail approval, or the step-limit question: see [chi as a sub-agent](sub-agent.md#the-step-limit)), and the session keeps waiting: stderr gets the whole question (`waiting for an answer (approval): …`, its text, the numbered options, whether free text is allowed) and how to answer it (`chi answer ID --question QID --option N`, or `chi --attach ID`, the web); 4 `--timeout S` passed with the turn still running (it goes on; wait again); 1 the turn ended without a reply (canceled, failed or empty), the worker failed or vanished, or the session was stopped; 130 on Ctrl-C, which leaves the turn running (`still running: chi --attach ID`). There is no default timeout.
 - `--format json` (with `--wait`) prints one JSON object on stdout however the wait ends, for a script or a parent agent (see [chi as a sub-agent](sub-agent.md)): `{"status":"answered","session_id":…,"text":…}`; `{"status":"question",…,"question":{"id","kind","header","text","options","multi_select","allow_freeform","approval"},"answer_with":"chi answer ID --question QID --option N"}`, where `kind` is `question` (the model's), `hook` or `approval` (with the tool, command, cwd, rule, reason and offered scopes); `{"status":"running",…,"detail":…}` (exit 4, and on Ctrl-C); and `failed`, `canceled`, `no_answer`, `error`, `worker_gone` or `stopped` with a `detail` line (exit 1); `failed` adds `error_kind` and `retryable`, `canceled` adds `cancel_reason` and `stopped_by`, when known. A failure before the wait (no such session, a busy one) is `error` too. A usage error (exit 2) prints no JSON.
 - `--wait ID` with no message (no `-m`, nothing piped) sends nothing: it waits for the session's next reply and prints and exits as above. A running session is fine (that is the point), so after exit 3, 4 or 130 an agent waits again this way while the user answers in the web or `chi --attach`; the question pending when it starts doesn't count again. An idle session with no worker waits until something wakes one. With `--new`, or two ids, it is a usage error (exit 2).
-- `--continues ID` (with `--new`) starts the next link of that session's chain instead (see *Session chains*): in its folder, on its model and LLM context, so `--dir`, `--model` and `--llm-context*` are refused beside it; `ID` may be a prefix or `last:ID`, the chain's latest link. Without a message the new link starts idle; `--wait` then has nothing to wait for (a usage error). It prints `<full id>  started (continues 3fa2c1d0)`; a refusal (continued already, naming the next link; a delegate still open; a turn running) is `chi send: refused: …`, exit 1.
+- `--continues ID` (with `--new`) starts the next link of that session's chain instead (see *Session chains*): in its folder, on its model and LLM context, so `--dir`, `--model` and `--llm-context*` are refused beside it; `ID` may be a prefix or `last:ID`, the chain's latest link. Without a message the new link starts idle; `--wait` then has nothing to wait for (a usage error). It prints `<full id>  started (continues 3fa2c1d0)`, with `; 2 delegates moved` inside the parentheses when open delegates moved to it; a refusal (continued already, naming the next link; an open delegate that can't move; a turn running) is `chi send: refused: …`, exit 1.
 - The 16 KiB cap applies: `git diff | chi send --new …` on a big diff is refused; name the branch in the message instead and let the session read it.
 - A session nobody attaches to stalls at its first question or guardrail ask until someone answers it (`chi answer`, the web, `chi --attach`), and its worker stays up meanwhile: it doesn't idle-exit while a question waits (`chi sessions list` shows it as `waiting`; `chi sessions stop ID` frees it). Otherwise it idle-exits after `session.idle_exit_minutes` like any worker. These are ordinary sessions: delete them like any other.
 
@@ -195,10 +195,12 @@ A session can **continue** an earlier one: "the next day of the same routine" (a
 - **What it copies:** the previous link's folder, its model (the name it was typed as, so an alias holds) and its own LLM context values. Its preview is the previous link's (until its first message is saved), unless it starts with a message.
 - **The carry note:** the new link starts with a context note from `session chain` (shown in its transcript as `note from session chain`), queued before its worker spawns, so its first turn sees it: `This session continues 3fa2c1d0 (2026-10-08), the previous link of its chain. Its recap, as of 2026-10-08 18:02:` and the previous link's recap (`recap.json`; cut at 8000 characters). No recap (fewer user turns than a recap needs, recaps off, none written in time): `… It left no recap.` Never more than the recap: no transcript. An idle new link holding only the note is kept, not discarded as empty.
 - **The recap first:** a previous link with a live worker is asked for a recap (the Bridge's `POST /recap`) and given up to 30 s to write it; one with none wrote its recap when its worker left.
-- **The previous link is archived** before the new one starts, by the archive's own rules (see *Archiving a session*): a turn running, a prompt queued or the step-limit question refuse it, a live idle worker is stopped, a plain REPL's session is refused. Its delegates are archived with it, as any archive does; so a continue is **refused while a delegate is still open** (at any depth, checked again after the recap wait): running, waiting for an answer, with a live worker, or with a reply its parent wasn't given (`ContinueRefused`, naming them). Wait for them, stop or archive them, then continue.
+- **The previous link is archived** before the new one starts, by the archive's own rules (see *Archiving a session*): a turn running, a prompt queued or the step-limit question refuse it, a live idle worker is stopped, a plain REPL's session is refused. Its finished delegates are archived with it, as any archive does.
+- **Its open delegates move to the new link** instead: each direct delegate that is running, waiting for an answer, has a live worker or a reply its parent wasn't given, or has such a delegate below it (checked again after the recap wait, so one delegated meanwhile moves too). It moves with its own delegates, stays unarchived, and from then on is the new link's: its card folds under the new link, its reports ring the new link (an idle one runs a wake turn for them, as for its own delegates), `delegate_result` and the `⑂` chip count it there, and what its parent was already told (`delegates.json`) and any report still waiting come along, so nothing is reported twice. A moved delegate gets a context note from `session chain`, `Your parent session is now 4b7e9a01 (…), the next link of its session chain: …`, as its system prompt keeps naming the parent it started with. The move writes `<child>/parent.json` (`{parent_id, from, at}`) beside the child's session file, never the file itself, so a live child worker saving its own copy changes nothing; every reader applies it (a later move overwrites it; it is never removed). A continue is **refused for an open delegate that can't move** (`ContinueRefused`, naming it): one whose live worker runs an older chi (`older chi worker 0.46.1; restart it`: `chi sessions restart <id>`, or stop it) or that is open in a chi REPL (close it there). An older `chi web` or CLI still running shows a moved delegate under the archived link until it is restarted.
+- **If the continue fails part-way:** a new link that fails to start gives its moved delegates back before it is deleted (each gets a note saying so; its worker is stopped first, if one started, and a worker that won't stop is reported, the link left), with any report one of them rang it with meanwhile; the previous link, back in the lists, is woken for reports waiting. A continue that dies in the middle leaves a `move.json` in the new link's folder: the new link's next worker finishes that move (only the delegates it names) as it starts. Until the new link's own worker holds it, a ring from a moved delegate doesn't start another (a `starting` marker in its folder, which that worker removes; a stale one, over 60 s old or from a process that is gone, is ignored). An open delegate below an archived delegate refuses the continue (`under archived …`): unarchive that one, or archive this one.
 - **Refused too:** a link that is continued already (naming the link that continues it; continue that one, or `last:<id>`), a previous link whose folder is gone, and one whose model names a host config.yml no longer has. A refusal starts nothing and archives nothing; a new link that fails to start puts back what was archived. Every refusal that can be known up front (the archive's ones included) comes before the recap wait. One continue of a session runs at a time (a lock in its folder; other chains don't wait), so a double click finds the first one's link and is refused, while a `last:<id>` continue that waited follows the chain to its new end.
-- **Web:** `POST /api/sessions` takes `continues: "<id, prefix or last:id>"`, with `idle: true` (a new link waiting for its first message, previewed by the previous link's, or `preview`) or a `prompt`, and not `dir`, `model` or `llm_context` (400 `invalid_continues`: the previous link's are taken). 201 is the new session's summary, `continues` set; 404 `not_found`; 400 `ambiguous_id` for a prefix of several sessions, `invalid_model` for a model whose host is gone; 409 `continued` with `next_id` (the link that continues it already, which the page opens instead), `open_children` with `ids`, `folder_gone`, `busy`, `scratch` or `owned_by_tui`. Every session summary carries `continues`.
-- **The page:** the info bar's `continue →` continues the open session (`continues: <id>, idle: true`; it reads `continuing…` through the recap wait) and opens the new link with `Continue where we left off.` in the composer, not sent (the same line for every chain; a draft already there stays instead); the previous link is archived, a toast says so. A link continued already has no `continue →`: its `→` link goes to the next link (a stale page's continue answered 409 `continued` opens `next_id`). A continue refused for open delegates shows a toast that names each one (its preview and why the server says it is open: `running`, `waiting`, `live`, `unreported reply`), each a link to its page; any other refusal shows the server's words. The info bar of a link carries `← 2026-10-08` (the previous link's day) and, on an earlier link, `2026-10-10 →`, each a link with its preview and id in the tooltip. A link whose title is the opener and nothing else (its first message once sent) shows its chain's first link's title instead, on its card, in the popover and in its info bar's title line, display only (its messages and data keep the opener; its own title when the first link is gone). The lists fold a chain into the card of its latest listed link, whatever the earlier links' archived state (typing in an archived link brings it back, folded there still), their delegates with them: the card's `↩ day N` chip (`day N of M` when later links aren't listed) opens a popover of the other links, newest first (`day N`, its date, its recap's first sentence or its preview, `archived`), a click opens one; the chip shows a live dot or `waiting` for a link that has a worker or waits on the user, and a waiting link puts its chain's card first. All sessions folds nothing while a search is typed or "include archived" is on: every link is a card of its own then, its chip `day N of M`, with its own delegates folded in, so a search finds an earlier link and its delegates.
+- **Web:** `POST /api/sessions` takes `continues: "<id, prefix or last:id>"`, with `idle: true` (a new link waiting for its first message, previewed by the previous link's, or `preview`) or a `prompt`, and not `dir`, `model` or `llm_context` (400 `invalid_continues`: the previous link's are taken). 201 is the new session's summary, `continues` set, with `moved`: the ids of the delegates that moved to it (`[]` for none); 404 `not_found`; 400 `ambiguous_id` for a prefix of several sessions, `invalid_model` for a model whose host is gone; 409 `continued` with `next_id` (the link that continues it already, which the page opens instead), `open_children` with `ids` (open delegates that can't move), `folder_gone`, `busy`, `scratch` or `owned_by_tui`. Every session summary carries `continues`.
+- **The page:** the info bar's `continue →` continues the open session (`continues: <id>, idle: true`; it reads `continuing…` through the recap wait) and opens the new link with `Continue where we left off.` in the composer, not sent (the same line for every chain; a draft already there stays instead); the previous link is archived, a toast says so (`Continued 3fa2c1d0 in 4b7e9a01; 3fa2c1d0 is archived; 1 open delegate moved`), and a moved delegate's card folds under the new link. A link continued already has no `continue →`: its `→` link goes to the next link (a stale page's continue answered 409 `continued` opens `next_id`). A continue refused for open delegates that can't move shows a toast that names each one (its preview and what the server says to do: `older chi worker 0.46.1; restart it`, `open in a chi REPL; close it there`), each a link to its page; any other refusal shows the server's words. The info bar of a link carries `← 2026-10-08` (the previous link's day) and, on an earlier link, `2026-10-10 →`, each a link with its preview and id in the tooltip. A link whose title is the opener and nothing else (its first message once sent) shows its chain's first link's title instead, on its card, in the popover and in its info bar's title line, display only (its messages and data keep the opener; its own title when the first link is gone). The lists fold a chain into the card of its latest listed link, whatever the earlier links' archived state (typing in an archived link brings it back, folded there still), their delegates with them: the card's `↩ day N` chip (`day N of M` when later links aren't listed) opens a popover of the other links, newest first (`day N`, its date, its recap's first sentence or its preview, `archived`), a click opens one; the chip shows a live dot or `waiting` for a link that has a worker or waits on the user, and a waiting link puts its chain's card first. All sessions folds nothing while a search is typed or "include archived" is on: every link is a card of its own then, its chip `day N of M`, with its own delegates folded in, so a search finds an earlier link and its delegates.
 - **CLI:** `chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT]` (see *Starting a session*).
 - **Which link:** an id, a unique prefix, or `last:<id or prefix>`, the latest link of the chain that session is in. It walks the links that still exist: a deleted link in the middle (`chi sessions delete`, the retention sweep of an unarchived one) ends the walk before it, so `last:` of an earlier link then names that earlier link, and continuing it starts a second line beside the links after the gap; name a link after the gap instead. A trigger names the chain this way: `chi send` to an archived link would bring it back (a human's input), not continue the chain.
 
@@ -219,7 +221,7 @@ The `delegate` tool hands a task to a **child session**: an ordinary chi session
   - No relay where the parent can't host one (a `--no-shared` REPL, `--non-interactive`) or isn't waiting (`wait: false` until the next `delegate_result`): the approval waits on the child, with the web's bell, and the result's question block says to deny it or leave it for the user. The model's own questions and hooks' questions come back to the model as before. A grandchild's (a plugin's `ctx.sessions.fork` can make one) is relayed hop by hop: `delegate ab12 → cd34 asks:`.
 - **Delegate reports: a child's reply comes back by itself.** When a child ends a turn that was its parent's (its task, a follow-up, a continue the parent answered, a reminder: not a turn its user typed into it directly), it rings the parent: a small file in the parent's `children/` dir, written after the child's turn is saved. So does a question the parent's model decides (the child's own `ask_user_question`, the step-limit continue; not an approval or a hook's question, which the user answers on the child's card), the turn after such a question whoever starts it, and the child's worker crashing. The parent reads the child as `delegate_result` would and hands its model a **report**: the same text (`session:`, `status:`, the reply), under its own header (`[Delegate report, delivered by chi …; not your user's message. Tell your user what it found …]`), as an input message with `source: "delegate_report"`.
   - Parent mid-turn: the report joins the turn at its next iteration boundary (a "delegate report" bubble in the web, `delegate report> ab12cd34 answered: …` in the attached terminal).
-  - Parent idle: it runs a turn for the report (a *wake turn*, `last_turn.origin: "delegate_report"`) within the worker's 5 s tick, or wakes a worker for it when the parent's has idle-exited. Several reports that wait together are one turn and one message. A stopped, archived or scratch parent, or one open in a `--no-shared` REPL, is not woken: the rings wait on disk and join the next turn it runs (the user's message first). A worker just started (`chi send` to a stopped parent) runs no wake turn in its first 2 s, so the message it was started for goes first.
+  - Parent idle: it runs a turn for the report (a *wake turn*, `last_turn.origin: "delegate_report"`) within the worker's 5 s tick, or wakes a worker for it when the parent's has idle-exited. Several reports that wait together are one turn and one message. A stopped, archived or scratch parent, or one open in a `--no-shared` REPL, is not woken: the rings wait on disk and join the next turn it runs (the user's message first). An archived parent that a later link continues wakes that link instead, which takes the rings its moved delegates left there (see *Session chains*). A worker just started (`chi send` to a stopped parent) runs no wake turn in its first 2 s, so the message it was started for goes first.
   - The parent's cursor per child (the newest reply it was given and the child as it was then) is in its `delegates.json`, shared with `delegate_result` and `wait: true`: a reply the model already had is never reported again, also after the parent's worker restarts. A ring is deleted only when the turn that took its report stays in the conversation (completed, canceled, or failed but kept: one that got to tool steps, or a reminder or continue turn, which keep what they read); a turn rolled back (a failed one that got nowhere, a canceled continue turn) leaves it for the next one (and the report isn't handed back to the composer). So the model reads each report once, unless a later `!rollback` erases a kept turn (what it read goes with it).
   - Limits: `session.max_wakes` (default `10`) wake turns in a row with no human input; past it the reports wait for the next message and the UIs show `N delegate reports waiting; they join your next message`. A wake turn that fails, or is stopped before the model call (a Stop, a `before_turn` hook's cancel), pauses wakes until the next human input; its reports' rings stay, so they join that input's turn, and a failure's note tells the model so. A continue offer waiting in the parent takes the reports into its continue turn instead.
   - `session.delegate_reports`: `wake` (default), `queue` (no wake turns: reports join the parent's next turn) or `off` (no rings; only `delegate_result` asks, as before). Env `SAMAGOTCHI_SESSION_DELEGATE_REPORTS`, `SAMAGOTCHI_SESSION_MAX_WAKES`.

data/lib/samagotchi/bridge.rb

@@ -474,7 +474,9 @@ module Samagotchi
     # than a version.
     # restart: POST /exit takes "restart": true (WorkerIdleExit#hold_for_restart).
     # task_stop: POST tasks/stop (#handle_task_stop), the web's stop-task button.
-    FEATURES = %w[restart task_stop].freeze
+    # reparent: the worker reads Session::PARENT_FILE (its rings, each turn's
+    # start), so a continue may move it to the chain's new link (ChildMove).
+    FEATURES = %w[restart task_stop reparent].freeze
 
     # The routes, by method and what follows /session/:id/: a handler takes
     # the session id and the request body and returns [headers, status, body].

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.47.0
+version: 0.48.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/child_move.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "atomic_file"
+require_relative "session"
+require_relative "session_inbox"
+require_relative "worker_sidecar"
+require_relative "log"
+require_relative "tools/delegate_cursor"
+
+module Samagotchi
+  # Loaded on first use: session_manager requires terminal_ui, which
+  # requires KernelLoop and so the tools (a require cycle otherwise).
+  autoload :SessionManager, File.expand_path("session_manager", __dir__)
+
+  # A continue moving the previous link's open delegates to the chain's new
+  # link (SessionManager.continue_session), instead of archiving them with
+  # it. A moved child gets a parent override (Session::PARENT_FILE), never a
+  # rewritten session file, so its live worker saving a stale copy changes
+  # nothing; its worker reads the override for its rings and at each turn's
+  # start (Bridge::FEATURES "reparent").
+  #
+  # #apply runs between the new link's save and its worker's spawn, while
+  # the link is #mark_starting (a ring from a moved child must not spawn a
+  # second worker from the child's process until the link's own holds it).
+  # Each step is idempotent,
+  # and an intent file (INTENT_FILE) in the new link's folder names the move
+  # until it is done: a worker that starts and finds one finishes the move
+  # (#adopt), and a failed continue moves the same children back.
+  module ChildMove
+    # <new link dir>/move.json: {from, ids}, while a move is under way.
+    INTENT_FILE = "move.json"
+    # <new link dir>/starting: {pid, at}, from the move to the worker's spawn.
+    STARTING_FILE = "starting"
+    # A starting marker older than this, or whose process is gone, is left
+    # over from a continue that died: it holds nothing back.
+    STARTING_STALE = 60.0
+    # Who the note to a moved child is from (ContextNote's label).
+    NOTE_SOURCE = "session chain"
+    # What a live child's worker must name in its sidecar to be moved.
+    FEATURE = "reparent"
+
+    # What a continue does with the previous link's children: +move+ the
+    # direct children whose subtree has an open node (they go to the new
+    # link, their subtrees with them), +refuse+ the open ones it can't move
+    # (SessionManager::OpenChild, why: an older chi worker or a chi REPL).
+    Plan = Data.define(:move, :refuse)
+    # A move under way: from the session, the children moved.
+    Intent = Data.define(:from, :ids)
+
+    module_function
+
+    # @param open [Array<SessionManager::OpenChild>] the previous link's open
+    #   nodes, at any depth (SessionManager.open_children)
+    # @return [Plan]
+    def plan(prev_id, open:, state_dir:)
+      open_ids = open.map(&:id)
+      move = []
+      refuse = []
+      SessionManager.children_of(prev_id, state_dir: state_dir).each do |row|
+        subtree = [row[:id], *SessionManager.descendant_ids(row[:id], state_dir)]
+        next if (subtree & open_ids).empty?
+
+        if row[:archived]
+          # An open delegate below an archived one: the archive's cascade
+          # would take it, the move doesn't (only unarchived ones move).
+          refuse.concat(open.select { |c| subtree.include?(c.id) }.map do |c|
+            c.with(why: "under archived #{row[:id][0, 8]}; unarchive that one or archive this one")
+          end)
+          next
+        end
+
+        why = unmovable(row[:id], state_dir: state_dir)
+        if why
+          refuse << SessionManager::OpenChild.new(id: row[:id], short_id: row[:id][0, 8], why: why)
+        else
+          move << row[:id]
+        end
+      end
+      Plan.new(move: move, refuse: refuse)
+    end
+
+    # Why a child's live owner keeps it from moving: a chi REPL holds its
+    # own Session and never reads the override; a worker on an older chi
+    # neither. A worker with no sidecar yet is starting, on the newest chi
+    # installed (SessionManager.worker_command): it moves.
+    # @return [String, nil]
+    def unmovable(child_id, state_dir:)
+      owner = SessionManager.session_owner(child_id, state_dir: state_dir) or return nil
+      return "open in a chi REPL; close it there" if owner.tui?
+
+      sidecar = WorkerSidecar.live(Session.session_dir(child_id, state_dir: state_dir), unlink: false)
+      return nil if sidecar.nil? || sidecar.features.include?(FEATURE)
+
+      "older chi worker#{" #{sidecar.version}" if sidecar.version}; restart it"
+    end
+
+    # Move +ids+ (direct children of +from+) to +to+: the intent, the
+    # cursors +to+ lacks (delegates.json), the overrides, the rings waiting
+    # in +from+'s children/, a note to each child, then the intent goes.
+    # Safe to run again on the same move.
+    # @param undo [Boolean] a failed continue moving them back: its note says so
+    def apply(ids, from:, to:, state_dir:, undo: false)
+      return if ids.empty?
+
+      write_intent(to, Intent.new(from: from, ids: ids), state_dir: state_dir)
+      copy_cursors(ids, from: from, to: to, state_dir: state_dir)
+      ids.each { |id| Session.reparent(id, to: to, from: from, state_dir: state_dir) }
+      move_rings(ids, from: from, to: to, state_dir: state_dir)
+      ids.each { |id| note_child(id, to: to, undo: undo, state_dir: state_dir) }
+      clear_intent(to, state_dir: state_dir)
+      Log.info(:worker, undo ? "delegates_moved_back" : "delegates_moved", from: from[0, 8], to: to[0, 8], count: ids.size)
+    end
+
+    # The rings in +from+'s children/ from children whose parent is +to+
+    # now (a failed continue's link, before it is deleted: a child that
+    # read the override just before the undo rang it).
+    def return_rings(from:, to:, state_dir:)
+      ids = SessionInbox.find_ring_files(Session.session_dir(from, state_dir: state_dir)).filter_map do |file|
+        id = SessionInbox.read_ring(file)&.dig(:child_id)
+        id if Session.valid_id?(id) && Session.parent_override(id, state_dir: state_dir) == to
+      end
+      move_rings(ids.uniq, from: from, to: to, state_dir: state_dir)
+    end
+
+    # A worker starting for +session_id+ finishes a move its continue left
+    # half done (the intent file is still there): only those children, never
+    # the predecessor's others.
+    # @return [Array<String>] the ids moved, [] with no intent
+    def adopt(session_id, state_dir:)
+      intent = read_intent(session_id, state_dir: state_dir) or return []
+      apply(intent.ids, from: intent.from, to: session_id, state_dir: state_dir)
+      intent.ids
+    rescue StandardError => e
+      Log.warn(:worker, "delegates_adopt_failed", sid: session_id[0, 8], error: e.class.name, msg: e.message)
+      []
+    end
+
+    # @return [Intent, nil]
+    def read_intent(session_id, state_dir:)
+      data = JSON.parse(File.read(File.join(Session.session_dir(session_id, state_dir: state_dir), INTENT_FILE)))
+      return nil unless data.is_a?(Hash) && Session.valid_id?(data["from"]) && data["ids"].is_a?(Array)
+
+      Intent.new(from: data["from"], ids: data["ids"].select { |id| Session.valid_id?(id) })
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    def write_intent(session_id, intent, state_dir:)
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, INTENT_FILE), JSON.generate({ "from" => intent.from, "ids" => intent.ids }))
+    end
+
+    def clear_intent(session_id, state_dir:)
+      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), INTENT_FILE))
+    end
+
+    def copy_cursors(ids, from:, to:, state_dir:)
+      cursors = Tools::DelegateCursors.read(from, state_dir: state_dir).slice(*ids)
+      Tools::DelegateCursors.merge(to, cursors, state_dir: state_dir)
+    end
+
+    # A ring keeps its file name (its time orders the rings).
+    def move_rings(ids, from:, to:, state_dir:)
+      rings = SessionInbox.find_ring_files(Session.session_dir(from, state_dir: state_dir)).select do |file|
+        ids.include?(SessionInbox.read_ring(file)&.dig(:child_id))
+      end
+      return if rings.empty?
+
+      dir = File.join(Session.session_dir(to, state_dir: state_dir), SessionInbox::CHILDREN_DIR)
+      FileUtils.mkdir_p(dir)
+      rings.each do |file|
+        File.rename(file, File.join(dir, File.basename(file)))
+      rescue Errno::ENOENT
+        nil # taken meanwhile
+      end
+    end
+
+    # The child's system prompt names the parent it started with for its
+    # whole life (a prompt-cache miss each time it changed): a note tells a
+    # running one where its notes and reports go now.
+    def note_child(child_id, to:, state_dir:, undo: false)
+      text = if undo
+               "Your parent session is #{to[0, 8]} (#{to}) again: the continue that moved you to its next link " \
+                 "failed. Send notes there, and your reports reach it."
+             else
+               "Your parent session is now #{to[0, 8]} (#{to}), the next link of its session chain: send notes " \
+                 "there, and your reports reach it."
+             end
+      SessionInbox.write_note(child_id, text: text, source: NOTE_SOURCE, state_dir: state_dir)
+    end
+
+    # Hold off a worker for the continue's new link (#starting?) until its
+    # own worker holds it: written before the move, removed by that worker
+    # once it has the owner lock (Worker#start).
+    def mark_starting(session_id, state_dir:)
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, STARTING_FILE), JSON.generate({ "pid" => Process.pid, "at" => Time.now.iso8601(3) }))
+    end
+
+    def clear_starting(session_id, state_dir:)
+      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), STARTING_FILE))
+    end
+
+    # Whether a continue is moving delegates to +session_id+ right now: its
+    # marker is there, fresh, and the process that wrote it runs.
+    def starting?(session_id, state_dir:)
+      file = File.join(Session.session_dir(session_id, state_dir: state_dir), STARTING_FILE)
+      return false unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      return false if Time.now - Time.iso8601(data["at"].to_s) > STARTING_STALE
+
+      process_alive?(data["pid"].to_i)
+    rescue JSON::ParserError, ArgumentError, SystemCallError
+      false
+    end
+
+    # Signal 0 only asks whether the process exists.
+    def process_alive?(pid)
+      return false unless pid.positive?
+
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    end
+  end
+end

data/lib/samagotchi/child_reports.rb

@@ -57,16 +57,21 @@ module Samagotchi
     # @param wake [#call, nil] (parent id) wakes a parent with no worker;
     #   nil: SessionManager.wake_for_report on a thread
     # @return [String, nil] the ring file, nil when none was written
+    # The parent is read fresh: a continue may have moved the child to the
+    # chain's new link (Session::PARENT_FILE) since its worker loaded it.
     def ring(child, why:, state_dir:, wake: nil)
       return nil if mode == "off"
-      return nil unless child&.delegate? && child.parent_id
+      return nil unless child&.delegate?
+
+      parent_id = Session.parent_override(child.id, state_dir: state_dir) || child.parent_id
+      return nil unless parent_id
       # A deleted parent gets no orphan dir.
-      return nil unless Session.exist?(child.parent_id, state_dir: state_dir)
+      return nil unless Session.exist?(parent_id, state_dir: state_dir)
 
-      parent_dir = Session.session_dir(child.parent_id, state_dir: state_dir)
+      parent_dir = Session.session_dir(parent_id, state_dir: state_dir)
       path = SessionInbox.write_ring(parent_dir, child_id: child.id, why: why)
-      Log.info(:worker, "delegate_rang", parent: child.parent_id[0, 8], why: why)
-      wake_parent(child.parent_id, state_dir: state_dir, wake: wake) if mode == "wake"
+      Log.info(:worker, "delegate_rang", parent: parent_id[0, 8], why: why)
+      wake_parent(parent_id, state_dir: state_dir, wake: wake) if mode == "wake"
       path
     rescue StandardError => e
       Log.warn(:worker, "delegate_ring_failed", parent: child&.parent_id.to_s[0, 8], error: e.class.name, msg: e.message)
@@ -129,10 +134,14 @@ module Samagotchi
       def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
     end
 
-    def initialize(session_id:, state_dir:)
+    # @param predecessor [String, nil] the link this session continues
+    #   (Session#continues): a child a continue moved here may have rung it
+    #   just as it moved (#ring_files)
+    def initialize(session_id:, state_dir:, predecessor: nil)
       @session_id = session_id
       @state_dir = state_dir
       @session_dir = Session.session_dir(session_id, state_dir: state_dir)
+      @predecessor_dir = Session.valid_id?(predecessor) ? Session.session_dir(predecessor, state_dir: state_dir) : nil
       # child id → the Report this turn took for it (rings merged).
       @taken = {}
     end
@@ -142,7 +151,7 @@ module Samagotchi
       return false if ChildRing.mode == "off"
 
       taken = taken_rings
-      SessionInbox.find_ring_files(@session_dir).any? { |file| !taken.include?(file) }
+      ring_files.any? { |file| !taken.include?(file) }
     end
 
     # The reports for rings this turn hasn't taken yet, recorded as taken.
@@ -153,7 +162,7 @@ module Samagotchi
       return [] if ChildRing.mode == "off"
 
       taken = taken_rings
-      fresh = SessionInbox.find_ring_files(@session_dir).reject { |file| taken.include?(file) }
+      fresh = ring_files.reject { |file| taken.include?(file) }
       by_child = fresh.group_by { |file| SessionInbox.read_ring(file)&.dig(:child_id) }
       by_child.filter_map do |child_id, rings|
         report = child_id && report_for(child_id, rings)
@@ -193,6 +202,21 @@ module Samagotchi
       @taken.values.flat_map(&:rings)
     end
 
+    # The rings in children/, and the predecessor's rings from children a
+    # continue moved here (their parent.json names this session): a ring
+    # its child wrote as the move went on. Another child's ring there is
+    # the predecessor's, left alone.
+    def ring_files
+      own = SessionInbox.find_ring_files(@session_dir)
+      return own unless @predecessor_dir
+
+      strays = SessionInbox.find_ring_files(@predecessor_dir).select do |file|
+        child_id = SessionInbox.read_ring(file)&.dig(:child_id)
+        Session.valid_id?(child_id) && Session.parent_override(child_id, state_dir: @state_dir) == @session_id
+      end
+      own + strays
+    end
+
     # A second ring for a child taken earlier in this turn: read from where
     # the first report left the cursor, keeping the first one's +before+.
     def merge_taken(earlier, report)

data/lib/samagotchi/send_command.rb

@@ -333,7 +333,12 @@ module Samagotchi
       false
     end
 
-    def continued_words(session) = session.continues ? " (continues #{session.continues[0, 8]})" : ""
+    def continued_words(session)
+      return "" unless session.continues
+
+      moved = Array(session.moved_children).size
+      " (continues #{session.continues[0, 8]}#{"; #{moved} delegate#{"s" if moved != 1} moved" if moved.positive?})"
+    end
 
     # One existing session, then its next reply. The cursor and baseline
     # are taken before the message goes in, so neither an older reply nor a

data/lib/samagotchi/session.rb

@@ -32,6 +32,12 @@ module Samagotchi
     # resume removes it. A file from before the marker says "stopped" in
     # its status field, which reads the same.
     STOPPED_FILE = "stopped"
+    # A moved session's parent, <session dir>/parent.json ({parent_id, from,
+    # at}): a continue moving a delegate to the chain's new link
+    # (ChildMove) writes it instead of rewriting the session file its live
+    # worker may save a stale copy of; both load paths apply it, like the
+    # stop marker. Never removed: a later move overwrites it.
+    PARENT_FILE = "parent.json"
     # The memory a delegate child starts with (Tools::Delegate::CHILD_MEMORIES).
     DELEGATE_MEMORY = "system/delegated"
 
@@ -130,6 +136,10 @@ module Samagotchi
     # not saved.
     attr_accessor :model_warning
 
+    # The delegates a continue moved to this new link (ChildMove;
+    # SessionManager.continue_session sets it); not saved.
+    attr_accessor :moved_children
+
     def initialize(id:, mode:, model_name:, working_directory:, messages:, created_at:, updated_at:,
                    metadata_version: METADATA_VERSION, status: STATUS_IDLE, last_prompt: "",
                    first_preview: "", test_run: false, pending_question: nil,
@@ -258,6 +268,7 @@ module Samagotchi
 
       session = from_h(JSON.parse(File.read(path)))
       session.status = STATUS_STOPPED if stopped_marker?(session.id, state_dir: state_dir)
+      session.parent_id = parent_override(session.id, state_dir: state_dir) || session.parent_id
       session
     rescue JSON::ParserError => e
       raise ArgumentError, "Session file corrupted (#{session_id}): #{e.message}"
@@ -386,6 +397,7 @@ module Samagotchi
 
       session = from_h(data, messages: false)
       session.status = STATUS_STOPPED if stopped_marker?(session.id, state_dir: File.dirname(path))
+      session.parent_id = parent_override(session.id, state_dir: File.dirname(path)) || session.parent_id
       session
     rescue JSON::ParserError, KeyError, SystemCallError
       nil
@@ -453,6 +465,29 @@ module Samagotchi
       File.exist?(File.join(session_dir(session_id, state_dir: state_dir), STOPPED_FILE))
     end
 
+    # Give +session_id+ a new parent (PARENT_FILE), +from+ the one it had.
+    def self.reparent(session_id, to:, from:, state_dir: default_state_dir)
+      dir = session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, PARENT_FILE),
+                       JSON.generate({ "parent_id" => check_id!(to), "from" => from, "at" => Time.now.iso8601(3) }))
+    end
+
+    # The parent PARENT_FILE gives the session, nil without one (or with
+    # one that doesn't hold an id).
+    # @return [String, nil]
+    def self.parent_override(session_id, state_dir: default_state_dir)
+      file = File.join(session_dir(session_id, state_dir: state_dir), PARENT_FILE)
+      # The lists read every session: most have none, so no exception each.
+      return nil unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      id = data.is_a?(Hash) && data["parent_id"]
+      valid_id?(id) ? id : nil
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
     # An id that is not a session id: it could name a path outside the
     # sessions dir ("../x", "/etc", "a/b", a NUL), or is empty.
     class InvalidId < ArgumentError; end

data/lib/samagotchi/session_manager.rb

@@ -31,6 +31,7 @@ require_relative "image_store"
 require_relative "plugin_session_state"
 require_relative "context_sources"
 require_relative "session_chain"
+require_relative "child_move"
 require_relative "terminal_ui"
 
 module Samagotchi
@@ -118,8 +119,9 @@ module Samagotchi
 
     # A continue that can't happen (#continue_session). reason: :continued
     # (another session continues it already: +ids+ names it), :open_children
-    # (children still running, waiting, live or with a reply it wasn't given:
-    # +ids+ names them) or :folder_gone (its folder isn't there).
+    # (open children it can't move to the new link: on an older chi's
+    # worker or open in a chi REPL; +ids+ names them) or :folder_gone (its
+    # folder isn't there).
     class ContinueRefused < StandardError
       attr_reader :session_id, :reason, :ids
 
@@ -137,7 +139,8 @@ module Samagotchi
         case @reason
         when :continued then "#{short} is continued already, by #{@ids.first[0, 8]}; continue that one (or last:#{short})"
         when :open_children
-          "#{short} has delegates still open: #{detail}; wait for them, stop them or archive them, then continue"
+          "#{short} has delegates still open that can't move to the next link: #{detail}; " \
+          "then continue (or wait for them, stop them or archive them)"
         else "#{short}'s folder #{detail} is gone"
         end
       end
@@ -166,12 +169,14 @@ module Samagotchi
     # @param note [String, nil] a context note the session starts with,
     #   from +note_source+: queued before its worker spawns, so its first
     #   turn sees it
+    # @param before_spawn [#call, nil] (session) runs once the session and
+    #   its note are saved, before its worker spawns
     # @return [Session] with #seed_images_dropped: refs whose file was gone,
     #   and #model_warning: an id its host's saved list doesn't have
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
                            title: nil, delegate: false, llm_context: nil, continues: nil, note: nil,
-                           note_source: "chi")
+                           note_source: "chi", before_spawn: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
       # alias is retargeted), with the name as typed beside it. A wrong host
@@ -210,6 +215,7 @@ module Samagotchi
       end
       setup_session_directory(session_dir, session, state_dir: sd)
       SessionInbox.write_note(session.id, text: note, source: note_source, state_dir: sd) if note
+      before_spawn&.call(session)
       spawn_worker_for_session(session, state_dir: sd)
       session
     end
@@ -228,10 +234,13 @@ module Samagotchi
     # it was typed as, so an alias holds) and with its own llm_context,
     # starting with a context note from chi: the link and the previous
     # link's recap (SessionChain.note_text). The previous link is archived
-    # first, with its delegates (archive_session's rules: a turn running,
-    # a prompt queued or the step-limit question refuse; an idle worker is
-    # stopped), so a refusal starts nothing. Before that its live worker is
-    # asked for a recap and given up to +recap_wait+ seconds to write it.
+    # first, with its finished delegates (archive_session's rules: a turn
+    # running, a prompt queued or the step-limit question refuse; an idle
+    # worker is stopped), so a refusal starts nothing. Its open delegates
+    # (running, waiting, live, an unreported reply, at any depth below them)
+    # move to the new link instead (ChildMove): their reports reach it.
+    # Before that its live worker is asked for a recap and given up to
+    # +recap_wait+ seconds to write it.
     # One continue of a session at a time (a lock in its folder): a double
     # click finds the first one's link and is refused; a last:<id> one
     # follows the chain to its new end instead.
@@ -239,9 +248,11 @@ module Samagotchi
     # @param prompt [String, nil] its first message (nil: it starts idle)
     # @param title [String, nil] what the lists show before the first turn;
     #   by default the prompt, else the previous link's preview
-    # @return [Session] the new link (#model_warning as spawn_session's)
+    # @return [Session] the new link (#model_warning as spawn_session's,
+    #   #moved_children: the delegates it took over)
     # @raise [ArgumentError] no such session (Session::AmbiguousId for a prefix of several)
-    # @raise [ContinueRefused] continued already, delegates still open, or its folder is gone
+    # @raise [ContinueRefused] continued already, delegates open that can't
+    #   move, or its folder is gone
     # @raise [ArchiveRefused, OwnedByTUI] as archive_session
     def self.continue_session(id_or_ref, prompt: nil, title: nil, state_dir: nil, recap_wait: CONTINUE_RECAP_WAIT,
                               archive_wait: 5)
@@ -270,82 +281,135 @@ module Samagotchi
 
     private_class_method def self.continue_locked(id, prompt:, title:, state_dir:, recap_wait:, archive_wait:)
       previous = Session.load(id, state_dir: state_dir)
-      check_continue!(previous, state_dir)
+      plan = check_continue!(previous, state_dir)
       # archive_session's refusals that can be known now, before the wait.
-      archivable!(id, state_dir)
+      archivable!(id, state_dir, except: plan.move)
       recap_before_archive(id, state_dir, wait: recap_wait)
-      # Again: a turn sent to it during the wait may have delegated.
-      check_open_children!(id, state_dir)
-      already = [id, *descendant_ids(id, state_dir)].select do |sid|
+      # Again: a turn sent to it during the wait may have delegated (they
+      # move too), or a delegate finished.
+      plan = move_plan!(id, state_dir)
+      already = [id, *descendant_ids(id, state_dir, except: plan.move)].select do |sid|
         ArchiveStore.archived?(Session.session_dir(sid, state_dir: state_dir))
       end
-      archived = archive_session(id, state_dir: state_dir, wait: archive_wait)[:archived] - already
+      archived = archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)[:archived] - already
       begin
-        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir)
+        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir, move: plan.move)
       rescue StandardError
-        # Nothing started: what this archived goes back to the lists, and
-        # a new link saved before its worker failed to spawn goes (left,
-        # it would hold the chain: "continued already", last: to it).
-        discard_failed_link(id, state_dir)
-        archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
+        # Nothing started: the delegates go back, what this archived goes
+        # back to the lists, and a new link saved before its worker failed
+        # to spawn goes (left, it would hold the chain: "continued already",
+        # last: to it).
+        undo_move(id, state_dir, moved: plan.move)
+        begin
+          discard_failed_link(id, state_dir)
+        ensure
+          archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
+          wake_for_rings(id, state_dir) unless plan.move.empty?
+        end
         raise
       end
     end
 
+    # The delegates a failed #continue_session moved, or began to (its
+    # intent names them), go back to +id+.
+    private_class_method def self.undo_move(id, state_dir, moved:)
+      link = SessionChain.next_of(id, state_dir: state_dir) or return
+      ids = ChildMove.read_intent(link, state_dir: state_dir)&.ids || moved
+      ChildMove.apply(ids, from: link, to: id, state_dir: state_dir, undo: true)
+      ChildMove.clear_intent(link, state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "continue_undo_move_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
     # The link a failed #continue_session saved (no other continues +id+:
-    # check_continue! made sure under the lock).
+    # check_continue! made sure under the lock): its worker stopped if one
+    # started, then the rings a moved delegate wrote into it just before
+    # the undo go back to +id+, then the link goes. A worker that outlives
+    # the stop is raised (DeleteRefused): the link stays, and the caller
+    # hears it.
     private_class_method def self.discard_failed_link(id, state_dir)
       orphan = SessionChain.next_of(id, state_dir: state_dir) or return
+      if refuse_tui!(orphan, state_dir: state_dir) && !stop_session(orphan, state_dir: state_dir, wait: 10)
+        raise DeleteRefused.new(orphan, :still_stopping)
+      end
+
+      ChildMove.return_rings(from: orphan, to: id, state_dir: state_dir)
       delete_session(orphan, state_dir: state_dir)
+    rescue DeleteRefused
+      raise
     rescue StandardError => e
       Log.warn(:worker, "continue_cleanup_failed", sid: id, error: e.class.name, msg: e.message)
     end
 
-    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:)
+    # A failed continue's previous link, back in the lists, with rings that
+    # came in meanwhile: wake it for them, as the ring's own wake would have.
+    private_class_method def self.wake_for_rings(id, state_dir)
+      return if SessionInbox.find_ring_files(Session.session_dir(id, state_dir: state_dir)).empty?
+
+      wake_for_report(id, state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "continue_wake_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # The new link, holding off any worker but its own (ChildMove.starting?)
+    # while +move+ goes to it.
+    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:, move:)
       recap = RecapStore.read(Session.session_dir(previous.id, state_dir: state_dir))
       start = prompt.to_s.strip.empty? ? nil : prompt
       title = previous.first_preview if title.to_s.strip.empty? && start.nil?
-      spawn_session(prompt: start, title: title, working_directory: previous.working_directory,
-                    model_name: previous.model_typed || previous.model_name, llm_context: previous.llm_context,
-                    continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
-                    note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir)
+      before_spawn = lambda do |link|
+        ChildMove.mark_starting(link.id, state_dir: state_dir)
+        ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
+      end
+      link = spawn_session(prompt: start, title: title, working_directory: previous.working_directory,
+                           model_name: previous.model_typed || previous.model_name, llm_context: previous.llm_context,
+                           continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
+                           note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn)
+      link.moved_children = move
+      link
     end
 
     # The refusals that come before anything changes: continued already (no
-    # forks in a chain), a delegate still open (its report would go to the
-    # archived link), the folder gone (the worker would run elsewhere), a
+    # forks in a chain), an open delegate that can't move to the new link
+    # (ChildMove.plan), the folder gone (the worker would run elsewhere), a
     # model whose host config.yml no longer has.
+    # @return [ChildMove::Plan]
     # @raise [ContinueRefused, ModelProfile::MissingModel]
     private_class_method def self.check_continue!(previous, state_dir)
       if (following = SessionChain.next_of(previous.id, state_dir: state_dir))
         raise ContinueRefused.new(previous.id, :continued, ids: [following])
       end
 
-      check_open_children!(previous.id, state_dir)
+      plan = move_plan!(previous.id, state_dir)
       # Its model's host, as spawn_session checks it: before the archive
       # stops the previous link's worker.
       ModelProfile.check_host!(ModelProfile.required_model_name(previous.model_typed || previous.model_name))
       dir = previous.working_directory.to_s
       raise ContinueRefused.new(previous.id, :folder_gone, detail: dir) unless File.directory?(dir)
+
+      plan
     end
 
-    # A child the next link couldn't follow once its parent is archived.
+    # A child still open below a session (#open_children); why: running,
+    # waiting, live, unreported reply, or why it can't move (ChildMove).
     OpenChild = Data.define(:id, :short_id, :why)
 
-    # @raise [ContinueRefused] while #open_children has any
-    private_class_method def self.check_open_children!(id, state_dir)
-      open = open_children(id, state_dir)
-      return if open.empty?
+    # The delegates a continue of +id+ moves (ChildMove.plan).
+    # @return [ChildMove::Plan]
+    # @raise [ContinueRefused] for open ones it can't move
+    private_class_method def self.move_plan!(id, state_dir)
+      plan = ChildMove.plan(id, open: open_children(id, state_dir), state_dir: state_dir)
+      return plan if plan.refuse.empty?
 
-      raise ContinueRefused.new(id, :open_children, ids: open.map(&:id),
-                                                    detail: open.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
+      raise ContinueRefused.new(id, :open_children, ids: plan.refuse.map(&:id),
+                                                    detail: plan.refuse.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
     end
 
     # The unarchived children, at any depth (the archive's cascade), of the
     # session still running, waiting for an answer, with a live worker, or
     # (a delegate) with a reply its parent wasn't given (ChildrenStatus).
     # @return [Array<OpenChild>]
-    private_class_method def self.open_children(id, state_dir)
+    def self.open_children(id, state_dir)
       require_relative "children_status"
       [id, *descendant_ids(id, state_dir)].flat_map { |node| ChildrenStatus.of(node, state_dir: state_dir) }.uniq(&:id)
                                           .filter_map do |child|
@@ -557,10 +621,12 @@ module Samagotchi
     # @raise [ArchiveRefused] a turn runs in it or in a child, a prompt is
     #   queued in one (a later resume would run it), a live one offers to
     #   continue past the step limit, or it is a scratch session
-    def self.archive_session(id_or_prefix, state_dir: nil, wait: 5)
+    # @param except [Array<String>] descendants left alone with their own
+    #   subtrees (delegates a continue moves to the chain's new link)
+    def self.archive_session(id_or_prefix, state_dir: nil, wait: 5, except: [])
       sd = state_dir || Session.default_state_dir
       id = archive_target(id_or_prefix, sd)
-      tree, owners = archivable!(id, sd)
+      tree, owners = archivable!(id, sd, except: except)
       stopped = tree.select { |sid| owners[sid] }
       stopped.each { |sid| stop_session(sid, state_dir: sd, wait: wait) }
       archived, discarded = tree.partition { |sid| ArchiveStore.archive(sid, state_dir: sd) }
@@ -571,10 +637,10 @@ module Samagotchi
     # archived now (#archive_refusal for each), else the refusal.
     # @return [Array(Array<String>, Hash)] the ids, and id => OwnerLock::Owner or nil
     # @raise [ArchiveRefused, OwnedByTUI]
-    private_class_method def self.archivable!(id, state_dir)
+    private_class_method def self.archivable!(id, state_dir, except: [])
       raise ArchiveRefused.new(id, :scratch) if Session.load(id, state_dir: state_dir).scratch
 
-      tree = [id, *descendant_ids(id, state_dir)]
+      tree = [id, *descendant_ids(id, state_dir, except: except)]
       owners = tree.to_h { |sid| [sid, session_owner(sid, state_dir: state_dir)] }
       tree.each do |sid|
         refusal = archive_refusal(sid, owners[sid], state_dir)
@@ -620,13 +686,13 @@ module Samagotchi
     end
 
     # Children, their children, …: a delegated session doesn't delegate
-    # further today, a plugin's fork may.
-    private_class_method def self.descendant_ids(id, state_dir)
+    # further today, a plugin's fork may. The walk doesn't enter +except+.
+    def self.descendant_ids(id, state_dir, except: [])
       seen = [id]
       queue = [id]
       until queue.empty?
         children_of(queue.shift, state_dir: state_dir).each do |child|
-          next if seen.include?(child[:id])
+          next if seen.include?(child[:id]) || except.include?(child[:id])
 
           seen << child[:id]
           queue << child[:id]
@@ -695,6 +761,9 @@ module Samagotchi
       # One this process just spawned may not hold the lock yet (a slow
       # start, deliver_turn's second resume): it would only lose it.
       return session if still_starting?(session.id, state_dir: sd)
+      # A continue moving delegates to it spawns its worker once they are
+      # moved; one spawned now (a moved child's ring) would race the move.
+      return session if ChildMove.starting?(session.id, state_dir: sd)
 
       Session.clear_stopped(session.id, state_dir: sd)
       session.status = Session::STATUS_IDLE
@@ -705,18 +774,27 @@ module Samagotchi
 
     # A delegate child rang a parent that has no worker (ChildRing): start
     # one, which runs a turn for the report. Not for a parent that is gone,
-    # stopped, archived, a scratch session, or open in a chi REPL: the ring
-    # waits on disk for whoever runs it next (#resume_session itself would
-    # clear the stop). A stop landing between the check and the resume is
-    # a small window, left as is.
+    # stopped, archived, a scratch session, open in a chi REPL, or a
+    # continue's new link still taking its delegates (its own spawn comes):
+    # the ring waits on disk for whoever runs it next (#resume_session
+    # itself would clear the stop). A stop landing between the check and
+    # the resume is a small window, left as is. An archived parent with a
+    # later link in its chain wakes that link instead: a ring a moved child
+    # wrote just as the continue moved it reaches the new link that way
+    # (ChildReports reads its predecessor's rings).
     # @return [Symbol] :woken, or why not (:gone, :stopped, :archived,
-    #   :scratch, :owned)
-    def self.wake_for_report(session_id, state_dir: nil)
+    #   :scratch, :owned, :starting)
+    def self.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)
-      return :archived if ArchiveStore.archived?(Session.session_dir(session_id, state_dir: sd))
+
+      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
+      end
+      return :starting if ChildMove.starting?(session_id, state_dir: sd)
 
       session = Session.load(session_id, state_dir: sd)
       return :stopped if session.status == Session::STATUS_STOPPED

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -33,10 +33,13 @@ module Samagotchi
     # The parent's cursors, one per child, in <parent dir>/delegates.json, so
     # a respawned worker (or a REPL resuming the session) doesn't hand the
     # model a reply it already had. Written by whoever owns the parent (its
-    # worker, or the REPL its kernel runs in), so a Mutex is enough for its
-    # turn thread vs its loop thread; the file is replaced whole.
+    # worker, or the REPL its kernel runs in), and by a continue moving
+    # delegates to the chain's new link (ChildMove, from another process):
+    # a Mutex for the owner's turn thread vs its loop thread, and a flock on
+    # LOCK_FILE between processes; the file is replaced whole.
     module DelegateCursors
       FILE = "delegates.json"
+      LOCK_FILE = "delegates.lock"
       LOCK = Mutex.new
 
       module_function
@@ -51,7 +54,7 @@ module Samagotchi
       # @yieldreturn [DelegateCursor]
       # @return [DelegateCursor] the new cursor
       def update(parent_id, child_id, state_dir:)
-        LOCK.synchronize do
+        locked(parent_id, state_dir: state_dir) do
           all = read(parent_id, state_dir: state_dir)
           cursor = yield get_from(all, child_id)
           all[child_id] = cursor.to_json_hash
@@ -60,6 +63,31 @@ module Samagotchi
         end
       end
 
+      # Add the cursors of +entries+ (child id → cursor fields, as #read
+      # gives them) that the parent has none for; one it has is kept.
+      # @return [Array<String>] the child ids added
+      def merge(parent_id, entries, state_dir:)
+        return [] if entries.empty?
+
+        locked(parent_id, state_dir: state_dir) do
+          all = read(parent_id, state_dir: state_dir)
+          added = entries.keys - all.keys
+          write(parent_id, all.merge(entries.slice(*added)), state_dir: state_dir) unless added.empty?
+          added
+        end
+      end
+
+      def locked(parent_id, state_dir:)
+        LOCK.synchronize do
+          dir = Session.session_dir(parent_id, state_dir: state_dir)
+          FileUtils.mkdir_p(dir)
+          File.open(File.join(dir, LOCK_FILE), File::RDWR | File::CREAT, 0o600) do |lock|
+            lock.flock(File::LOCK_EX)
+            yield
+          end
+        end
+      end
+
       def get_from(all, child_id)
         data = all[child_id]
         return DelegateCursor.empty unless data.is_a?(Hash)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -655,9 +655,11 @@ module Samagotchi
         return error if error
 
         port = await_bridge_port(session.id)
-        [session.continues, session.id].each { |sid| @hub&.touch(sid) }
+        moved = session.moved_children || []
+        # The moved delegates' cards fold under the new link now.
+        [session.continues, session.id, *moved].each { |sid| @hub&.touch(sid) }
         record_history(body, prompt) if !idle && PromptHistory.shell_line?(prompt.to_s.strip)
-        json_response(201, session_to_json(session).merge(bridge_port: port))
+        json_response(201, session_to_json(session).merge(bridge_port: port, moved: moved))
       end
 
       # SessionManager.continue_session, its refusals as responses: [session,

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

@@ -37,7 +37,7 @@ import { createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { BADGES, emptyAnswerHtml, htmlElement, stateBadgeHtml, userBubbleHtml } from "./turn_html.js";
 import { createStageView } from "./stage_view.js";
 import { createFamilyPop, familyChipHtml, familyRowsHtml } from "./families_view.js";
-import { CONTINUE_OPENER, allViewChains, chainChipHtml, chainTitle, isOpener, chainDate, chainNeighbours, chainRowsHtml, continueRefusal, foldChains, openChildrenHtml } from "./chains.js";
+import { CONTINUE_OPENER, allViewChains, chainChipHtml, chainTitle, isOpener, chainDate, chainNeighbours, chainRowsHtml, continueRefusal, continuedText, foldChains, openChildrenHtml } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
 import { appendQuote } from "./annotations.js";
 import { parsePresets } from "./annotate_presets.js";
@@ -2863,8 +2863,9 @@ $("#infoArchiveBtn").addEventListener("click", () => {
 // Continue → starts the next link of the open session's chain (the server
 // waits up to 30 s for its recap, archives it, starts the new one with the
 // recap as a note) and opens it with the opener in the composer, not sent.
-// A link continued already opens that next link; a refusal for delegates
-// still open names them, each a link.
+// A link continued already opens that next link; its open delegates move
+// to the new link (the toast counts them); a refusal for open delegates
+// that can't move names them, each a link.
 // One continue per session at a time (the server locks it too); another
 // session's continue may run beside it.
 const continuingIds = new Set();
@@ -2881,12 +2882,12 @@ async function continueSelected() {
     addCreatedSession(created);
     const next = created.id;
     if (selected !== id) {
-      showToast(`Continued ${short} in ${next.slice(0, 8)}`, { label: "Open", run: () => select(next) });
+      showToast(continuedText(id, created, { opened: false }), { label: "Open", run: () => select(next) });
       return;
     }
     await select(next);
     if (selected === next) fillOpener();
-    showToast(`Continued ${short} in ${next.slice(0, 8)}; ${short} is archived`);
+    showToast(continuedText(id, created));
   } catch (e) {
     const refusal = continueRefusal(e, allSessions);
     if (refusal.kind === "open") {

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

@@ -201,7 +201,7 @@ export function chainRowsHtml(f, { activeId = null, now = Date.now() } = {}) {
 // What the page does with a refused continue (POST /api/sessions
 // continues, api()'s error with the answer's body): "open" the link that
 // continues it already (409 continued, next_id), "children" naming the
-// delegates still open (409 open_children, ids: {id, short, text} each,
+// delegates still open that can't move (409 open_children, ids: {id, short, text} each,
 // the text its preview and why it is open: the server's word from its
 // detail, "<short> (running)", else its state here), or "error" with the
 // server's words.
@@ -224,11 +224,24 @@ export function continueRefusal(error, sessions = []) {
   return { kind: "error", text };
 }
 
-// The open-children refusal as the toast shows it: the delegates named,
-// each a link to its session.
+// The open-children refusal as the toast shows it: the open delegates the
+// continue can't move to the next link (an older chi's worker, a chi
+// REPL), each a link to its session with what to do about it.
 // @param hrefFor (id) → its page's href
 export function openChildrenHtml(prevId, children, hrefFor) {
   const n = children.length;
   const items = children.map((c) => `<li><a href="${escapeHtml(hrefFor(c.id))}" class="cr-child">${escapeHtml(c.short)}</a>${c.text ? ` ${escapeHtml(c.text)}` : ""}</li>`).join("");
-  return `<div class="continue-refused"><div>Can't continue ${escapeHtml(String(prevId).slice(0, 8))}: ${n} ${n === 1 ? "delegate is" : "delegates are"} still open. Wait for ${n === 1 ? "it" : "them"}, stop or archive ${n === 1 ? "it" : "them"}, then continue.</div><ul>${items}</ul></div>`;
+  return `<div class="continue-refused"><div>Can't continue ${escapeHtml(String(prevId).slice(0, 8))}: ${n} open ${n === 1 ? "delegate" : "delegates"} can't move to the next link. Do what ${n === 1 ? "it says" : "each says"}, or wait for ${n === 1 ? "it" : "them"}, then continue.</div><ul>${items}</ul></div>`;
+}
+
+// The toast after a continue: the new link, the previous one archived (when
+// the page shows the new one), and how many open delegates moved to it
+// (the answer's moved).
+export function continuedText(prevId, created, { opened = true } = {}) {
+  const short = String(prevId).slice(0, 8);
+  const moved = Array.isArray(created?.moved) ? created.moved.length : 0;
+  const parts = [`Continued ${short} in ${String(created?.id || "").slice(0, 8)}`];
+  if (opened) parts.push(`${short} is archived`);
+  if (moved) parts.push(`${moved} open ${moved === 1 ? "delegate" : "delegates"} moved`);
+  return parts.join("; ");
 }

data/lib/samagotchi/worker.rb

@@ -22,6 +22,7 @@ require_relative "iteration_limit"
 require_relative "session_commands"
 require_relative "model_profile"
 require_relative "child_reports"
+require_relative "child_move"
 require_relative "context_absorber"
 require_relative "context_poller"
 require_relative "tools/task_runtime"
@@ -162,6 +163,11 @@ module Samagotchi
     def start
       # The wake turns' budget (delegate reports, attached context), from now.
       @wakes = WorkerWakes.new(grace: WAKE_START_GRACE)
+      # This worker holds the session now (a continue's starting marker held
+      # off any other until it did), and a continue that died moving
+      # delegates here left its intent: finish it.
+      ChildMove.clear_starting(@session_id, state_dir: @state_dir)
+      ChildMove.adopt(@session_id, state_dir: @state_dir)
       @session = Session.load(@session_id, state_dir: @state_dir)
       drop_dead_question
       @engine = build_engine
@@ -195,7 +201,8 @@ module Samagotchi
         ring_question(event) if event[:type] == :question_requested
       })
       # This session's own delegate children's news (rings in children/).
-      @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir)
+      @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir,
+                                        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)
@@ -802,6 +809,10 @@ module Samagotchi
       restores = @turn_flow.restores
       begin
         @session.status = Session::STATUS_RUNNING
+        # A continue that moved this session to the chain's new link wrote
+        # the new parent beside it (Session::PARENT_FILE): this turn's
+        # status, its rings and every save from here on say so.
+        @session.parent_id = Session.parent_override(@session_id, state_dir: @state_dir) || @session.parent_id
         @session.save(state_dir: @state_dir)
         result = @engine.run_turn(@session, prompt, pending_input: pending_input_drain, **turn_args)
       rescue StandardError => e

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.47.0
+  version: 0.48.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -211,6 +211,7 @@ files:
 - lib/samagotchi/bundles/system/memory_guide.md
 - lib/samagotchi/bundles/system/self_map.md
 - lib/samagotchi/cancellation_controller.rb
+- lib/samagotchi/child_move.rb
 - lib/samagotchi/child_reports.rb
 - lib/samagotchi/children_status.rb
 - lib/samagotchi/cli/command.rb