orizu 0.5.17 → 0.5.18

package/dist/optimization-export-cli.js

@@ -0,0 +1,30 @@
+import { parseJsonResponse, sanitizeHumanInlineText, } from './json-response.js';
+export function printDiffCommentsSuppressionMarker(ctx, data) {
+    const reason = data.diffCommentsSuppressedReason;
+    if (typeof reason !== 'string' || reason.length === 0) {
+        return;
+    }
+    ctx.printLine(`Diff comments suppressed: ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, reason)}`);
+}
+export async function exportOptimizationRunCommand(ctx) {
+    const runId = ctx.getPositionalArg(2) || ctx.getArg('--run-id');
+    const outPathArg = ctx.getArg('--out');
+    if (!runId) {
+        throw new Error('Usage: orizu optimizations export <run-id> [--out <path>] [--json]');
+    }
+    const response = await ctx.authedFetch(`/api/cli/optimization-runs/${encodeURIComponent(runId)}/export`);
+    if (!response.ok) {
+        throw new Error(`Failed to export optimization run: ${await response.text()}`);
+    }
+    const data = await parseJsonResponse(response, 'Optimization export');
+    if (ctx.hasJsonFlag() && !outPathArg) {
+        ctx.printJson(data);
+        return;
+    }
+    const filename = outPathArg
+        ? ctx.expandHomePath(outPathArg)
+        : `${runId}.optimization.json`;
+    ctx.writeTextFileEnsuringDir(filename, `${JSON.stringify(data, null, 2)}\n`);
+    ctx.printLine(`Saved optimization export to ${ctx.sanitizeTerminalText(filename)}`);
+    printDiffCommentsSuppressionMarker(ctx, data);
+}

package/dist/optimizations-list-cli.js

@@ -12,6 +12,7 @@
  */
 import { authedFetch } from './http.js';
 import { extractErrorMessage } from './error-response.js';
+import { sanitizeTerminalText } from './json-response.js';
 // ALI-1175: best scores here derive from agent-reported score runs — nothing is
 // server-attested yet. Both the table footer AND the --json payload carry this
 // signal so no consumer, human or machine, mistakes the number for attested
@@ -25,9 +26,6 @@ function argValue(args, flag) {
     }
     return args[index + 1];
 }
-function sanitizeTerminalText(value) {
-    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-}
 // Shared-parser behavior (artifact-pull.ts pattern): a non-JSON or malformed
 // body becomes a bounded, sanitized error — never a raw JSON.parse throw.
 async function parseJsonPayload(response, context) {

package/dist/prompt-draft-push.js

@@ -1,4 +1,5 @@
 import { authedFetch } from './http.js';
+import { sanitizeTerminalText } from './json-response.js';
 import { appendRegistrationTagWarning } from './registration-tag-warning.js';
 /**
  * ADR-007 P4 (ALI-1074): the session-scoped, commit-first prompt push.
@@ -18,11 +19,6 @@ import { appendRegistrationTagWarning } from './registration-tag-warning.js';
  * Lives outside index.ts per the CLI line ratchet (ALI-976).
  */
 export const PROMPT_PRIMARY_GIT_FILENAME = 'prompt.md';
-// Mirrors index.ts `sanitizeTerminalText` (precedent: artifact-pull.ts keeps
-// its own copy to avoid importing the CLI entrypoint).
-function sanitizeTerminalText(value) {
-    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-}
 /**
  * Build the git file set for a prompt-version draft: the primary text at the
  * canonical prompt.md plus every sidecar at its own relative path. A sidecar
@@ -74,6 +70,12 @@ export async function pushPromptDraft(input) {
             parentVersionId: input.parentVersionId,
             createdBy: manifest.provenance || { kind: 'human-edit' },
             files,
+            ...(input.report
+                ? {
+                    reportMarkdown: input.report.markdown,
+                    reportSourceName: input.report.sourceName,
+                }
+                : {}),
         }),
     });
     if (!response.ok) {

package/dist/prompt-report-cli.js

@@ -0,0 +1,86 @@
+import { extractErrorMessage } from './error-response.js';
+import { authedFetch } from './http.js';
+import { parseJsonResponse, sanitizeTerminalText } from './json-response.js';
+import { readMarkdownReportInput } from './markdown-report-input.js';
+const IDENTICAL_PROMPT_VERSION_ERROR = 'Prompt version is identical to the current prompt version.';
+function getArg(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1 || index + 1 >= args.length)
+        return null;
+    return args[index + 1];
+}
+function rejectDashPrefixedOptionValue(name, value) {
+    if (value?.startsWith('-')) {
+        throw new Error(`Invalid value for ${name}: option values cannot start with a dash`);
+    }
+}
+export async function promptReportCommand(args, context) {
+    const prompt = getArg(args, '--prompt');
+    const projectArg = getArg(args, '--project');
+    const version = getArg(args, '--version');
+    const versionId = getArg(args, '--version-id');
+    for (const [name, value] of [
+        ['--prompt', prompt],
+        ['--project', projectArg],
+        ['--version-id', versionId],
+    ]) {
+        rejectDashPrefixedOptionValue(name, value);
+    }
+    if (!prompt) {
+        throw new Error('Usage: orizu prompts report set --prompt <id-or-name> --project <team/project> ' +
+            '(--version <n> | --version-id <id>) ' +
+            '(--report <markdown|@file> | --report-file <path>) [--json]');
+    }
+    if (Boolean(version) === Boolean(versionId)) {
+        throw new Error('Exactly one of --version or --version-id is required');
+    }
+    if (version && (!/^[1-9]\d*$/.test(version) || !Number.isSafeInteger(Number(version)))) {
+        throw new Error('--version must be a positive integer');
+    }
+    const report = readMarkdownReportInput(args, 'Prompt');
+    if (!report) {
+        throw new Error('Usage: orizu prompts report set --prompt <id-or-name> --project <team/project> ' +
+            '(--version <n> | --version-id <id>) ' +
+            '(--report <markdown|@file> | --report-file <path>) [--json]');
+    }
+    const project = projectArg || await context.resolveProjectSlug(null);
+    const query = new URLSearchParams({ project });
+    if (version)
+        query.set('version', version);
+    else
+        query.set('versionId', versionId);
+    const fetcher = context.fetcher ?? authedFetch;
+    const response = await fetcher(`/api/cli/prompts/${encodeURIComponent(prompt)}/report?${query.toString()}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            reportMarkdown: report.markdown,
+            reportSourceName: report.sourceName,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to update prompt report: ${await extractErrorMessage(response)}`);
+    }
+    const data = await parseJsonResponse(response, 'Prompt report update');
+    if (context.json) {
+        context.printJson(data);
+        return;
+    }
+    const versionLabel = data.version
+        ? data.version.versionNumber === null
+            ? data.version.id
+            : `v${data.version.versionNumber}`
+        : data.promptVersionId || versionId || `v${version}`;
+    const promptName = data.prompt?.name || prompt;
+    const status = data.version?.status || 'updated';
+    context.printLine(`Uploaded prompt report for ${sanitizeTerminalText(promptName)} ` +
+        `(${sanitizeTerminalText(versionLabel)}) [${sanitizeTerminalText(status)}]`);
+}
+export async function promptPushErrorMessage(response, kind, hasReport) {
+    const message = await extractErrorMessage(response);
+    if (hasReport && response.status === 409 && message === IDENTICAL_PROMPT_VERSION_ERROR) {
+        return (`${IDENTICAL_PROMPT_VERSION_ERROR} ` +
+            'Attach the report to the existing version with `orizu prompts report set`.');
+    }
+    return `Failed to push ${kind}: ${message}`;
+}

package/dist/scorer-draft-push.js

@@ -1,27 +1,6 @@
 import { authedFetch } from './http.js';
+import { sanitizeTerminalText } from './json-response.js';
 import { appendRegistrationTagWarning } from './registration-tag-warning.js';
-/**
- * ADR-007 P5 (ALI-1074): the session-scoped, commit-first scorer push.
- *
- * `orizu scorers register --session <id>` creates the version through
- * POST /api/cli/scorers/drafts: the server commits the scorer's canonical
- * `manifest.json` to the session's `orizu/session-*` branch (one Git Data API
- * commit) and then writes a DRAFT row pinning
- * repo_path/content_sha/commit_sha. The draft seals — and gets its version
- * number — when the session branch merges via `orizu session finish` +
- * promotion-manifest apply.
- *
- * The git filename is ALWAYS `manifest.json`: the server read side
- * (lib/artifact-git-read.ts SCORER_MANIFEST_FILENAMES) prefers that name.
- *
- * Lives outside index.ts per the CLI line ratchet (ALI-976); mirrors
- * prompt-draft-push.ts.
- */
-// Mirrors index.ts `sanitizeTerminalText` (precedent: artifact-pull.ts keeps
-// its own copy to avoid importing the CLI entrypoint).
-function sanitizeTerminalText(value) {
-    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-}
 /** The full `orizu scorers register` command (moved out of index.ts for the
  * CLI line ratchet): --session takes the ADR-007 P5 commit-first draft path,
  * sessionless stays on the legacy create endpoint. */

package/dist/scores-accept-cli.js

@@ -11,9 +11,7 @@
  * own argument parsing and printing via injected io.
  */
 import { authedFetch } from './http.js';
-function sanitizeTerminalText(value) {
-    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-}
+import { sanitizeTerminalText } from './json-response.js';
 function argValue(args, flag) {
     const index = args.indexOf(flag);
     if (index === -1 || index + 1 >= args.length || args[index + 1].startsWith('--')) {

package/dist/zip-draft-push.js

@@ -1,31 +1,8 @@
 import { basename } from 'path';
 import { zipDirectoryToBase64 } from './artifact-archive.js';
 import { authedFetch } from './http.js';
+import { sanitizeTerminalText } from './json-response.js';
 import { appendRegistrationTagWarning } from './registration-tag-warning.js';
-/**
- * ADR-007 P5 (ALI-1074): the session-scoped, commit-first runner/optimizer
- * push.
- *
- * `orizu runners|optimizers push --session <id>` sends the SAME deterministic
- * zip as the legacy push to POST /api/cli/{runners|optimizers}/drafts: the
- * server unpacks the zip's file set and commits it to the session's
- * `orizu/session-*` branch (one Git Data API commit; binary entries travel
- * base64), keeps uploading the zip to storage (dual-write until ALI-1046),
- * and writes a DRAFT row pinning repo_path/content_sha/commit_sha. The draft
- * seals — and gets its version number — when the session branch merges via
- * `orizu session finish` + promotion-manifest apply.
- *
- * Labels cannot ride a draft push (`--label` with `--session` is an error at
- * the command layer): labels address sealed versions only.
- *
- * Lives outside index.ts per the CLI line ratchet (ALI-976); mirrors
- * prompt-draft-push.ts.
- */
-// Mirrors index.ts `sanitizeTerminalText` (precedent: artifact-pull.ts keeps
-// its own copy to avoid importing the CLI entrypoint).
-function sanitizeTerminalText(value) {
-    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
-}
 /** The full `orizu runners|optimizers push` command (moved out of index.ts
  * for the CLI line ratchet): --session takes the ADR-007 P5 commit-first
  * draft path, sessionless stays on the legacy zip-only endpoint. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "private": false,
   "type": "module",
   "bin": {

package/src/archive-artifacts-cli.ts

@@ -8,6 +8,7 @@
 
 import { authedFetch } from './http.js'
 import { extractErrorMessage } from './error-response.js'
+import { sanitizeTerminalText } from './json-response.js'
 
 type ArchiveStatus = 'active' | 'archived' | 'all'
 type ArchiveAction = 'archive' | 'restore'
@@ -109,13 +110,6 @@ function argValue(args: readonly string[], flag: string): string | null {
   return args[index + 1]
 }
 
-function sanitizeTerminalText(value: unknown): string {
-  return String(value).replace(
-    /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g,
-    ''
-  )
-}
-
 function columnWidths(headers: string[], rows: string[][]): number[] {
   return headers.map((header, index) =>
     Math.max(header.length, ...rows.map(row => row[index]?.length || 0))

package/src/artifact-pull.ts

@@ -18,6 +18,7 @@ import { tmpdir } from 'os'
 import { dirname, join } from 'path'
 
 import { authedFetch } from './http.js'
+import { sanitizeTerminalText } from './json-response.js'
 
 export type PullableArtifactKind = 'runner' | 'optimizer'
 
@@ -31,10 +32,6 @@ export interface PullArtifactIo {
 // Shared with the runners exec download path in index.ts.
 export const ARTIFACT_MAX_BYTES = 25 * 1024 * 1024
 
-function sanitizeTerminalText(value: unknown): string {
-  return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '')
-}
-
 function expandHomePath(path: string): string {
   if (path.startsWith('~/')) {
     const home = process.env.HOME || ''

package/src/diff-comments-cli.ts

@@ -1,3 +1,9 @@
+import {
+  extractErrorMessage,
+  isJsonErrorResponsePayload,
+} from './error-response.js'
+import { sanitizeHumanInlineText } from './json-response.js'
+
 interface DiffCommentAuthor {
   name?: string
   person?: { name?: string }
@@ -5,6 +11,7 @@ interface DiffCommentAuthor {
 
 type DiffCommentContextUnavailableReason =
   | 'diff_degraded_size_limit'
+  | 'diff_degraded_cell_limit'
   | 'bodies_unavailable_event_cap'
   | 'body_unresolvable'
   | 'anchor_out_of_range'
@@ -25,8 +32,8 @@ interface DiffCommentPayloadComment {
   anchor: { side: 'old' | 'new'; line: number }
   context: {
     lineText: string
-    lineOp: 'add' | 'del' | 'context'
-    hunk: { lines: DiffCommentContextLine[] }
+    lineOp: 'add' | 'del' | 'context' | null
+    hunk: { lines: DiffCommentContextLine[] } | null
   } | null
   contextUnavailableReason?: DiffCommentContextUnavailableReason
 }
@@ -71,6 +78,7 @@ export interface DiffCommentsCliContext {
 }
 
 const DETAIL_LEVELS = ['hunk', 'diff', 'full'] as const
+const CONTEXT_UNAVAILABLE_WITHOUT_REASON = '    Context unavailable (no reason supplied)'
 
 function isCandidatePair(
   pair: DiffCommentPayloadPair
@@ -92,18 +100,47 @@ function sanitizeHumanText(
   return ctx.sanitizeTerminalText(value).replaceAll('\r', '')
 }
 
-function sanitizeHumanInlineText(
-  ctx: DiffCommentsCliContext,
-  value: unknown
-): string {
-  return sanitizeHumanText(ctx, value).replaceAll('\n', '\\n')
+// Quote untrusted multiline blocks so none of their rows can impersonate a
+// genuine hunk row, whose marker begins immediately after the four-space indent.
+function printHumanTextBlock(ctx: DiffCommentsCliContext, value: unknown): void {
+  for (const line of sanitizeHumanText(ctx, value).split('\n')) {
+    ctx.printLine(`    │ ${line}`)
+  }
+}
+
+function hasExplicitlyEmptyJsonError(response: Response, rawBody: string): boolean {
+  try {
+    const payload: unknown = JSON.parse(rawBody)
+    return isJsonErrorResponsePayload(response, payload) && payload.error.length === 0
+  } catch {
+    return false
+  }
+}
+
+async function extractDiffCommentsErrorMessage(response: Response): Promise<string> {
+  const statusFallback = `HTTP ${response.status}`
+
+  try {
+    const rawBody = await response.text()
+    if (hasExplicitlyEmptyJsonError(response, rawBody)) {
+      return statusFallback
+    }
+
+    const copiedResponse = new Response(rawBody, { headers: response.headers })
+    const extractedMessage = await extractErrorMessage(copiedResponse)
+    return extractedMessage.trim() ? extractedMessage : statusFallback
+  } catch {
+    return statusFallback
+  }
 }
 
 function humanLineNumber(
   ctx: DiffCommentsCliContext,
   line: number | null
 ): string {
-  return line === null ? '-' : sanitizeHumanText(ctx, String(line + 1))
+  return line === null
+    ? '-'
+    : sanitizeHumanInlineText(ctx.sanitizeTerminalText, String(line + 1))
 }
 
 function buildParams(ctx: DiffCommentsCliContext): URLSearchParams {
@@ -123,9 +160,15 @@ function buildParams(ctx: DiffCommentsCliContext): URLSearchParams {
     ctx.rejectDashPrefixedOptionValue(name, value)
   }
 
+  if (runId === '' || promptId === '') {
+    throw new Error(usage())
+  }
   if (Number(Boolean(runId)) + Number(Boolean(promptId)) !== 1) {
     throw new Error(usage())
   }
+  if (from === '' || to === '') {
+    throw new Error('--from and --to must not be empty')
+  }
   if (Boolean(from) !== Boolean(to)) {
     throw new Error('--from and --to must be provided together')
   }
@@ -164,16 +207,17 @@ function printDiffComments(ctx: DiffCommentsCliContext, payload: DiffCommentsPay
     ctx.printLine('')
     ctx.printLine(
       `${hasCandidateIds ? 'Candidates' : 'Versions'} ` +
-      `${sanitizeHumanInlineText(ctx, from)} → ${sanitizeHumanInlineText(ctx, to)}`
+      `${sanitizeHumanInlineText(ctx.sanitizeTerminalText, from)} → ` +
+      `${sanitizeHumanInlineText(ctx.sanitizeTerminalText, to)}`
     )
     if (pair.degraded) {
-      ctx.printLine(`  Context unavailable: ${sanitizeHumanText(ctx, pair.degraded.reason)}`)
+      ctx.printLine(
+        `  Context unavailable: ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, pair.degraded.reason)}`
+      )
     }
     if (pair.diff !== null) {
       ctx.printLine('  Diff:')
-      for (const line of sanitizeHumanText(ctx, pair.diff).split('\n')) {
-        ctx.printLine(`    ${line}`)
-      }
+      printHumanTextBlock(ctx, pair.diff)
     }
     if (pair.bodies !== null) {
       for (const [label, body] of [
@@ -181,29 +225,40 @@ function printDiffComments(ctx: DiffCommentsCliContext, payload: DiffCommentsPay
         ['To body', pair.bodies.to],
       ] as const) {
         ctx.printLine(`  ${label}:`)
-        for (const line of sanitizeHumanText(ctx, body).split('\n')) {
-          ctx.printLine(`    ${line}`)
-        }
+        printHumanTextBlock(ctx, body)
       }
     }
 
     for (const comment of pair.comments) {
       const authorName = comment.author?.person?.name || comment.author?.name || 'Unknown'
       ctx.printLine(
-        `  ${sanitizeHumanInlineText(ctx, comment.id)} · ` +
-        `${sanitizeHumanInlineText(ctx, authorName)} · ` +
-        `${sanitizeHumanInlineText(ctx, comment.createdAt)} · ` +
-        `${sanitizeHumanInlineText(ctx, comment.anchor.side)} line ` +
-        `${sanitizeHumanInlineText(ctx, String(comment.anchor.line + 1))}`
+        `  ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, comment.id)} · ` +
+        `${sanitizeHumanInlineText(ctx.sanitizeTerminalText, authorName)} · ` +
+        `${sanitizeHumanInlineText(ctx.sanitizeTerminalText, comment.createdAt)} · ` +
+        `${sanitizeHumanInlineText(ctx.sanitizeTerminalText, comment.anchor.side)} line ` +
+        `${sanitizeHumanInlineText(ctx.sanitizeTerminalText, String(comment.anchor.line + 1))}`
       )
-      for (const line of sanitizeHumanText(ctx, comment.body).split('\n')) {
-        ctx.printLine(`    ${line}`)
-      }
+      printHumanTextBlock(ctx, comment.body)
 
+      if (comment.contextUnavailableReason) {
+        ctx.printLine(
+          `    Context unavailable: ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, comment.contextUnavailableReason)}`
+        )
+        if (comment.context) {
+          ctx.printLine(
+            `    Anchored line: ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, comment.context.lineText)}`
+          )
+        }
+        continue
+      }
       if (!comment.context) {
+        ctx.printLine(CONTEXT_UNAVAILABLE_WITHOUT_REASON)
+        continue
+      }
+      if (!comment.context.hunk) {
+        ctx.printLine(CONTEXT_UNAVAILABLE_WITHOUT_REASON)
         ctx.printLine(
-          `    Context unavailable: ` +
-          `${sanitizeHumanText(ctx, comment.contextUnavailableReason ?? 'body_unresolvable')}`
+          `    Anchored line: ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, comment.context.lineText)}`
         )
         continue
       }
@@ -217,7 +272,7 @@ function printDiffComments(ctx: DiffCommentsCliContext, payload: DiffCommentsPay
         ctx.printLine(
           `    ${marker} old:${humanLineNumber(ctx, line.oldLine)} ` +
           `new:${humanLineNumber(ctx, line.newLine)} | ` +
-          `${prefix}${sanitizeHumanText(ctx, line.text)}`
+          `${prefix}${sanitizeHumanInlineText(ctx.sanitizeTerminalText, line.text)}`
         )
       }
     }
@@ -228,16 +283,10 @@ export async function diffCommentsCommand(ctx: DiffCommentsCliContext) {
   const params = buildParams(ctx)
   const response = await ctx.authedFetch(`/api/cli/diff-comments?${params.toString()}`)
   if (!response.ok) {
-    let message = `HTTP ${response.status}`
-    try {
-      const payload = await response.clone().json() as { error?: unknown }
-      if (typeof payload.error === 'string' && payload.error.trim()) {
-        message = sanitizeHumanInlineText(ctx, payload.error)
-      }
-    } catch {
-      // Keep the status-only error for non-JSON responses.
-    }
-    throw new Error(`Failed to fetch diff comments: ${message}`)
+    const message = await extractDiffCommentsErrorMessage(response)
+    throw new Error(
+      `Failed to fetch diff comments: ${sanitizeHumanInlineText(ctx.sanitizeTerminalText, message)}`
+    )
   }
 
   const payload = await ctx.parseJsonResponse<DiffCommentsPayload>(response, 'Diff comments')

package/src/error-response.ts

@@ -1,37 +1,39 @@
+import { sanitizeTerminalText } from './json-response.js'
+
 interface ErrorResponsePayload {
   error?: string
 }
 
 const ERROR_BODY_PREVIEW_LIMIT = 180
 
+export function isJsonErrorResponsePayload(
+  response: Response,
+  payload: unknown
+): payload is ErrorResponsePayload & { error: string } {
+  const contentType = response.headers.get('content-type') || ''
+  return (
+    contentType.includes('application/json') &&
+    payload !== null &&
+    typeof payload === 'object' &&
+    !Array.isArray(payload) &&
+    typeof (payload as ErrorResponsePayload).error === 'string'
+  )
+}
+
 function boundedTerminalPreview(value: unknown): string {
-  return String(value)
-    .replace(
-      /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g,
-      ''
-    )
-    .slice(0, ERROR_BODY_PREVIEW_LIMIT)
+  return sanitizeTerminalText(value).slice(0, ERROR_BODY_PREVIEW_LIMIT)
 }
 
 export async function extractErrorMessage(response: Response): Promise<string> {
-  const contentType = response.headers.get('content-type') || ''
   const rawBody = await response.text()
 
-  if (contentType.includes('application/json')) {
-    try {
-      const payload = JSON.parse(rawBody) as ErrorResponsePayload | null
-      if (
-        payload &&
-        typeof payload === 'object' &&
-        !Array.isArray(payload) &&
-        typeof payload.error === 'string' &&
-        payload.error.length > 0
-      ) {
-        return boundedTerminalPreview(payload.error)
-      }
-    } catch {
-      // Fall through to raw body
+  try {
+    const payload: unknown = JSON.parse(rawBody)
+    if (isJsonErrorResponsePayload(response, payload) && payload.error.length > 0) {
+      return boundedTerminalPreview(payload.error)
     }
+  } catch {
+    // Fall through to raw body
   }
 
   return boundedTerminalPreview(rawBody)

package/src/github-setup.ts

@@ -19,20 +19,11 @@ import { existsSync, mkdirSync } from 'fs'
 import { join } from 'path'
 
 import { authedFetch } from './http.js'
+import { sanitizeTerminalText } from './json-response.js'
 import { assertWorkspaceDirUsable, workspaceExists } from './workspace.js'
 
 export type SetupFetcher = (path: string, init?: RequestInit) => Promise<Response>
 
-/**
- * Strip terminal control characters from server-supplied strings before they
- * are printed (mirrors index.ts `sanitizeTerminalText`), so a hostile or
- * mangled provisioning `warnings[]`/`defaultBranch` value can't inject escape
- * sequences into the user's terminal.
- */
-function sanitizeServerText(value: unknown): string {
-  return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '')
-}
-
 export interface GithubLinkIo {
   print: (line: string) => void
   fetcher?: SetupFetcher
@@ -349,12 +340,12 @@ export async function runHostedAttach(
     if (data.rulesetApplied === true) {
       io.print(
         `   Default-branch protection applied (ruleset "orizu-default-branch-protection"${
-          data.defaultBranch ? ` on ${sanitizeServerText(data.defaultBranch)}` : ''
+          data.defaultBranch ? ` on ${sanitizeTerminalText(data.defaultBranch)}` : ''
         }).`
       )
     }
     for (const warning of data.warnings ?? []) {
-      io.print(`   ⚠ ${sanitizeServerText(warning)}`)
+      io.print(`   ⚠ ${sanitizeTerminalText(warning)}`)
     }
   }
 

package/src/help.ts

@@ -362,10 +362,30 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
   },
   {
     path: ['prompts', 'push'],
-    usage: 'orizu prompts push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--session <session-id>] [--json]',
+    usage: 'orizu prompts push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--session <session-id>] [--report-file <path>] [--json]',
     summary: 'Push a local prompt artifact directory as a new version (with --session: a commit-first git draft).',
     group: 'Prompts and judges',
   },
+  {
+    path: ['prompts', 'report', 'set'],
+    usage: 'orizu prompts report set --prompt <id-or-name> --project <team/project> (--version <n> | --version-id <id>) (--report <markdown|@file> | --report-file <path>) [--json]',
+    summary: 'Upload or replace the Markdown report for one explicit prompt version.',
+    group: 'Prompts and judges',
+    aliases: [['prompts', 'report', 'upload']],
+    options: [
+      { name: '--prompt <id-or-name>', help: 'Prompt ID or name.', required: true },
+      { name: '--project <team/project>', help: 'Project slug containing the prompt.', required: true },
+      { name: '--version <n>', help: 'Positive prompt version number.' },
+      { name: '--version-id <id>', help: 'Explicit prompt version ID.' },
+      { name: '--report <markdown|@file>', help: 'Inline Markdown or an @file reference.' },
+      { name: '--report-file <path>', help: 'Markdown file to upload.' },
+      { name: '--json', help: 'Emit the updated prompt report payload.' },
+    ],
+    examples: [
+      'orizu prompts report set --prompt Generator --project core/evals --version 3 --report-file ./report.md',
+      'orizu prompts report upload --prompt Generator --project core/evals --version-id <id> --report @./report.md',
+    ],
+  },
   {
     path: ['prompts', 'labels', 'set'],
     usage: 'orizu prompts labels set <prompt-name> <label> --version <version-id> [--project <team/project>] [--json]',
@@ -398,7 +418,7 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
   },
   {
     path: ['judges', 'push'],
-    usage: 'orizu judges push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--session <session-id>] [--json]',
+    usage: 'orizu judges push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--session <session-id>] [--report-file <path>] [--json]',
     summary: 'Push a local judge artifact directory as a new version (with --session: a commit-first git draft).',
     group: 'Prompts and judges',
   },