@sweny-ai/core 0.1.195 → 0.1.197

package/dist/cli/resume.js

@@ -44,13 +44,23 @@ export function formatResumePlan(plan, mayRepeat) {
     const label = (node, iteration) => (iteration > 1 ? `${node} (#${iteration})` : node).padEnd(width + 5);
     for (const v of plan.visits) {
         if (v.action === "replay") {
-            const writes = v.applied > 0 ? `, ${v.applied} write(s) not re-sent` : "";
-            lines.push(`  ✓ ${label(v.node, v.iteration)} replay from journal (${v.status}${writes})`);
+            const parts = [String(v.status)];
+            if (v.applied > 0)
+                parts.push(`${v.applied} write(s) not re-sent`);
+            // A replayed visit runs no write stage: its transient refusals stand too.
+            const refused = v.refused + v.transient;
+            if (refused > 0)
+                parts.push(`${refused} refused write(s), not re-sent`);
+            lines.push(`  ✓ ${label(v.node, v.iteration)} replay from journal (${parts.join(", ")})`);
         }
         else if (v.action === "write-stage") {
             const parts = ["agent result reused"];
             if (v.applied > 0)
                 parts.push(`${v.applied} write(s) already applied, not re-sent`);
+            if (v.refused > 0)
+                parts.push(`${v.refused} refused write(s), not re-sent`);
+            if (v.transient > 0)
+                parts.push(`${v.transient} transient refusal(s) to try again, checked on the provider first`);
             if (v.unconfirmed > 0)
                 parts.push(`${v.unconfirmed} write(s) to confirm on the provider first`);
             lines.push(`  ↻ ${label(v.node, v.iteration)} write stage only: ${parts.join("; ")}`);

package/dist/harness/tool-bridge/protocol.d.ts

@@ -76,7 +76,8 @@ export declare function parseRequest(value: unknown): BridgeRequest | undefined;
 /**
  * A handler's return value as MCP content. Strings pass through; anything else
  * is JSON. A {@link ToolRefusal} is a tool error (#544): the agent and the
- * tool-call status (and so evals) see that the write did not happen.
+ * tool-call status (and so evals) see that the write did not happen. Any
+ * refusal counts, by the predicate the write stage and the journal use (#558).
  */
 export declare function toolOutputToMcpResult(output: unknown): McpCallToolResult;
 /** A handler's thrown error as an MCP error result. */

package/dist/harness/tool-bridge/protocol.js

@@ -17,7 +17,7 @@
  */
 import { timingSafeEqual } from "node:crypto";
 import { z } from "zod";
-import { isToolRefusal } from "../../types.js";
+import { isRefusal, refusalReason } from "../../types.js";
 export const BRIDGE_PROTOCOL_VERSION = 1;
 /** Frames longer than this are refused and the connection is dropped. */
 export const MAX_FRAME_BYTES = 8 * 1024 * 1024;
@@ -90,11 +90,13 @@ export function parseRequest(value) {
 /**
  * A handler's return value as MCP content. Strings pass through; anything else
  * is JSON. A {@link ToolRefusal} is a tool error (#544): the agent and the
- * tool-call status (and so evals) see that the write did not happen.
+ * tool-call status (and so evals) see that the write did not happen. Any
+ * refusal counts, by the predicate the write stage and the journal use (#558).
  */
 export function toolOutputToMcpResult(output) {
-    if (isToolRefusal(output)) {
-        return { content: [{ type: "text", text: `Refused: ${output.reason}\n${JSON.stringify(output)}` }], isError: true };
+    if (isRefusal(output)) {
+        const text = `Refused: ${refusalReason(output)}\n${JSON.stringify(output)}`;
+        return { content: [{ type: "text", text }], isError: true };
     }
     return {
         content: [{ type: "text", text: typeof output === "string" ? output : JSON.stringify(output) }],

package/dist/journal.d.ts

@@ -93,8 +93,11 @@
  * refusal named would otherwise be taken for an applied one). The one
  * exception is a refusal marked `transient` that names nothing it produced:
  * nothing was written, so it goes through the unconfirmed-intent path above
- * (provider lookup, then a first send). `--allow-repeat-writes` does not
- * override a refusal: its outcome is known, not unconfirmed.
+ * (provider lookup, then a first send). That is decided once, from the
+ * handler's own output when the refusal is recorded, and stored as
+ * `retry: true` on the record (#558); a record without it stands.
+ * `--allow-repeat-writes` does not override a refusal: its outcome is known,
+ * not unconfirmed.
  */
 import type { Logger, NodeResult, NodeUsage, RouteRung, Skill, Workflow } from "./types.js";
 import type { SafeOutputIntent, WriteStageState } from "./safe-outputs.js";
@@ -280,6 +283,8 @@ interface OutputRecord extends JournalRecord {
     tool: string;
     output?: unknown;
     recovered?: boolean;
+    /** On `output:refused`: a transient refusal that named nothing it produced, so resume tries it again (#558). */
+    retry?: boolean;
 }
 /** Thrown when the journal was written by a newer sweny, or by an older one without record authentication. */
 export declare class JournalVersionError extends Error {
@@ -356,6 +361,8 @@ export interface PlannedVisit {
     applied: number;
     /** Writes whose handler refused (#544): the refusal is replayed, not re-sent. */
     refused: number;
+    /** Transient refusals that wrote nothing (#558): tried again, through the provider lookup first. */
+    transient: number;
     /** Writes with an intent but no receipt: checked on the provider before anything is re-sent. */
     unconfirmed: number;
 }

package/dist/journal.js

@@ -93,14 +93,17 @@
  * refusal named would otherwise be taken for an applied one). The one
  * exception is a refusal marked `transient` that names nothing it produced:
  * nothing was written, so it goes through the unconfirmed-intent path above
- * (provider lookup, then a first send). `--allow-repeat-writes` does not
- * override a refusal: its outcome is known, not unconfirmed.
+ * (provider lookup, then a first send). That is decided once, from the
+ * handler's own output when the refusal is recorded, and stored as
+ * `retry: true` on the record (#558); a record without it stands.
+ * `--allow-repeat-writes` does not override a refusal: its outcome is known,
+ * not unconfirmed.
  */
 import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { isToolRefusal } from "./types.js";
+import { isRefusal, refusalReason } from "./types.js";
 import { resolveNodePermissions } from "./node-policy.js";
 import { CURRENT_SPEC_VERSION } from "./migrations.js";
 import { spendOf } from "./budget.js";
@@ -1205,7 +1208,9 @@ export function buildResumePlan(records) {
         const complete = !!v.end && !(isLast && v.end.result.status === "failed" && typeof v.next !== "string");
         const keys = (rec) => [...rec.values()].filter((o) => o.node === v.node && o.iteration === v.iteration).map((o) => o.key);
         const applied = keys(receipts).length;
-        const refused = keys(refusals).filter((k) => !receipts.has(k)).length;
+        const refusedKeys = keys(refusals).filter((k) => !receipts.has(k));
+        const transient = refusedKeys.filter((k) => refusals.get(k).retry === true).length;
+        const refused = refusedKeys.length - transient;
         const unconfirmed = keys(intents).filter((k) => !receipts.has(k) && !refusals.has(k)).length;
         if (complete && !resumed) {
             visits.push({
@@ -1217,6 +1222,7 @@ export function buildResumePlan(records) {
                 ...(v.rung ? { rung: v.rung } : {}),
                 applied,
                 refused,
+                transient,
                 unconfirmed,
             });
             writeState = v.end.write_state;
@@ -1229,6 +1235,7 @@ export function buildResumePlan(records) {
             action: v.checkpoint ? "write-stage" : "rerun",
             applied,
             refused,
+            transient,
             unconfirmed,
         });
         break;
@@ -1416,11 +1423,10 @@ function slimOutput(o, depth = 0) {
     if (!o || typeof o !== "object" || Array.isArray(o) || depth > 3)
         return null;
     const out = {};
-    // A refusal keeps what it is and its fixed-wording reason (#544); never `detail`.
-    if (depth === 0 && o.refused === true) {
+    // A refusal keeps what it is and its fixed-wording reason, capped (#544, #558); never `detail`.
+    if (depth === 0 && isRefusal(o)) {
         out.refused = true;
-        if (isToolRefusal(o))
-            out.reason = o.reason;
+        out.reason = refusalReason(o);
         if (o.transient === true)
             out.transient = true;
     }
@@ -1894,7 +1900,7 @@ export class RunJournal {
                     return receipt.output ?? null;
                 }
                 const refusal = plan?.refusals.get(key);
-                if (refusal && !retriesRefusal(refusal.output)) {
+                if (refusal && refusal.retry !== true) {
                     this.logger.info(`  run journal: ${tool.name} was refused in an earlier attempt; not re-sent`, { node });
                     const prior = refusal.output && typeof refusal.output === "object" ? refusal.output : {};
                     return { reason: "the tool refused the write", ...prior, refused: true };
@@ -1920,13 +1926,15 @@ export class RunJournal {
                 // A write the journal cannot record is never sent: append throws first.
                 this.append("output:intent", { node, iteration, key, tool: tool.name });
                 const output = await tool.handler(withMarker(tool.name, args, key), ctx);
-                const refused = !!output && typeof output === "object" && output.refused === true;
+                const refused = isRefusal(output);
                 this.append(refused ? "output:refused" : "output:applied", {
                     node,
                     iteration,
                     key,
                     tool: tool.name,
                     output: slimOutput(output),
+                    // Decided here, from the handler's own output, not from the slimmed record (#558).
+                    ...(refused && retriesRefusal(output) ? { retry: true } : {}),
                 });
                 return output;
             },
@@ -1934,15 +1942,23 @@ export class RunJournal {
     }
 }
 /**
- * Whether a journaled refusal is tried again on resume (#544): only a
- * transient one that names nothing it produced. Anything else stands.
+ * Whether a refusal is tried again on resume (#544): only a transient one that
+ * names nothing it produced. Decided from the handler's full output when the
+ * refusal is recorded (#558). Anything else stands.
  */
 function retriesRefusal(output) {
-    if (!output || typeof output !== "object")
+    return output.transient === true && !namesProduced(output);
+}
+const PRODUCED_KEYS = new Set(["number", "identifier", "id", "html_url", "url", "reused"]);
+/** Whether an output names anything a write produced, at any depth or in any array; too deep counts as yes. */
+function namesProduced(o, depth = 0) {
+    if (!o || typeof o !== "object")
         return false;
-    const o = output;
-    // Anything besides the refusal itself is something the write produced.
-    return o.transient === true && Object.keys(o).every((k) => k === "refused" || k === "reason" || k === "transient");
+    if (depth > 8)
+        return true;
+    if (Array.isArray(o))
+        return o.some((v) => namesProduced(v, depth + 1));
+    return Object.entries(o).some(([k, v]) => (PRODUCED_KEYS.has(k) && v !== undefined && v !== null) || namesProduced(v, depth + 1));
 }
 /** What a node result needs to continue a run. Tool call inputs and outputs are dropped. */
 function journalResult(r) {

package/dist/safe-outputs.js

@@ -15,7 +15,7 @@
  */
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { SAFE_OUTPUT_APPLIERS, isToolRefusal, skippedReason } from "./types.js";
+import { SAFE_OUTPUT_APPLIERS, isRefusal, refusalReason, skippedReason } from "./types.js";
 import { trustedEnvValue } from "./startup-env.js";
 /** Name of the intent-recording tool a node with `outputs` receives. */
 export const EMIT_OUTPUT_TOOL = "emit_output";
@@ -585,14 +585,13 @@ export async function applySafeOutputs(o) {
             const ref = refOf(output);
             const url = urlOf(output);
             const produced = { ...(ref !== undefined ? { ref } : {}), ...(url ? { url } : {}) };
-            const refused = !!output && typeof output === "object" && output.refused === true;
-            if (refused) {
+            if (isRefusal(output)) {
                 // #544: the handler declined the write, or could not vouch for it. The
                 // receipt says refused with the handler's fixed-wording reason (and
                 // names anything it did create); the node fails and the rest are
                 // skipped, the same as a failed apply. A refusal without a usable
                 // reason still counts as one.
-                const reason = isToolRefusal(output) ? output.reason.slice(0, 200) : "the tool refused the write";
+                const reason = refusalReason(output);
                 receipts[index] = { ...receipts[index], ...produced, status: "refused", reason };
                 for (const rest of accepted.slice(n + 1)) {
                     receipts[rest.index] = { ...receipts[rest.index], status: "skipped", reason: "an earlier write was refused" };

package/dist/skills/git-push.d.ts

@@ -111,9 +111,10 @@ export interface PushHeadResult {
     /** Why nothing was pushed, or why the push failed. Never carries the token. */
     reason?: string;
     /**
-     * The local commit the push tried to publish. Set when the push ran and
-     * failed: `github_create_pr` then opens the PR only if the remote head is
-     * this commit (#544).
+     * The local commit of the head branch, set whenever it was read: on a push,
+     * a failed push and every skip after the read. `github_create_pr` opens the
+     * PR only when its head is this commit (#544, #558). Called without
+     * `remoteSha` or `token` (a lease skip), the pusher only reads it.
      */
     sha?: string;
 }

package/dist/skills/git-push.js

@@ -337,17 +337,9 @@ export async function pushHeadBranch(opts) {
         return { pushed: false, attempted: false, reason: `head "${head}" is not a plain branch name` };
     if (head === base)
         return { pushed: false, attempted: false, reason: "head is the base branch" };
-    if (!defaultBranch)
-        return { pushed: false, attempted: false, reason: "the repo's default branch is unknown" };
-    if (head === defaultBranch || head === "main" || head === "master") {
+    if ((defaultBranch && head === defaultBranch) || head === "main" || head === "master") {
         return { pushed: false, attempted: false, reason: `head ${head} is the default branch` };
     }
-    const remoteSha = opts.remoteSha;
-    if (remoteSha === undefined || !/^([0-9a-f]{40}([0-9a-f]{24})?)?$/.test(remoteSha)) {
-        return { pushed: false, attempted: false, reason: `the remote state of ${head} is unknown` };
-    }
-    if (!token)
-        return { pushed: false, attempted: false, reason: "no GITHUB_TOKEN" };
     const opEnv = opts.env ?? process.env;
     const cwd = path.resolve(opts.cwd);
     // git and its PATH come from the startup snapshot, never the run's env or the workspace.
@@ -372,6 +364,14 @@ export async function pushHeadBranch(opts) {
     const destination = `${serverBase}/${opts.repo}.git`;
     const env = hardenedGitEnv(opEnv, trustedPathDirs(startupPath, cwd).join(path.delimiter));
     let tmp;
+    // The local commit, once read: every result after that carries it (#558).
+    let sha;
+    const skip = (reason) => ({
+        pushed: false,
+        attempted: false,
+        reason,
+        ...(sha ? { sha } : {}),
+    });
     try {
         tmp = mkdtempSync(path.join(startupTmpdir(), "sweny-push-"));
         const hooks = path.join(tmp, "hooks");
@@ -380,14 +380,25 @@ export async function pushHeadBranch(opts) {
         // Reads in the agent's checkout: no token in the env, nothing run from its config.
         const read = (args) => git([...hard, "-c", "safe.directory=*", ...args], { cwd, env });
         const local = await read(["rev-parse", "--verify", "--quiet", `refs/heads/${head}^{commit}`]);
-        const sha = local.stdout.trim();
-        if (local.code !== 0 || !/^[0-9a-f]{40}([0-9a-f]{24})?$/.test(sha)) {
+        const localSha = local.stdout.trim();
+        if (local.code !== 0 || !/^[0-9a-f]{40}([0-9a-f]{24})?$/.test(localSha)) {
             return { pushed: false, attempted: false, reason: `no local branch ${head}` };
         }
+        sha = localSha;
+        // Without the API's remote state or a token nothing is pushed; the local commit is still reported.
+        const remoteSha = opts.remoteSha;
+        if (remoteSha === undefined || !/^([0-9a-f]{40}([0-9a-f]{24})?)?$/.test(remoteSha)) {
+            return skip(`the remote state of ${head} is unknown`);
+        }
+        if (!token)
+            return skip("no GITHUB_TOKEN");
+        // An API flake on the default branch still reports the local commit (#558).
+        if (!defaultBranch)
+            return skip("the repo's default branch is unknown");
         const fetchUrls = await read(["remote", "get-url", "--all", "origin"]);
         const pushUrls = await read(["remote", "get-url", "--push", "--all", "origin"]);
         if (fetchUrls.code !== 0 || pushUrls.code !== 0) {
-            return { pushed: false, attempted: false, reason: "no origin remote" };
+            return skip("no origin remote");
         }
         const urls = `${fetchUrls.stdout}\n${pushUrls.stdout}`
             .split("\n")
@@ -400,11 +411,11 @@ export async function pushHeadBranch(opts) {
                 return !p || p.repo !== wanted || p.host !== serverHost;
             });
         if (bad)
-            return { pushed: false, attempted: false, reason: `origin is not ${opts.repo} on ${serverHost}` };
+            return skip(`origin is not ${opts.repo} on ${serverHost}`);
         const objectsOut = await read(["rev-parse", "--git-path", "objects"]);
         const shallowOut = await read(["rev-parse", "--git-path", "shallow"]);
         if (objectsOut.code !== 0 || shallowOut.code !== 0) {
-            return { pushed: false, attempted: false, reason: "cannot locate the checkout's object store" };
+            return skip("cannot locate the checkout's object store");
         }
         const objects = path.resolve(cwd, objectsOut.stdout.trim());
         const shallow = path.resolve(cwd, shallowOut.stdout.trim());
@@ -413,10 +424,10 @@ export async function pushHeadBranch(opts) {
         const own = (args, extraEnv) => git([...hard, `--git-dir=${repoDir}`, ...args], { cwd: tmp, env: { ...env, ...extraEnv } });
         const init = await git([...hard, "init", "--quiet", "--bare", repoDir], { cwd: tmp, env });
         if (init.code !== 0)
-            return { pushed: false, attempted: false, reason: "cannot create the push repo" };
+            return skip("cannot create the push repo");
         // The config `init` wrote may only hold plain repo-format keys: no url, http, include or remote.
         if (!isPlainRepoConfig(readFileSync(path.join(repoDir, "config"), "utf8"))) {
-            return { pushed: false, attempted: false, reason: "the private push repo changed before the push" };
+            return skip("the private push repo changed before the push");
         }
         writeFileSync(path.join(repoDir, "objects", "info", "alternates"), `${objects}\n`);
         // A shallow checkout (actions/checkout's default): copy its boundary list. Only a
@@ -433,20 +444,20 @@ export async function pushHeadBranch(opts) {
             readdirSync(hooks).sort(),
         ]);
         const staged = fingerprint();
-        const ref = await own(["update-ref", `refs/heads/${head}`, sha]);
+        const ref = await own(["update-ref", `refs/heads/${head}`, localSha]);
         if (ref.code !== 0)
-            return { pushed: false, attempted: false, reason: `cannot stage ${head} for the push` };
+            return skip(`cannot stage ${head} for the push`);
         // An existing remote head (an open PR's branch) is only fast-forwarded:
         // the lease below would otherwise let a diverged commit replace it.
         if (remoteSha) {
-            const ff = await own(["merge-base", "--is-ancestor", remoteSha, sha]);
+            const ff = await own(["merge-base", "--is-ancestor", remoteSha, localSha]);
             if (ff.code !== 0) {
-                return { pushed: false, attempted: false, reason: `${head} is not a fast-forward of the remote ${head}` };
+                return skip(`${head} is not a fast-forward of the remote ${head}`);
             }
         }
         const pushEnv = pushAuthConfig(serverBase, token, withCommandConfig({}, pushTransportConfig(destination, env)));
         if (fingerprint() !== staged) {
-            return { pushed: false, attempted: false, reason: "the private push repo changed before the push" };
+            return skip("the private push repo changed before the push");
         }
         const r = await own([
             "push",
@@ -459,16 +470,12 @@ export async function pushHeadBranch(opts) {
         ], pushEnv);
         if (r.code !== 0) {
             const why = (r.stderr || r.stdout).trim().split("\n").at(-1) ?? "";
-            return { pushed: false, attempted: true, reason: `git push failed: ${redact(why, token)}`, sha };
+            return { pushed: false, attempted: true, reason: `git push failed: ${redact(why, token)}`, sha: localSha };
         }
-        return { pushed: true, attempted: true };
+        return { pushed: true, attempted: true, sha: localSha };
     }
     catch (err) {
-        return {
-            pushed: false,
-            attempted: false,
-            reason: redact(err instanceof Error ? err.message : String(err), token),
-        };
+        return skip(redact(err instanceof Error ? err.message : String(err), token));
     }
     finally {
         if (tmp) {

package/dist/skills/github.js

@@ -163,6 +163,14 @@ const REFUSE_NO_LOCAL = "the head push failed and the pusher did not report the
 const REFUSE_UNREADABLE = "the head push failed and the remote head could not be read";
 const REFUSE_MISMATCH = "the head push failed and the remote head is not the commit this run produced";
 const REFUSE_PR_MISMATCH = "the PR was opened but its head is not the commit this run produced";
+// #558: the paths where sweny did not push, or pushed without naming the commit.
+const REFUSE_SKIP_UNREADABLE = "the head branch was not pushed and the remote head could not be read";
+const REFUSE_SKIP_MISMATCH = "the head branch was not pushed and the remote head is not the commit this run produced";
+const REFUSE_NO_COMMIT = "the run has no local commit for the head branch";
+const REFUSE_PUSHED_NO_LOCAL = "the head was pushed but the pusher did not report the local commit";
+// #558: the 422 recovery reuses only an open PR into the requested base.
+const REFUSE_REUSE_NOT_OPEN = "a PR for this head already exists and is not open";
+const REFUSE_REUSE_OTHER_BASE = "a PR for this head already exists into another base branch";
 const REFUSE_PR_UNVERIFIED = "the PR was opened but its head commit could not be verified";
 /**
  * The sha the remote `head` branch points at, read through the API (#544), or
@@ -392,7 +400,7 @@ export const github = {
                 let reused = false;
                 // The remote head this run saw, for the result (#544).
                 let observedHead;
-                // Set after sweny's own push failed: the PR's head must be this commit (#544).
+                // With a checkout, the PR's head must be this run's local commit (#544, #558).
                 let mustHead;
                 // #473: push the head branch from sweny with this skill's token, so the
                 // recommended `persist-credentials: false` checkout still ships the
@@ -411,61 +419,73 @@ export const github = {
                         // The pusher refuses without it; the PR request below reports the API error.
                     }
                     const lease = await headPushLease(input.repo, input.head, input.base ?? "main", ctx);
-                    const push = "skip" in lease
-                        ? { pushed: false, attempted: false, reason: lease.skip }
-                        : await ctx.pushBranch({
-                            repo: input.repo,
-                            head: input.head,
-                            base: input.base ?? "main",
-                            ...(defaultBranch ? { defaultBranch } : {}),
-                            remoteSha: lease.remoteSha,
-                            token: ctx.config.GITHUB_TOKEN,
-                        });
+                    // #558: on a lease skip the pusher is still asked for the local
+                    // commit, with no lease and no token, so it cannot push.
+                    const push = await ctx.pushBranch({
+                        repo: input.repo,
+                        head: input.head,
+                        base: input.base ?? "main",
+                        ...(defaultBranch ? { defaultBranch } : {}),
+                        ...("skip" in lease ? {} : { remoteSha: lease.remoteSha, token: ctx.config.GITHUB_TOKEN }),
+                    });
                     if (lease.remoteSha)
                         observedHead = lease.remoteSha;
+                    const notPushed = "skip" in lease ? lease.skip : push.reason;
                     if ("skip" in lease)
                         ctx.logger?.warn?.(`  github_create_pr: not pushing: ${lease.skip}`);
                     else if (push.pushed)
                         ctx.logger?.info?.(`  github_create_pr: pushed ${input.head} to ${input.repo}`);
-                    else if (push.attempted) {
-                        // #544: a push sweny ran and that failed. The PR would publish
-                        // whatever the remote branch holds, so open it only when that is
-                        // the commit this run would have pushed. Anything else, or a
-                        // remote head that cannot be read, refuses.
-                        const local = typeof push.sha === "string" && SHA.test(push.sha) ? push.sha : null;
-                        const remote = local ? await remoteHeadSha(input.repo, input.head, ctx) : undefined;
-                        const remoteSha = remote && "sha" in remote ? remote.sha : null;
-                        if (!local || !remoteSha || remoteSha !== local) {
-                            const [reason, why] = !local
-                                ? [REFUSE_NO_LOCAL, "the pusher did not report the local commit"]
-                                : remote && "error" in remote
-                                    ? [REFUSE_UNREADABLE, `cannot read the remote head of ${input.head}: ${remote.error}`]
-                                    : remoteSha
-                                        ? [
-                                            REFUSE_MISMATCH,
-                                            `the remote head of ${input.head} is ${remoteSha}, not the local commit ${local}`,
-                                        ]
-                                        : [REFUSE_MISMATCH, `${input.head} does not exist on ${input.repo}; the local commit is ${local}`];
-                            const detail = `sweny's push failed (${push.reason}) and ${why}`;
-                            ctx.logger?.warn?.(`  github_create_pr: refusing to open the PR: ${detail}`);
-                            const refusal = {
-                                refused: true,
-                                reason,
-                                detail,
-                                // A ref read that failed may succeed later; nothing was written.
-                                ...(reason === REFUSE_UNREADABLE ? { transient: true } : {}),
-                                head: input.head,
-                                local_sha: local,
-                                remote_sha: remoteSha,
-                            };
-                            return refusal;
-                        }
-                        observedHead = remoteSha;
-                        mustHead = local;
-                        ctx.logger?.warn?.(`  github_create_pr: ${push.reason}; the remote head is already the local commit ${local}, requesting the PR`);
-                    }
+                    else if (push.attempted)
+                        ctx.logger?.warn?.(`  github_create_pr: ${push.reason}`);
                     else
                         ctx.logger?.debug?.(`  github_create_pr: no sweny-side push (${push.reason})`);
+                    const local = typeof push.sha === "string" && SHA.test(push.sha) ? push.sha : null;
+                    const failed = !push.pushed && push.attempted;
+                    const refuse = (reason, detail, remoteSha, transient = false) => {
+                        ctx.logger?.warn?.(`  github_create_pr: refusing to open the PR: ${detail}`);
+                        const refusal = {
+                            refused: true,
+                            reason,
+                            detail,
+                            // A ref read that failed may succeed later; nothing was written.
+                            ...(transient ? { transient: true } : {}),
+                            head: input.head,
+                            local_sha: local,
+                            remote_sha: remoteSha,
+                        };
+                        return refusal;
+                    };
+                    if (!local) {
+                        // #558: no local commit for the head. Nothing ties the remote branch
+                        // (the agent named it) to this run, so no PR. A failed push keeps #544's wording.
+                        if (push.pushed) {
+                            return refuse(REFUSE_PUSHED_NO_LOCAL, `sweny pushed ${input.head} but did not get the local commit`, null);
+                        }
+                        return failed
+                            ? refuse(REFUSE_NO_LOCAL, `sweny's push failed (${push.reason}) and the pusher did not report the local commit`, null)
+                            : refuse(REFUSE_NO_COMMIT, `sweny did not push (${notPushed}) and the checkout has no commit for ${input.head}`, lease.remoteSha || null);
+                    }
+                    if (!push.pushed) {
+                        // #544, #558: sweny did not push, or its push failed. The PR would
+                        // publish whatever the remote branch holds, so open it only when that
+                        // is this run's local commit. Anything else, or a remote head that
+                        // cannot be read, refuses.
+                        const remote = await remoteHeadSha(input.repo, input.head, ctx);
+                        const remoteSha = "sha" in remote ? remote.sha : null;
+                        const lead = failed ? `sweny's push failed (${push.reason})` : `sweny did not push (${notPushed})`;
+                        if ("error" in remote) {
+                            return refuse(failed ? REFUSE_UNREADABLE : REFUSE_SKIP_UNREADABLE, `${lead} and cannot read the remote head of ${input.head}: ${remote.error}`, null, true);
+                        }
+                        if (remoteSha !== local) {
+                            const why = remoteSha
+                                ? `the remote head of ${input.head} is ${remoteSha}, not the local commit ${local}`
+                                : `${input.head} does not exist on ${input.repo}; the local commit is ${local}`;
+                            return refuse(failed ? REFUSE_MISMATCH : REFUSE_SKIP_MISMATCH, `${lead} and ${why}`, remoteSha);
+                        }
+                        ctx.logger?.info?.(`  github_create_pr: the remote head is already the local commit ${local}, requesting the PR`);
+                    }
+                    observedHead = local;
+                    mustHead = local;
                 }
                 try {
                     pr = (await gh(`/repos/${input.repo}/pulls`, ctx, {
@@ -488,19 +508,48 @@ export const github = {
                     // and-recreate loop on the same branch.
                     if (!isAlreadyExistsError(err))
                         throw err;
+                    // #558: reuse only an open PR from this head into the requested base.
+                    // Anything else that exists for the head (closed, merged, or into
+                    // another base) is named in a refusal, never returned as reused.
                     const owner = input.repo.split("/")[0];
                     const headQ = encodeURIComponent(`${owner}:${input.head}`);
-                    const open = (await gh(`/repos/${input.repo}/pulls?head=${headQ}&state=open&per_page=1`, ctx));
-                    const existing = open[0] ??
+                    const target = (input.base ?? "main").replace(/^refs\/heads\//, "");
+                    const open = (await gh(`/repos/${input.repo}/pulls?head=${headQ}&base=${encodeURIComponent(target)}&state=open&per_page=1`, ctx));
+                    const existing = (Array.isArray(open) ? open[0] : undefined) ??
                         (await gh(`/repos/${input.repo}/pulls?head=${headQ}&state=all&per_page=1`, ctx))[0];
                     if (!existing)
                         throw err;
+                    const prState = typeof existing.state === "string" ? existing.state : null;
+                    const prBase = typeof existing.base?.ref === "string" ? existing.base.ref : null;
+                    if (prState !== "open" || prBase !== target) {
+                        const merged = typeof existing.merged_at === "string" && existing.merged_at.length > 0;
+                        const priorHead = existing.head?.sha;
+                        const name = existing.html_url ?? `#${existing.number}`;
+                        const detail = `GitHub has a PR for ${input.head} already (${name}), ${merged ? "merged" : (prState ?? "in an unknown state")} ` +
+                            `into ${prBase ?? "an unknown base"}; sweny reuses only an open PR into ${target}`;
+                        ctx.logger?.warn?.(`  github_create_pr: not reusing ${name}: ${detail}`);
+                        const refusal = {
+                            refused: true,
+                            reason: prState !== "open" ? REFUSE_REUSE_NOT_OPEN : REFUSE_REUSE_OTHER_BASE,
+                            detail,
+                            ...(existing.number !== undefined ? { number: existing.number } : {}),
+                            ...(existing.html_url ? { html_url: existing.html_url } : {}),
+                            pr_state: prState,
+                            ...(merged ? { merged: true } : {}),
+                            pr_base: prBase,
+                            head: input.head,
+                            local_sha: mustHead ?? null,
+                            remote_sha: typeof priorHead === "string" && SHA.test(priorHead) ? priorHead : null,
+                        };
+                        return refusal;
+                    }
                     pr = existing;
                     reused = true;
                 }
-                // #544: the remote could move between the ref read and the request. The
-                // PR exists now; it is not closed (that would be another write nobody
-                // asked for), but the result refuses to vouch for it.
+                // #544, #558: the remote could move between the push or the ref read and
+                // the request, and a reused PR (the 422 recovery) may sit on another
+                // commit. The PR exists now; it is not closed (that would be another
+                // write nobody asked for), but the result refuses to vouch for it.
                 const prHead = pr.head?.sha;
                 const prHeadSha = typeof prHead === "string" && SHA.test(prHead) ? prHead : null;
                 if (mustHead && prHeadSha !== mustHead) {

package/dist/types.d.ts

@@ -77,8 +77,8 @@ export type BranchPusher = (opts: {
     attempted: boolean;
     reason?: string;
     /**
-     * The local commit the push tried to publish. Set when a push was attempted
-     * and failed, so the caller can check what the remote head holds (#544).
+     * The local commit of the head branch, set whenever the pusher read it
+     * (pushed, failed or skipped), so the caller can bind the PR to it (#544, #558).
      */
     sha?: string;
 }>;
@@ -127,6 +127,19 @@ export interface ToolRefusal {
 }
 /** Whether a tool handler's output is a {@link ToolRefusal}. */
 export declare function isToolRefusal(output: unknown): output is ToolRefusal;
+/**
+ * Whether a tool handler's output refuses (#558): `refused: true` on an
+ * object. The one predicate the tool bridge, the write stage and the journal
+ * share. A refusal without a usable reason still counts; {@link refusalReason}
+ * gives it fixed wording.
+ */
+export declare function isRefusal(output: unknown): output is {
+    refused: true;
+} & Record<string, unknown>;
+/** Longest refusal reason a receipt, the journal or the agent sees. */
+export declare const REFUSAL_REASON_MAX = 200;
+/** A refusal's fixed-wording reason, capped; generic wording when it has no usable one. */
+export declare function refusalReason(output: unknown): string;
 /** Config field declaration — skills say what they need */
 export interface ConfigField {
     description: string;

package/dist/types.js

@@ -19,6 +19,24 @@ export function isToolRefusal(output) {
     const o = output;
     return o.refused === true && typeof o.reason === "string" && o.reason.length > 0;
 }
+/**
+ * Whether a tool handler's output refuses (#558): `refused: true` on an
+ * object. The one predicate the tool bridge, the write stage and the journal
+ * share. A refusal without a usable reason still counts; {@link refusalReason}
+ * gives it fixed wording.
+ */
+export function isRefusal(output) {
+    return (!!output &&
+        typeof output === "object" &&
+        !Array.isArray(output) &&
+        output.refused === true);
+}
+/** Longest refusal reason a receipt, the journal or the agent sees. */
+export const REFUSAL_REASON_MAX = 200;
+/** A refusal's fixed-wording reason, capped; generic wording when it has no usable one. */
+export function refusalReason(output) {
+    return isToolRefusal(output) ? output.reason.slice(0, REFUSAL_REASON_MAX) : "the tool refused the write";
+}
 /**
  * Skill categories: used for per-node validation and grouping.
  *

package/package.json

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