@plurnk/plurnk-service 1.3.2 → 1.3.4

package/dist/core/Dispatcher.js

@@ -7,12 +7,14 @@ import WorkerCap from "./worker-cap.js";
 import { decodePathParens } from "./path-decode.js";
 import Namespace from "./namespace.js";
 import { DEFAULT_LOOP_FLAGS } from "./scheme-types.js";
+import ChannelWrite from "./ChannelWrite.js";
 import { LineMarkerOps, MimetypeBinary } from "../content/index.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
 import EntryCrud from "../schemes/_entry-crud.js";
 import EntryFind from "../schemes/_entry-find.js";
 import EntryOps from "../schemes/_entry-ops.js";
 import WorkspaceSettings from "./workspace-settings.js";
+import LoopLifecycle from "./LoopLifecycle.js";
 // SPEC §scheme-surface: writer must be in target scheme's manifest.writableBy.
 // OPEN/FOLD/READ/FIND are not gated — they curate the log or read, never mutating an entry.
 const MUTATING_OPS = new Set(["EDIT", "SEND", "COPY", "MOVE", "EXEC", "KILL", "FORK", "WORK"]);
@@ -39,6 +41,7 @@ class Dispatcher {
     #wakeWorkerNotify;
     #injectWorker;
     #cancelWorker;
+    #cancelDescendants;
     // §send-premature-terminate/[102]<T> — the engine-owned park-deadline registry (loopId → seconds;
     // -1 = indefinite). The dispatcher WRITES at park; the daemon's drain park-exit consumes.
     #parkDeadlines;
@@ -46,7 +49,10 @@ class Dispatcher {
     // §join-blocking-collect (#354) — loops with a READ(worker://running-child) armed this turn; a bare
     // SEND[102] parks on it (blocking join). Engine-owned, twin of #parkDeadlines.
     #joinTargets;
-    constructor({ db, schemes, mimetypes, tokenize, telemetry, proposals, executors, loopSignal, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, searchGate, parkDeadlines, joinTargets }) {
+    #liveSubscriptions;
+    #lifecycle;
+    #preparedEdits = new WeakMap();
+    constructor({ db, schemes, mimetypes, tokenize, telemetry, proposals, executors, loopSignal, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants, searchGate, parkDeadlines, joinTargets, liveSubscriptions }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#mimetypes = mimetypes;
@@ -59,13 +65,58 @@ class Dispatcher {
         this.#wakeWorkerNotify = wakeWorkerNotify;
         this.#injectWorker = injectWorker;
         this.#cancelWorker = cancelWorker;
+        this.#cancelDescendants = cancelDescendants;
         this.#parkDeadlines = parkDeadlines ?? new Map();
         this.#searchGate = searchGate;
         this.#joinTargets = joinTargets ?? new Set();
+        this.#liveSubscriptions = liveSubscriptions;
+        this.#lifecycle = new LoopLifecycle(db);
     }
     // workspace → project_root, memoized: {§fs-namespace} fixes the root immutably at
     // workspace creation, so a process-lifetime cache can never go stale.
     #rootCache = new Map();
+    #handlerContext(scheme, ctx) {
+        const manifest = this.#schemes.manifestFor(scheme);
+        return manifest === undefined ? null : new SchemeCtxImpl(ctx, scheme, manifest, this.#liveSubscriptions);
+    }
+    #entryContext(scheme, ctx) {
+        const handlerCtx = this.#handlerContext(scheme, ctx);
+        return this.#schemes.manifestFor(scheme)?.category === "data" ? handlerCtx : null;
+    }
+    async #readEntry(scheme, pathname, ctx) {
+        const handler = this.#schemes.get(scheme);
+        const handlerCtx = this.#entryContext(scheme, ctx);
+        if (typeof handler?.readEntry === "function" && handlerCtx !== null)
+            return handler.readEntry(pathname, handlerCtx);
+        const caps = handlerCtx?.entries;
+        if (caps === undefined)
+            return { status: 501, entry: null };
+        const result = await caps.read(pathname, scheme === "prompt" ? "worker" : "commons");
+        return {
+            status: result.status,
+            entry: result.entry === null
+                ? null
+                : { channels: { ...result.entry.channels }, tags: [...result.entry.tags] },
+        };
+    }
+    async #writeEntry(scheme, pathname, entry, ctx) {
+        const handler = this.#schemes.get(scheme);
+        const handlerCtx = this.#entryContext(scheme, ctx);
+        if (typeof handler?.writeEntry === "function" && handlerCtx !== null)
+            return handler.writeEntry(pathname, entry, handlerCtx);
+        const caps = handlerCtx?.entries;
+        if (caps === undefined)
+            return { status: 501, created: false, entryId: null };
+        return caps.write(pathname, entry);
+    }
+    async #deleteEntry(scheme, pathname, ctx) {
+        const handler = this.#schemes.get(scheme);
+        const handlerCtx = this.#entryContext(scheme, ctx);
+        if (typeof handler?.deleteEntry === "function" && handlerCtx !== null)
+            return handler.deleteEntry(pathname, handlerCtx);
+        const caps = handlerCtx?.entries;
+        return caps === undefined ? { status: 501 } : caps.delete(pathname);
+    }
     async #workspaceRoot(workspaceId) {
         if (this.#rootCache.has(workspaceId))
             return this.#rootCache.get(workspaceId) ?? null;
@@ -85,7 +136,86 @@ class Dispatcher {
         if (key !== null)
             target.pathname = key;
     }
+    async prepareEditBatches(statements, context) {
+        const { workspaceId, workerId, loopId, turnId, origin } = context;
+        const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId, origin });
+        const groups = new Map();
+        for (const statement of statements) {
+            const target = this.#extractTarget(statement.target);
+            await this.#canonColumns(target, workspaceId);
+            const key = JSON.stringify([
+                schemeNameOf(statement.target),
+                target.scheme,
+                target.hostname,
+                target.pathname,
+                target.fragment,
+            ]);
+            const group = groups.get(key);
+            if (group === undefined)
+                groups.set(key, [statement]);
+            else
+                group.push(statement);
+        }
+        for (const group of groups.values()) {
+            const first = group[0];
+            const schemeName = schemeNameOf(first.target);
+            let initial;
+            let denial = group.map((statement) => this.#checkWritable(statement, origin)).find((result) => result !== null) ?? null;
+            if (denial === null) {
+                for (const statement of group) {
+                    denial = await this.#checkFlagsGate(statement, loopId);
+                    if (denial !== null)
+                        break;
+                }
+            }
+            if (denial !== null) {
+                initial = denial;
+            }
+            else if (schemeName === null) {
+                initial = { status: 400 };
+            }
+            else {
+                const handler = this.#schemes.get(schemeName);
+                const method = handler?.editBatch;
+                const manifest = this.#schemes.manifestFor(schemeName);
+                if (typeof method !== "function" || manifest === undefined) {
+                    initial = { status: 501 };
+                }
+                else {
+                    try {
+                        const addressedScheme = first.target?.kind === "url" ? first.target.scheme : schemeName;
+                        initial = await method.call(handler, group, new SchemeCtxImpl(schemeCtx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions));
+                    }
+                    catch (err) {
+                        initial = { status: 500, error: err instanceof Error ? err.message : String(err) };
+                    }
+                }
+            }
+            let resolveSettled;
+            const settled = new Promise((resolve) => { resolveSettled = resolve; });
+            const prepared = {
+                first: true,
+                index: 0,
+                initial,
+                settled,
+                settle: resolveSettled,
+            };
+            this.#preparedEdits.set(first, prepared);
+            for (const [index, statement] of group.slice(1).entries()) {
+                this.#preparedEdits.set(statement, { ...prepared, first: false, index: index + 1 });
+            }
+        }
+    }
     async dispatch(context) {
+        const result = await this.#dispatchOne(context);
+        if (context.statement.op === "EDIT") {
+            const prepared = this.#preparedEdits.get(context.statement);
+            if (prepared?.first === true)
+                prepared.settle(result);
+        }
+        return result;
+    }
+    async #dispatchOne(context) {
         const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, turnParseErrors } = context;
         const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId, origin });
         let result;
@@ -108,7 +238,37 @@ class Dispatcher {
             // skips it. Logging failures (#writeLog throws) are NOT caught —
             // those are system failures.
             try {
-                if (statement.op === "SEND" && statement.target === null) {
+                if (statement.op === "EDIT") {
+                    const prepared = this.#preparedEdits.get(statement);
+                    if (prepared === undefined) {
+                        result = { status: 500, error: "EDIT reached dispatch without a prepared resource batch" };
+                    }
+                    else {
+                        const settled = prepared.first ? prepared.initial : await prepared.settled;
+                        const aggregate = settled.editReceipt ?? prepared.initial.editReceipt;
+                        if (aggregate !== null && typeof aggregate === "object") {
+                            const receipt = aggregate;
+                            const effect = receipt.effects[prepared.index];
+                            if (effect === undefined)
+                                throw new Error(`EDIT receipt has no effect at index ${prepared.index}`);
+                            const { editReceipt: _editReceipt, ...withoutAggregate } = settled;
+                            result = {
+                                ...withoutAggregate,
+                                receipt: {
+                                    revision: receipt.revision,
+                                    unit: receipt.unit,
+                                    before: receipt.before,
+                                    after: receipt.after,
+                                    effect,
+                                },
+                            };
+                        }
+                        else {
+                            result = settled;
+                        }
+                    }
+                }
+                else if (statement.op === "SEND" && statement.target === null) {
                     result = await this.#handleSendBroadcast(statement, { workspaceId, workerId, loopId, turnId, turnParseErrors });
                 }
                 else if (statement.op === "FORK" || statement.op === "WORK") {
@@ -216,12 +376,13 @@ class Dispatcher {
                 const moveSource = result.attrs?.moveSource;
                 if (moveSource !== undefined) {
                     const srcHandler = this.#schemes.get(moveSource.scheme);
-                    if (srcHandler !== undefined && typeof srcHandler.deleteEntry === "function") {
-                        const del = await srcHandler.deleteEntry(moveSource.pathname, schemeCtx);
+                    if (srcHandler !== undefined) {
+                        const del = await this.#deleteEntry(moveSource.scheme, moveSource.pathname, schemeCtx);
                         // A host-effecting source-delete PROPOSES (202); the MOVE proposal already gated the whole
                         // create+kill, so apply the source-delete now — never raise a second review for one MOVE.
-                        if (del.status === 202 && del.attrs !== undefined && typeof srcHandler.applyResolution === "function")
-                            await srcHandler.applyResolution({ attrs: del.attrs }, schemeCtx);
+                        const sourceCtx = this.#handlerContext(moveSource.scheme, schemeCtx);
+                        if (del.status === 202 && del.attrs !== undefined && typeof srcHandler.applyResolution === "function" && sourceCtx !== null)
+                            await srcHandler.applyResolution({ attrs: del.attrs }, sourceCtx);
                     }
                 }
             }
@@ -501,8 +662,7 @@ class Dispatcher {
         const srcSchemeName = schemeNameOf(srcPath);
         if (srcSchemeName === null)
             return { status: 400, error: "MOVE source must be a URL path with a scheme" };
-        const srcHandler = this.#schemes.get(srcSchemeName);
-        if (srcHandler === undefined || typeof srcHandler.deleteEntry !== "function")
+        if (!this.#schemes.has(srcSchemeName))
             return { status: 501 };
         // Relocation: COPY then DELETE source (§move-relocation-deletes-source).
         const copyResult = await this.#copyOrchestration({ statement, srcPath, dstPath, ctx });
@@ -516,7 +676,7 @@ class Dispatcher {
         if (copyResult.status === 202) {
             return { ...copyResult, attrs: { ...copyResult.attrs, moveSource: { scheme: srcSchemeName, pathname: srcPathname } } };
         }
-        const delResult = await srcHandler.deleteEntry(srcPathname, ctx);
+        const delResult = await this.#deleteEntry(srcSchemeName, srcPathname, ctx);
         if (delResult.status >= 400)
             return { status: delResult.status };
         return copyResult;
@@ -549,7 +709,8 @@ class Dispatcher {
         if (killable !== undefined && typeof killable.kill === "function") {
             // Pass the model's OWN scheme so a stream-KILL error answers in the runtime tag the
             // model addressed (sh:///…), not the internal `exec` ({§fs-answer-in-canon}).
-            return await killable.kill(pathnameFromPath(path), statement.signal, ctx, schemeName);
+            const handlerCtx = this.#handlerContext(schemeName, ctx);
+            return handlerCtx === null ? { status: 501 } : await killable.kill(pathnameFromPath(path), statement.signal, handlerCtx, schemeName);
         }
         if (schemeName === "worker") {
             // Entry-path present → KILL a worker-scope scratch ENTRY (delete it), self-only —
@@ -558,11 +719,11 @@ class Dispatcher {
             const entryPath = path.kind === "url" ? (path.pathname ?? "") : "";
             if (entryPath !== "" && entryPath !== "/") {
                 const workerHandler = this.#schemes.get("worker");
-                return await workerHandler.killEntry(statement, ctx);
+                const handlerCtx = this.#handlerContext("worker", ctx);
+                return handlerCtx === null ? { status: 501 } : await workerHandler.killEntry(statement, handlerCtx);
             }
-            // terminate — abort any worker by address; whoever holds it may end it.
-            // `worker://self` = self. cancelWorker (→ Daemon.cancelDrain) aborts the worker's signal
-            // (its loop closes 499); an idle run is a no-op-200, a missing run 404.
+            // Terminate an addressed worker's structured scope. `worker://self` = self.
+            // An idle worker is a no-op 200; a missing worker is 404.
             const name = path.kind === "url" ? (path.hostname ?? "") : ""; // §worker-scheme — the worker is the AUTHORITY
             if (name === "")
                 return { status: 400, error: "worker:// kill requires a worker name or ~ (worker://<name>)" };
@@ -575,21 +736,16 @@ class Dispatcher {
             }
             if (this.#cancelWorker === undefined)
                 throw new Error("run kill: cancelWorker capability absent");
-            // §op-synchronous — KILL is DECISIVE: flip the worker's live loops to 499 NOW so the
-            // same-turn premature-terminate gate sees it dead (KILL … SEND[200] concludes in ONE
-            // turn — the model never reasons about async reap timing). The physical scope reap
-            // (drain abort + stream teardown) then rides cancelWorker; a killed loop can't heal back
-            // because cancelWorker aborts its drain's signal.
-            await this.#db.engine_terminate_worker_live_loops.run({ worker_id: workerId, message: "killed via worker:// KILL" });
-            this.#cancelWorker(workerId);
+            // §op-synchronous — KILL is decisive. Await the one lifecycle owner so the
+            // same-turn pending-work gate observes the complete subtree as terminal.
+            await this.#cancelWorker(workerId, "killed via worker:// KILL");
             return { status: 200 };
         }
-        const handler = this.#schemes.get(schemeName);
-        if (handler === undefined || typeof handler.deleteEntry !== "function")
+        if (!this.#schemes.has(schemeName))
             return { status: 501 };
         // A host-effecting delete (file) returns 202 to PROPOSE — pass its attrs through so the proposal
         // carries the delete target to review (§isProposal fires on 202). Plurnk-internal deletes execute inline.
-        const delResult = await handler.deleteEntry(pathnameFromPath(path), ctx);
+        const delResult = await this.#deleteEntry(schemeName, pathnameFromPath(path), ctx);
         return delResult.attrs !== undefined ? { status: delResult.status, attrs: delResult.attrs } : { status: delResult.status };
     }
     // Multi-file READ fan-out (SPEC §matcher-result — "the companion to FIND's survey"). A glob
@@ -613,15 +769,15 @@ class Dispatcher {
         const schemeName = schemeNameOf(t);
         return p.endsWith("/") && schemeName !== null && this.#schemes.manifestFor(schemeName)?.folderScopes === true;
     }
-    // Clone the READ onto one concrete match — the FIND already matched, so the per-match READ
-    // delivers content at the span: strip the body (no re-match) and set <L> to the span. A null
-    // span (body-less folder/glob fan-out) reads the whole entry. #286
+    // Clone the READ onto one concrete match — the FIND already matched, so strip the body
+    // (no re-match) and set <L> to its readable-row span. A null span (body-less folder/glob
+    // fan-out) reads the whole entry. #286
     static #retargetRead(statement, pathname, span) {
         const t = statement.target;
         const target = t !== null && t.kind === "url"
             ? { ...t, pathname, raw: `${t.scheme}://${pathname}` }
             : { ...t, raw: pathname };
-        const lineMarker = span !== null ? { marks: [span.lineStart, span.lineEnd] } : null;
+        const lineMarker = span !== null ? { marks: [span.rowStart, span.rowEnd] } : null;
         return { ...statement, target: target, lineMarker, body: null };
     }
     #standardEntryManifest(schemeName, statement) {
@@ -652,7 +808,7 @@ class Dispatcher {
         const displayPath = hostPrefix !== null && pathname.startsWith(`${hostPrefix}/`)
             ? pathname.slice(hostPrefix.length)
             : pathname;
-        const lineMarker = span === null ? null : { marks: [span.lineStart, span.lineEnd] };
+        const lineMarker = span === null ? null : { marks: [span.rowStart, span.rowEnd] };
         return {
             ...statement,
             target: storage
@@ -695,10 +851,10 @@ class Dispatcher {
             onDispatch?.(id);
             return { ...result, rowsWritten: 1 };
         }
-        // One READ row per MATCH — the span's source lines (or the whole entry for a body-less
-        // folder/glob). The match span is SOURCE LINES, so deliver via a raw line-slice — NOT the
-        // scheme's <L> (which is item-index for application/json, structural for xml). Read each
-        // distinct entry's content once, then line-slice per match. #286
+        // One READ row per MATCH — deliver its source lines (or the whole entry for a body-less
+        // folder/glob) while the logged statement carries the corresponding readable-row scope.
+        // The delivery uses a raw line-slice rather than reinterpreting provenance as the scheme's
+        // structural <L>. Read each distinct entry's content once, then line-slice per match. #286
         // §matcher-selection-signal — the SELECTION SUMMARY row: the internal FIND that located
         // the matches is WRITTEN (op=FIND, its full result — per-hit matchSpan + matchPath, the
         // canonical dialect coordinate) before the per-match deliveries, exactly as if the model
@@ -791,20 +947,16 @@ class Dispatcher {
         const dstHandler = this.#schemes.get(dstSchemeName);
         if (srcHandler === undefined || dstHandler === undefined)
             return { status: 501 };
-        if (typeof srcHandler.readEntry !== "function" || typeof dstHandler.writeEntry !== "function")
-            return { status: 501 };
         const srcPathname = pathnameFromPath(srcPath);
         const dstPathname = pathnameFromPath(dstPath);
-        const srcResult = await srcHandler.readEntry(srcPathname, ctx);
+        const srcResult = await this.#readEntry(srcSchemeName, srcPathname, ctx);
         if (srcResult.status !== 200 || srcResult.entry === null)
             return { status: 404, error: `COPY/MOVE source not found: ${srcSchemeName}://${srcPathname}` }; // §copy-missing-source-404 §move-missing-source-404
         const entry = srcResult.entry;
         // Destination read — the conflict/no-op verdict is deferred until the
         // to-be-written content is known (after <L> slice + tag resolution below),
         // so an identical re-copy resolves to 304 instead of a phantom 409.
-        const dstExisting = typeof dstHandler.readEntry === "function"
-            ? await dstHandler.readEntry(dstPathname, ctx)
-            : null;
+        const dstExisting = await this.#readEntry(dstSchemeName, dstPathname, ctx);
         // Mimetype compatibility check against the destination scheme's manifest
         const dstManifest = dstHandler.constructor.manifest;
         const dstChannels = dstManifest?.channels ?? {};
@@ -852,7 +1004,7 @@ class Dispatcher {
                 return { status: 304 }; // identical → §copy-noop-304
             return { status: 409, error: `COPY/MOVE destination exists: ${dstSchemeName}://${dstPathname}` }; // §copy-conflict-409
         }
-        const writeResult = await dstHandler.writeEntry(dstPathname, { channels, tags }, ctx);
+        const writeResult = await this.#writeEntry(dstSchemeName, dstPathname, { channels, tags }, ctx);
         // A file dest returns 202 (disk write → §membership review): propagate the
         // proposal so dispatch runs the gate + routes applyResolution to the dest.
         if (writeResult.status === 202)
@@ -874,16 +1026,34 @@ class Dispatcher {
         const liveChild = await this.#db.engine_worker_has_live_child.get({ worker_id: workerId });
         if (liveChild !== undefined)
             pending.push("surviving workers");
-        const retrievals = await this.#db.engine_turn_retrievals.all({ turn_id: turnId });
-        if (retrievals.length > 0)
+        const observations = await this.#pendingObservations(workerId, turnId);
+        if (observations.retrievals)
             pending.push("this turn's retrieval results (they land in the NEXT packet's Log)");
-        // §send-undelivered-child-term — a worker that concluded DURING this turn's generation is no
-        // longer "live" but its deliverable hasn't reached any packet yet; concluding discards it.
-        const undelivered = await this.#db.engine_worker_has_undelivered_child_term.get({ worker_id: workerId, turn_id: turnId });
-        if (undelivered !== undefined)
+        if (observations.streamTerminations) {
+            pending.push("completed stream results that land in the NEXT packet's Log");
+        }
+        if (observations.childTerminations)
             pending.push("worker results that arrived during this turn (they land NEXT turn)");
         return pending;
     }
+    // Results cross an observation boundary only when they have appeared in a
+    // packet. Completion alone is not delivery. Keep the three next-packet
+    // producers in one classifier so SEND[200]'s discard gate and SEND[202]'s
+    // empty-join decision cannot disagree about what remains unseen.
+    async #pendingObservations(workerId, turnId) {
+        const [retrievals, streamTermination, childTermination] = await Promise.all([
+            this.#db.engine_turn_retrievals.all({ turn_id: turnId }),
+            this.#db.engine_worker_has_undelivered_stream_term
+                .get({ worker_id: workerId }),
+            this.#db.engine_worker_has_undelivered_child_term
+                .get({ worker_id: workerId, turn_id: turnId }),
+        ]);
+        return {
+            retrievals: retrievals.length > 0,
+            streamTerminations: streamTermination !== undefined,
+            childTerminations: childTermination !== undefined,
+        };
+    }
     // J — a live obligation to WAIT on: a spawned child or an open stream (NOT retrievals, which land
     // next turn regardless). The wait-side twin of #pendingSet's stream+child legs (§wait-obligation-matrix).
     async #hasLiveWork(workerId) {
@@ -917,12 +1087,14 @@ class Dispatcher {
         // terminal with a live child stays the existing premature-terminate steer (#354 decision #1).
         const joinArmed = this.#joinTargets.delete(loopId);
         if (status === 102 && statement.lineMarker === null && joinArmed) {
-            await this.#db.engine_loop_set_status.run({ status: 202, loop_id: loopId, message: raw.length > 0 ? raw : "parked — awaiting a worker's result (blocking collect)" });
+            if (!await this.#lifecycle.park(loopId, raw.length > 0 ? raw : "parked — awaiting a worker's result (blocking collect)")) {
+                return { status: await this.#lifecycle.status(loopId) };
+            }
             this.#parkDeadlines.set(loopId, -1); // indefinite: the bounded child's terminal is the wake edge
             return { status: 102, attrs: { parked: -1, join: true } };
         }
-        // §wait-obligation-matrix — the WAIT: SEND[202], and the legacy SEND[102]<T> the terminal
-        // redesign spelled the same park with, are one obligation-checked wait (waitpid). A live
+        // §wait-obligation-matrix — SEND[202] and the legacy SEND[102]<T> are one
+        // obligation-checked join. A live
         // obligation (a spawned child or open stream, J) BLOCKS the loop until it concludes and
         // reawakens it (§worker-lifecycle-child-wake); a wait on nothing (∅) is already satisfied and
         // resolves like 200, so <-1>+∅ self-resolves rather than hang the agent; a pending own
@@ -931,26 +1103,27 @@ class Dispatcher {
             const marks = statement.lineMarker?.marks[0];
             const seconds = typeof marks === "number" ? marks : -1; // bare 202 / absent T = indefinite, bounded by the join
             if (await this.#hasLiveWork(workerId)) {
-                await this.#db.engine_loop_set_status.run({ status: 202, loop_id: loopId, message: raw.length > 0 ? raw : "waiting on live work" });
+                if (!await this.#lifecycle.park(loopId, raw.length > 0 ? raw : "waiting on live work")) {
+                    return { status: await this.#lifecycle.status(loopId) };
+                }
                 this.#parkDeadlines.set(loopId, seconds);
                 return { status: 202, attrs: { waiting: seconds } };
             }
-            const retrievals = await this.#db.engine_turn_retrievals.all({ turn_id: turnId });
-            if (retrievals.length > 0)
-                return { status: 102 }; // R lands next turn — continue, don't conclude over it
-            // §send-undelivered-child-term — the fan-out race: a worker that concluded DURING this
-            // turn's generation is not live (J misses it), but its collect delta is queued for the
-            // NEXT build. The wait is NOT on nothing — the results are on the doorstep. Parking
-            // would hang (the wake edges already fired into an unparked run); R semantics: continue,
-            // the deltas land next turn, the model weighs them and concludes.
-            const undelivered = await this.#db.engine_worker_has_undelivered_child_term.get({ worker_id: workerId, turn_id: turnId });
-            if (undelivered !== undefined)
+            // Retrievals, fast stream conclusions, and child conclusions are
+            // all complete-but-unobserved. Their wake edge may already have
+            // fired, so do not park; continue directly to the packet that
+            // materializes them.
+            const observations = await this.#pendingObservations(workerId, turnId);
+            if (observations.retrievals || observations.streamTerminations || observations.childTerminations) {
                 return { status: 102 };
-            // ∅ — a wait on nothing is a contradiction, the mirror of premature-terminate (owner
-            // ruling, #502 run113): concluding it silently laundered the one signal that something
-            // was structurally off (the model believed work was pending; nothing was). 409 gives
-            // the turn back with the fact — the recovery rail this exact confusion needs.
-            return { status: 409, error: "Attempted [202] wait with nothing pending: no surviving streams, no worker runs, no unretrieved results." };
+            }
+            // The joined set is already drained. Awaiting an empty task group completes
+            // immediately; it never parks and needs no corrective model turn.
+            const finished = await this.#lifecycle.finish(loopId, 200, raw === "" ? null : raw);
+            return {
+                status: finished ? 200 : await this.#lifecycle.status(loopId),
+                attrs: { joined: true, pending: 0 },
+            };
         }
         // §send-300-choices — ask the operator and park (the answer returns via loop.inject).
         // The three-state cascade (owner design): PLURNK_QUESTIONS unset = ALLOWED (not enabled);
@@ -975,7 +1148,7 @@ class Dispatcher {
         }
         // [200] — terminate, gated by the pending set (post-batch). The row records the refused
         // attempt faithfully (status_rx=409, never erased); the loop stays a continue; the strike
-        // couples in runTurn. [499] abandons regardless — discard by stated intent.
+        // couples in runTurn. [499] abandons and cancels the descendant scope.
         if (status === 200) {
             // §send-200-failed-ops (#363, owner ruling: never 200 over a failed op) — the failure
             // twin of the pending set: this turn's failed op results (and this emission's parse
@@ -1008,11 +1181,14 @@ class Dispatcher {
                 }
                 return { status: 409, error: `Attempted [200] termination in a turn that performs retrieval or has surviving work: ${pending.join("; ")}. KILL what you no longer need; SEND[102] (or [102]<seconds>) to receive the rest; then conclude.` };
             }
-            await this.#db.engine_loop_set_status.run({ status: 200, loop_id: loopId, message: raw === "" ? null : raw });
-            return { status: 200 };
+            const finished = await this.#lifecycle.finish(loopId, 200, raw === "" ? null : raw);
+            return { status: finished ? 200 : await this.#lifecycle.status(loopId) };
         }
         if (status === 499) {
-            await this.#db.engine_loop_set_status.run({ status: 499, loop_id: loopId, message: raw === "" ? null : raw });
+            const finished = await this.#lifecycle.finish(loopId, 499, raw === "" ? null : raw);
+            if (!finished)
+                return { status: await this.#lifecycle.status(loopId) };
+            await this.#cancelDescendants?.(workerId, raw === "" ? "parent abandoned its scope" : raw);
             return { status: 499 };
         }
         // Every other signal — 102 bare, 202 (retired as a terminal; now ordinary mid-comms), 1xx —
@@ -1022,6 +1198,26 @@ class Dispatcher {
     async #run(schemeName, statement, ctx) {
         if (schemeName === null)
             return { status: 400 };
+        if (statement.op === "SEND" && statement.signal === 499 && statement.target?.kind === "url") {
+            const entry = await this.#db.crud_find_workspace_entry.get({
+                workspace_id: ctx.workspaceId,
+                owner_id: await Owner.commonsId(this.#db, ctx.workspaceId),
+                scheme: schemeName,
+                pathname: pathnameFromPath(statement.target),
+            });
+            if (entry !== undefined) {
+                const subscription = await ChannelWrite.findActiveSubscription(this.#db, {
+                    workerId: ctx.workerId,
+                    entryId: entry.id,
+                });
+                if (subscription !== null && subscription.scheme === schemeName) {
+                    const cancelled = await this.#liveSubscriptions.cancel(subscription.id);
+                    return cancelled
+                        ? { status: 200 }
+                        : { status: 500, error: `subscription ${subscription.id} is durable but has no live cancellation handle` };
+                }
+            }
+        }
         const handler = this.#schemes.get(schemeName);
         if (handler === undefined)
             return { status: 501 };
@@ -1033,7 +1229,7 @@ class Dispatcher {
         const manifest = this.#schemes.manifestFor(schemeName);
         if (manifest === undefined)
             throw new Error(`scheme '${schemeName}' has no manifest`);
-        return method.call(handler, statement, new SchemeCtxImpl(ctx, addressedScheme ?? schemeName, manifest));
+        return method.call(handler, statement, new SchemeCtxImpl(ctx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions));
     }
     // A status-202 result is a reviewable PROPOSAL (a side-effecting op — EDIT/EXEC/
     // directed write — paused for client resolution) UNLESS it is a broadcast SEND.