@plurnk/plurnk-service 1.29.0 → 3.0.0

package/dist/core/TurnRunner.js

@@ -2,7 +2,7 @@ var _a;
 import NativeContent from "./NativeContent.js";
 import { PlurnkParser } from "@plurnk/plurnk-parser";
 import { PathSyntax, PlurnkParseError, TurnDisposition, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
-import LoopPolicyReader from "./LoopPolicyReader.js";
+import WorkerOwners from "./WorkerOwners.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { aggregateProviderAccounting } from "@plurnk/plurnk-providers";
 const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
@@ -35,7 +35,6 @@ import { RECEIPT_RESERVE, reserved } from "./ContextFit.js";
 import Results, { OperationFailureError } from "./results.js";
 import Turn from "./Turn.js";
 import ProviderRecovery from "./ProviderRecovery.js";
-import PacketBuilder from "./PacketBuilder.js";
 import StoredPacket from "./StoredPacket.js";
 import { observed, observedSync } from "../observe/spans.js";
 import { genAiRequestName, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
@@ -43,7 +42,6 @@ import { PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
 import ModelCall, { ModelCallPersistenceError, ProviderAccountingIntegrityError } from "./ModelCall.js";
 import WorkerName from "./WorkerName.js";
 import TurnOps from "./TurnOps.js";
-import CapabilityPolicies from "./CapabilityPolicies.js";
 import CapabilityResolver from "./CapabilityResolver.js";
 const regexLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 const workerCatalogTarget = (namespace) => {
@@ -270,18 +268,15 @@ class TurnRunner {
     // {§packet-attachment-parts}: native parts come from the READ's immutable snapshot,
     // never from a source that may have changed since the observation.
     async #wireMessages(packet, ctx, provider) {
-        // {§packet-wire-envelope} — each emission row the packet placed carries its emission as the
-        // worker's own assistant message.
-        const emissions = this.#packets.emissionsFor(packet);
         const accepted = acceptedKinds(provider.inputModalities);
         if (accepted.length === 0 || !(packet.attachments ?? []).some((attachment) => accepted.includes(attachment.kind))) {
             return {
-                messages: PacketWire.packetToWireMessages(packet, emissions),
+                messages: PacketWire.packetToWireMessages(packet),
                 nativeInputs: [],
             };
         }
         const nativeInputs = new Set();
-        const messages = await PacketWire.wireMessages(packet, emissions, async (attachment) => {
+        const messages = await PacketWire.wireMessages(packet, async (attachment) => {
             const bytes = await NativeContent.read(ctx.db, attachment.contentHash);
             nativeInputs.add(attachment.coordinate);
             return bytes;
@@ -300,8 +295,6 @@ class TurnRunner {
         const createdTurnIds = [];
         const turnSignal = this.#loopSignal(loopId) ?? signal;
         try {
-            // {§configuration-repair-path} — a retired packet knob refuses inference before any turn opens.
-            PacketBuilder.assertConfiguration();
             const container = await this.#openTurnContainer(args, createdTurnIds);
             const gitStatus = await this.#deriveWorkspace(args, container.systemCtx);
             if (container.initializationTurn !== null)
@@ -312,7 +305,7 @@ class TurnRunner {
             if (admitted.overflow !== null)
                 return await this.#failCuration(admitted.request, admitted.overflow);
             const request = admitted.request;
-            const attempts = await this.#prepareProviderAttempts(args, request);
+            const attempts = await this.#prepareProviderAttempts(args, request, admitted.wire);
             let emission;
             try {
                 emission = await this.#attemptProvider(args, request, attempts);
@@ -376,7 +369,7 @@ class TurnRunner {
             createdTurnIds.push(initializationTurn.id);
         const initializationPolicies = initializationTurn === null
             ? []
-            : (await CapabilityPolicies.layers(this.#db, workspaceId, loopId)).map((layer) => layer.policy);
+            : (await this.#capabilities.layers(workspaceId, workerId)).map((layer) => layer.policy);
         const modelTurn = initializationTurn === null
             ? await Turn.open(this.#db, { loopId, producer: "model", kind: "inference" })
             : null;
@@ -473,17 +466,11 @@ class TurnRunner {
         await this.#warmWorkspace(systemCtx, true, false);
         return gitStatus;
     }
-    // {§worker-initialization-entry} — the worker's first turn is the worked example
-    // itself: the actual orienting operations and ordinary NOTEs, executed as a
-    // complete turn before the model boundary.
+    // {§worker-initialization-entry}: execute the initialization program before the model boundary.
     async #runInitializationTurn(args, container, initializationTurn, gitStatus) {
         const { workspaceId, workerId, loopId, onDispatch, onSettled } = args;
         const { initializationStatements, initializationPolicies } = container;
-        // Turn-0 catalog preview (PLURNK_SERVICE_FILES_ITEMS, {§actor-boundary-catalog-preview}):
-        // Nine bodyless FIND surveys in the worker's packetless initialization turn establish the Agent
-        // Skills, the plurnk references, the enabled tools, agents, and members, then the project, commons,
-        // named scratch, and the worker's own reasoning, in that order.
-        // Their `init` classification lets the model curate this opening survey as one log set.
+        // {§actor-boundary-catalog-preview}: `init` lets the model curate the opening surveys as one set.
         // {§operator-config-workspace-files-items} — workspace filesItems replaces the env default.
         const { filesItems: workspaceMI } = await WorkspaceSettings.read(this.#db, workspaceId);
         const filesItems = workspaceMI !== null ? normalizeFilesItems(workspaceMI) : readFilesItems();
@@ -518,7 +505,7 @@ class TurnRunner {
             turnId: initializationTurn.id,
             fromSequence: 1,
             failOnOperationError: true,
-            fit: this.#fitFor(args, { turnId: initializationTurn.id, seq: initializationTurn.sequence, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, bodiless: new Set() }),
+            fit: this.#fitFor(args, { turnId: initializationTurn.id, seq: initializationTurn.sequence, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, projection: { bodiless: new Set(), omitPreviousEmission: false } }),
             signal: this.#loopSignal(loopId),
             onDispatch,
             onSettled,
@@ -548,8 +535,8 @@ class TurnRunner {
                 matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
             },
             {
-                // {§tools-resource-materialization} — enabled tool families
-                // (MCP servers) survey at family level; each row's summary is
+                // {§tools-resource-materialization} — enabled MCP runtimes
+                // survey one row per server; each row's summary is
                 // the server one-liner or its flagship invocation form, so the
                 // discovery row itself orients. Servers named in
                 // PLURNK_MCP_EXPANDED add a second survey of their complete
@@ -598,20 +585,12 @@ class TurnRunner {
                 metadata: null,
                 matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
             },
-            {
-                // {§worker-initialization-entry} — the worker's own reasoning is an addressable, searchable
-                // space from the first packet: surveyed by name, never read back.
-                op: "FIND", aside: "this worker's reasoning, by loop and turn",
-                target: { kind: "url", raw: `reasoning://${workerName}/**`, scheme: "reasoning", username: null, password: null, hostname: workerName, port: null, pathname: "/**", query: null, fragment: null },
-                metadata: null,
-                matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
-            },
         ];
         return surveys.filter(({ target }) => this.#schemes.get(target?.kind === "url" ? target.scheme : "file", workspaceId) !== undefined);
     }
-    // {§tools-resource-materialization} — expanded families project complete
+    // {§tools-resource-materialization} — expanded runtimes project complete
     // invocation blocks, paged through ordinary FIND result ranges: one pattern FIND
-    // per family, naming the admitted tools when the policy narrows them.
+    // per runtime, naming the admitted tools when the policy narrows them.
     #toolExpansions(workspaceId, policies) {
         const registry = this.#executors();
         const expansions = [];
@@ -652,7 +631,7 @@ class TurnRunner {
         const systemCtx = this.#schemeContext(args, turnId);
         // {§context-fit} — one measure for everything this turn lands: the budget less the packet as it
         // would render now. The drained notices join the same facts below.
-        const facts = { turnId, seq, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, bodiless: new Set() };
+        const facts = { turnId, seq, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, projection: { bodiless: new Set(), omitPreviousEmission: false } };
         const fit = this.#fitFor(args, facts);
         const messages = await this.#publishMessages(args, turnId, fit);
         let nextActionIndex = await this.#readOpenPaths(args, turnId, messages.openPaths, messages.nextActionIndex, fit);
@@ -734,8 +713,9 @@ class TurnRunner {
         }
         return nextActionIndex;
     }
-    #buildPacket({ messages, recap, workspaceId, workerId, loopId, provider }, facts) {
-        return this.#packets.buildRequestPacket({
+    async #buildPacket(args, facts) {
+        const { messages, recap, workspaceId, workerId, loopId, provider } = args;
+        const packet = await this.#packets.buildRequestPacket({
             initialMessages: messages,
             recap,
             workspaceId,
@@ -747,8 +727,16 @@ class TurnRunner {
             notices: facts.notices,
             transientOpenLogEntryId: facts.transientOpenLogEntryId,
             turnId: facts.turnId,
-            bodiless: facts.bodiless,
+            bodiless: facts.projection.bodiless,
+            omitPreviousEmission: facts.projection.omitPreviousEmission,
         });
+        // {§previous-emission}: all builds, including result-admission probes, shed the optional
+        // replay before taking result bodies. Share the decision across this request's rebuilds.
+        if (PacketWire.sectionContent(packet, "previous-emission").length > 0 && this.#packets.windowOverflow(packet, provider) !== null) {
+            facts.projection.omitPreviousEmission = true;
+            return this.#buildPacket(args, facts);
+        }
+        return packet;
     }
     // {§context-fit} — the budget left for one more row, measured by building the packet as it would
     // render now: every row landed so far, every KILL already honoured. Null without a budget.
@@ -774,41 +762,61 @@ class TurnRunner {
         const packet = await this.#buildPacket(args, request);
         return { ...request, nextActionIndex: request.nextActionIndex + 1, packet };
     }
-    // The packet against the wall and the budget: the newest rows go bodiless until it fits the window
-    // ({§context-own-rows-fit}); a packet still over budget then says so in a row ({§context-over-budget-row}),
-    // whose own weight takes the same wall. The overflow is returned only when the packet cannot fit even
-    // as receipts.
+    // {§context-admission} — one request through the room: over the wall by the estimate, it sheds; over
+    // budget, it carries one row whose own weight takes the same wall ({§context-over-budget-row}); then the
+    // provider assesses the exact wire request, and an exact refusal sheds by its excess
+    // ({§context-wall-measure}). Only a packet that cannot fit even as receipts returns its overflow.
     async #admitPacket(args, request) {
-        const fitted = await this.#fitOwnRows(args, request);
-        if (fitted.overflow !== null)
-            return fitted;
-        if (this.#packets.curationOverflow(fitted.request.packet) === null)
-            return fitted;
-        return await this.#fitOwnRows(args, await this.#noteOverBudget(args, fitted.request));
-    }
-    // {§context-own-rows-fit} — while the packet is over the wall ({§context-wall}), the newest rows still
-    // carrying a body are taken, enough of them by their rendered tokens to shed the excess, and the packet
-    // is rebuilt with them bodiless; every body stays stored. The rebuilt packet is measured again until
-    // it fits, or until no row is left to take.
-    async #fitOwnRows(args, request) {
+        const { provider, loopId, signal } = args;
         let current = request;
+        let noted = false;
         for (;;) {
-            const overflow = this.#packets.windowOverflow(current.packet, args.provider);
-            if (overflow === null)
-                return { request: current, overflow: null };
+            const estimated = this.#packets.windowOverflow(current.packet, provider);
+            if (estimated !== null) {
+                const shed = await this.#shed(args, current, estimated);
+                if (shed === null)
+                    return { request: current, wire: null, overflow: estimated };
+                current = shed;
+                continue;
+            }
+            if (!noted && this.#packets.curationOverflow(current.packet) !== null) {
+                current = await this.#noteOverBudget(args, current);
+                noted = true;
+                continue;
+            }
+            const wire = await this.#wireMessages(current.packet, current.systemCtx, provider);
+            const capacity = await provider.assessRequestCapacity(wire.messages, undefined, this.#loopSignal(loopId) ?? signal);
+            const refused = this.#packets.exactOverflow(current.packet, capacity);
+            if (refused === null)
+                return { request: current, wire, overflow: null };
+            const shed = await this.#shed(args, current, refused);
+            if (shed === null)
+                return { request: current, wire: null, overflow: refused };
+            current = shed;
+        }
+    }
+    // {§context-own-rows-fit} — one shedding step for whichever measure found the request over the wall: the
+    // previous program goes whole first ({§previous-emission}), then the newest rows still carrying a body,
+    // enough of them by their rendered tokens to shed the excess; every body stays stored. Null when nothing
+    // is left to take.
+    async #shed(args, request, overflow) {
+        if (!request.projection.omitPreviousEmission && PacketWire.sectionContent(request.packet, "previous-emission").length > 0) {
+            request.projection.omitPreviousEmission = true;
+        }
+        else {
             let shed = 0;
             let taken = 0;
-            for (const { id, tokens } of this.#packets.bodiedRowsOf(current.packet).toReversed()) {
+            for (const { id, tokens } of this.#packets.bodiedRowsOf(request.packet).toReversed()) {
                 if (shed >= overflow.excessWeight)
                     break;
-                current.bodiless.add(id);
+                request.projection.bodiless.add(id);
                 shed += tokens;
                 taken += 1;
             }
             if (taken === 0)
-                return { request: current, overflow };
-            current = { ...current, packet: await this.#buildPacket(args, current) };
+                return null;
         }
+        return { ...request, packet: await this.#buildPacket(args, request) };
     }
     // {§context-wall} — the packet cannot fit the window even as receipts: the turn completes on the
     // overflow and the loop rules the terminal; no provider I/O.
@@ -819,8 +827,7 @@ class TurnRunner {
     }
     // Phase 4's bookkeeping: the wire request, the recovery knobs, the signal the
     // provider sees, the client id and the worker's provider identity.
-    async #prepareProviderAttempts({ provider, workspaceId, workerId, loopId, signal }, request) {
-        const wire = await this.#wireMessages(request.packet, request.systemCtx, provider);
+    async #prepareProviderAttempts({ workerId, loopId, signal }, request, wire) {
         // {§provider-recovery} — this turn's recovery clock: the first recoverable provider
         // failure starts it; the budget and backoff are the operator's.
         const recoveryBudget = ProviderRecovery.budget();
@@ -852,9 +859,8 @@ class TurnRunner {
         };
     }
     // Phase 4 — the provider attempt loop. Each iteration is one logical call: a
-    // recoverable failure or a capacity rebuild re-issues the same emission attempt,
-    // an invalid emission spends one, and a valid emission ends the loop
-    // ({§invalid-emission-attempts}).
+    // recoverable failure re-issues the same emission attempt, an invalid emission
+    // spends one, and a valid emission ends the loop ({§invalid-emission-attempts}).
     async #attemptProvider(args, request, attempts) {
         const { provider, workspaceId, workerId, loopId, signal } = args;
         // {§turn-lifecycle}: bracket the complete provider-attempt window with liveness notices.
@@ -913,14 +919,13 @@ class TurnRunner {
         return emission;
     }
     // One logical provider call: its durable model call and attempt row, the exchange
-    // under the reasoning observer, and its classification. Capacity recovery and
-    // {§provider-recovery} re-issue the same emission attempt; the parser's admission
-    // is the one verdict on a completed exchange.
+    // under the reasoning observer, and its classification. {§provider-recovery}
+    // re-issues the same emission attempt; the parser's admission is the one verdict
+    // on a completed exchange.
     async #issueProviderCall(args, request, attempts, attempt, strikeStreak) {
         const { provider, workspaceId, workerId, loopId } = args;
-        // Capacity recovery may rebuild and resend the request without
-        // consuming a grammar-emission attempt. Every logical provider
-        // call still receives its own durable sequence and accounting.
+        // A recovery re-issue does not consume a grammar-emission attempt. Every
+        // logical provider call still receives its own durable sequence and accounting.
         attempts.currentEmissionAttempt = attempt;
         attempts.modelCallSequence++;
         const attributionContext = Object.freeze({
@@ -959,8 +964,8 @@ class TurnRunner {
                 await this.#recoverProviderFailure(args, request, attempts, modelCall, attemptRow.id, error);
                 return "reissued";
             }
-            // {§context-wall} — a provider capacity rejection after the provider's own retries is this
-            // turn's failure; nothing is withheld to make the request smaller.
+            // {§context-wall-measure} — admission already shed for an exact refusal of this wire request;
+            // an upstream refusal is the provider's own 413.
             throw error;
         }
         finally {
@@ -1195,14 +1200,12 @@ class TurnRunner {
         if (attempts.parked) {
             // {§provider-recovery} — the recovery budget is spent: the loop parks exactly like a
             // [202] wait and resumes on the next prompt or wake; the failure stays durable.
-            // {§loop-attendance} — unattended, nothing will wake it, so LoopDriver concludes instead
-            // and the notice says that rather than promising a resumption nobody can deliver.
-            const { attended } = await LoopPolicyReader.read(this.#db, loopId);
+            const recoverable = await WorkerOwners.interactive(this.#db, loopId);
             this.#notices.push(workspaceId, workerId, loopId, {
                 source: "engine:provider",
                 kind: "provider_unavailable",
                 level: "error",
-                message: `${recorded.result.problem?.title ?? "Provider failure"}: the ${Math.round(attempts.recoveryBudget / 1000)}s recovery budget is spent; ${attended ? "the loop is parked and resumes on the next prompt or wake" : "this run is unattended, so the loop ends here"}.`,
+                message: `${recorded.result.problem?.title ?? "Provider failure"}: the ${Math.round(attempts.recoveryBudget / 1000)}s recovery budget is spent; ${recoverable ? "the loop is parked and resumes on the next prompt or wake" : "nobody attends the worker's owner, so the loop ends here"}.`,
             });
             return turnResult(request, 202, { providerParked: true, providerFailure: recorded.result, emissionAttempts });
         }
@@ -1377,6 +1380,7 @@ class TurnRunner {
     async #settleAdmittedTurn(args, request, emission) {
         const { childProvider, workspaceId, workerId, loopId, onDispatch, onSettled } = args;
         const { split } = emission;
+        const coordinates = { workerName: request.workerName, loopSeq: request.loopSeq, turnSeq: request.seq };
         // {§operator-config-workspace-max-commands} — workspace maxCommands
         // narrows the operator ceiling before the admitted program reaches the
         // shared executor.
@@ -1385,10 +1389,10 @@ class TurnRunner {
             statements: split.packetAssistant.ops,
             source: split.sourceBacked ? split.packetAssistant.content : null,
             emission: split.emissionStatements === null ? null : {
-                content: TurnOps.renderEmission(split.emissionStatements, `ops://${request.workerName}/${request.loopSeq}/${request.seq}`),
-                workerName: request.workerName, loopSeq: request.loopSeq, turnSeq: request.seq,
-                reasoning: split.packetAssistant.reasoning ?? null, // {§reasoning-row}
+                content: TurnOps.renderEmission(split.emissionStatements),
+                ...coordinates,
             },
+            reasoning: split.packetAssistant.reasoning ? { content: split.packetAssistant.reasoning, ...coordinates } : null,
             sourceModelCallId: emission.modelCallId,
             origin: "model",
             workspaceId,
@@ -1593,7 +1597,7 @@ class TurnRunner {
             emissionStatements,
         };
     }
-    // #note12 — plugin reference docs are materialized beneath
+    // #note12 — extension reference docs are materialized beneath
     // worker:///_plurnk/plurnk/ by LoopDocs.
     // {§exec-lifetime} — a `"turn"` lifetime: abort the worker's open turn-scoped streams via their
     // owning scheme (the same registry-routed abort the total reap uses). Called at each pre-turn