omp-conductor 0.12.0 → 0.14.0

package/src/worker.ts

@@ -11,6 +11,7 @@
  */
 
 import { createSession, disposeSession } from "./omp.ts";
+import type { ReleaseBlockContext } from "./release-policy.ts";
 import type { Caps, ReleaseShape, ResolvedGrants, RunState } from "./types.ts";
 
 /** Structured evidence fields from the worker's final report. */
@@ -21,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;
@@ -47,6 +50,9 @@ export interface WorkerPauseControl {
   /** Returns a parked session to work with a continuation prompt. Throws
    * when the phase is not `paused`. */
   resume(): void;
+  /** Terminally ends this run for an operator-supplied reason. The run is
+   * recorded as an administrative kill and cannot be resumed. */
+  stop(reason: string): void;
 }
 
 /** What a resumed session is told. One literal so tests can pin it. */
@@ -59,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
@@ -78,7 +86,7 @@ export interface WorkerOpts {
    */
   releaseGrants?: ResolvedGrants;
   /** Durable audit sink for rejected release/deploy calls. */
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   /** The child's pid, the instant it exists. See {@link VerbListener.bindPid}. */
   onSpawn?: (pid: number) => void;
   /** Control socket for that child, beside the run's own session directory. */
@@ -135,6 +143,8 @@ export interface WorkerResult {
   spendUsd: number;
   report: string;
   killedBy?: KilledBy;
+  /** Present only when an operator terminally stopped this run. */
+  stoppedReason?: string;
   /**
    * Transcript the session actually opened, absent if it opened none. Recorded
    * per run because it is the only readable evidence left once the worktree is
@@ -173,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";
@@ -280,6 +298,7 @@ export async function runWorker(
   // merged (#217).
   let claim: { prUrl: string; headSha: string } | undefined;
   let killedBy: KilledBy | undefined;
+  let stoppedReason: string | undefined;
   // Canceler for the armed wall clock; invoked on every exit path below.
   let cancelWallClock: (() => void) | undefined;
   let wallClockRemainingMs = workerWallClockMs;
@@ -309,7 +328,7 @@ export async function runWorker(
   };
 
   const kill = (by: KilledBy) => {
-    if (killedBy !== undefined) return;
+    if (killedBy !== undefined || stoppedReason !== undefined) return;
     killedBy = by;
     o.onKilled?.(by);
     clearWallClock();
@@ -331,7 +350,7 @@ export async function runWorker(
       resumeWaiter = undefined;
       pauseRequested = Promise.withResolvers<void>();
     }
-    return killedBy !== undefined || done ? undefined : prompt;
+    return killedBy !== undefined || stoppedReason !== undefined || done ? undefined : prompt;
   };
 
   o.onPauseControl?.({
@@ -388,6 +407,16 @@ export async function runWorker(
       armWallClock();
       resumeWaiter?.resolve(RESUME_PROMPT);
     },
+    stop: (reason) => {
+      if (killedBy !== undefined || done) {
+        throw new Error("the run is settling; nothing left to stop");
+      }
+      stoppedReason = reason;
+      clearWallClock();
+      done = true;
+      settle();
+      session.abort();
+    },
   });
 
   session.on("turn_start", () => {
@@ -407,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 };
       }
@@ -464,7 +493,7 @@ export async function runWorker(
       } catch (cause) {
         // Our own abort surfaces here on some paths: a cap kill (existing
         // behavior) or an operator park (new). Anything else is a real failure.
-        if (killedBy === undefined && resumeWaiter === undefined) throw cause;
+        if (killedBy === undefined && stoppedReason === undefined && resumeWaiter === undefined) throw cause;
       }
       next = undefined;
       if (killedBy !== undefined) break;
@@ -483,7 +512,7 @@ export async function runWorker(
     }
   } catch (cause) {
     // Our own abort surfaces here on some paths; that is a kill, not a crash.
-    if (killedBy === undefined) {
+    if (killedBy === undefined && stoppedReason === undefined) {
       const detail = cause instanceof Error ? cause.message : String(cause);
       return withSessionFacts({
         state: "failed",
@@ -504,6 +533,17 @@ export async function runWorker(
     }
   }
 
+  if (stoppedReason !== undefined) {
+    return withSessionFacts({
+      state: "stopped",
+      turns,
+      spendUsd,
+      report,
+      stoppedReason,
+      ...(claim === undefined ? {} : { prUrl: claim.prUrl, headSha: claim.headSha }),
+    });
+  }
+
   if (killedBy !== undefined) {
     // The PR and head are facts the session already established, so they
     // survive the kill. Without them `shouldContinueAfterTurnsCap` sees no
@@ -526,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,

package/src/worktree.ts

@@ -317,6 +317,11 @@ async function ensureMirrorUnlocked(repo: RepoTarget, mirrorRoot: string): Promi
     throw err;
   }
   await configureMirror(mirrorPath);
+  // `clone --mirror` writes upstream heads under `refs/heads/*`; the safe
+  // normal-clone refspec above uses `refs/remotes/origin/*`. Populate that
+  // namespace before returning so first-use callers see the same fresh mirror
+  // shape as every later refresh.
+  await refreshMirror(mirrorPath);
   return mirrorPath;
 }