@sweny-ai/core 0.1.199 → 0.1.200

package/dist/safe-outputs.d.ts

@@ -114,6 +114,15 @@ export interface ApplySafeOutputsOptions {
      * passed every deterministic check). Anything but `ALLOW` is a veto.
      */
     screen?: (writes: Record<string, unknown>[]) => Promise<string | null>;
+    /**
+     * Resume: reconcile one write (its skill, tool and arguments) with the
+     * journal and, for an outstanding intent, the provider's read-only probes,
+     * before the screen. `applied`: recorded or found on the provider; it is not
+     * screened and keeps its receipt even when the screen vetoes the rest.
+     * `unknown`: the probe could not tell; it is not screened or vetoed, and the
+     * write handler reports the uncertainty. `absent`: screened as usual.
+     */
+    reconcile?: (skill: Skill, tool: string, args: unknown, ctx: ToolContext) => Promise<"applied" | "unknown" | "absent">;
     now?: () => number;
 }
 export interface ApplySafeOutputsResult {

package/dist/safe-outputs.js

@@ -545,26 +545,49 @@ export async function applySafeOutputs(o) {
             printPreview(write, o.logger);
         return { receipts };
     }
-    // Model screen: veto only. It sees only what passed every deterministic check.
+    const toolCtx = {
+        config: o.config,
+        logger: o.logger,
+        ...(o.cwd ? { cwd: o.cwd } : {}),
+        ...(o.pushBranch ? { pushBranch: o.pushBranch } : {}),
+        ...(o.githubApiUrl ? { githubApiUrl: o.githubApiUrl } : {}),
+        ...(o.run ? { run: o.run } : {}),
+        ...(o.summary ? { summary: o.summary } : {}),
+    };
+    // Model screen: veto only. It sees only what passed every deterministic
+    // check and is not already applied: on a resume, outstanding writes are
+    // reconciled with the journal and the provider first, so a write that
+    // landed before the crash keeps its receipt, and one whose probe could not
+    // tell is reported as uncertain by its handler, never as vetoed.
+    let toApply = accepted;
     if (o.policy?.screen) {
-        let verdict = null;
-        try {
-            verdict = o.screen ? await o.screen(accepted.map(({ write }) => ({ ...write }))) : null;
-        }
-        catch {
-            verdict = null;
+        const state = new Map();
+        for (const a of accepted) {
+            const applier = APPLIERS[a.write.via][a.write.type];
+            const skill = o.skills.get(a.write.via);
+            state.set(a.index, o.reconcile && skill ? await o.reconcile(skill, applier.tool, applier.build(a.write), toolCtx) : "absent");
         }
-        const allow = (verdict ?? "").trim().replace(/\.$/, "").toUpperCase() === "ALLOW";
-        if (!allow) {
-            o.logger.warn(`  safe outputs: screen vetoed ${accepted.length} write(s)`, { node: o.nodeId });
-            for (const { index } of accepted) {
-                receipts[index] = { ...receipts[index], status: "vetoed", reason: "screen vetoed" };
+        const pending = accepted.filter((a) => state.get(a.index) === "absent");
+        if (pending.length > 0) {
+            let verdict = null;
+            try {
+                verdict = o.screen ? await o.screen(pending.map(({ write }) => ({ ...write }))) : null;
+            }
+            catch {
+                verdict = null;
+            }
+            const allow = (verdict ?? "").trim().replace(/\.$/, "").toUpperCase() === "ALLOW";
+            if (!allow) {
+                o.logger.warn(`  safe outputs: screen vetoed ${pending.length} write(s)`, { node: o.nodeId });
+                for (const { index } of pending) {
+                    receipts[index] = { ...receipts[index], status: "vetoed", reason: "screen vetoed" };
+                }
+                toApply = accepted.filter((a) => state.get(a.index) !== "absent");
             }
-            return { receipts };
         }
     }
-    for (let n = 0; n < accepted.length; n++) {
-        const { index, write } = accepted[n];
+    for (let n = 0; n < toApply.length; n++) {
+        const { index, write } = toApply[n];
         const applier = APPLIERS[write.via][write.type];
         const skill = o.skills.get(write.via);
         const tool = skill?.tools.find((t) => t.name === applier.tool);
@@ -573,15 +596,7 @@ export async function applySafeOutputs(o) {
             continue;
         }
         try {
-            const output = await tool.handler(applier.build(write), {
-                config: o.config,
-                logger: o.logger,
-                ...(o.cwd ? { cwd: o.cwd } : {}),
-                ...(o.pushBranch ? { pushBranch: o.pushBranch } : {}),
-                ...(o.githubApiUrl ? { githubApiUrl: o.githubApiUrl } : {}),
-                ...(o.run ? { run: o.run } : {}),
-                ...(o.summary ? { summary: o.summary } : {}),
-            });
+            const output = await tool.handler(applier.build(write), toolCtx);
             const ref = refOf(output);
             const url = urlOf(output);
             const produced = { ...(ref !== undefined ? { ref } : {}), ...(url ? { url } : {}) };
@@ -593,7 +608,7 @@ export async function applySafeOutputs(o) {
                 // reason still counts as one.
                 const reason = refusalReason(output);
                 receipts[index] = { ...receipts[index], ...produced, status: "refused", reason };
-                for (const rest of accepted.slice(n + 1)) {
+                for (const rest of toApply.slice(n + 1)) {
                     receipts[rest.index] = { ...receipts[rest.index], status: "skipped", reason: "an earlier write was refused" };
                 }
                 return { receipts, error: `safe output ${write.type} via ${write.via} was refused: ${reason}` };
@@ -613,7 +628,7 @@ export async function applySafeOutputs(o) {
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             receipts[index] = { ...receipts[index], status: "failed", reason: "apply failed" };
-            for (const rest of accepted.slice(n + 1)) {
+            for (const rest of toApply.slice(n + 1)) {
                 receipts[rest.index] = { ...receipts[rest.index], status: "skipped", reason: "an earlier write failed" };
             }
             return { receipts, error: `safe output ${write.type} via ${write.via} failed: ${msg}` };

package/dist/skills/linear.js

@@ -68,9 +68,11 @@ export const linear = {
                 },
                 required: ["query"],
             },
+            // `withDescription` is not in the schema: only the run journal's resume
+            // probe sets it, to match a write's marker. Agent results stay as they were.
             handler: async (input, ctx) => linearGql(`query($query: String!, $first: Int) {
             searchIssues(term: $query, first: $first) {
-              nodes { id identifier title state { name } priority url }
+              nodes { id identifier title ${input.withDescription === true ? "description " : ""}state { name } priority url }
             }
           }`, { query: input.query, first: input.limit ?? 10 }, ctx),
         },

package/dist/studio.js

@@ -120,7 +120,8 @@ export function applyExecutionEvent(event, nodeDataMap) {
                 data.exec.currentTool = undefined;
             break;
         }
-        case "node:exit": {
+        case "node:exit":
+        case "node:amended": {
             const data = nodeDataMap.get(event.node);
             if (data) {
                 // NodeResult.status is already one of "success" | "failed" | "skipped";

package/dist/types.d.ts

@@ -3,7 +3,7 @@ export type { WorkflowInputs, WorkflowInputField, WorkflowInputType, InputValida
 export { WORKFLOW_INPUT_TYPES } from "./inputs.js";
 import type { Source as _Source, ResolvedSource as _ResolvedSource } from "./sources.js";
 import type { ToolClass } from "./harness/types.js";
-import type { Budget, BudgetOverrun } from "./budget.js";
+import type { Budget, BudgetOverrun, SpendBreakdown } from "./budget.js";
 import type { DeciderConfig, DeciderRecord } from "./decider.js";
 export type JSONSchema = Record<string, unknown>;
 /** Context passed to tool handlers at execution time */
@@ -873,6 +873,16 @@ export type ExecutionEvent = {
     type: "node:exit";
     node: string;
     result: NodeResult;
+}
+/**
+ * A finished node's result changed after its `node:exit` (a budget stop at
+ * the route that followed it). Not a second exit: consumers that keep each
+ * node's final result replace it; timers and step printers ignore it.
+ */
+ | {
+    type: "node:amended";
+    node: string;
+    result: NodeResult;
 } | {
     type: "node:progress";
     node: string;
@@ -951,6 +961,13 @@ export interface ExecutionTrace {
      * URL, an open breaker or a spent call cap. Absent when nothing turned it off.
      */
     deciderOff?: string;
+    /**
+     * Model spend by kind: agent `node` runs and the executor's own `judge`,
+     * `route`, `reflect` (retry reflection) and `screen` completions. Absent
+     * unless one of those own completions reported usage. The run budget is
+     * over the sum. `node` covers every attempt of every visit.
+     */
+    spend?: SpendBreakdown;
 }
 /** Result of execute() — final node results + full execution trace */
 export interface ExecutionResult {
@@ -1047,6 +1064,14 @@ export interface Claude {
         timeoutMs?: number;
         /** Caller-supplied abort signal. Aborting it interrupts the query. */
         signal?: AbortSignal;
+        /**
+         * Called once with the completion's total usage, when the harness reports
+         * it, before the outcome is known (a failed completion was still billed).
+         * Unlike `run`'s `onUsage`, which streams cumulative reports while a node
+         * runs, this is one report per completion. The executor counts it against
+         * the run budget. A hook that throws never changes the result.
+         */
+        onUsage?: (usage: NodeUsage) => void;
     }): Promise<string | null>;
     /**
      * Single-completion free-text query. No tools, no output schema.
@@ -1064,6 +1089,14 @@ export interface Claude {
         timeoutMs?: number;
         /** Caller-supplied abort signal. Aborting it interrupts the query. */
         signal?: AbortSignal;
+        /**
+         * Called once with the completion's total usage, when the harness reports
+         * it, before the outcome is known (a failed completion was still billed).
+         * Unlike `run`'s `onUsage`, which streams cumulative reports while a node
+         * runs, this is one report per completion. The executor counts it against
+         * the run budget. A hook that throws never changes the result.
+         */
+        onUsage?: (usage: NodeUsage) => void;
     }): Promise<string>;
 }
 export interface McpServerConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.199",
+  "version": "0.1.200",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"