orizu 0.5.43 → 0.5.45

package/src/index.ts

@@ -796,9 +796,13 @@ async function submitRunResults() {
   const resultsJsonl = resultsPath.endsWith('.gz')
     ? gunzipSync(resultBytes).toString('utf8')
     : resultBytes.toString('utf8')
-  const response = await authedFetch(`/api/cli/runs/submit?project=${encodeURIComponent(project)}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+  const { sendScoreSave } = await import('./score-save-workflow.js')
+  const data = await sendScoreSave({
+    command: 'run',
+    path: `/api/cli/runs/submit?project=${encodeURIComponent(project)}`,
+    project,
+    promptVersionId,
+    saves: true,
     body: JSON.stringify({
       promptVersionId,
       runnerVersionId,
@@ -810,19 +814,13 @@ async function submitRunResults() {
       resultsJsonl,
       ...instructionSetProvenanceFields(project),
     }),
-  })
-
-  if (!response.ok) {
-    throw new Error(`Failed to submit run: ${await response.text()}`)
-  }
-
-  const data = await parseJsonResponse<{
+  }, authedFetch) as {
     run: {
       id: string
       aggregateScore: number | null
       perRowResultsStoragePath: string
     }
-  }>(response, 'Run submit')
+  }
   if (hasJsonFlag()) {
     printJson({ run: data.run })
     return

package/src/score-save-workflow.ts

@@ -8,34 +8,39 @@ import { appErrorOf, unreachedCode } from './request-outcome.js'
 
 // Loaded only through `await import(...)`, like the dataset workflows.
 
+const SavedScore = Schema.Struct({ scoreRun: Schema.Struct({ id: Schema.NonEmptyString }) })
+const SavedRun = Schema.Struct({ run: Schema.Struct({ id: Schema.NonEmptyString }) })
+
+// `serverMayBeSaved` is what the route says when it cannot tell whether the run was saved.
 const COMMANDS = {
-  submit: { label: 'Score submit', failed: 'Failed to submit score' },
-  exec: { label: 'Scorer exec', failed: 'Failed to execute scorer' },
+  submit: { label: 'Score submit', failed: 'Failed to submit score', serverMayBeSaved: 'Score run may already be saved', saved: SavedScore },
+  exec: { label: 'Scorer exec', failed: 'Failed to execute scorer', serverMayBeSaved: 'Score run may already be saved', saved: SavedScore },
+  run: { label: 'Run submit', failed: 'Failed to submit run', serverMayBeSaved: 'Run may already be saved', saved: SavedRun },
 } as const
 
-// What the server says when it cannot tell whether the run was saved.
-const SERVER_MAY_BE_SAVED = 'Score run may already be saved'
 // Node's fetch publishes this once a request's whole body has been written.
 const BODY_SENT = 'undici:request:bodySent'
 
-const SavedReply = Schema.Struct({ scoreRun: Schema.Struct({ id: Schema.NonEmptyString }) })
-
-export interface ScoreSave {
-  command: keyof typeof COMMANDS
+interface SaveRequest {
   /** The route path with its query, as sent. */
   path: string
   body: string
   project: string
-  scorerVersionId: string
   /** False for `scorers exec --no-submit`, which saves nothing. */
   saves: boolean
 }
 
+/** `scores submit` and `scorers exec`, or `runs submit` (ORI-1097 S3b). */
+export type ScoreSave =
+  | SaveRequest & { command: 'submit' | 'exec'; scorerVersionId: string }
+  | SaveRequest & { command: 'run'; promptVersionId: string }
+
 /** Sends one request; calls `onRequestStart` just before anything goes out. */
 export type ScoreSaveRequest = (path: string, init: RequestInit, onRequestStart?: () => void) => Promise<Response>
 
-const scoreMayBeSaved = (save: ScoreSave) =>
-  `The score may already be saved: run \`orizu scorers detail ${save.scorerVersionId} --project ${save.project}\` and check its newest score runs before running this again.`
+const mayBeSaved = (save: ScoreSave) => save.command === 'run'
+  ? `The run may already be saved: run \`orizu runs list --project ${save.project} --prompt-version ${save.promptVersionId}\` and check its newest runs before running this again.`
+  : `The score may already be saved: run \`orizu scorers detail ${save.scorerVersionId} --project ${save.project}\` and check its newest score runs before running this again.`
 
 // The run may be saved when the server says so, when the reply was lost, late
 // or unreadable after the request was sent, when a 5xx did not come from the
@@ -50,7 +55,7 @@ class ScoreSaveFailure extends Error {
 // second run. The deadline starts once the whole body has been sent, so a
 // large upload on a slow link takes as long as it did before.
 function scoreSave(save: ScoreSave, request: ScoreSaveRequest, timeoutMs: number): Effect.Effect<Record<string, unknown>, ScoreSaveFailure> {
-  const { label, failed } = COMMANDS[save.command]
+  const { label, failed, serverMayBeSaved, saved } = COMMANDS[save.command]
   return Effect.suspend(() => {
     let sent = false
     let timedOut = false
@@ -79,7 +84,7 @@ function scoreSave(save: ScoreSave, request: ScoreSaveRequest, timeoutMs: number
           if (!response.ok) {
             const appError = await appErrorOf(response.clone())
             const detail = await extractErrorMessage(response)
-            if (appError === SERVER_MAY_BE_SAVED) throw new ScoreSaveFailure(appError, true)
+            if (appError === serverMayBeSaved) throw new ScoreSaveFailure(appError, true)
             if (response.status < 400 || (response.status >= 500 && appError === null)) {
               throw new ScoreSaveFailure(`${label} got no clear answer (status ${response.status}).`, true)
             }
@@ -94,7 +99,7 @@ function scoreSave(save: ScoreSave, request: ScoreSaveRequest, timeoutMs: number
             data = undefined
           }
           const usable = save.saves
-            ? Result.isSuccess(Schema.decodeUnknownResult(SavedReply)(data))
+            ? Result.isSuccess(Schema.decodeUnknownResult(saved)(data))
             : typeof data === 'object' && data !== null && !Array.isArray(data)
           if (!usable) {
             throw new ScoreSaveFailure(`${label} returned an unexpected response (status ${response.status}).`, true)
@@ -122,10 +127,10 @@ function scoreSave(save: ScoreSave, request: ScoreSaveRequest, timeoutMs: number
   })
 }
 
-/** `orizu scores submit` and `orizu scorers exec`: the reply, or an error saying whether the score may be saved. */
+/** `orizu scores submit`, `orizu scorers exec` and `orizu runs submit`: the reply, or an error saying whether the save may have happened. */
 export async function sendScoreSave(save: ScoreSave, request: ScoreSaveRequest): Promise<Record<string, unknown>> {
   const exit = await Effect.runPromiseExit(scoreSave(save, request, datasetTransferTimeoutMs()).pipe(
-    Effect.mapError(failure => new Error(failure.mayBeSaved && save.saves ? `${failure.message}\n${scoreMayBeSaved(save)}` : failure.message)),
+    Effect.mapError(failure => new Error(failure.mayBeSaved && save.saves ? `${failure.message}\n${mayBeSaved(save)}` : failure.message)),
   ))
   if (Exit.isSuccess(exit)) return exit.value
   throw Cause.squash(exit.cause)

package/src/secret-redaction.ts

@@ -76,6 +76,36 @@ function redactString(input: string, secrets: readonly string[]): string {
   return out
 }
 
+/**
+ * The shape pass alone, for servers that hold no secret values: the web app
+ * and the session coordinator scrub agent text with it before it reaches a
+ * browser (ORI-1905). One list of shapes for the CLI and both servers.
+ */
+export function redactSecretShapes(input: string): string {
+  return redactString(input, [])
+}
+
+// A known credential prefix at the end of the text, followed by fewer
+// characters than its shape above needs: the start of a token still being
+// written. Each run is bounded, so the scan stays linear in the text, and a
+// longer run that is not a token (a path, a word) is left alone. `Bearer` only
+// counts in an Authorization header, so prose like "a Bearer token" keeps its
+// last word.
+const OPEN_TOKEN_AT_END = /(?:\bgithub_pat_[A-Za-z0-9_]{0,19}|\bgh[posur]_[A-Za-z0-9_]{0,19}|\borizu_(?:agent|pat)_[A-Za-z0-9_-]{0,9}|\bsk-[A-Za-z0-9_-]{0,19}|\b(authorization:\s*bearer)\s+[A-Za-z0-9._~+/-]{0,15})$/i
+
+/**
+ * For reply text shown as it is written: each snapshot is the reply so far, so
+ * one can end part-way through a token, before it is long enough for its shape
+ * to match. Such a tail is redacted too. The saved read shows a reply's last
+ * snapshot, so a finished reply that really ends in a bare `sk-` loses those
+ * characters there as well.
+ */
+export function redactStreamedTextShapes(input: string): string {
+  return redactSecretShapes(input).replace(OPEN_TOKEN_AT_END, (_match, header?: string) =>
+    header ? `${header} ${REDACTION_PLACEHOLDER}` : REDACTION_PLACEHOLDER
+  )
+}
+
 export interface RedactOptions {
   /** Verbatim secret values to strip wherever they appear (bearer, tokens). */
   secrets?: readonly string[]

package/src/skilled-proposer-launch.ts

@@ -49,39 +49,64 @@ function materializeConfigPayload(engine: GepaEngine, environment: NodeJS.Proces
   return () => rmSync(root, { recursive: true, force: true })
 }
 
+const STOP_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'] as const
+// The optimizer marks its run stopped before exiting (at most 10 s for the
+// status write); past this it is killed so nothing is left running (ORI-2402).
+const CHILD_STOP_WAIT_MS = 15_000
+
+/**
+ * Run the optimizer, passing a stop signal on to it. On a stop signal the CLI
+ * waits until the optimizer exits (capped at CHILD_STOP_WAIT_MS, then kills
+ * it) and then ends by that same signal.
+ */
 export async function spawnSkilledProposerChild(
   command: string, args: string[], engine: GepaEngine, environment: NodeJS.ProcessEnv,
   onSpawn?: () => Promise<void>,
   output?: SkilledProposerChildOutput,
 ) {
   const childEnvironment = { ...environment }
-  const shouldMaterialize = engine === 'official'
-    && childEnvironment.ORIZU_CANDIDATE_PROPOSER === 'skilled-proposer'
-    && childEnvironment.ORIZU_SKILLED_PROPOSER_CONFIG !== undefined
-  if (!shouldMaterialize) return spawnSync(command, args, { stdio: 'inherit', env: childEnvironment })
-
   let child: ReturnType<typeof spawn> | PipedChild | undefined
   let cleanup = () => {}
-  const signals = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'] as const
-  const handlers = signals.map(signal => ({
+  let stopSignal: NodeJS.Signals | undefined
+  // On the terminal path the optimizer leads its own process group, so a stop
+  // also reaches its runners, which may run in worker threads it can't stop.
+  let childGroup: number | undefined
+  const forward = (signal: NodeJS.Signals) => {
+    if (childGroup) {
+      try { process.kill(-childGroup, signal); return } catch { /* group already gone */ }
+    }
+    try { child?.kill(signal) } catch { /* already exited */ }
+  }
+  let giveUp: ReturnType<typeof setTimeout> | undefined
+  const removeHandlers = () => { for (const entry of handlers) process.off(entry.signal, entry.handle) }
+  const endBySignal = (signal: NodeJS.Signals): Promise<never> => {
+    if (giveUp) clearTimeout(giveUp)
+    removeHandlers()
+    cleanup()
+    // With our handlers gone, the signal's default action ends the process.
+    process.kill(process.pid, signal)
+    return new Promise<never>(() => {})
+  }
+  const handlers = STOP_SIGNALS.map(signal => ({
     signal,
     handle: () => {
-      try { cleanup() }
-      finally {
-        try { child?.kill(signal) }
-        finally {
-          for (const entry of handlers) process.off(entry.signal, entry.handle)
-          process.kill(process.pid, signal)
-        }
-      }
+      if (!child) { void endBySignal(signal); return }
+      forward(signal)
+      if (stopSignal) return
+      stopSignal = signal
+      // The child read the private payload at start and a stopping run
+      // proposes nothing, so it goes now rather than when the child exits.
+      cleanup()
+      giveUp = setTimeout(() => forward('SIGKILL'), CHILD_STOP_WAIT_MS)
     },
   }))
-  for (const entry of handlers) process.once(entry.signal, entry.handle)
+  for (const entry of handlers) process.on(entry.signal, entry.handle)
   try {
     cleanup = materializeConfigPayload(engine, childEnvironment) ?? cleanup
     await new Promise<void>(resolve => setImmediate(resolve))
+    let result: { status: number | null, error?: Error }
     if (output) {
-      return await runPipedChild(
+      result = await runPipedChild(
         command,
         args,
         childEnvironment,
@@ -89,27 +114,44 @@ export async function spawnSkilledProposerChild(
         output,
         spawnedChild => { child = spawnedChild }
       )
+    } else {
+      // stdin is not passed on: a process outside the terminal's foreground
+      // group that read the terminal would be stopped by it.
+      // Outside the CLI's group, the optimizer would outlive a SIGKILL of the
+      // CLI; it watches for that and stops itself.
+      const spawnedChild = spawn(command, args, {
+        stdio: ['ignore', 'inherit', 'inherit'],
+        env: { ...childEnvironment, ORIZU_STOP_WITH_PARENT: '1' },
+        detached: true,
+      })
+      child = spawnedChild
+      childGroup = spawnedChild.pid
+      const spawned = new Promise<void>((resolve, reject) => {
+        spawnedChild.once('spawn', resolve)
+        spawnedChild.once('error', reject)
+      })
+      const closed = new Promise<{ status: number | null, error?: Error }>(resolve => {
+        let error: Error | undefined
+        spawnedChild.once('error', cause => { error = cause })
+        spawnedChild.once('close', status => resolve(error ? { status, error } : { status }))
+      })
+      // A launch failure (e.g. ENOENT) is returned, not thrown, so callers
+      // name the engine as they did with spawnSync.
+      try { await spawned }
+      catch (error) { return { status: null, error: error as Error } }
+      try { await onSpawn?.() }
+      catch (error) { spawnedChild.kill('SIGTERM'); await closed; throw error }
+      result = await closed
+      // A runner that ignored the stop must not outlive the optimizer.
+      if (stopSignal) {
+        try { process.kill(-spawnedChild.pid!, 'SIGKILL') } catch { /* group already gone */ }
+      }
     }
-    const spawnedChild = spawn(command, args, {
-      stdio: 'inherit',
-      env: childEnvironment,
-    })
-    child = spawnedChild
-    const spawned = new Promise<void>((resolve, reject) => {
-      spawnedChild.once('spawn', resolve)
-      spawnedChild.once('error', reject)
-    })
-    const closed = new Promise<{ status: number | null, error?: Error }>(resolve => {
-      let error: Error | undefined
-      spawnedChild.once('error', cause => { error = cause })
-      spawnedChild.once('close', status => resolve(error ? { status, error } : { status }))
-    })
-    await spawned
-    try { await onSpawn?.() }
-    catch (error) { spawnedChild.kill('SIGTERM'); await closed; throw error }
-    return await closed
+    if (stopSignal) return await endBySignal(stopSignal)
+    return result
   } finally {
-    for (const entry of handlers) process.off(entry.signal, entry.handle)
+    if (giveUp) clearTimeout(giveUp)
+    removeHandlers()
     cleanup()
   }
 }

package/vendor/orizu-gepa/src/orizu_gepa_connector/runtime.py

@@ -4,6 +4,11 @@ from __future__ import annotations
 
 import json
 import os
+import signal
+import sys
+import threading
+import time
+from contextlib import contextmanager
 from pathlib import Path
 from typing import Any
 from uuid import uuid4
@@ -431,7 +436,120 @@ def _result_summary(*, run_id: str, best_id: str, best_score: float, seed_score:
     }
 
 
+_STOP_SIGNALS = (signal.SIGINT, signal.SIGTERM, signal.SIGHUP, signal.SIGQUIT)
+# One Ctrl-C reaches the optimizer twice: from the terminal and again from the
+# CLI that passes it on. A repeat this soon after the first is the same press.
+_REPEAT_WINDOW_SECONDS = 1.0
+_STATUS_WRITE_SECONDS = 10.0
+
+
+class RunInterrupted(BaseException):
+    """A stop signal (Ctrl-C, SIGTERM, a closed terminal) reached the run."""
+
+    def __init__(self, signal_name: str, signum: int) -> None:
+        super().__init__(signal_name)
+        self.signal_name = signal_name
+        self.signum = signum
+
+
+def _end_by_signal(signum: int) -> None:
+    """Exit the way an unhandled signal would, so callers see 128 + its number."""
+    sys.stdout.flush()
+    sys.stderr.flush()
+    signal.signal(signum, signal.SIG_DFL)
+    os.kill(os.getpid(), signum)
+
+
+@contextmanager
+def interrupt_signals():
+    """Turn the first stop signal into ``RunInterrupted``; a later one ends at once."""
+    first_at: list[float] = []
+
+    def handle(signum: int, _frame: Any) -> None:
+        if not first_at:
+            first_at.append(time.monotonic())
+            if os.getpgrp() == os.getpid():
+                # Runners may run in worker threads, which this interrupt does
+                # not reach; when we lead the process group, stop them too.
+                # Our own copy of the signal falls in the repeat window.
+                try:
+                    os.killpg(os.getpgrp(), signum)
+                except OSError:
+                    pass
+            raise RunInterrupted(signal.Signals(signum).name, signum)
+        if time.monotonic() - first_at[0] < _REPEAT_WINDOW_SECONDS:
+            return
+        _end_by_signal(signum)
+
+    previous = {signum: signal.getsignal(signum) for signum in _STOP_SIGNALS}
+    for signum in _STOP_SIGNALS:
+        signal.signal(signum, handle)
+    try:
+        yield
+    finally:
+        for signum, handler in previous.items():
+            signal.signal(signum, handler)
+
+
+def _stop_when_parent_exits() -> None:
+    """Stop like SIGTERM once the CLI that started us is gone (e.g. SIGKILLed).
+
+    The CLI puts the optimizer in its own process group, so a signal sent to
+    the CLI's group no longer reaches it; without this it would keep running.
+    """
+    parent = os.getppid()
+
+    def watch() -> None:
+        while os.getppid() == parent:
+            time.sleep(0.5)
+        os.kill(os.getpid(), signal.SIGTERM)
+
+    threading.Thread(target=watch, daemon=True).start()
+
+
+def _mark_interrupted_run(client: OrizuClient, run_id: str, signal_name: str) -> None:
+    """Mark a stopped local run cancelled once, waiting at most 10 s; never retry."""
+    outcome: list[BaseException | None] = []
+
+    def write() -> None:
+        try:
+            client.update_run(run_id, status="cancelled",
+                              metadata={"stop_reason": "interrupted", "signal": signal_name})
+            outcome.append(None)
+        except BaseException as error:  # reported below; the run still stops
+            outcome.append(error)
+
+    writer = threading.Thread(target=write, daemon=True)
+    writer.start()
+    writer.join(_STATUS_WRITE_SECONDS)
+    if not outcome or outcome[0] is not None:
+        print(
+            f"Run {run_id} may still show as running: run "
+            f"`orizu optimizations cancel {run_id}` to mark it stopped.",
+            file=sys.stderr, flush=True,
+        )
+
+
 def run_from_environment() -> dict[str, Any]:
+    """Run official GEPA; a stopped local run is marked cancelled (ORI-2402).
+
+    A hosted run's final status belongs to its coordinator, which records it
+    before stopping the sandbox, so a hosted run writes no status here.
+    """
+    started: dict[str, Any] = {}
+    with interrupt_signals():
+        if os.environ.get("ORIZU_STOP_WITH_PARENT") == "1":
+            _stop_when_parent_exits()
+        try:
+            return _run_from_environment(started)
+        except RunInterrupted as interrupt:
+            if started.get("run_id") and not started.get("hosted"):
+                _mark_interrupted_run(started["client"], started["run_id"], interrupt.signal_name)
+            _end_by_signal(interrupt.signum)
+            raise
+
+
+def _run_from_environment(started: dict[str, Any]) -> dict[str, Any]:
     """Run official GEPA over the verified legacy runner subprocess contract.
 
     ALI-1502 supplies these variables after verifying runner bytes. Scorer
@@ -542,6 +660,7 @@ def run_from_environment() -> dict[str, Any]:
         model_config_settings_version_id=instruction_set.get("model_config_settings_version_id") if isinstance(instruction_set, dict) else None,
         runner_version_id=prompt_context.runner_version_id,
     )
+    started.update(client=client, run_id=run_id, hosted=hosted_run_id is not None)
     print(json.dumps({"optimization_run_id": run_id}), flush=True)
     # The frozen sink treats ``None`` as no local artifact writer.  Keep that
     # legacy behavior rather than maintaining a connector-local no-op logger.
@@ -728,6 +847,9 @@ def run_from_environment() -> dict[str, Any]:
                     total_tokens_out=int(getattr(reflection_lm, "total_tokens_out", 0)),
                     total_tokens=int(getattr(reflection_lm, "total_tokens", 0)),
                 )
+        # From here the run has its own final status; a stop must not
+        # overwrite it with "cancelled".
+        started.pop("run_id", None)
         if budget_exhausted:
             if hosted_run_id is None:
                 client.update_run(
@@ -764,6 +886,7 @@ def run_from_environment() -> dict[str, Any]:
             temporary_result_path.replace(result_path)
         return summary
     except Exception as error:
+        started.pop("run_id", None)
         if sink.failed:
             sink.retry_failed_status()
         elif hosted_run_id is None: