@pome-sh/cli 0.4.0 → 0.7.0

package/dist/src/hosted/evalResultView.js

@@ -36,7 +36,7 @@ export function scoreStatus(score, passThreshold) {
         return "unevaluated";
     return score.satisfaction >= passThreshold ? "pass" : "fail";
 }
-export function scenarioPassed(score, passThreshold) {
+export function taskPassed(score, passThreshold) {
     return scoreStatus(score, passThreshold) === "pass";
 }
 // FDRS-591/611 per-criterion marker: ✓ passed, ✗ failed, - skipped, ! errored.

package/dist/src/hosted/uploadAndFinalize.d.ts

@@ -81,5 +81,5 @@ export declare function uploadRunBlobs(client: UploadClient, sessionId: string,
 export declare function scoreFromFinalizeResponse(finalized: FinalizeResponse): Score;
 /** Redact a JSONL payload line-by-line before upload. Lines that fail to
  *  parse as JSON are redacted as raw strings. Moved verbatim from
- *  runScenarioHosted.ts (FDRS-656). */
+ *  runTaskHosted.ts (FDRS-656). */
 export declare function redactJsonl(body: string): string;

package/dist/src/hosted/uploadAndFinalize.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 // Shared presigned-upload + finalize-score orchestration for cloud sessions
-// (ADR-013). Extracted verbatim from runScenarioHosted.ts (FDRS-656) so
+// (ADR-013). Extracted verbatim from runTaskHosted.ts (FDRS-656) so
 // `pome eval <run-dir>` reuses the exact same best-effort PUT semantics
 // without duplicating them. Behavior-preserving for the hosted run path:
 // warning text, the 30s PUT timeout, and the null-key fallbacks all match
@@ -218,7 +218,7 @@ export function scoreFromFinalizeResponse(finalized) {
 }
 /** Redact a JSONL payload line-by-line before upload. Lines that fail to
  *  parse as JSON are redacted as raw strings. Moved verbatim from
- *  runScenarioHosted.ts (FDRS-656). */
+ *  runTaskHosted.ts (FDRS-656). */
 export function redactJsonl(body) {
     const lines = body.split("\n");
     const redacted = lines

package/dist/src/recorder/artifacts.d.ts

@@ -1,5 +1,5 @@
 import { toTwinHttpEventRow } from "@pome-sh/sdk/server";
-import type { Scenario } from "../scenario/scenarioSchema.js";
+import type { Task } from "../task/taskSchema.js";
 import type { RecorderEvent } from "@pome-sh/shared-types";
 export declare const toTwinHttpEvent: typeof toTwinHttpEventRow;
 export type RunArtifacts = {
@@ -9,7 +9,7 @@ export type RunArtifacts = {
 export type RunArtifactCoreInput = {
     artifactsDir: string;
     runId: string;
-    scenario: Scenario;
+    scenario: Task;
     startedAt: string;
     completedAt: string;
     stdout: string;

package/dist/src/recorder/inspect.d.ts

@@ -28,9 +28,9 @@ export type TraceHealthLayer = {
 };
 export type TraceHealthInput = {
     events: Event[];
-    scenarioUsesTwin?: boolean;
-    scenarioExpectsLlm?: boolean;
-    scenarioExpectsCas?: boolean;
+    taskUsesTwin?: boolean;
+    taskExpectsLlm?: boolean;
+    taskExpectsCas?: boolean;
 };
 export declare function computeTraceHealth(input: TraceHealthInput): TraceHealthLayer[];
 export declare function renderTraceHealth(layers: TraceHealthLayer[]): string[];

package/dist/src/recorder/inspect.js

@@ -32,7 +32,7 @@ export function computeTraceHealth(input) {
     // never warns). When the scenario manifest declares LLM usage we expect at
     // least one row even with zero observed; absence then surfaces as a warning
     // ("capture-server may not have started").
-    const proxyExpected = input.scenarioExpectsLlm
+    const proxyExpected = input.taskExpectsLlm
         ? 1
         : counts.LlmCallEvent > 0
             ? 1
@@ -48,7 +48,7 @@ export function computeTraceHealth(input) {
     };
     // twin layer — TwinHttpEvent rows. A scenario always declares ≥1 twin in
     // `config.twins`, so when we know the scenario we expect ≥1 row.
-    const twinExpectedBool = input.scenarioUsesTwin ?? counts.TwinHttpEvent > 0;
+    const twinExpectedBool = input.taskUsesTwin ?? counts.TwinHttpEvent > 0;
     const twinExpected = twinExpectedBool ? 1 : 0;
     const twin = {
         name: "twin",
@@ -68,7 +68,7 @@ export function computeTraceHealth(input) {
         counts.SubagentSpawnEvent +
         counts.HookEvent +
         counts.LlmTurnEvent;
-    const casExpected = input.scenarioExpectsCas ? 1 : casCount > 0 ? 1 : 0;
+    const casExpected = input.taskExpectsCas ? 1 : casCount > 0 ? 1 : 0;
     const cas = {
         name: "CAS adapter",
         count: casCount,

package/dist/src/runner/captureServerChild.js

@@ -98,7 +98,7 @@ function defaultBinArgs(eventsOut, allowHosts, egressOut) {
     }
     return [script, "capture-server", "--port", "0", "--events-out", eventsOut, ...egressArgs(allowHosts, egressOut)];
 }
-// Shared by defaultBinArgs and runScenario's test-override path so the two
+// Shared by defaultBinArgs and runTask's test-override path so the two
 // spawn shapes can't drift.
 export function egressArgs(allowHosts, egressOut) {
     const args = [];

package/dist/src/runner/{runScenario.d.ts → runTask.d.ts}

@@ -3,8 +3,8 @@ export type CaptureServerCommand = {
     execPath: string;
     prefixArgs: string[];
 };
-export type RunScenarioOptions = {
-    scenarioPath: string;
+export type RunTaskOptions = {
+    taskPath: string;
     agentCommand: string;
     artifactsDir?: string;
     captureServerCommand?: CaptureServerCommand;
@@ -13,7 +13,7 @@ export type RunScenarioOptions = {
     extraAgentEnv?: Record<string, string>;
     egressExtraHosts?: readonly string[];
 };
-export declare function runScenario(options: RunScenarioOptions): Promise<{
+export declare function runTask(options: RunTaskOptions): Promise<{
     scenario: {
         slug: string;
         title: string;

package/dist/src/runner/{runScenario.js → runTask.js}

@@ -4,7 +4,7 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve as resolvePath, sep as pathSep } from "node:path";
 import { sign } from "hono/jwt";
-import { parseScenarioFile, seedStateForTwin } from "../scenario/parseScenario.js";
+import { parseTaskFile, seedStateForTwin } from "../task/parseTask.js";
 import { bootTwin } from "../twin/twinHarness.js";
 import { createRecorder } from "../recorder/recorder.js";
 import { redactSecrets } from "../recorder/redaction.js";
@@ -13,7 +13,7 @@ import { runAgentCommand } from "./agentRunner.js";
 import { egressArgs, spawnCaptureServerChild } from "./captureServerChild.js";
 import { buildEgressAllowlist, readBlockedEgress } from "../capture-server/egress.js";
 import { mergeAdapterSignalsIntoEvents } from "./mergeAdapterSignals.js";
-import { writeRunNoScore } from "./runScenarioCore.js";
+import { writeRunNoScore } from "./runTaskCore.js";
 // Promisify a Hono/node server `close()` so teardown can await in-flight
 // handlers draining before the twin's DB handle is released.
 function closeServer(server) {
@@ -21,8 +21,8 @@ function closeServer(server) {
         server.close((err) => (err ? reject(err) : resolvePromise()));
     });
 }
-export async function runScenario(options) {
-    const scenario = await parseScenarioFile(options.scenarioPath);
+export async function runTask(options) {
+    const scenario = await parseTaskFile(options.taskPath);
     const runId = `run_${randomUUID()}`;
     const artifactsDir = options.artifactsDir ?? "runs";
     const startedAt = new Date().toISOString();

package/dist/src/runner/{runScenarioCore.d.ts → runTaskCore.d.ts}

@@ -1,10 +1,10 @@
-import type { Scenario } from "../scenario/scenarioSchema.js";
+import type { Task } from "../task/taskSchema.js";
 import { writeRunArtifactsCore } from "../recorder/artifacts.js";
 import type { RecorderEvent } from "@pome-sh/shared-types";
 export interface WriteRunInput {
     artifactsDir: string;
     runId: string;
-    scenario: Scenario;
+    scenario: Task;
     startedAt: string;
     completedAt: string;
     agentStdout: string;

package/dist/src/runner/{runScenarioHosted.d.ts → runTaskHosted.d.ts}

@@ -1,10 +1,10 @@
 import { type HostedClient } from "../hosted/client.js";
 import type { CreateSessionResponse } from "../types/shared.js";
-import type { Scenario } from "../scenario/scenarioSchema.js";
+import type { Task } from "../task/taskSchema.js";
 import type { Score } from "../hosted/evalResultView.js";
 import type { RunArtifacts } from "../recorder/artifacts.js";
-export interface RunScenarioHostedOptions {
-    scenarioPath: string;
+export interface RunTaskHostedOptions {
+    taskPath: string;
     agentCommand: string;
     artifactsDir?: string;
     hosted: {
@@ -37,8 +37,8 @@ export interface RunScenarioHostedOptions {
      *  local artifacts. Absent on single runs (verdict.json gets null). */
     groupId?: string;
 }
-export interface RunScenarioHostedResult {
-    scenario: Scenario;
+export interface RunTaskHostedResult {
+    scenario: Task;
     runId: string;
     cloudRunId: string;
     cloudDashboardUrl: string;
@@ -87,4 +87,4 @@ export declare function buildAgentEnv(params: {
     slug: string;
     signalsPath: string;
 }): Record<string, string>;
-export declare function runScenarioHosted(options: RunScenarioHostedOptions): Promise<RunScenarioHostedResult>;
+export declare function runTaskHosted(options: RunTaskHostedOptions): Promise<RunTaskHostedResult>;

package/dist/src/runner/{runScenarioHosted.js → runTaskHosted.js}

@@ -7,7 +7,7 @@ import { runAgentCommand } from "./agentRunner.js";
 import { toTwinHttpEvent, writeRunArtifactsCore } from "../recorder/artifacts.js";
 import { VERDICT_ARTIFACT_VERSION, writeVerdictArtifact, } from "../hosted/evalResultCache.js";
 import { redactEvent, redactSecrets } from "../recorder/redaction.js";
-import { parseScenarioFile } from "../scenario/parseScenario.js";
+import { parseTaskFile } from "../task/parseTask.js";
 import { createHostedClient, perTwinReturnedByCloud, } from "../hosted/client.js";
 import { ensureMcpSuffix } from "../cli/session.js";
 import { redactJsonl, scoreFromFinalizeResponse, uploadRunBlobs, } from "../hosted/uploadAndFinalize.js";
@@ -105,10 +105,10 @@ export function buildAgentEnv(params) {
     }
     return env;
 }
-export async function runScenarioHosted(options) {
-    const scenario = await parseScenarioFile(options.scenarioPath);
-    const scenarioSource = await readFile(options.scenarioPath, "utf8");
-    const scenarioHash = createHash("sha256").update(scenarioSource).digest("hex");
+export async function runTaskHosted(options) {
+    const scenario = await parseTaskFile(options.taskPath);
+    const taskSource = await readFile(options.taskPath, "utf8");
+    const taskHash = createHash("sha256").update(taskSource).digest("hex");
     const artifactsDir = options.artifactsDir ?? "runs";
     const startedAt = new Date().toISOString();
     const client = options.client ??
@@ -119,7 +119,7 @@ export async function runScenarioHosted(options) {
     // `agent_version` stamps the session; `--agent-version` overrides it. All are
     // optional during rollout — a manifest-less repo runs unattributed.
     const identity = await resolveRunAgentIdentity({
-        startDir: dirname(options.scenarioPath),
+        startDir: dirname(options.taskPath),
         apiBaseUrl: options.hosted.baseUrl,
         agentVersionOverride: options.agentVersion,
     });
@@ -138,11 +138,11 @@ export async function runScenarioHosted(options) {
     // groups mint all k sessions upfront (one shared group_id) and pass each
     // one in as `premintedSession`; the single-run path mints its own here.
     // Forward the resolved seed (sidecar -> inline JSON -> twin defaults, in that
-    // precedence; see parseScenario.resolveSeedState) so the cloud doesn't need
+    // precedence; see parseTask.resolveSeedState) so the cloud doesn't need
     // to re-extract it from the markdown. Prose `## Seed State` sections have no
     // fenced JSON to extract — cloud would 422 with "no fenced code block".
     const session = await createSessionOrExplain(client, options.premintedSession, {
-        scenarioSource,
+        taskSource,
         twins: scenario.config.twins,
         agentId,
         agentVersion,
@@ -450,9 +450,9 @@ export async function runScenarioHosted(options) {
             agentModel: options.agentModel ?? "unknown",
             agentSdk,
             criteria: criteriaDefs,
-            scenarioName: scenario.slug,
-            scenarioHash,
-            scenarioPrompt: scenario.prompt,
+            taskName: scenario.slug,
+            taskHash,
+            taskPrompt: scenario.prompt,
             expectedBehavior: scenario.expectedBehavior,
             // Explicit overrides when uploads succeeded; otherwise let cloud fall
             // back. For events.jsonl the conventional `team-<>/session-<>/events.jsonl`
@@ -504,7 +504,7 @@ export async function runScenarioHosted(options) {
                 version: VERDICT_ARTIFACT_VERSION,
                 source: "cloud-finalize",
                 task_name: scenario.slug,
-                scenario_path: options.scenarioPath,
+                scenario_path: options.taskPath,
                 group_id: options.groupId ?? null,
                 session_id: session.session_id,
                 cloud_run_id: finalized.run_id,

package/dist/src/runner/runTrialGroup.d.ts

@@ -1,5 +1,5 @@
 import { type HostedClient } from "../hosted/client.js";
-import { runScenarioHosted } from "./runScenarioHosted.js";
+import { runTaskHosted } from "./runTaskHosted.js";
 import { type TrialRow } from "./groupRender.js";
 /** Per-request transport timeout. Durable evaluation has a separate budget. */
 export declare const GROUP_FINALIZE_TIMEOUT_MS = 60000;
@@ -9,7 +9,7 @@ export declare const GROUP_FINALIZE_TIMEOUT_MS = 60000;
 export declare const LAZY_MINT_RETRY_MS = 2000;
 export declare const LAZY_MINT_MAX_ATTEMPTS = 5;
 export interface RunTrialGroupOptions {
-    scenarioPath: string;
+    taskPath: string;
     agentCommand: string;
     /** Where the agent command came from, for the header copy
      *  ("pome.json" | "--agent" | "built-in default"). */
@@ -31,11 +31,11 @@ export interface RunTrialGroupOptions {
     /** FDRS-644 — the literal command the fix handoff tells the user to
      *  re-run after their coding agent applies a fix. The caller knows the
      *  invocation shape (bare `pome run` vs an explicit path + -n); default
-     *  reconstructs it from scenarioPath + trials. */
+     *  reconstructs it from taskPath + trials. */
     rerunCommand?: string;
     out?: (line: string) => void;
     client?: HostedClient;
-    runScenarioHostedFn?: typeof runScenarioHosted;
+    runTaskHostedFn?: typeof runTaskHosted;
     groupId?: string;
     /** FDRS-663 — lazy-mint retry pause; defaults to a real setTimeout. */
     sleepFn?: (ms: number) => Promise<void>;

package/dist/src/runner/runTrialGroup.js

@@ -16,7 +16,7 @@
 //      half-group back (best-effort DELETEs) and aborts before any agent
 //      spawns.
 //   2. Run the k trials with concurrency = the number of upfront mints
-//      (= k when quota never pushed back). runScenarioHosted stays the
+//      (= k when quota never pushed back). runTaskHosted stays the
 //      isolation unit: each trial gets its session via the
 //      `premintedSession` seam, `abandonOnFailure` on, and still DELETEs
 //      its own session in its `finally` — that delete frees the quota slot
@@ -40,10 +40,10 @@ import { createHostedClient } from "../hosted/client.js";
 import { HostedQuotaError, HostedTrialError } from "../hosted/errors.js";
 import { newGroupId } from "../demo/ids.js";
 import { criterionPhrase } from "../demo/render.js";
-import { parseScenarioFile } from "../scenario/parseScenario.js";
+import { parseTaskFile } from "../task/parseTask.js";
 import { outcomeOf } from "../hosted/evalResultView.js";
 import { resolveRunAgentIdentity } from "../cli/agent-identity.js";
-import { runScenarioHosted } from "./runScenarioHosted.js";
+import { runTaskHosted } from "./runTaskHosted.js";
 import { fixHandoffLines, flagHintLine, groupExitCode, groupSummaryLines, mostCommonFailedCriterion, provisioningLine, shortReason, spawningAgentLine, trialRowLine, } from "./groupRender.js";
 /** Per-request transport timeout. Durable evaluation has a separate budget. */
 export const GROUP_FINALIZE_TIMEOUT_MS = 60_000;
@@ -57,7 +57,7 @@ export async function runTrialGroup(options) {
         throw new Error(`runTrialGroup requires k>1 (got ${options.trials}); k=1 takes the single-run path so no group is stamped.`);
     }
     const out = options.out ?? ((line) => console.error(line));
-    const runFn = options.runScenarioHostedFn ?? runScenarioHosted;
+    const runFn = options.runTaskHostedFn ?? runTaskHosted;
     const client = options.client ??
         createHostedClient({
             baseUrl: options.hosted.baseUrl,
@@ -66,12 +66,12 @@ export async function runTrialGroup(options) {
         });
     const groupId = options.groupId ?? newGroupId();
     const agentCommandSource = options.agentCommandSource ?? "pome.json";
-    const scenario = await parseScenarioFile(options.scenarioPath);
-    const scenarioSource = await readFile(options.scenarioPath, "utf8");
+    const scenario = await parseTaskFile(options.taskPath);
+    const taskSource = await readFile(options.taskPath, "utf8");
     // Same agent resolution as the single-run path (F-819): the group's trials
     // are recorded under the agent the manifest's `agent.slug` resolves to.
     const identity = await resolveRunAgentIdentity({
-        startDir: dirname(options.scenarioPath),
+        startDir: dirname(options.taskPath),
         apiBaseUrl: options.hosted.baseUrl,
         agentVersionOverride: options.agentVersion,
     });
@@ -83,7 +83,7 @@ export async function runTrialGroup(options) {
     const sleep = options.sleepFn ??
         ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const mintOne = () => client.createSession({
-        scenarioSource,
+        taskSource,
         twins: scenario.config.twins,
         agentId,
         agentVersion,
@@ -158,7 +158,7 @@ export async function runTrialGroup(options) {
         try {
             const session = index < sessions.length ? sessions[index] : await mintLazily();
             const result = await runFn({
-                scenarioPath: options.scenarioPath,
+                taskPath: options.taskPath,
                 agentCommand: options.agentCommand,
                 artifactsDir: options.artifactsDir,
                 hosted: options.hosted,
@@ -239,7 +239,7 @@ export async function runTrialGroup(options) {
             ? "pome fix-prompt"
             : `pome fix-prompt ${artifactsDir}`;
         const rerunCommand = options.rerunCommand ??
-            `pome run ${options.scenarioPath} -n ${options.trials}`;
+            `pome run ${options.taskPath} -n ${options.trials}`;
         for (const line of fixHandoffLines({ fixPromptCommand, rerunCommand })) {
             out(line);
         }

package/dist/src/runner/trialCount.js

@@ -2,7 +2,7 @@
 // FDRS-636 — trial-count resolution for `pome run -n k`.
 //
 // [DECISION 2026-07-05]: -n is an integer 1..20 on the hosted run path. The
-// DEFAULT is the scenario config's `runs` field (scenarioConfigSchema parses
+// DEFAULT is the scenario config's `runs` field (taskConfigSchema parses
 // it, defaulting 1; nothing consumed it before this ticket) — -n overrides;
 // both are capped at 20. k=1 keeps EXACTLY today's single-run behavior (no
 // group is ever stamped — a group of 1 would flip the reliability page off

package/dist/src/task/parseTask.d.ts

@@ -0,0 +1,9 @@
+import { type Task } from "./taskSchema.js";
+export declare function parseTaskFile(path: string): Promise<Task>;
+export declare function parseTask(markdown: string, slug?: string, sidecarSeed?: unknown, taskPath?: string): Task;
+/** The flat seed a single twin boots from. Single-twin scenarios return the
+ *  flat `seedState` as-is; multi-twin scenarios return that twin's slice of the
+ *  per-twin envelope (decided from `config.twins`, per the envelope-iff-multi-twin
+ *  rule). Used by the local runner to seed each twin harness. */
+export declare function seedStateForTwin(scenario: Task, twin: string): unknown;
+export declare function formatTaskError(error: unknown, filePath: string): string;

package/dist/src/{scenario/parseScenario.js → task/parseTask.js}

@@ -8,23 +8,23 @@ import { defaultSeedState, seedSchema } from "@pome-sh/twin-github";
 import { defaultSeedState as defaultGmailSeedState, gmailSeedSchema, } from "@pome-sh/twin-gmail";
 import { defaultSeedState as defaultLinearSeedState, linearSeedSchema as linearSeedStateSchema, } from "@pome-sh/twin-linear";
 import { parseGitHubSeedState } from "./githubSeedCompat.js";
-import { criterionSchema, scenarioConfigSchema, scenarioSchema, slackSeedStateSchema, stripeSeedStateSchema } from "./scenarioSchema.js";
-export async function parseScenarioFile(path) {
+import { criterionSchema, taskConfigSchema, taskSchema, slackSeedStateSchema, stripeSeedStateSchema } from "./taskSchema.js";
+export async function parseTaskFile(path) {
     const markdown = await readFile(path, "utf8");
     const sidecarSeed = await readSidecarSeed(path);
-    return parseScenario(markdown, slugFromPath(path), sidecarSeed, path);
+    return parseTask(markdown, slugFromPath(path), sidecarSeed, path);
 }
-export function parseScenario(markdown, slug = "scenario", sidecarSeed, scenarioPath) {
+export function parseTask(markdown, slug = "scenario", sidecarSeed, taskPath) {
     const title = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? slug;
     const sections = splitSections(markdown);
     const prompt = sections.get("prompt") ?? sections.get("task") ?? "";
     const criteriaText = sections.get("success criteria") ?? sections.get("checks") ?? "";
     const configText = sections.get("config") ?? "";
     const seedText = sections.get("seed state") ?? "";
-    const config = configText.trim() ? scenarioConfigSchema.parse(parseFencedYaml(configText)) : scenarioConfigSchema.parse({});
+    const config = configText.trim() ? taskConfigSchema.parse(parseFencedYaml(configText)) : taskConfigSchema.parse({});
     const criteria = parseCriteria(criteriaText, config.twins);
-    const seedState = resolveSeedState({ sidecarSeed, seedText, config, scenarioPath });
-    return scenarioSchema.parse({
+    const seedState = resolveSeedState({ sidecarSeed, seedText, config, taskPath });
+    return taskSchema.parse({
         slug,
         title,
         setup: sections.get("setup") ?? "",
@@ -46,7 +46,7 @@ function resolveSeedState(args) {
     // validated against the in-memory twin. The `_meta` key (source hash,
     // model, etc.) is stripped before schema parsing.
     if (args.sidecarSeed !== undefined) {
-        return parseSeedStateForScenario(stripSidecarMeta(args.sidecarSeed), args.config);
+        return parseSeedStateForTask(stripSidecarMeta(args.sidecarSeed), args.config);
     }
     if (args.seedText.trim()) {
         const raw = stripFence(args.seedText);
@@ -55,10 +55,10 @@ function resolveSeedState(args) {
         // got here, the sidecar is missing — tell the user what to do instead of
         // letting JSON.parse surface "Unexpected token 'A'".
         if (!/^[\[{]/.test(raw)) {
-            throw new Error(missingSidecarMessage(args.scenarioPath));
+            throw new Error(missingSidecarMessage(args.taskPath));
         }
         try {
-            return parseSeedStateForScenario(JSON.parse(raw), args.config);
+            return parseSeedStateForTask(JSON.parse(raw), args.config);
         }
         catch (err) {
             if (err instanceof SyntaxError) {
@@ -84,7 +84,7 @@ function resolveMultiTwinSeedState(args) {
     else if (args.seedText.trim()) {
         const text = stripFence(args.seedText);
         if (!/^[\[{]/.test(text)) {
-            throw new Error(missingSidecarMessage(args.scenarioPath));
+            throw new Error(missingSidecarMessage(args.taskPath));
         }
         try {
             raw = JSON.parse(text);
@@ -155,10 +155,10 @@ function defaultSeedForTwin(twin) {
     }
     return seedSchema.parse(defaultSeedState());
 }
-function missingSidecarMessage(scenarioPath) {
-    const pathLabel = scenarioPath ?? "<task>.md";
-    const sidecarLabel = scenarioPath
-        ? scenarioPath.replace(/\.md$/i, ".seed.json")
+function missingSidecarMessage(taskPath) {
+    const pathLabel = taskPath ?? "<task>.md";
+    const sidecarLabel = taskPath
+        ? taskPath.replace(/\.md$/i, ".seed.json")
         : "<task>.seed.json";
     return [
         `Task has a prose ## Seed State section but no compiled sidecar (${sidecarLabel}). Run:`,
@@ -175,9 +175,9 @@ function stripSidecarMeta(seed) {
     }
     return seed;
 }
-async function readSidecarSeed(scenarioPath) {
-    const sidecarPath = scenarioPath.replace(/\.md$/i, ".seed.json");
-    if (sidecarPath === scenarioPath || !existsSync(sidecarPath))
+async function readSidecarSeed(taskPath) {
+    const sidecarPath = taskPath.replace(/\.md$/i, ".seed.json");
+    if (sidecarPath === taskPath || !existsSync(sidecarPath))
         return undefined;
     const raw = await readFile(sidecarPath, "utf8");
     try {
@@ -276,7 +276,7 @@ function parseFencedYaml(input) {
 // FDRS-365: scenario seed shape is FLAT per twin, disambiguated by config.twins.
 // Stripe-only scenarios parse with the Stripe schema; everything else (default
 // `["github"]`, or explicit github) parses with the GitHub schema.
-function parseSeedStateForScenario(input, config) {
+function parseSeedStateForTask(input, config) {
     if (isStripeOnly(config.twins))
         return stripeSeedStateSchema.parse(input);
     if (isSlackOnly(config.twins))
@@ -295,7 +295,7 @@ function defaultSeedStateForConfig(twins) {
     }
     if (isSlackOnly(twins)) {
         // Empty Slack seed — the twin's own `parseSeed`/`defaultSeedState` fills the
-        // world at boot. Scenarios always ship a sidecar, so this is just the
+        // world at boot. Tasks always ship a sidecar, so this is just the
         // schema-valid floor.
         return slackSeedStateSchema.parse({});
     }
@@ -329,7 +329,7 @@ function slugFromPath(path) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "");
 }
-export function formatScenarioError(error, filePath) {
+export function formatTaskError(error, filePath) {
     if (error instanceof z.ZodError) {
         return `Invalid task ${filePath}: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`;
     }

package/dist/src/{scenario → task}/seed-compiler-hosted.d.ts

@@ -2,7 +2,7 @@ import type { CompileResult } from "./seed-compiler.js";
 export interface CompileSeedHostedOptions {
     apiBaseUrl: string;
     twin?: "github";
-    scenarioPath?: string;
+    taskPath?: string;
     timeoutMs?: number;
 }
 export declare function compileSeedHosted(prose: string, opts: CompileSeedHostedOptions): Promise<CompileResult>;

package/dist/src/{scenario → task}/seed-compiler-hosted.js

@@ -59,7 +59,7 @@ export async function compileSeedHosted(prose, opts) {
             body: JSON.stringify({
                 prose,
                 twin: opts.twin ?? "github",
-                scenario_path: opts.scenarioPath
+                scenario_path: opts.taskPath
             }),
             signal: controller.signal
         });

package/dist/src/{scenario/scenarioSchema.d.ts → task/taskSchema.d.ts}

@@ -4,7 +4,7 @@ import { linearSeedSchema as linearSeedStateSchema } from "@pome-sh/twin-linear"
 import { criterionSchema } from "@pome-sh/shared-types";
 import { z } from "zod";
 export { criterionSchema };
-export declare const scenarioConfigSchema: z.ZodObject<{
+export declare const taskConfigSchema: z.ZodObject<{
     twins: z.ZodDefault<z.ZodArray<z.ZodString>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     runs: z.ZodDefault<z.ZodNumber>;
@@ -979,7 +979,7 @@ export declare const seedEnvelopeSchema: z.ZodRecord<z.ZodString, z.ZodUnion<rea
         body: z.ZodUnknown;
     }, z.core.$strip>>>;
 }, z.core.$strict>]>>;
-export declare const scenarioSchema: z.ZodObject<{
+export declare const taskSchema: z.ZodObject<{
     slug: z.ZodString;
     title: z.ZodString;
     setup: z.ZodDefault<z.ZodString>;
@@ -1930,7 +1930,7 @@ export declare const scenarioSchema: z.ZodObject<{
     }, z.core.$strict>]>>]>;
 }, z.core.$strip>;
 export type Criterion = z.infer<typeof criterionSchema>;
-export type ScenarioConfig = z.infer<typeof scenarioConfigSchema>;
+export type TaskConfig = z.infer<typeof taskConfigSchema>;
 export type GithubSeedState = z.infer<typeof githubSeedStateSchema>;
 export type StripeSeedState = z.infer<typeof stripeSeedStateSchema>;
 export type SlackSeedState = z.infer<typeof slackSeedStateSchema>;
@@ -1939,4 +1939,4 @@ export type LinearSeedState = z.infer<typeof linearSeedStateSchema>;
 export type StripeFailureInjectionRule = z.infer<typeof stripeFailureInjectionRuleSchema>;
 export type SeedState = z.infer<typeof seedStateSchema>;
 export type SeedEnvelope = z.infer<typeof seedEnvelopeSchema>;
-export type Scenario = z.infer<typeof scenarioSchema>;
+export type Task = z.infer<typeof taskSchema>;

package/dist/src/{scenario/scenarioSchema.js → task/taskSchema.js}

@@ -10,7 +10,7 @@ import { linearSeedSchema as linearSeedStateSchema } from "@pome-sh/twin-linear"
 import { criterionSchema } from "@pome-sh/shared-types";
 import { z } from "zod";
 export { criterionSchema };
-export const scenarioConfigSchema = z.object({
+export const taskConfigSchema = z.object({
     twins: z.array(z.string()).default(["github"]),
     timeout: z.number().int().positive().default(60),
     runs: z.number().int().positive().default(1),
@@ -70,7 +70,7 @@ export const slackSeedStateSchema = z
 // Slack scenarios use the Slack seed shape (`{ users, channels, ... }`).
 // Multi-twin scenarios are not a current requirement; the wrapped
 // `{ <twin>: { seed: ... } }` form was rejected here to keep one canonical
-// shape that twin parsers already speak natively. parseScenario disambiguates
+// shape that twin parsers already speak natively. parseTask disambiguates
 // the union by `config.twins`.
 //
 // Slack arm is FIRST because it is the only `.strict()` arm: a GitHub/Stripe
@@ -87,18 +87,18 @@ export const seedStateSchema = z.union([
 // ONLY for scenarios whose `config.twins` has >1 entry (the envelope-iff-multi-twin
 // rule, decided from `twins` alone — never by sniffing the seed shape). Each value
 // is one twin's flat seed, the same shapes `seedStateSchema` unions. Single-twin
-// scenarios keep the flat shape byte-identical. parseScenario builds and validates
+// scenarios keep the flat shape byte-identical. parseTask builds and validates
 // the envelope value-by-value with each twin's own schema; this record is the outer
-// shape scenarioSchema re-validates against.
+// shape taskSchema re-validates against.
 export const seedEnvelopeSchema = z.record(z.string(), seedStateSchema);
-export const scenarioSchema = z.object({
+export const taskSchema = z.object({
     slug: z.string().min(1),
     title: z.string().min(1),
     setup: z.string().default(""),
     prompt: z.string().min(1),
     expectedBehavior: z.string().default(""),
     criteria: z.array(criterionSchema).min(1),
-    config: scenarioConfigSchema,
+    config: taskConfigSchema,
     // Flat single-twin seed OR the multi-twin per-twin envelope. Flat is tried
     // first so single-twin seeds match their strict arms; the envelope only
     // matches when the flat union can't (its keys are twin ids, not seed fields).

package/examples/agents/llm-refund-agent.ts

@@ -102,7 +102,7 @@ async function callStripeTool(name: string, input: any) {
   throw new Error(`Unknown tool ${name}`);
 }
 
-// Hero bug surfaced by scenarios/14-stripe-refund-retry.md: this agent intentionally
+// Hero bug surfaced by tasks/14-stripe-refund-retry.md: this agent intentionally
 // never sends an `Idempotency-Key` header on POST /v1/refunds. When the twin's
 // failure-injection middleware drops the first response, the LLM-driven retry
 // creates a second refund row — exactly the double-charge bug Pome is built to catch.

package/node_modules/@pome-sh/twin-gmail/CHANGELOG.md

@@ -1,5 +1,10 @@
 # @pome-sh/twin-gmail — CHANGELOG
 
+## 0.1.1 — 2026-07-21
+
+Dependency-only patch: repin `@pome-sh/sdk` to 0.5.1 (F-818 batch). No twin
+surface change.
+
 ## 0.1.0 — 2026-07-20
 
 First public release of the deterministic Gmail twin: