omp-conductor 0.13.0 → 0.14.0

package/src/tracker/github.ts

@@ -272,6 +272,28 @@ export function mergedPrInfoFrom(raw: string): MergedPrInfo | undefined {
     : undefined;
 }
 
+/** Parse the commit identity emitted by GitHub's branch REST endpoint. */
+export function branchHeadFrom(raw: string): string | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw) as unknown;
+  } catch {
+    return undefined;
+  }
+  if (
+    parsed === null ||
+    typeof parsed !== "object" ||
+    !("commit" in parsed) ||
+    parsed.commit === null ||
+    typeof parsed.commit !== "object" ||
+    !("sha" in parsed.commit)
+  ) {
+    return undefined;
+  }
+  const sha = parsed.commit.sha;
+  return typeof sha === "string" && /^[0-9a-f]{40,64}$/i.test(sha) ? sha : undefined;
+}
+
 /** Parse an Actions workflow-run list, skipping malformed entries without
  *  turning a valid empty list into an unreadable response. */
 export function workflowRunsFrom(raw: string): WorkflowRun[] | undefined {
@@ -1187,16 +1209,32 @@ export function makeTracker(
       }
     },
 
-    async workflowRunsAt(repo: string, sha: string): Promise<WorkflowRun[] | undefined> {
+    async branchHead(repo: string, branch: string): Promise<string | undefined> {
+      if (!/^[^/\s]+\/[^/\s]+$/.test(repo) || branch.length === 0) return undefined;
+      try {
+        return branchHeadFrom(
+          await runGh(["api", `repos/${repo}/branches/${encodeURIComponent(branch)}`]),
+        );
+      } catch {
+        return undefined;
+      }
+    },
+
+    async workflowRunsAt(
+      repo: string,
+      sha: string,
+      opts?: { event?: string; branch?: string },
+    ): Promise<WorkflowRun[] | undefined> {
       if (!/^[^/\s]+\/[^/\s]+$/.test(repo) || !/^[0-9a-f]{40,64}$/i.test(sha)) {
         return undefined;
       }
+      const query = [`head_sha=${encodeURIComponent(sha)}`];
+      if (opts?.event !== undefined) query.push(`event=${encodeURIComponent(opts.event)}`);
+      if (opts?.branch !== undefined) query.push(`branch=${encodeURIComponent(opts.branch)}`);
+      query.push("per_page=50");
       try {
         return workflowRunsFrom(
-          await runGh([
-            "api",
-            `repos/${repo}/actions/runs?head_sha=${encodeURIComponent(sha)}&per_page=50`,
-          ]),
+          await runGh(["api", `repos/${repo}/actions/runs?${query.join("&")}`]),
         );
       } catch {
         return undefined;

package/src/types.ts

@@ -136,8 +136,8 @@ export interface RepoTarget {
  * `escalations` interrupts only for a tier-2 decision. `material` reports every
  * material event as it happens. `decisions` sits between them: a decision the
  * session needs, or a condition that stops the fleet, interrupts immediately;
- * every other material event accumulates and ships with the next tick report —
- * one message on a schedule instead of a ping per merge (#138).
+ * every other material event accumulates and ships with the configured digest
+ * instead of as a ping per merge (#138).
  */
 export const REPORT_SCOPES = ["escalations", "decisions", "material"] as const;
 
@@ -177,6 +177,24 @@ export const INTERRUPT_CATEGORIES = [
 
 export type InterruptCategory = (typeof INTERRUPT_CATEGORIES)[number];
 
+/** Operator-local weekdays used by a weekly availability window. */
+export const WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] as const;
+
+export type Weekday = (typeof WEEKDAYS)[number];
+
+/**
+ * One operator-local interruption window. A day names the day the window
+ * opens; when `start` is later than `end`, it closes on the following day.
+ */
+export interface WeeklyAvailability {
+  timezone: string;
+  days: Weekday[];
+  start: string;
+  end: string;
+  /** Categories that may still interrupt outside the window. */
+  bypass: InterruptCategory[];
+}
+
 /** When the daily/report rollup is due. */
 export const DIGEST_CADENCES = ["none", "per-tick", "daily"] as const;
 
@@ -190,6 +208,8 @@ export type DigestCadence = (typeof DIGEST_CADENCES)[number];
 export interface ReportingPolicy {
   interruptOn: InterruptCategory[];
   digest: { cadence: DigestCadence; at?: string; timezone?: string };
+  /** Absent preserves the legacy 24-hour interruption behaviour. */
+  availability?: WeeklyAvailability;
   /** Set when the policy came from a legacy `scope` preset. */
   scopePreset?: ReportScope;
 }
@@ -710,6 +730,10 @@ export const SETTLEMENT_FLAG_KINDS = [
   "changed-line-missing",
   /** `changed:` named a path the PR never touched. The weaker direction. */
   "unmatched-claim",
+  /** The same file appears as both claimed-but-untouched and
+   *  touched-but-unclaimed — the `changed:` line's format defeated the parser;
+   *  read the diff directly. */
+  "report-format-unparsed",
   /** A test file left the tree and no rename in the PR accounts for it. */
   "test-file-deleted",
   /** A skip/only/focus marker appears on a line the PR added. */
@@ -869,7 +893,13 @@ export interface Tracker {
   /** The merge commit and base ref for a merged pull request. */
   mergedPrInfo(url: string): Promise<MergedPrInfo | undefined>;
   /** Workflow runs GitHub associated with one exact commit SHA. */
-  workflowRunsAt(repo: string, sha: string): Promise<WorkflowRun[] | undefined>;
+  workflowRunsAt(
+    repo: string,
+    sha: string,
+    opts?: { event?: string; branch?: string },
+  ): Promise<WorkflowRun[] | undefined>;
+  /** The live commit at one repository branch, or undefined when unreadable. */
+  branchHead(repo: string, branch: string): Promise<string | undefined>;
   /** The newest run of this workflow on the base branch before `before`.
    *  `null` means no earlier run; `undefined` means the history could not be read. */
   previousWorkflowRun(
@@ -959,6 +989,9 @@ export const FAILURE_CLASSES = [
   "settlement-stuck",
   "provider-credit",
   "provider-transient",
+  /** A reviewer closed pushed-green or pushed-pending work without merging it:
+   *  a review decision, not a worker failure. */
+  "returned-for-revision",
   "unknown",
 ] as const;
 
@@ -994,6 +1027,17 @@ export const BASE_CHECK_STATES = [
 
 export type BaseCheckState = (typeof BASE_CHECK_STATES)[number];
 
+/** Current push-workflow health at a routed repository's live base head. */
+export interface BaseHealth {
+  repo: string;
+  branch: string;
+  headSha: string;
+  verdict: "green" | "red" | "pending" | "unknown";
+  runsCount: number;
+  detail?: string;
+  checkedAt: number;
+}
+
 /**
  * Execution state is separate from the tracker's own labels on purpose: labels
  * are coarse and human-editable, while the loop needs to distinguish "pushed
@@ -1266,6 +1310,43 @@ export interface ReportEnqueue {
   deduped: boolean;
 }
 
+/** Maximum ledger rows of each kind placed in one digest prompt. Older rows
+ * stay first, so a busy day drains deterministically over later digests. */
+export const DIGEST_BACKLOG_LIMIT = 20;
+
+/** One ordinary material outcome waiting for a rendered digest (#274). */
+export interface MaterialEvent {
+  id: string;
+  project: string;
+  category: string;
+  summary: string;
+  evidence: string;
+  occurredAt: number;
+  recordedAt: number;
+  /** The accepted outbox row that took responsibility for this event. */
+  digestReportId?: string;
+}
+
+/** What the orchestrator records when an outcome happens. */
+export interface MaterialEventDraft {
+  project: string;
+  category: string;
+  summary: string;
+  evidence: string;
+  occurredAt: number;
+  recordedAt: number;
+}
+
+/** Counts and oldest timestamps for the two distinct digest sources. */
+export interface DigestBacklog {
+  materialCount: number;
+  materialOldestAt?: number;
+  heldNoticeCount: number;
+  /** Subset held only for the next availability window. */
+  availabilityHeldNoticeCount?: number;
+  heldNoticeOldestAt?: number;
+}
+
 /**
  * Where one operator decision stands (#136).
  *
@@ -1359,8 +1440,15 @@ export interface Store {
   recentRuns(project: string, mergedSinceEpochMs: number): RunRecord[];
   /** Merged rows whose post-merge workflow verdict is still pending, oldest first. */
   runsNeedingBaseCheck(project: string, limit?: number): RunRecord[];
-  /** Newest checked merge per routed repository inside the supplied history window. */
-  latestBaseChecks(project: string, sinceEpochMs: number): RunRecord[];
+  /** Replace the current live-head health row for one routed repository. */
+  upsertBaseHealth(project: string, row: BaseHealth): void;
+  /** Current live-head health, ordered by routed repository name. */
+  baseHealth(project: string): BaseHealth[];
+  /** Recently merged routed repository/branch pairs that establish health scope. */
+  mergedRepoBranches(
+    project: string,
+    sinceEpochMs: number,
+  ): { repo: string; baseRef?: string }[];
   /** Newest attempt per issue that preserved work or failed to, so `status`
    *  can name every WIP tip a re-claim would build on and every tree that is
    *  still the only copy. */
@@ -1405,12 +1493,26 @@ export interface Store {
   /** The newest `digest:` dedupe key a project has run toward without ending in
    *  failure — what the off-schedule-digest refusal compares against (#229). */
   lastDigestDedupeKey(project: string): string | undefined;
-  /** Hold a tier-2 escalation the interrupt policy deferred to the digest. */
+  /** Hold a tier-2 escalation the interrupt policy or availability window deferred. */
   addHeldNotice(notice: HeldNoticeDraft): void;
-  /** Held notices still owed (not yet re-surfaced by a digest pass). */
-  undigestedNotices(project: string): HeldNotice[];
-  /** Mark every undigested notice for a project as re-surfaced. */
-  markNoticesDigested(project: string, at: number): void;
+  /**
+   * Held notices still owed, oldest first and bounded. `availabilityOnly`
+   * selects notices that may be released at the next configured opening.
+   */
+  undigestedNotices(
+    project: string,
+    limit?: number,
+    availabilityOnly?: boolean,
+    categories?: readonly InterruptCategory[],
+    urgent?: boolean,
+  ): HeldNotice[];
+  /** Persist one ordinary material outcome without sending it. */
+  recordMaterialEvent(event: MaterialEventDraft): MaterialEvent;
+  getMaterialEvent(id: string): MaterialEvent | undefined;
+  /** Ordinary material outcomes still owed, oldest first and bounded. */
+  undigestedMaterialEvents(project: string, limit?: number): MaterialEvent[];
+  /** Count and age source for status and digest prompt bounds. */
+  digestBacklog(project: string): DigestBacklog;
   /** Add one bounded observation to the per-day friction rollup. */
   recordFriction(project: string, observation: FrictionObservation): void;
   /** Repeated signals not surfaced within the supplied cooldown window. */
@@ -1440,7 +1542,35 @@ export interface Store {
    * suppressed without asking the model what it sent yesterday.
    */
   enqueueReport(draft: ReportDraft): ReportEnqueue;
+  /** Atomically hand a digest to the outbox and associate only the named
+   * material events and deferred escalations. A handoff deduplicated by its
+   * optional daily key consumes nothing new. */
+  enqueueDigestReport(
+    draft: ReportDraft,
+    materialEventIds: readonly string[],
+    heldNoticeIds: readonly string[],
+  ): ReportEnqueue;
+  /** Atomically enqueue a working-hours catch-up unless a due digest currently
+   * owns the handoff window. `undefined` leaves every notice unowned. */
+  enqueueAvailabilityReport(
+    draft: ReportDraft,
+    heldNoticeIds: readonly string[],
+  ): ReportEnqueue | undefined;
   getReport(id: string): ReportRecord | undefined;
+  /** Atomically remove an unsent material report from the outbox and preserve
+   * its body as a held notice after policy or availability changes. */
+  deferPendingReportToNotice(id: string, notice: HeldNoticeDraft): boolean;
+  /** Remove a still-pending working-hours catch-up and make its associated
+   * notices digest-eligible again after a live policy change. */
+  releasePendingAvailabilityReport(id: string, project: string, possibleRepeat?: boolean): boolean;
+  /** Give one due digest a bounded, once-per-day lease on availability-held
+   * notices. Pending catch-ups are released inside the same transaction. */
+  reserveAvailabilityDigest(
+    project: string,
+    cycleKey: string,
+    at: number,
+    expiresAt: number,
+  ): boolean;
   /** `pending` rows whose backoff has elapsed, oldest first. */
   dueReports(project: string, now: number, limit: number): ReportRecord[];
   /** Atomically take a due `pending` row into `sending` under `attemptId`, so
@@ -1582,22 +1712,31 @@ export interface Escalation {
   urgent?: true;
 }
 
-/** A tier-2 escalation the project's interrupt policy deferred to the digest. */
 export interface HeldNotice {
   id: string;
   category: InterruptCategory;
   summary: string;
   detail: string;
   createdAt: number;
+  /**
+   * This notice was otherwise interruptible and was held only by the
+   * availability window. It may be surfaced when the current policy opens.
+   */
+  releaseOnAvailable?: true;
+  /** Urgent recovery may bypass category batching, but never availability. */
+  urgent?: true;
 }
 
-/** What it takes to persist one held notice. */
 export interface HeldNoticeDraft {
+  /** Caller-supplied identity when the handoff must print or deduplicate it. */
+  id?: string;
   project: string;
   category: InterruptCategory;
   summary: string;
   detail: string;
   createdAt: number;
+  releaseOnAvailable?: true;
+  urgent?: true;
 }
 
 /**

package/src/verbs/actions.ts

@@ -132,6 +132,30 @@ export function githubVerbActions(
       `live ${repo.defaultBranch} lookup`,
     );
 
+  const remoteTagCommit = async (
+    mirror: string,
+    tag: string,
+  ): Promise<{ ok: true; sha: string | undefined } | { ok: false; stderr: string }> => {
+    const directRef = `refs/tags/${tag}`;
+    const peeledRef = `${directRef}^{}`;
+    const { argv, result } = await git(mirror, ["ls-remote", "origin", directRef, peeledRef]);
+    if (!result.ok) return failed(result, argv);
+    if (result.stdout.trim() === "") return { ok: true, sha: undefined };
+
+    const refs = new Map(
+      result.stdout
+        .trim()
+        .split("\n")
+        .map((line) => line.trim().split(/\s+/, 2))
+        .filter((entry): entry is [string, string] => entry.length === 2)
+        .map(([sha, ref]) => [ref, sha] as const),
+    );
+    const sha = commitFrom(refs.get(peeledRef) ?? refs.get(directRef) ?? "");
+    return sha === undefined
+      ? { ok: false, stderr: `remote tag ${tag} lookup returned no full commit SHA` }
+      : { ok: true, sha };
+  };
+
   const releaseTargetMoved = (repo: RepoTarget, target: string, live: string): { ok: false; stderr: string } => ({
     ok: false,
     stderr:
@@ -217,11 +241,40 @@ export function githubVerbActions(
         if (!liveBefore.ok) return liveBefore;
         if (target.sha !== liveBefore.sha) return releaseTargetMoved(execution.repo, target.sha, liveBefore.sha);
 
+        const localTag = await git(mirror, ["rev-parse", "-q", "--verify", `refs/tags/${tag}^{commit}`]);
+        let previousSha: string | undefined;
+        if (localTag.result.ok) {
+          previousSha = commitFrom(localTag.result.stdout);
+          if (previousSha === undefined) {
+            return { ok: false, stderr: `tag ${tag} returned no full commit SHA` };
+          }
+
+          const remoteTag = await remoteTagCommit(mirror, tag);
+          if (!remoteTag.ok) return remoteTag;
+          if (remoteTag.sha === target.sha) {
+            return {
+              ok: true,
+              sha: target.sha,
+              detail: `tag ${tag} already exists at ${target.sha} and is already on origin`,
+            };
+          }
+          if (remoteTag.sha !== undefined) {
+            return {
+              ok: false,
+              stderr:
+                `refusing release: ${tag} already exists on origin at ${remoteTag.sha}. ` +
+                "A published tag is never re-cut or moved; choose a new tag name.",
+            };
+          }
+        }
+
+        const repointed = previousSha !== undefined;
         // An unattended daemon cannot depend on a host-level Git identity or a
         // signing key with an interactive passphrase.
         const tagged = await git(mirror, [
           ...RELEASE_TAG_CONFIG,
           "tag",
+          ...(repointed ? ["-f"] : []),
           "-a",
           tag,
           "-m",
@@ -232,30 +285,95 @@ export function githubVerbActions(
 
         const liveAfter = await liveDefaultHead(mirror, execution.repo);
         if (!liveAfter.ok || liveAfter.sha !== target.sha) {
-          const removed = await git(mirror, ["tag", "-d", tag]);
+          const rollback = previousSha !== undefined
+            ? await git(mirror, [
+                ...RELEASE_TAG_CONFIG,
+                "tag",
+                "-f",
+                "-a",
+                tag,
+                "-m",
+                `release ${tag}`,
+                previousSha,
+              ])
+            : await git(mirror, ["tag", "-d", tag]);
           const reason = liveAfter.ok
             ? releaseTargetMoved(execution.repo, target.sha, liveAfter.sha).stderr
-            : `created ${tag} at ${target.sha}, but could not verify the live default branch: ${liveAfter.stderr}`;
-          return {
-            ok: false,
-            stderr:
-              reason +
-              (removed.result.ok
-                ? " The unpushed local tag was deleted."
-                : ` WARNING: the unpushed local tag could not be deleted: ${failed(removed.result, removed.argv).stderr}`),
-          };
+            : `${repointed ? "re-pointed" : "created"} ${tag} at ${target.sha}, but could not verify the live default branch: ${liveAfter.stderr}`;
+          const rollbackDetail = repointed
+            ? rollback.result.ok
+              ? ` The tag was restored to ${previousSha}.`
+              : ` WARNING: the tag could not be restored to ${previousSha}: ${failed(rollback.result, rollback.argv).stderr}`
+            : rollback.result.ok
+              ? " The unpushed local tag was deleted."
+              : ` WARNING: the unpushed local tag could not be deleted: ${failed(rollback.result, rollback.argv).stderr}`;
+          return { ok: false, stderr: reason + rollbackDetail };
         }
-        return { ok: true, sha: target.sha, detail: `tagged ${tag} at ${target.sha}` };
+        return {
+          ok: true,
+          sha: target.sha,
+          detail: repointed
+            ? `re-pointed unpushed ${tag} from ${previousSha} to ${target.sha}`
+            : `tagged ${tag} at ${target.sha}`,
+        };
       }
 
       const target = await readCommit(mirror, ["rev-parse", `refs/tags/${tag}^{commit}`], `tag ${tag}`);
       if (!target.ok) return target;
+      let tagSha = target.sha;
       const live = await liveDefaultHead(mirror, execution.repo);
       if (!live.ok) return live;
-      if (target.sha !== live.sha) return releaseTargetMoved(execution.repo, target.sha, live.sha);
+
+      const remoteTag = await remoteTagCommit(mirror, tag);
+      if (!remoteTag.ok) return remoteTag;
+      if (remoteTag.sha === tagSha) {
+        return { ok: true, sha: tagSha, detail: `refs/tags/${tag} already on origin at ${tagSha}` };
+      }
+      if (remoteTag.sha !== undefined) {
+        return {
+          ok: false,
+          stderr:
+            `refusing release: origin already has ${tag} at ${remoteTag.sha}, ` +
+            `which differs from the local tag at ${tagSha}. ` +
+            "A published tag is never force-moved; cut a new tag instead.",
+        };
+      }
+
+      let oldSha: string | undefined;
+      if (tagSha !== live.sha) {
+        const fresh = await readCommit(
+          mirror,
+          ["rev-parse", `refs/remotes/origin/${execution.repo.defaultBranch}^{commit}`],
+          `refreshed ${execution.repo.defaultBranch}`,
+        );
+        if (!fresh.ok) return fresh;
+        if (fresh.sha !== live.sha) return releaseTargetMoved(execution.repo, fresh.sha, live.sha);
+
+        oldSha = tagSha;
+        const retagged = await git(mirror, [
+          ...RELEASE_TAG_CONFIG,
+          "tag",
+          "-f",
+          "-a",
+          tag,
+          "-m",
+          `release ${tag}`,
+          live.sha,
+        ]);
+        if (!retagged.result.ok) return failed(retagged.result, retagged.argv);
+        tagSha = live.sha;
+      }
+
       const pushed = await git(mirror, ["push", "origin", `refs/tags/${tag}`]);
       return pushed.result.ok
-        ? { ok: true, sha: target.sha, detail: `pushed refs/tags/${tag} at ${target.sha}` }
+        ? {
+            ok: true,
+            sha: tagSha,
+            detail:
+              oldSha === undefined
+                ? `pushed refs/tags/${tag} at ${tagSha}`
+                : `re-pointed unpushed ${tag} from ${oldSha} to ${tagSha}; pushed refs/tags/${tag} at ${tagSha}`,
+          }
         : failed(pushed.result, pushed.argv);
     },
   };

package/src/verbs/server.ts

@@ -265,9 +265,9 @@ export interface ReleaseFacts {
   openPrs: number;
   /** Queue depth, or `undefined` when the tracker could not be read. */
   queueDepth: number | undefined;
-  /** Newest observed verdict for the released routed repository. */
+  /** Current live-head workflow verdict for the released routed repository. */
   baseCheck?: RunRecord["baseCheck"];
-  /** Evidence attached to a newest red verdict. */
+  /** Evidence attached to a current red verdict. */
   redBase?: string;
 }
 
@@ -978,18 +978,17 @@ async function releaseVerb(
     }
   }
   const wantsBase = policy.release.requires.includes("base-branch-green");
-  const latestBase = wantsBase
-    ? deps.store.latestBaseChecks(project.name, 0).find((run) => run.repo === repoName)
+  const health = wantsBase
+    ? deps.store.baseHealth(project.name).find((row) => row.repo === repoName)
     : undefined;
-  const redBase = latestBase?.settlementFlags?.find(
-    (flag) => flag.kind === "base-branch-red",
-  )?.detail;
   const unmet = releaseRequirementRefusal(policy.release.requires, {
     unsettledRuns: active.length,
     openPrs: active.filter((r) => r.prUrl !== undefined).length,
     queueDepth,
-    ...(latestBase?.baseCheck === undefined ? {} : { baseCheck: latestBase.baseCheck }),
-    ...(redBase === undefined ? {} : { redBase }),
+    ...(health === undefined ? {} : { baseCheck: health.verdict }),
+    ...(health?.verdict === "red" && health.detail !== undefined
+      ? { redBase: health.detail }
+      : {}),
   });
   if (unmet !== undefined) return refuse("release-not-granted", `refused: ${unmet}`);
 

package/src/worker.ts

@@ -22,6 +22,8 @@ const BLOCKED_PATTERN = /^state:\s*blocked\s*$/im;
 
 /** Any explicit verdict line, whatever it claims. */
 const STATE_LINE_PATTERN = /^state:\s*\S+\s*$/im;
+/** GitHub PR URLs in unstructured prose; capture their canonical `owner/repo`. */
+const GITHUB_PR_URL_PATTERN = /https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/pull\/\d+\b/gi;
 
 /** `{{KEY}}` placeholders in a brief template. */
 const PLACEHOLDER_PATTERN = /\{\{([A-Za-z0-9_]+)\}\}/g;
@@ -63,6 +65,8 @@ export interface WorkerOpts {
   brief: string;
   cwd: string;
   caps: Caps;
+  /** Canonical `owner/repo` identity used to scope prose-only PR URLs. */
+  repoSlug?: string;
   /**
    * Directory the harness writes this run's transcript into — a directory, not
    * a file. The SDK takes no `sessionFile` input, so naming a path here would
@@ -179,15 +183,23 @@ export function renderBrief(template: string, vars: Record<string, string>): str
  * asks the tracker to verify those facts independently. Missing or malformed
  * evidence fails closed.
  */
-export function deriveResult(report: string): {
+export function deriveResult(report: string, repoSlug?: string): {
   state: RunState;
   prUrl?: string;
   headSha?: string;
 } {
-  const prUrl = PR_URL_PATTERN.exec(report)?.[1];
+  const structuredPrUrl = PR_URL_PATTERN.exec(report)?.[1];
   const headSha = HEAD_SHA_PATTERN.exec(report)?.[1]?.toLowerCase();
-  if (PUSHED_GREEN_PATTERN.test(report) && prUrl !== undefined && headSha !== undefined) {
-    return { state: "pushed-green", prUrl, headSha };
+  if (PUSHED_GREEN_PATTERN.test(report) && structuredPrUrl !== undefined && headSha !== undefined) {
+    return { state: "pushed-green", prUrl: structuredPrUrl, headSha };
+  }
+
+  let prUrl = structuredPrUrl;
+  if (prUrl === undefined && repoSlug !== undefined) {
+    const expectedRepo = repoSlug.toLowerCase();
+    for (const match of report.matchAll(GITHUB_PR_URL_PATTERN)) {
+      if (match[1]?.toLowerCase() === expectedRepo) prUrl = match[0];
+    }
   }
 
   const state: RunState = BLOCKED_PATTERN.test(report) ? "blocked" : "failed";
@@ -424,7 +436,7 @@ export async function runWorker(
     const text = reportText(field(message, "content"));
     if (text !== "") {
       report = text;
-      const stated = deriveResult(text);
+      const stated = deriveResult(text, o.repoSlug);
       if (stated.state === "pushed-green" && stated.prUrl !== undefined && stated.headSha !== undefined) {
         claim = { prUrl: stated.prUrl, headSha: stated.headSha };
       }
@@ -554,7 +566,7 @@ export async function runWorker(
     return withSessionFacts({ state: "pushed-green", ...claim, turns, spendUsd, report });
   }
   return withSessionFacts({
-    ...deriveResult(report),
+    ...deriveResult(report, o.repoSlug),
     turns,
     spendUsd,
     report,