@plurnk/plurnk-service 1.7.0 → 1.9.0

package/dist/core/Engine.sql

@@ -6,13 +6,13 @@ SELECT status FROM loops WHERE id = $loop_id;
 -- PREP: engine_worker_has_live_child
 -- A non-terminal child worker (worker:// spawn/fork set parent_worker_id) — a "live thing the worker holds",
 -- like an open stream. A SEND signal 200 while one exists is a premature-terminate ({§send-premature-terminate}).
--- Live = a child whose LATEST loop is still pending/running/parked (100/102/202) — the SAME definition
+-- Live = a child with ANY unresolved loop (100/102/202) — the SAME definition
 -- engine_child_workers_live uses for the Active Child Workers orientation, so the 409 gate and the section the model
 -- reads NEVER disagree: a refused termination is always backed by a child the model can SEE and KILL
--- ({§child-orientation}). An inherited/historical loop (a fork copies the parent's loops) is not the
--- latest, so it never makes a concluded child look forever-live.
+-- ({§child-orientation}). Administrative loops may interleave with model loops, so newest-loop
+-- inference is not a valid worker-liveness test.
 SELECT 1 AS live FROM workers r
-JOIN loops l ON l.id = (SELECT id FROM loops WHERE worker_id = r.id ORDER BY sequence DESC, id DESC LIMIT 1)
+JOIN loops l ON l.worker_id = r.id
 WHERE r.parent_worker_id = $worker_id AND l.status IN (100, 102, 202) LIMIT 1;
 
 -- PREP: engine_count_active_loops_for_worker
@@ -36,9 +36,18 @@ UPDATE loops SET flags = $flags WHERE id = $loop_id;
 UPDATE loops SET open_paths = $open_paths WHERE id = $loop_id;
 
 -- PREP: engine_get_loop_prompt
--- Initial prompt frame. On turn 1, runTurn stores the owner-keyed
--- prompt:///<loop>/1 entry with its selected paths and publishes it.
-SELECT prompt, sequence, open_paths FROM loops WHERE id = $loop_id;
+-- Initial prompt frame. Its durable log occurrence, not a process-local/model
+-- ordinal, decides whether runTurn still needs to publish it.
+SELECT l.prompt, l.prompt_source, l.sequence, l.open_paths,
+       EXISTS (
+           SELECT 1
+           FROM log_entries le
+           WHERE le.loop_id = l.id
+             AND le.op = 'prompt'
+             AND le.pathname = '/' || l.sequence || '/1'
+       ) AS prompt_published
+FROM loops l
+WHERE l.id = $loop_id;
 
 -- PREP: engine_reclaim_queued_loop
 -- {§worker-lifecycle-wake-requeue-not-terminal} — atomic 100→102 re-claim by loop id. A wake
@@ -52,22 +61,11 @@ UPDATE loops SET status = 102 WHERE id = $loop_id AND status = 100;
 -- each owning use site with its declared composition semantics.
 SELECT settings FROM workspaces WHERE id = $workspace_id;
 
--- PREP: engine_target_diverged_this_turn
--- #note10 — did this entry diverge on disk THIS turn? A source=file env-delta for the
--- target, materialized into this worker's log at the current turn, means the model's view
--- predates the ambient change — a auto resolution of a same-turn EDIT would clobber it.
-SELECT 1 AS hit
-FROM log_entries
-WHERE worker_id = $worker_id AND turn_id = $turn_id
-  AND origin = 'plurnk' AND source = 'file' AND op = 'EDIT'
-  AND scheme IS $scheme AND pathname = $pathname
-LIMIT 1;
-
 -- PREP: engine_list_owner_entries
 -- {§entry-owner} — one principal's entries (catalogRowsFor source for an owner-scoped FIND/foist):
 -- the commons, a worker's own space, or a named space — exactly one owner's rows, its perspective.
-SELECT e.id AS entry_id, e.scheme, e.pathname, ec.name AS channel, ec.content, ec.mimetype, ec.weight AS weight, e.deep_hash,
-    d.parse_issues,
+SELECT e.id AS entry_id, e.scheme, e.authority, e.pathname, ec.name AS channel, ec.content, ec.mimetype, ec.weight AS weight, ec.deep_hash,
+    d.parse_issues, d.summary,
     s.id AS subscription_id,
     CASE WHEN s.closed_at IS NULL
         THEN CAST(unixepoch('now') - unixepoch(s.opened_at) AS INTEGER)
@@ -76,7 +74,8 @@ SELECT e.id AS entry_id, e.scheme, e.pathname, ec.name AS channel, ec.content, e
     s.close_status
 FROM entries e
 JOIN entry_channels ec ON ec.entry_id = e.id
-LEFT JOIN derivations d ON d.deep_hash = e.deep_hash
+JOIN workers owner ON owner.id = e.owner_id
+LEFT JOIN derivations d ON d.deep_hash = ec.deep_hash
 LEFT JOIN subscriptions s ON s.id = (
     SELECT latest.id
     FROM subscriptions latest
@@ -84,22 +83,23 @@ LEFT JOIN subscriptions s ON s.id = (
     ORDER BY latest.id DESC
     LIMIT 1
 )
-WHERE e.workspace_id = $workspace_id AND e.owner_id = $owner_id
+WHERE owner.workspace_id = $workspace_id AND e.owner_id = $owner_id
 ORDER BY e.updated_at ASC, e.id ASC, ec.name;
 
 -- PREP: engine_next_turn_sequence
 SELECT COALESCE(MAX(sequence), 0) + 1 AS next FROM turns WHERE loop_id = $loop_id;
 
 -- PREP: engine_loop_usage
--- Latest-turn gauge ({§tokenomics-client-gauge}), surfaced beside the derived
+-- Latest packet-bearing model-turn gauge ({§tokenomics-client-gauge}), surfaced beside the derived
 -- accounting projection on {§notifications-loop-terminated}. Physical usage
 -- and capacity bind to the same latest completed emission call. A preflight
 -- rejection has capacity evidence but no physical input usage; neither fact
--- falls back to an earlier call or turn.
+-- falls back to an earlier call. Packetless chronology cannot erase the latest
+-- assembled model request.
 WITH latest_turn AS (
     SELECT id, packet, usage_curation_budget, meta
       FROM turns
-     WHERE loop_id = $loop_id
+     WHERE loop_id = $loop_id AND packet IS NOT NULL
      ORDER BY sequence DESC
      LIMIT 1
 ), latest_emission AS (
@@ -167,29 +167,6 @@ SELECT l.sequence AS loop_seq, t.sequence AS turn_seq
 FROM loops l, turns t
 WHERE l.id = $loop_id AND t.id = $turn_id;
 
--- PREP: engine_open_turn
--- Turn-as-container model: insert a turn row at runTurn open with no assembled
--- model request and status=102 (in-progress). Pre-model writes
--- (the user prompt; later, system signals/notices) land into
--- this row before the provider is called. The turn is then "closed"
--- via engine_close_turn with the final packet + status + usage stats
--- after dispatch completes.
-INSERT INTO turns (loop_id, sequence, status)
-VALUES ($loop_id, $sequence, 102)
-RETURNING id;
-
--- PREP: engine_close_turn
--- Updates the turn with the response packet and terminal metadata once dispatch
--- is complete. Provider attempts own and materialize usage/cost above this path.
-UPDATE turns SET
-    status = $status,
-    packet = $packet,
-    usage_curation_budget = $usage_curation_budget,
-    finish_reason = $finish_reason,
-    model = $model,
-    meta = $meta
-WHERE id = $id;
-
 -- PREP: engine_open_model_call
 -- Logical identity and request attribution become durable before provider I/O.
 INSERT INTO model_calls (turn_id, sequence, kind, attributions, model)
@@ -263,7 +240,7 @@ WHERE id = $id AND state = 'pending';
 -- The latest subscription carries stream lifecycle into the catalog. `seconds`
 -- is the live age of an open stream; close_status is the exact terminal status
 -- of a closed one. Entries with no subscription remain ordinary static entries.
-SELECT e.id AS entry_id, e.scheme, e.pathname, ec.name AS channel, ec.content, ec.mimetype, ec.weight AS weight, e.deep_hash,
+SELECT e.id AS entry_id, e.scheme, e.authority, e.pathname, ec.name AS channel, ec.content, ec.mimetype, ec.weight AS weight, ec.deep_hash,
     s.id AS subscription_id,
     CASE WHEN s.closed_at IS NULL
         THEN CAST(unixepoch('now') - unixepoch(s.opened_at) AS INTEGER)
@@ -272,6 +249,7 @@ SELECT e.id AS entry_id, e.scheme, e.pathname, ec.name AS channel, ec.content, e
     s.close_status
 FROM entries e
 JOIN entry_channels ec ON ec.entry_id = e.id
+JOIN workers owner ON owner.id = e.owner_id
 LEFT JOIN subscriptions s ON s.id = (
     SELECT latest.id
     FROM subscriptions latest
@@ -279,7 +257,7 @@ LEFT JOIN subscriptions s ON s.id = (
     ORDER BY latest.id DESC
     LIMIT 1
 )
-WHERE e.workspace_id = $workspace_id
+WHERE owner.workspace_id = $workspace_id
 -- User Note 5 — mtime-ascending: dormant entries hold the stable prompt-cache prefix; churn clusters at the tail.
 ORDER BY e.updated_at ASC, e.id ASC, ec.name;
 
@@ -292,33 +270,31 @@ SELECT e.scheme AS scheme,
     COUNT(DISTINCT e.id) AS entries,
     COUNT(DISTINCT CASE
         WHEN instr(ltrim(e.pathname, '/'), '/') = 0
-            THEN 'entry:' || ltrim(e.pathname, '/')
-        ELSE 'scope:' || substr(ltrim(e.pathname, '/'), 1, instr(ltrim(e.pathname, '/'), '/'))
+            THEN json_array('entry', e.authority, ltrim(e.pathname, '/'))
+        ELSE json_array('scope', e.authority, substr(ltrim(e.pathname, '/'), 1, instr(ltrim(e.pathname, '/'), '/')))
     END) AS shallow_items
 FROM entries e
 JOIN entry_channels ec ON ec.entry_id = e.id
-WHERE e.workspace_id = $workspace_id
+JOIN workers owner ON owner.id = e.owner_id
+WHERE owner.workspace_id = $workspace_id
 GROUP BY e.scheme
 ORDER BY e.scheme;
 
 -- PREP: engine_initialize_ambient_cursor
--- A worker's first packet reads current shared state directly, so pre-existing
--- occurrences are its baseline rather than historical deltas. The NULL guard
--- makes this safe on every turn and preserves a fork's inherited progress.
-UPDATE workers
-SET ambient_event_cursor = COALESCE((
-    SELECT MAX(ae.id) FROM ambient_events ae WHERE ae.workspace_id = $workspace_id
-), 0)
+-- Worker creation owns the baseline, and fork creation owns its inherited
+-- cursor/boundary. Packet assembly merely verifies that durable invariant.
+SELECT ambient_event_cursor
+FROM workers
 WHERE id = $worker_id
-  AND workspace_id = $workspace_id
-  AND ambient_event_cursor IS NULL
-RETURNING ambient_event_cursor;
+  AND workspace_id = $workspace_id;
 
 -- PREP: engine_pull_ambient_events
 -- One SQLite snapshot captures both ends of the closed observation window.
 -- The LEFT JOIN returns the boundary even when the window contains no event.
 WITH observation AS (
     SELECT w.ambient_event_cursor AS cursor,
+           w.parent_worker_id,
+           w.fork_event_boundary,
            COALESCE(
                (SELECT MAX(ae.id) FROM ambient_events ae WHERE ae.workspace_id = $workspace_id),
                w.ambient_event_cursor,
@@ -329,8 +305,12 @@ WITH observation AS (
 )
 SELECT o.cursor, o.boundary,
        ae.id AS event_id, ae.producer_worker_id, producer.name AS producer_worker_name,
-       ae.kind, ae.source,
-       ae.op, ae.scheme, ae.hostname, ae.pathname, ae.rx, ae.attrs, ae.tags,
+       ae.kind, ae.source, ae.at,
+       ae.op, ae.delimiter, ae.signal,
+       ae.scheme, ae.username, ae.password, ae.hostname, ae.port,
+       ae.pathname, ae.query, ae.fragment, ae.line_marker,
+       ae.tx, ae.mimetype_tx, ae.rx, ae.mimetype_rx,
+       ae.state, ae.outcome, ae.attrs, ae.tags,
        ae.status_rx, ae.terminated_by
 FROM observation o
 LEFT JOIN ambient_events ae
@@ -338,6 +318,15 @@ LEFT JOIN ambient_events ae
  AND ae.id > o.cursor
  AND ae.id <= o.boundary
  AND ae.producer_worker_id != $worker_id
+ AND (
+     ae.target_parent_worker_id = $worker_id
+     OR ae.workspace_broadcast = 1
+     OR (
+         o.fork_event_boundary IS NOT NULL
+         AND ae.target_parent_worker_id = o.parent_worker_id
+         AND ae.id <= o.fork_event_boundary
+     )
+ )
 LEFT JOIN workers producer ON producer.id = ae.producer_worker_id
 ORDER BY ae.id;
 
@@ -346,13 +335,17 @@ ORDER BY ae.id;
 -- targeted conflict rule makes crash replay idempotent without swallowing any
 -- unrelated sequence, FK, or shape violation.
 INSERT INTO log_entries (
-    worker_id, loop_id, turn_id, sequence, origin, source, ambient_event_id,
-    op, scheme, hostname, pathname, tx, mimetype_tx,
-    rx, mimetype_rx, status_rx, weight, expanded, attrs
+    worker_id, loop_id, turn_id, sequence, at, origin, source, ambient_event_id,
+    op, delimiter, signal,
+    scheme, username, password, hostname, port, pathname, query, fragment,
+    lineMarker, tx, mimetype_tx,
+    rx, mimetype_rx, status_rx, weight, state, outcome, folded, attrs
 ) VALUES (
-    $worker_id, $loop_id, $turn_id, $sequence, 'plurnk', $source, $event_id,
-    $op, $scheme, $hostname, $pathname, '', 'text/plain',
-    $rx, $mimetype_rx, $status, $weight, $expanded, $attrs
+    $worker_id, $loop_id, $turn_id, $sequence, $at, '_plurnk', $source, $event_id,
+    $op, $delimiter, $signal,
+    $scheme, $username, $password, $hostname, $port, $pathname, $query, $fragment,
+    $line_marker, $tx, $mimetype_tx,
+    $rx, $mimetype_rx, $status, $weight, $state, $outcome, $folded, $attrs
 )
 ON CONFLICT(worker_id, ambient_event_id) WHERE ambient_event_id IS NOT NULL DO NOTHING
 RETURNING id;
@@ -374,58 +367,59 @@ WHERE id = $worker_id
 RETURNING ambient_event_cursor;
 
 -- PREP: engine_worker_stream_channels
--- {§exec-stream} — every stream channel the worker owns (an EXEC's stdout/stderr live on the
--- runtime-tag entry), with content + mimetype + state + coordinate, so the per-turn injector can
--- publish the channel's next complete unit. Stays listed until its terminal observation is shown.
-SELECT s.id AS subscription_id, e.scheme AS runtime, e.pathname AS coord,
+-- {§exec-stream} — every not-yet-terminally-published stream channel the worker
+-- owns, with its durable per-subscription cursor. Log curation never rewinds it.
+SELECT s.id AS subscription_id, sp.id AS publication_id,
+    sp.published_end, sp.terminal_published,
+    e.scheme AS runtime, e.authority, e.pathname AS coord,
     ec.name AS channel, ec.content AS content, ec.mimetype AS mimetype,
-    ec.state AS state, s.close_status AS close_status,
-    s.close_result AS close_result, s.published_channel AS published_channel
+    ec.state AS state, ec.producer_result AS producer_result,
+    s.published_channel AS published_channel
 FROM subscriptions s
 JOIN entries e ON e.id = s.entry_id
-JOIN entry_channels ec ON ec.entry_id = s.entry_id
+JOIN subscription_publications sp ON sp.subscription_id = s.id
+JOIN entry_channels ec ON ec.entry_id = s.entry_id AND ec.name = sp.channel
 WHERE s.worker_id = $worker_id
-  AND (s.published_channel IS NULL OR ec.name = s.published_channel)
+  AND sp.terminal_published = 0
 ORDER BY s.id, ec.name;
 
--- PREP: engine_stream_cursor
--- {§exec-stream} — content offset already shown to the worker: the streamEnd recorded on its latest
--- foisted observation (the caller defaults to 0 when none exists yet).
-SELECT attrs
-FROM log_entries
-WHERE worker_id = $worker_id AND origin = 'plurnk' AND op = 'READ'
-    AND scheme = $scheme AND pathname = $pathname AND fragment IS $fragment
-ORDER BY id DESC LIMIT 1;
-
 -- PREP: engine_insert_stream_delta
 -- {§exec-stream} / {§env-delta} — materialize a channel's next publishable content as a
--- foisted READ row (the model READs the stream it never typed). origin=plurnk; fragment is
--- the channel; attrs.streamEnd is the next turn's cursor; expanded=1 for a terminal
--- observation, 0 for an ongoing observation. {§exec-stream}
+-- foisted READ row (the model READs the stream it never typed). origin=_plurnk; fragment is
+-- the channel; attrs.streamEnd is the next turn's cursor; terminal observations
+-- are born open and ongoing observations wholly folded. {§exec-stream}
 INSERT INTO log_entries (
     worker_id, loop_id, turn_id, sequence, origin, source, model_call_id,
-    op, scheme, pathname, fragment, tx, mimetype_tx, rx, mimetype_rx, status_rx, weight, attrs, expanded
+    subscription_publication_id,
+    op, scheme, hostname, port, pathname, fragment, tx, mimetype_tx, rx, mimetype_rx, status_rx, weight, attrs, folded
 ) VALUES (
-    $worker_id, $loop_id, $turn_id, $sequence, 'plurnk', NULL, NULL,
-    'READ', $scheme, $pathname, $fragment, '', 'text/plain', $rx, 'application/json', $status, $weight, $attrs, $expanded
+    $worker_id, $loop_id, $turn_id, $sequence, '_plurnk', NULL, NULL,
+    $subscription_publication_id,
+    'READ', $scheme, $hostname, $port, $pathname, $fragment, '', 'text/plain', $rx, 'application/json', $status, $weight, $attrs, $folded
 );
 
 -- PREP: engine_child_workers_live
--- The worker's LIVE child workers — latest loop non-terminal (100 pending / 102 processing / 202 parked).
+-- The worker's LIVE child workers — any loop non-terminal (100 pending / 102 processing / 202 parked).
 -- Powers the Active Child Workers orienting section ({§child-orientation}): terse `* <status> worker://<name>`
 -- pointers so the model SEES what it holds live and reasons for itself (READ/KILL), never told to.
 -- Empty → section omitted.
-SELECT r.name, l.status
+SELECT r.name,
+       CASE
+           WHEN SUM(CASE WHEN l.status = 102 THEN 1 ELSE 0 END) > 0 THEN 102
+           WHEN SUM(CASE WHEN l.status = 202 THEN 1 ELSE 0 END) > 0 THEN 202
+           ELSE 100
+       END AS status
 FROM workers r
-JOIN loops l ON l.id = (SELECT id FROM loops WHERE worker_id = r.id ORDER BY sequence DESC, id DESC LIMIT 1)
+JOIN loops l ON l.worker_id = r.id AND l.status IN (100, 102, 202)
 WHERE r.parent_worker_id = $worker_id AND l.status IN (100, 102, 202)
+GROUP BY r.id, r.name
 ORDER BY r.name;
 
 -- PREP: engine_child_streams_open
 -- The worker's OPEN streams (subscriptions not yet closed) — their addressable coord. Powers the Child
 -- Streams orienting section ({§child-orientation}): terse `* active <runtime>:///<coord>` pointers the
 -- model OPENs/READs/KILLs. Empty → section omitted.
-SELECT s.scheme, e.pathname
+SELECT s.scheme, e.authority, e.pathname
 FROM subscriptions s
 JOIN entries e ON e.id = s.entry_id
 WHERE s.worker_id = $worker_id AND s.closed_at IS NULL
@@ -434,10 +428,22 @@ ORDER BY e.pathname;
 -- PREP: engine_render_errors
 -- SPEC {§operation-results}: 4xx/5xx log rows are indexed in the packet's errors as
 -- LogCoordinate pointers, forcing the model to confront failures instead of letting
--- them rot in log:///. Window = the current turn AND the immediately-prior one
--- (>= current_turn_seq - 1): prior-turn for action failures the model just caused,
--- current-turn so a pre-generate engine error surfaces THIS turn rather than a turn late.
+-- them rot in log:///. Window = the current would-be model turn AND the immediately
+-- preceding completed model turn: prior-model-turn for action failures the
+-- model just caused, current-turn so a pre-generate engine error surfaces THIS turn
+-- rather than a turn late. Packetless chronology never hides a model failure.
 -- {§operation-result-uniform-error-channel}
+WITH previous_model_turn AS (
+    SELECT id
+    FROM turns
+    WHERE loop_id = $loop_id
+      AND sequence < $current_turn_seq
+      AND producer = 'model'
+      AND kind = 'inference'
+      AND completed_at IS NOT NULL
+    ORDER BY sequence DESC
+    LIMIT 1
+)
 SELECT
     le.origin, le.op, le.attrs, le.sequence, le.status_rx, le.rx, le.mimetype_rx,
     le.scheme, le.pathname,
@@ -449,57 +455,68 @@ WHERE le.loop_id = $loop_id
   AND le.status_rx >= 400
   -- {§log-row-self-explains}: every >=400 row points at ITSELF — the op row carries its failure
   -- message on its meta line (packet-wire), so the pointer leads to a record that states its why.
-  AND t.sequence >= $current_turn_seq - 1
+  AND (
+      t.sequence = $current_turn_seq
+      OR t.id = (SELECT id FROM previous_model_turn)
+  )
 ORDER BY t.sequence, le.sequence;
 
--- TX: engine_grinder_fold_newest_turn
--- {§grinder-layer1-rollback} — THE DOCTRINE: the log is the model's memory and the model ALONE
--- curates it (FOLD/KILL). The grinder rolls back only context introduced by the newest turn
--- boundary: rows born in the immediately-prior/current turn plus exact older rows that a successful
--- OPEN in the immediately-prior turn transitioned from folded to open. The durable effect relation
--- owns that landed set; never re-run an authored glob/tag/matcher against later state. An OPEN no-op
--- contributes no older row. Turn 1 is the same rule (no prior turn; its foists are the newest).
--- Folded, never deleted; THREE exemptions ({§grinder-errors-exempt}): op='error',
--- the user prompt, and PLAN. The temporary set captures the
--- selection once so folding and additive `overflow` tagging cannot diverge.
-CREATE TEMP TABLE IF NOT EXISTS engine_grinder_fold_set (id INTEGER PRIMARY KEY);
-DELETE FROM engine_grinder_fold_set;
-WITH previous_turn AS (
-    SELECT MAX(id) AS id FROM turns WHERE loop_id = $loop_id AND id < $turn_id
+-- PREP: overflow_turn_causal_rows
+-- {§overflow-turn-curation} — one deterministic causal set: rows already in
+-- the packetless candidate, rows from the worker's immediately preceding turn,
+-- and older bodies that preceding turn actually made more visible.
+WITH current_turn AS (
+    SELECT turn.id, turn.sequence AS turn_seq,
+           loop.id AS loop_id, loop.sequence AS loop_seq, loop.worker_id
+    FROM turns turn
+    JOIN loops loop ON loop.id = turn.loop_id
+    WHERE turn.id = $turn_id AND loop.id = $loop_id
+),
+previous_turn AS (
+    SELECT prior.id
+    FROM turns prior
+    JOIN loops prior_loop ON prior_loop.id = prior.loop_id
+    JOIN current_turn current ON current.worker_id = prior_loop.worker_id
+    WHERE prior.completed_at IS NOT NULL
+      AND (
+          prior_loop.sequence < current.loop_seq
+          OR (
+              prior_loop.sequence = current.loop_seq
+              AND prior.sequence < current.turn_seq
+          )
+      )
+    ORDER BY prior_loop.sequence DESC, prior.sequence DESC
+    LIMIT 1
+),
+causal_rows(id) AS (
+    SELECT row.id
+    FROM log_entries row
+    WHERE row.turn_id = $turn_id
+       OR row.turn_id = (SELECT id FROM previous_turn)
+    UNION
+    SELECT effect.target_log_entry_id
+    FROM log_curation_effects effect
+    JOIN log_entries operation ON operation.id = effect.operation_log_entry_id
+    WHERE operation.turn_id = (SELECT id FROM previous_turn)
+      AND operation.op = 'OPEN'
+      AND operation.status_rx < 400
+      AND effect.folded_before != effect.folded_after
 )
-INSERT INTO engine_grinder_fold_set (id)
-SELECT boundary.id
-FROM log_entries boundary
-WHERE boundary.loop_id = $loop_id
-  AND boundary.expanded = 1
-  AND COALESCE(boundary.op, '') NOT IN ('error', 'PLAN')
-  AND COALESCE(boundary.scheme, '') != 'prompt'  -- the task frame ({§prompt-self-only}); NULL-safe: a model-emission row's scheme is NULL
-  AND (boundary.turn_id = $turn_id OR boundary.turn_id = (SELECT id FROM previous_turn))
-UNION
-SELECT target.id
-FROM log_curation_effects effect
-JOIN log_entries operation ON operation.id = effect.operation_log_entry_id
-JOIN log_entries target ON target.id = effect.target_log_entry_id
-WHERE operation.turn_id = (SELECT id FROM previous_turn)
-  AND operation.op = 'OPEN'
-  AND operation.status_rx < 400
-  AND effect.expanded_before = 0
-  AND target.expanded = 1
-  AND COALESCE(target.op, '') NOT IN ('error', 'PLAN')
-  AND COALESCE(target.scheme, '') != 'prompt';
-
-UPDATE log_entries SET expanded = 0
-WHERE id IN (SELECT id FROM engine_grinder_fold_set);
-
-INSERT OR IGNORE INTO log_tags (log_entry_id, tag)
-SELECT id, 'overflow' FROM engine_grinder_fold_set;
-
-DELETE FROM engine_grinder_fold_set;
+SELECT row.id,
+       (loop.sequence || '/' || turn.sequence || '/' || row.sequence) AS coordinate,
+       row.origin, row.op, row.attrs,
+       row.tx, row.mimetype_tx, row.rx, row.mimetype_rx,
+       row.folded
+FROM causal_rows causal
+JOIN log_entries row ON row.id = causal.id
+JOIN turns turn ON turn.id = row.turn_id
+JOIN loops loop ON loop.id = row.loop_id
+ORDER BY loop.sequence, turn.sequence, row.sequence;
 
 -- PREP: engine_fold_log_entry
 -- Fold one known log row by id. Model-emission rows use this after insertion so
 -- the complete admitted emission remains available without opening by default.
-UPDATE log_entries SET expanded = 0 WHERE id = $id;
+UPDATE log_entries SET folded = '[[1,-1]]' WHERE id = $id;
 
 -- PREP: engine_render_log
 -- Render-time log-section assembly ({§body-projection}).
@@ -507,8 +524,8 @@ UPDATE log_entries SET expanded = 0 WHERE id = $id;
 -- memory carries across loops within a worker, not just the
 -- current loop. Coordinates append /<op> only for rows that represent an operation.
 -- Status 202 entries in state='proposed' are model-invisible until resolved.
--- `expanded = 0` rows are FOLDED — listed but collapsed to their coordinate
--- (FOLD); the renderer elides the body. {§open-fold}: folded rows stay listed, re-OPENable.
+-- Folded intervals are projected against the canonical body by packet-wire;
+-- wholly folded rows remain listed and re-OPENable. {§open-fold}
 SELECT
     le.id,
     l.sequence  AS loop_seq,
@@ -516,13 +533,13 @@ SELECT
     le.sequence,
     -- le.origin is attribution, never a render filter; the worker's actor — {§actor-boundary-origin-not-filter} {§machine-processes-worker-origin}
     le.origin,
-    le.op, le.suffix, le.signal,
+    le.op, le.delimiter, le.signal,
     le.scheme, le.username, le.password,
     le.hostname, le.port, le.pathname,
     le.query, le.fragment,
     le.status_rx, le.rx, le.mimetype_rx,
     le.tx, le.mimetype_tx,
-    le.state, le.outcome, le.expanded, le.source, le.weight, le.attrs,
+    le.state, le.outcome, le.folded, le.source, le.weight, le.attrs,
     COALESCE((
         SELECT json_group_array(ordered.tag)
         FROM (
@@ -540,8 +557,21 @@ JOIN loops l ON l.id = le.loop_id
 -- {§operation-result-uniform-error-channel}.
 WHERE le.worker_id = $worker_id
   AND NOT (le.status_rx = 202 AND le.state = 'proposed')
-  AND NOT (COALESCE(le.op, '') IN ('OPEN', 'FOLD') AND le.status_rx < 400)
-  AND NOT (COALESCE(le.op, '') = 'KILL' AND le.scheme = 'log' AND le.status_rx < 400)
+  AND NOT (
+      COALESCE(le.op, '') IN ('OPEN', 'FOLD')
+      AND le.status_rx < 400
+      AND le.source IS NULL
+  )
+  AND NOT (COALESCE(le.op, '') = 'KILL' AND le.scheme = 'log' AND le.status_rx < 400 AND le.source IS NULL)
+  -- Successful maintenance-turn rows (doc reconciliation) never render: a
+  -- receipt answers an asker and these turns have none. Rows stay durable and
+  -- READ-able; failures remain visible ({§operation-result-uniform-error-channel}).
+  AND NOT (
+      t.producer = '_plurnk'
+      AND t.kind = 'maintenance'
+      AND COALESCE(le.status_rx, 200) < 400
+      AND le.source IS NULL
+  )
 ORDER BY l.sequence, t.sequence, le.sequence;
 
 -- PREP: engine_insert_log_entry
@@ -551,14 +581,14 @@ ORDER BY l.sequence, t.sequence, le.sequence;
 -- via proposal resolution; entry transitions through engine_resolve_log_entry).
 INSERT INTO log_entries (
     worker_id, loop_id, turn_id, sequence, origin, source, model_call_id,
-    op, suffix, signal,
+    op, delimiter, signal,
     scheme, username, password, hostname, port,
     pathname, query, fragment, lineMarker,
     tx, mimetype_tx, rx, mimetype_rx, status_rx, weight,
     state, outcome, attrs
 ) VALUES (
     $worker_id, $loop_id, $turn_id, $sequence, $origin, $source, $model_call_id,
-    $op, $suffix, $signal,
+    $op, $delimiter, $signal,
     $scheme, $username, $password, $hostname, $port,
     $pathname, $query, $fragment, $lineMarker,
     $tx, $mimetype_tx, $rx, $mimetype_rx, $status_rx, $weight,
@@ -610,25 +640,18 @@ WHERE turn_id = $turn_id
 -- PREP: engine_worker_has_undelivered_stream_term
 -- A stream may finish between its EXEC and a same-turn SEND. It is then no longer
 -- live, but its terminal outcome has not crossed the pre-turn observation boundary:
--- no foisted terminal READ exists yet. Treat that closed result like a same-turn
--- retrieval or child termination so an empty join cannot conclude over unseen work.
+-- one or more selected channel publication rows remain nonterminal. Treat that
+-- closed result like a same-turn retrieval or child termination so an empty
+-- join cannot conclude over unseen work.
 -- Completion is information independently of payload: an empty success and especially
 -- an empty failure must receive the same terminal observation as a non-empty stream.
-SELECT 1 AS pending
+SELECT DISTINCT s.handle AS handle
 FROM subscriptions s
-JOIN entries e ON e.id = s.entry_id
+JOIN subscription_publications sp ON sp.subscription_id = s.id
 WHERE s.worker_id = $worker_id
   AND s.closed_at IS NOT NULL
-  AND NOT EXISTS (
-      SELECT 1 FROM log_entries le
-      WHERE le.worker_id = $worker_id
-        AND le.origin = 'plurnk'
-        AND le.op = 'READ'
-        AND le.scheme = e.scheme
-        AND le.pathname = e.pathname
-        AND json_extract(le.attrs, '$.terminal') = 1
-  )
-LIMIT 1;
+  AND sp.terminal_published = 0
+LIMIT 8;
 
 -- PREP: engine_turn_failures
 -- {§send-premature-terminate} — THIS turn's failed op results (the model's own ops, status >= 400), whose
@@ -646,20 +669,23 @@ WHERE turn_id = $turn_id
   AND status_rx >= 400
   AND (op != 'error' OR source = 'grammar');
 
--- PREP: engine_reconcile_turn_status
--- A SEND's signal is only provisional until dispatch adjudicates live obligations and failures.
--- The close writes packet+usage before ops dispatch, so reconcile the persisted turn whenever
--- dispatch changes that disposition (for example refused 200 -> 102 or drained 202 -> 200).
-UPDATE turns SET status = $status WHERE id = $id;
-
-
-
 -- PREP: engine_loop_sequence
 -- The loop's per-worker sequence — the model-facing coordinate (prompt/<worker>/<loop-seq>/<turn-seq>,
 -- matching the log's loop-relative numbering). The raw db id leaked into prompt paths and the
 -- model's first loop read as prompt/2/1 (the docs loop holds id 1). Owner: minor but annoying.
 SELECT sequence FROM loops WHERE id = $loop_id;
 
+-- PREP: engine_worker_has_inference_history
+-- Administrative turns may legitimately precede the first provider exchange.
+-- Initialization is therefore keyed to inference history, never loop ordinals.
+SELECT EXISTS (
+    SELECT 1
+    FROM turns t
+    JOIN loops l ON l.id = t.loop_id
+    WHERE l.worker_id = $worker_id
+      AND (t.producer = 'model' OR t.kind = 'initialization')
+) AS present;
+
 -- PREP: engine_worker_lineage_root
 -- The no-parent root of a worker lineage; a root worker returns itself.
 -- {§worker-primary}
@@ -692,10 +718,9 @@ WHERE current.id = $worker_id;
 -- not a second timestamp race. {§send-undelivered-child-term}
 SELECT 1 AS pending
 FROM ambient_events ae
-JOIN workers child ON child.id = ae.producer_worker_id
 JOIN workers parent ON parent.id = $worker_id
 WHERE ae.workspace_id = parent.workspace_id
   AND ae.kind = 'loop_termination'
-  AND child.parent_worker_id = parent.id
+  AND ae.target_parent_worker_id = parent.id
   AND ae.id > COALESCE(parent.ambient_event_cursor, 0)
 LIMIT 1;

package/dist/core/EntryAddressBinding.d.ts

@@ -0,0 +1,32 @@
+import { type ParsedPath } from "@plurnk/plurnk-contracts";
+import { type SchemeAddressCtx, type SchemeHandler, type SchemeResult } from "@plurnk/plurnk-schemes";
+import type { Db } from "./Db.ts";
+import type { PlurnkSchemeContext, SchemeManifest } from "./scheme-types.ts";
+export interface BoundEntryAddress {
+    readonly ownerId: number;
+    readonly scheme: string;
+    readonly authority: string;
+    readonly pathname: string;
+}
+export interface EntryAddressResolution {
+    readonly address: BoundEntryAddress | null;
+    readonly result: SchemeResult | null;
+}
+type AddressResolver = Pick<SchemeHandler, "resolveEntryAddress">;
+export default class EntryAddressBinding {
+    #private;
+    constructor(db: Db);
+    static addressContext(ctx: PlurnkSchemeContext): SchemeAddressCtx;
+    fixedOwnerId(manifest: SchemeManifest, ctx: PlurnkSchemeContext): Promise<number | null>;
+    resolve({ target, routedScheme, handler, manifest, ctx, }: {
+        target: ParsedPath;
+        routedScheme: string;
+        handler: AddressResolver;
+        manifest: SchemeManifest & {
+            readonly category: "data";
+        };
+        ctx: PlurnkSchemeContext;
+    }): Promise<EntryAddressResolution>;
+}
+export {};
+//# sourceMappingURL=EntryAddressBinding.d.ts.map