@parcha/agentrun-pi 0.1.0-beta.17 → 0.1.0-beta.19

package/README.md

@@ -1,13 +1,13 @@
 # agent.run() + Pi
 
-Describe a task in Pi, inspect the workflow, run it with your current model, and save its definition for new input. Requires Node 22.19+ and Pi 1.2.0.
+Describe a task in Pi, inspect the workflow, run it with your current model, and save its definition for new input. Requires Node 22.19+ and Pi 1.0.4 to below 1.4 (CI tests 1.0.4, 1.1.0, 1.2.0 and 1.3.0).
 
 ## Install
 
-If you do not have Pi, install the tested host version first:
+If you do not have Pi, install it first; 1.3.0 is the newest version CI tests:
 
 ```sh
-npm install -g @earendil-works/pi-coding-agent@1.2.0
+npm install -g @earendil-works/pi-coding-agent@1.3.0
 ```
 
 Then, in your project:
@@ -37,7 +37,7 @@ npx @parcha/agentrun-pi@beta demo
 
 It prints each sub-question with its answer, then `Status: complete`, the answer and the scripted call counts, and exits 0. `npx @parcha/agentrun-pi@beta demo empty` runs the missing-evidence path and prints `Status: escalated`.
 
-The demo shows the workflow graph, progress, and a completed result with call counts. It uses scripted responses over fictional sources. It makes no model calls and does not test model quality. Run `/agentrun status` to check the loaded skill and Pi host version. The tested version is 1.2.0; status flags a different host without blocking it. Missing Pi or Jev access does not prevent the scripted demo. To repeat it, run `/agentrun run` or `/agentrun demo`. A scripted demo stays scripted on rerun, including its missing-evidence path. Use `/agentrun demo live` to switch to real Pi and Jev calls. Workflows authored by Pi use real adapters.
+The demo shows the workflow graph, progress, and a completed result with call counts. It uses scripted responses over fictional sources. It makes no model calls and does not test model quality. Run `/agentrun status` to check the loaded skill and Pi host version. Status names the supported range, 1.0.4 to below 1.4, and flags a host outside it without blocking it. Missing Pi or Jev access does not prevent the scripted demo. To repeat it, run `/agentrun run` or `/agentrun demo`. A scripted demo stays scripted on rerun, including its missing-evidence path. Use `/agentrun demo live` to switch to real Pi and Jev calls. Workflows authored by Pi use real adapters.
 
 For an offline Pi startup, use `pi --offline`. Without that flag, Pi may download optional command-line tools on first launch. This is separate from the scripted demo, which makes no network calls.
 
@@ -213,7 +213,7 @@ const result = await runWorkflow(workflow, input, {
 });
 ```
 
-`ctx` supplies the active model and public model registry. Tools are explicitly supplied and receive the original context; outer hooks are not copied. The captured active model remains fixed for the run. The host thinking level is inherited when provided, and a node can override it. The runner bounds turns, submissions, and time, and refuses an absent model instead of selecting a fallback. These limits do not impose token or spending caps.
+`ctx` supplies the active model and public model registry. Tools are explicitly supplied and receive the original context; outer hooks are not copied. The captured active model remains fixed for the run. A node thinks at its own `thinking` level; a node that names none thinks at medium, not at the host session's level, unless the runner's own `thinkingLevel` option sets another. Thinking is never off: a level of `off` runs at medium. The runner bounds turns, submissions, and time, and refuses an absent model instead of selecting a fallback. These limits do not impose token or spending caps.
 
 For a standalone application, `createPiRunner(options)` accepts a configured SDK `ModelRuntime` and its selected `model`. Supply `tools` explicitly. It loads no ambient filesystem tools, workspace instructions, extensions, prompt templates, or skills. `createPiHostSessionFactory(ctx)` exposes the same native child session transport for integrations that own their own runner. Factories are unnecessary for ordinary extension use.
 
@@ -248,7 +248,7 @@ The standalone CLI remains available as `node packages/pi/dist/cli.js --help` fr
 
 ## Sign in, pick a model, check keys
 
-`@parcha/agentrun-pi/signin` is what a demo, or your own app, runs before its first model call. It is the only entry of this package that loads `@earendil-works/pi-ai`, an optional peer: install it beside the package (`npm install @earendil-works/pi-ai@~1.2.0`) to use this entry. No other entry imports it.
+`@parcha/agentrun-pi/signin` is what a demo, or your own app, runs before its first model call. It is the only entry of this package that loads `@earendil-works/pi-ai`, an optional peer: install it beside the package (`npm install @earendil-works/pi-ai`) to use this entry. No other entry imports it.
 
 ```js
 import { builtinModels } from '@earendil-works/pi-ai/providers/all';
@@ -290,7 +290,7 @@ These commands create a separate `agentrun-pi-project` beside the checkout. You
 
 Pi is optional for `@parcha/agentrun-dsl`. This package depends on the DSL and the Jev adapter only. The Pi packages it uses (`@earendil-works/pi-coding-agent`, `@earendil-works/pi-agent-core`, `@earendil-works/pi-tui`, and `@earendil-works/pi-ai` for the sign-in entry only) and `typebox` are optional peer dependencies at `*`, as Pi's package guidance requires, so an installed copy never shadows the host's. The release inventory records the locked versions.
 
-When loaded as an extension, Pi resolves its core packages and TypeBox through the host loader, and `pi install` adds nothing else. A standalone application or the `agentrun-pi` CLI has no host: install the peers yourself (`npm install @earendil-works/pi-coding-agent@~1.2.0 @earendil-works/pi-agent-core@~1.2.0 @earendil-works/pi-tui@~1.2.0 typebox`). The pi packages are pinned to 1.2: pi 1.3.0 pins its own packages to exact versions, and this release's ranges stop below 1.3 until the next one. The tested host is Pi 1.2.0; peer ranges at `*` do not make an older or newer host compatible. The sign-in entry needs pi-ai 1.1.0 or later: pi-ai 1.0.x ignores the app name and would put pi's name on ChatGPT's sign-in page, so `signIn` refuses it with `SignInError` (`APP_NAME_IGNORED`) before the page is shown. The offline loader regression checks competing local dependencies, a native file read, and the scripted workflow. Pi's [package guidance](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md#dependencies) is the rule this follows.
+When loaded as an extension, Pi resolves its core packages and TypeBox through the host loader, and `pi install` adds nothing else. A standalone application or the `agentrun-pi` CLI has no host: install the peers yourself (`npm install @earendil-works/pi-coding-agent @earendil-works/pi-agent-core @earendil-works/pi-tui typebox`). This release supports Pi 1.0.4 to below 1.4, and CI tests 1.0.4, 1.1.0, 1.2.0 and 1.3.0; peer ranges at `*` do not make an older or newer host compatible. The sign-in entry needs pi-ai 1.1.0 or later: pi-ai 1.0.x ignores the app name and would put pi's name on ChatGPT's sign-in page, so `signIn` refuses it with `SignInError` (`APP_NAME_IGNORED`) before the page is shown. The offline loader regression checks competing local dependencies, a native file read, and the scripted workflow. Pi's [package guidance](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md#dependencies) is the rule this follows.
 
 The durable entry (`@parcha/agentrun-pi/durable`) takes pi-durable and chord as optional peers from 1.0.4 to below 1.4; CI runs it on 1.0.4, 1.1.0, 1.2.0 and 1.3.0. A run that pi-durable 1.1 left (killed, paused, or with a tool call in flight) continues on 1.2. The move does not go back. A run that pi 1.2 left with a tool call in flight cannot be continued by pi 1.1: 1.1 waits on the newer task, and the only thing it writes is that task's mark from running back to pending, as pi does for any task a dead process left running. Continue such a run on 1.2, and do not downgrade pi under a live run. A host can call `refuseNewerTasks(harness, context)` from the durable entry after opening its Harness. On pi before 1.2, it then fails such a store with `NewerTaskError` (code `PI_TASK_NEWER`, naming the task's kind and version) instead of waiting.
 

package/dist/durable/node-runner.d.ts

@@ -33,7 +33,9 @@ export type NodeRecord = Pick<RecordContract, "contracts" | "checks"> & {
 };
 export type NodeHost = {
     /** The agent a node's conversation runs with: its model, thinking level, working directory and the host's own
-     *  extensions and tools. The runner adds its extension and `submit` where the host did not place them. */
+     *  extensions and tools. The runner adds its extension and `submit` where the host did not place them. The node's
+     *  own thinking level outranks the host's; when neither names one, the node thinks at medium (never at the level its
+     *  conversation would copy from its owner's, and never off). */
     agent(node: NodeRequest): AgentChange | Promise<AgentChange>;
     /** Duty text for a node's system prompt, after the interpreter's. `offered` names the tools the agent lists. */
     stance?(node: NodeRequest, offered: {
@@ -74,10 +76,14 @@ export declare class NodeFailure extends Error {
         detail?: JsonValue;
     } | undefined;
     readonly code = "NODE_NOT_DELIVERED";
+    /** The item a map that collects its items' failures ends on this (`isItemFailure`): the node's delivery attempts are
+     *  spent, or its model will not answer (`model_error`, as a provider's content filter). Never an abort, a stale or
+     *  faulted run, a missing model, or a schema no record can satisfy. */
+    readonly itemFailure: boolean;
     constructor(message: string, node: string, final: boolean, executionPath?: string | undefined, unanswered?: {
         reason: string;
         detail?: JsonValue;
-    } | undefined);
+    } | undefined, itemFailure?: boolean);
 }
 /** The node runner over a host. Install `extension` in the registry before the Harness opens; `on` binds the runner
  *  to where its conversations live (`taskScope`, `hostScope`). */

package/dist/durable/node-runner.js

@@ -12,6 +12,7 @@
 import { randomUUID } from "node:crypto";
 import { configure, defineDoc, defineExtension, GenerationTask, hook, section, } from "@earendil-works/pi-durable";
 import { canonicalSha256, runStopOf } from "@parcha/agentrun-dsl/recovery";
+import { nodeThinking } from "../thinking.js";
 import { closeNodeAttempt, runNodeAttempt } from "./node.js";
 import { DELIVERY_ATTEMPTS, lintRecordRoot, submitFooter } from "./record.js";
 import { workspaceRecordFile } from "./record-file.js";
@@ -29,13 +30,18 @@ export class NodeFailure extends Error {
     executionPath;
     unanswered;
     code = "NODE_NOT_DELIVERED";
-    constructor(message, node, final, executionPath, unanswered) {
+    /** The item a map that collects its items' failures ends on this (`isItemFailure`): the node's delivery attempts are
+     *  spent, or its model will not answer (`model_error`, as a provider's content filter). Never an abort, a stale or
+     *  faulted run, a missing model, or a schema no record can satisfy. */
+    itemFailure;
+    constructor(message, node, final, executionPath, unanswered, itemFailure = false) {
         super(message);
         this.node = node;
         this.final = final;
         this.executionPath = executionPath;
         this.unanswered = unanswered;
         this.name = "NodeFailure";
+        this.itemFailure = final && itemFailure;
     }
 }
 /** `work` under a run's stop: its result, or the stop's reason as soon as the stop lands, and at once when it already
@@ -123,6 +129,9 @@ export function nodeRunner(host, options = {}) {
         sections: [section("task", async (input, context) => (await input.read.snapshot(NodeDoc, input.conversationId, context))?.system || undefined, { tag: false })],
         hooks: [hook(GenerationTask, { beforeRequest: present }), nudge],
     });
+    /** The host's agent at the node's thinking level. A level left unset would follow the conversation's creation: a
+     *  task's node copies its owner's level, and a node no task owns starts off. */
+    const leveled = (agent, node) => ({ ...agent, thinkingLevel: nodeThinking(node.thinking, agent.thinkingLevel) });
     /** The host's agent with the runner's extension first and `submit` last, unless the host placed them. */
     const withNodes = (agent) => ({
         ...agent,
@@ -145,13 +154,13 @@ export function nodeRunner(host, options = {}) {
                 const { review, signal, step, ...asked } = params;
                 // An attempt the driver admitted is found again by its session; any other call is a conversation of its own.
                 const node = { ...asked, sessionId: step?.sessionId ?? `unjournaled:${randomUUID()}`, attempt: step?.attempt ?? 0, earlierSessionIds: step?.earlierSessionIds ?? [] };
-                const fail = (message, final, unanswered) => new NodeFailure(message, node.label, final, node.executionPath, unanswered);
+                const fail = (message, final, unanswered, itemFailure = false) => new NodeFailure(message, node.label, final, node.executionPath, unanswered, itemFailure);
                 // Only a schema no submit call can satisfy is refused here: any other is the node's contract as its author wrote it.
                 const lint = lintRecordRoot(node.schema);
                 if (lint.length)
                     throw fail(`${node.kind} node "${node.label}" cannot deliver a record of its schema: ${lint.join("; ")}`, true);
                 // The host's own answers are awaited under the stop too: one that lands meanwhile opens no conversation.
-                const { agent, record } = await underStop(signal, async () => ({ agent: await host.agent(node), record: await host.record?.(node) ?? {} }));
+                const { agent, record } = await underStop(signal, async () => ({ agent: leveled(await host.agent(node), node), record: await host.record?.(node) ?? {} }));
                 const label = record.label ?? `the ${node.label} record`;
                 const offered = (listed(agent.tools) ? agent.tools : listed(agent.extensions) ? agent.extensions.flatMap((selected) => selected.tools ?? []) : [])
                     .map((offer) => offer.name).filter((name) => name !== "submit");
@@ -215,10 +224,11 @@ export function nodeRunner(host, options = {}) {
                         return outcome.delivered.record;
                     if (outcome.settled?.status === "unanswered") {
                         const { reason, detail } = outcome.settled;
-                        throw fail(`${node.label}: the model did not answer (${reason})`, true, { reason, ...(detail !== undefined ? { detail } : {}) });
+                        // Only the model's own refusal to answer is the item's: an abort, a stale or faulted run and a missing model are the run's.
+                        throw fail(`${node.label}: the model did not answer (${reason})`, true, { reason, ...(detail !== undefined ? { detail } : {}) }, reason === "model_error");
                     }
                     const spent = ((await scope.snapshot(RecordDoc, outcome.conversationId, base))?.attempts ?? 0) >= maxAttempts;
-                    throw fail(`${node.label} did not submit (${spent ? "its delivery attempts are spent" : "it ended its run without a record"})`, spent);
+                    throw fail(`${node.label} did not submit (${spent ? "its delivery attempts are spent" : "it ended its run without a record"})`, spent, undefined, spent);
                 }
                 catch (error) {
                     if (!signal?.aborted)

package/dist/host-session.js

@@ -74,9 +74,10 @@ export function createPiHostSessionFactory(context) {
 }
 export function createPiHostRunner(context, options = {}) {
     const model = selectedModel(context);
+    // The host session's thinking level is not a node's: a node that names none thinks at medium, unless the caller
+    // passes its own `thinkingLevel`.
     return createPiRunner({
         ...options, model, cwd: options.cwd ?? context.cwd,
-        thinkingLevel: options.thinkingLevel ?? context.thinkingLevel,
         sessionFactory: createPiHostSessionFactory(context),
     });
 }

package/dist/runner.js

@@ -1,6 +1,7 @@
 import { Compile } from "typebox/compile";
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, ModelRuntime, } from "@earendil-works/pi-coding-agent";
 import { PiRunError } from "./run-error.js";
+import { nodeThinking } from "./thinking.js";
 export { PiRunError } from "./run-error.js";
 function positive(value, name) {
     if (!Number.isSafeInteger(value) || value < 1)
@@ -159,7 +160,7 @@ export function createPiRunner(options) {
             const sessionManager = SessionManager.inMemory(cwd);
             const prepared = {
                 cwd, model: options.model, modelRuntime: options.modelRuntime,
-                thinkingLevel: request.thinking ?? options.thinkingLevel ?? "low", maxTurns: maxTurns ?? undefined, resourceLoader, settingsManager,
+                thinkingLevel: nodeThinking(request.thinking, options.thinkingLevel), maxTurns: maxTurns ?? undefined, resourceLoader, settingsManager,
                 sessionManager,
                 tools: [...requested, "submit"],
                 customTools: [...(options.tools ?? []).filter(tool => requested.includes(tool.name)).map(tool => ({

package/dist/skills/author/SKILL.md

@@ -58,6 +58,8 @@ A mandatory category with no valid `unknown` value needs a missing-facts path wh
 }
 ```
 
+A dry run gives a boolean whose schema leaves it open (no `const` or `enum`) the value `false`, so an `escalate` on such a boolean being `false`, like this one, always fires there: the dry run reports `not_run` and names the escalation in `skipped`. The steps after it are not exercised, and that is not a defect to repair.
+
 For Jev nodes, use the bundled [decision design guide](references/jev-decisions.md), also returned by `describe` under `authoring.jev`. No separate TypeSafe skill installation or live documentation access is required to author this DSL. Give each decision the actual material it must judge: a researcher's summary is a claim, not an independent source. Let code perform exact operations and agents do open-ended research; use Jev for focused semantic decisions with complete context.
 
 ## Minimal typed example

package/dist/skills/author/references/language.md

@@ -25,7 +25,7 @@ This is the complete set. Each kind accepts exactly these fields; any other fiel
 - `extract`: `label`, `state`, `instructions`, `sopSection`, `out`, `as`, `requires`, `tools`, `effort`, `thinking`, `verify`, `tier`
 - `report`: `label`, `state`, `instructions`, `sopSection`, `requires`, `tools`, `effort`, `thinking`
 - `artifact`: `label`, `state`, `type`, `path`, `instructions`, `sopSection`, `requires`, `tools`, `effort`, `thinking`
-- `map`: `label`, `itemsPath`, `body`, `as`, `resultPath`, `maxConcurrency`
+- `map`: `label`, `itemsPath`, `body`, `as`, `resultPath`, `maxConcurrency`, `onItemFailure`, `failedAs`
 - `parallel`: `label`, `branches`
 - `loop`: `label`, `body`, `until`, `maxIters`, `expect_iters`
 - `escalate`: `label`, `when`, `kind`, `stage`, `summary`
@@ -51,7 +51,7 @@ Their fields:
 - `out` names the schema the submission must satisfy; the value lands at `as`.
 - `requires` lists state paths that must hold evidence before the node runs, each produced upstream: missing values, null, blank strings, empty arrays and empty objects stop the run; `false` and `0` pass.
 - `tools` names tools the host offers. `[]` means no tools; omitting `tools` offers every tool the host allows. Never name a tool the host did not offer.
-- `effort` is minimal|low|medium|high; `thinking` is low|medium|high (never off); `tier` is fast|default|strong. They are requests to the host: resource ceilings are the host's.
+- `effort` is minimal|low|medium|high; `thinking` is low|medium|high (never off); `tier` is fast|default|strong. They are requests to the host: resource ceilings are the host's. A node that names no `thinking` thinks at medium, unless its host sets another level.
 - An `agent` node may carry `budget_usd`, the most it asks to spend in dollars (above 0), which the host caps by what it has left, and `context`, fresh|fork: `fresh` (the default) sees only its instructions and state; `fork` asks the host to start it from the caller's transcript, which a host refuses where it has none.
 - `sopSection` names one heading of the host's SOP, or a list of them, as the exact text after "## ". The node receives those sections verbatim.
 - `verify` reviews a submission before it is accepted: {"out": a question schema with at least one boolean question, "state"?, "maxDrives"?: an integer >= 1 (default 2, no maximum), "override"?: {"below": a number in (0, 1), default 0.3}}. A boolean question named after a submission field doubts that field when its yes-probability is below `override.below`; any other boolean question is a requirement met at 0.5. A rejected submission returns to the same session with the reasons.
@@ -76,7 +76,7 @@ Typed questions answered by the host's judge in one request each: no tools, no s
 ### Control nodes
 
 - `chain`: non-empty `steps`, run in order.
-- `map`: `itemsPath` (an upstream list), `body` and `as`. The body sees `item` and `item_index`; `maxConcurrency` is a positive integer (default 4); `resultPath` selects one path from each completed item's state. Without `resultPath`, and with no `as` in the body, each item's result is its whole state, the mapped list included: set `resultPath` (or an `as` in the body) for a large map; the validator warns.
+- `map`: `itemsPath` (an upstream list), `body` and `as`. The body sees `item` and `item_index`; `maxConcurrency` is a positive integer (default 4); `resultPath` selects one path from each completed item's state. Without `resultPath`, and with no `as` in the body, each item's result is its whole state, the mapped list included: set `resultPath` (or an `as` in the body) for a large map; the validator warns. `onItemFailure` is `stop` (default: the first failing item stops the map and the run) or `collect`. With `collect`, an item whose node fails (a call that failed after its retries, an agent that delivered no record, output that does not match its schema, a failed check) ends as {item_index, label, code, message} in the list at `failedAs`, the other items finish, and `as` stays aligned with the items: `as[i]` is item i's result, or `null` when item i failed. Filter the nulls explicitly if only successes are wanted. Gate on `failedAs` with `escalate` or a code node; never let failures pass silently. A crash, a cancel, an `escalate` inside the item or an effect whose outcome is unknown is never collected.
 - `parallel`: at least two `branches`, each starting from the state before the parallel node. Branches write disjoint keys and never read a sibling's writes.
 - `loop`: `body`, `until` (a predicate) and an integer `maxIters` of at least 1 (no maximum), optionally an integer `expect_iters` of at least 1 (priced passes). At the bound the state passes through with `until` unmet; follow the loop with an escalate or gate on that condition.
 - `escalate`: `when` (a predicate), and non-empty `kind`, `stage` and `summary`. When the predicate holds the run stops without output and returns the escalation with its interpolated summary.

package/dist/thinking.d.ts

@@ -0,0 +1,3 @@
+/** A workflow node's thinking level: the first level given, the node's own before its host's, else medium. Thinking is
+ *  never off: a level of `off` is medium too. */
+export declare function nodeThinking<Level extends string>(...given: readonly (Level | null | undefined)[]): Exclude<Level, "off"> | "medium";

package/dist/thinking.js

@@ -0,0 +1,7 @@
+// Kept apart from runner.ts so the durable node runner reads it without a pi coding agent installed.
+/** A workflow node's thinking level: the first level given, the node's own before its host's, else medium. Thinking is
+ *  never off: a level of `off` is medium too. */
+export function nodeThinking(...given) {
+    const level = given.find((named) => named !== undefined && named !== null);
+    return level === undefined || level === "off" ? "medium" : level;
+}

package/dist/types.d.ts

@@ -88,6 +88,8 @@ export type PiSessionFactory = (options: PiSessionOptions) => Promise<{
 }>;
 export interface PiRunnerCommonOptions {
     model: PiModel;
+    /** The level a node that names none thinks at (default `medium`). A node's own level outranks it, and `off` is
+     *  `medium`: thinking is never off. */
     thinkingLevel?: PiThinkingLevel;
     cwd?: string;
     tools?: PiToolDefinition[];
@@ -117,6 +119,8 @@ export interface PiHostContext {
             result(): Promise<unknown>;
         };
     };
+    /** The host session's thinking level. A node does not inherit it: a node that names no level thinks at medium,
+     *  unless the runner's own `thinkingLevel` option says otherwise. */
     thinkingLevel?: PiThinkingLevel;
 }
 export type PiHostRunnerOptions = Omit<PiRunnerCommonOptions, "model">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcha/agentrun-pi",
-  "version": "0.1.0-beta.17",
+  "version": "0.1.0-beta.19",
   "description": "Pi extension for building, running and evaluating AgentRun workflows",
   "type": "module",
   "license": "Apache-2.0",
@@ -50,12 +50,12 @@
     "@earendil-works/pi-coding-agent": "1.1.0",
     "@earendil-works/pi-durable": "1.1.0",
     "@earendil-works/pi-tui": "1.1.0",
-    "@parcha/pi-durable-disk": "0.1.0-beta.17",
+    "@parcha/pi-durable-disk": "0.1.0-beta.19",
     "typebox": "1.3.7"
   },
   "dependencies": {
-    "@parcha/agentrun-dsl": "0.1.0-beta.17",
-    "@parcha/agentrun-jev": "0.1.0-beta.17"
+    "@parcha/agentrun-dsl": "0.1.0-beta.19",
+    "@parcha/agentrun-jev": "0.1.0-beta.19"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",