@bastani/atomic 0.9.11-alpha.9 → 0.9.11

package/dist/builtin/web-access/flat-string.ts

@@ -0,0 +1,37 @@
+/**
+ * Truncation that actually releases the untruncated source.
+ *
+ * This local web-access copy mirrors the original helper in
+ * `packages/workflows/src/shared/flat-string.ts`; web-access is a standalone package and
+ * cannot import that workflows module.
+ *
+ * V8 does not copy characters for `String.prototype.slice`. For a flat parent of
+ * 13 characters or more it allocates a **SlicedString**, which is a length, an
+ * offset, and a pointer to the parent. Template interpolation then wraps that in
+ * a **ConsString**, which keeps the same pointer. So the obvious way to bound a
+ * value for storage:
+ *
+ * ```ts
+ * `${JSON.stringify(value).slice(0, 237)}...`
+ * ```
+ *
+ * produces a 240-character string that reports `length === 240` while holding
+ * the entire serialized payload alive. The bound is on what you can read, not on
+ * what you retain. An 8 MiB tool result summarized to 240 characters still costs
+ * 8 MiB for as long as anything keeps the summary.
+ *
+ * That is invisible in every ordinary test: the value is correct, its length is
+ * correct, and equality holds. It only shows up as heap that never comes back.
+ *
+ * `split("").join("")` copies the code units into a fresh flat string with no
+ * parent pointer. It is code-unit exact, including lone surrogates, because
+ * `split("")` splits on UTF-16 code units rather than code points.
+ *
+ * Use this at any truncation whose result outlives the value it came from —
+ * memoized projections, durable checkpoints, catalogs, persisted summaries.
+ * A truncation that is consumed and dropped within the same turn does not need
+ * it, and paying for a copy there is waste.
+ */
+export function flattenTruncatedString(value: string): string {
+	return value.split("").join("");
+}

package/dist/builtin/web-access/github-api.ts

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
 import type { ExtractedContent } from "./extract.js";
+import { flattenTruncatedString } from "./flat-string.js";
 import type { GitHubUrlInfo } from "./github-extract.js";
 
 const MAX_TREE_ENTRIES = 200;
@@ -97,7 +98,7 @@ async function fetchReadmeViaApi(owner: string, repo: string, ref: string): Prom
 				}
 				try {
 					const decoded = Buffer.from(stdout.trim(), "base64").toString("utf-8");
-					resolve(decoded.length > 8192 ? decoded.slice(0, 8192) + "\n\n[README truncated at 8K chars]" : decoded);
+					resolve(decoded.length > 8192 ? flattenTruncatedString(decoded.slice(0, 8192) + "\n\n[README truncated at 8K chars]") : decoded);
 				} catch {
 					resolve(null);
 				}

package/dist/builtin/web-access/github-extract.ts

@@ -3,6 +3,7 @@ import { execFile } from "node:child_process";
 import { extname, join, resolve as resolvePath, sep as pathSep } from "node:path";
 import { activityMonitor } from "./activity.js";
 import type { ExtractedContent } from "./extract.js";
+import { flattenTruncatedString } from "./flat-string.js";
 import { checkGhAvailable, checkRepoSize, fetchViaApi, showGhHint } from "./github-api.js";
 import { BINARY_EXTENSIONS, MAX_INLINE_FILE_CHARS, MAX_TREE_ENTRIES, NOISE_DIRS, loadGitHubConfig, parseGitHubUrl, resetGitHubConfig, type GitHubCloneConfig, type GitHubUrlInfo } from "./github-config.js";
 export { parseGitHubUrl, type GitHubUrlInfo } from "./github-config.js";
@@ -225,14 +226,14 @@ function buildDirListing(rootPath: string, subPath: string): string {
 	return lines.join("\n");
 }
 
-function readReadme(localPath: string): string | null {
+export function readReadme(localPath: string): string | null {
 	const candidates = ["README.md", "readme.md", "README", "README.txt", "README.rst"];
 	for (const name of candidates) {
 		const readmePath = join(localPath, name);
 		if (existsSync(readmePath)) {
 			try {
 				const content = readFileSync(readmePath, "utf-8");
-				return content.length > 8192 ? content.slice(0, 8192) + "\n\n[README truncated at 8K chars]" : content;
+				return content.length > 8192 ? flattenTruncatedString(content.slice(0, 8192) + "\n\n[README truncated at 8K chars]") : content;
 			} catch {
 				continue;
 			}

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.11-alpha.9",
+  "version": "0.9.11",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [
@@ -46,6 +46,6 @@
     "linkedom": "^0.18.13",
     "p-limit": "^7.3.0",
     "turndown": "^7.2.0",
-    "unpdf": "^1.6.2"
+    "unpdf": "1.7.0"
   }
 }

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,63 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.11] - 2026-08-03
+
+### Added
+
+- Added per-node cancellation and abort targeting to `ctx.tool`. Every callback receives a `WorkflowToolContext` (`{ signal }`) combining a per-invocation controller with the run signal, and `workflow({ action: "quit"|"interrupt", runId, stageId })` resolves a tool node by expanded id, local `tool:<argsHash>` id, or tool name. Aborting one node leaves siblings running; existing zero-argument callbacks are unchanged ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Added opt-in `ctx.tool(..., { failureMode: "return" })` for checks that may fail during repair flows, preserving bounded redacted `exitCode`, `stdout`, and `stderr` as typed durable data that replays without rerunning the callback ([#1993](https://github.com/bastani-inc/atomic/issues/1993)).
+- Re-added the built-in Goal and Ralph workflows with their typed composition exports, command metadata, tests, and docs.
+- Added a run-contract discipline to every builtin workflow: only the user may change a run's contract, mid-run steering and resume text are authoritative amendments, and each stage restates the amendments it received. Every bundled workflow wraps its context once through `withSteeringPropagationContext` (exported from `@bastani/workflows/builtin/steering-context`), so `ctx.task`, `ctx.chain`, and `ctx.parallel` prompts carry it automatically. Implementation stages also freeze acceptance criteria before writing code and keep a deferred list instead of a growing diff.
+- Added a draft handoff for `ralph` runs that exhaust their review budget: with `create_pr` enabled, the run opens a draft pull request reproducing every unresolved blocking finding with priority and cited `file:line` instead of leaving the branch unpushed.
+- Added the opt-in `autoAttach` workflow-definition field, which opens the graph overlay for interactive top-level named launches, and `ctx.models`, which optionally exposes the host session's model catalog to custom definitions.
+- Embedded DBOS Postgres now works when Atomic runs as root on Linux (containers, CI sandboxes, eval harnesses) by resolving an unprivileged system account and keeping the cluster under `/var/lib/atomic-postgres`.
+
+### Changed
+
+- Workflow invocations now assign a stable, non-`default` Intercom group from the top-level run identity and apply it to every Intercom-capable stage. Nested workflows, model fallback, pause/resume, durable replay, and subagent inheritance retain the group; separate runs stay isolated and explicit overrides still win, so authors no longer thread group names manually ([#1999](https://github.com/bastani-inc/atomic/issues/1999)).
+- Adopted Claude Opus 5 as the primary model for the Ralph prompt-engineer, orchestrator, and reviewer-A stages, the Goal orchestrator and reviewer stages, and the Open Claude Design chain, with Copilot and OpenRouter mirrors added throughout. Ralph's research and reviewer-B chains keep GPT-5.6 primaries and gain Opus 5 fallbacks.
+- Reworked the Goal, Ralph, Open Claude Design, and six pattern-workflow stage prompts, plus the bundled `prompt-engineer` skill (864 → 396 lines), for GPT-5.6, Claude Opus 5, and Claude Fable 5: artifacts before the final query, explicit output and stop contracts, evidence-grounded status claims, damped delegation, and no response prefilling or internal-reasoning requests. Schemas, convergence semantics, and exports are preserved.
+- Changed the builtin Goal execution stage from a direct worker into a Ralph-style sub-agent orchestrator that delegates implementation, validation, and documentation through the `subagent` tool and writes `orchestrator-receipt.md`, while retaining Goal's ledger, reviewer, reducer, and optional PR flow.
+- Strengthened reviewer prompts with a contract-probe playbook and a code-delta integrity contract: reviewers prove the delta exists in the review checkout before trusting receipts, treat claimed-but-absent work as blocking, and flag modified or deleted pre-existing tests ([#1973](https://github.com/bastani-inc/atomic/issues/1973)).
+- Strengthened workflow-authoring and routing guidance to require DAG-only dynamic topologies with pre-launch cycle rejection, bounded loop unrolling, and topology sketches, and to triage multi-item queues into bounded concurrent top-level runs with separate worktrees ([#2010](https://github.com/bastani-inc/atomic/issues/2010), [#2012](https://github.com/bastani-inc/atomic/issues/2012)).
+- Added a worktree-discipline contract to Goal and Ralph prompts (work stays in the invoking checkout), and made PR creation an explicitly authorized `create_pr=true` action rather than embedded task text.
+- Documented deterministic delivery timing for stage messages: `steer` is consumed after the current response finishes its whole tool batch and before the next model request, `followUp` only when the agent would otherwise stop ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- Workflow stage chat now renders Atomic's one-cell `∀` on the shared 88 ms luminance ramp, honours caller-supplied palettes through the detected terminal color mode, and drops redundant overlay status chrome.
+
+### Removed
+
+- Removed the parenthesized context-window authoring token (`(1m)`, `(1.1m)`, `(936k)`, `(long)`) from workflow model strings along with the `contextWindow` / `contextWindowStrict` stage options. Every stage session uses its model's catalog context window.
+- Removed Cursor model fallbacks and Cursor-branded Impeccable harness compatibility ([#1994](https://github.com/bastani-inc/atomic/issues/1994)), and removed the built-in `deep-research-codebase` workflow.
+
+### Fixed
+
+- Fixed workflow graph rendering and memory on large fan-outs. Cards, edges, and composed rows clip to the viewport; store observation offers a synchronous invalidation channel plus one memoized immutable graph projection per store version, so a status update no longer `JSON.stringify`/`JSON.parse`-clones the full run payload; and truncated fields plus durable tool-result summaries copy into fresh flat strings, since a V8 SlicedString kept multi-megabyte results alive behind a 240-character summary ([#2100](https://github.com/bastani-inc/atomic/issues/2100)).
+- Fixed graceful quit ignoring in-flight `ctx.tool` calls, which previously reported `No controllable stages on run <id>` and left callbacks running. Quit now counts running tool nodes as controllable work, closes the tool-admission boundary, aborts the whole root/nested set, and only then records the durable paused transition. Resume re-executes the cancelled call at the same node instead of replaying a cancellation as data, a caught cancellation cannot publish a completed run over quit's paused record, and a failed durable write still leaves the run controllable so a retried quit can upgrade the pause ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Fixed durable nested `ctx.workflow(...)` resume and completed hydration across fresh processes: boundary identity persists before child dispatch, ids stay stable under reversed parallel ordering, and stale, aliased, cyclic, or nonreciprocal records fail closed instead of flattening an unrelated run. Completed child work and `ctx.tool(...)` effects stay exactly-once, and ambiguous child-local stage ids no longer route to the first match.
+- Fixed `ctx.tool()` calls durably completing side effects before a late empty-stage rejection. Tools now create ordered, inspectable, non-attachable graph nodes with live, failed, completed, cancelled, and cached states; tool-only workflows complete normally; and terminal publication closes admission so post-terminal calls reject before any callback runs ([#1991](https://github.com/bastani-inc/atomic/issues/1991)).
+- Fixed host-session replacement (`/new`, `/resume`, `/fork`, `/reload`) leaving the process-global DBOS executor stopped, so every later run in the same process failed at its first durable checkpoint with `` `DBOS.launch()` must be called before running workflows ``. The executor lifetime is now process-scoped, and the backend factory never hands out a stopped backend ([#1957](https://github.com/bastani-inc/atomic/issues/1957)).
+- Fixed stage message queues across detach and reattach: a typed Enter in an attached stage chat names steering explicitly instead of being demoted to a follow-up, the stage handle keeps its own projection of `queue_update` snapshots so pending rows survive detaching, the graph shows a `✉ N queued` badge, a session that arrives already holding queued messages replays the snapshot its listeners missed, and Escape restores queued steering and follow-ups into the editor ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- Fixed controlled workflow pauses allowing queued or late-arriving work to run after a stage was visibly paused. A synchronous raw queue hold is established before one serialized abort boundary, and resume releases preserved steering, follow-up, custom, async, and user entries exactly once ([#1983](https://github.com/bastani-inc/atomic/issues/1983)).
+- Fixed programmatic `workflow send` reopening retained stage conversations after the root workflow had terminated; terminal roots now return a structured `WORKFLOW_TERMINAL` failure before any session probing or delivery, while `/workflow attach` and Intercom keep their explicit post-mortem paths ([#2009](https://github.com/bastani-inc/atomic/issues/2009)).
+- Fixed three `open-claude-design` faults: a failed `user-feedback-*` stage no longer converts into design approval and exports an unreviewed design ([#2123](https://github.com/bastani-inc/atomic/issues/2123)); research context now persists to `<artifact_dir>/design-context.md` and `references.md` and is read through `reads` instead of embedded inline, removing the `413 request_too_large` class ([#2121](https://github.com/bastani-inc/atomic/issues/2121)); and each refinement round raises a run-level prompt naming the preview path and `file://` URL instead of blocking on live review while reporting `running` ([#2060](https://github.com/bastani-inc/atomic/issues/2060)).
+- Fixed the Ralph research stage destroying its own artifact by declaring the authored report path as its runner-owned `output`; research stages now return the full report as their final message. Fixed the Classify-and-act, Fan-out-and-synthesize, Generate-and-filter, Loop-until-done, and Tournament workflows returning whole terminal artifacts into the calling session's context — each `result` is now the compact artifact reference, with the full report on the existing path outputs.
+- Fixed admitted durable `ctx.tool(...)` failures being misclassified as killed or cancelled, and fixed failed physical session appends leaving malformed JSONL tails, duplicate ids, or phantom parents after a partial write ([#2021](https://github.com/bastani-inc/atomic/issues/2021)).
+- Fixed fresh-process resume and completed-run inspection losing nested child-workflow and parallel hierarchy, and fixed `workflow({ action: "resume", runId })` returning `Run not found` for eligible durably paused runs after session-local state was cleared ([#1924](https://github.com/bastani-inc/atomic/issues/1924)).
+- Fixed session teardown crashing the process with exit code 1 after DBOS provisioning had failed, which turned otherwise-successful `--print` runs into nonzero exits. When no durable backend can be provisioned at all, workflows degrade to a loud non-durable in-memory backend instead of failing every action.
+- Hardened the bundled `impeccable` live-mode scripts against four CodeQL findings (insecure randomness, resource exhaustion, regex injection, double escaping), preserving behaviour for all valid inputs.
+- Fixed retained terminal stage chats dropping the Working indicator after Enter and before the follow-up turn started ([#1982](https://github.com/bastani-inc/atomic/issues/1982)).
+
+## [0.9.11-alpha.11] - 2026-08-03
+
+### Fixed
+
+- Fixed workflow graph rendering for large, wide fan-outs by clipping cards, edges, and composed rows to the visible viewport, retaining cached topology and layout across status-only updates, and making idle animation eligibility constant-time ([#2100](https://github.com/bastani-inc/atomic/issues/2100)).
+- Fixed every interactive store mutation cloning the full run payload before the graph could repaint. A status or question update used to build a complete `JSON.stringify`/`JSON.parse` snapshot, traversing workflow inputs, authored stage result bodies, child output values, and tool input/output bodies, so mutation cost scaled with payload size rather than with the graph. Store observation now offers a synchronous invalidation-only channel plus one immutable memoized graph projection per store version, and the graph, overlay, attach pane, stage chat, widget, lifecycle and HIL notifications, resume picker, and send admission all read that projection. In the default configuration (`statusFile: false`), mutations no longer build the legacy full snapshot; enabling `statusFile` retains that snapshot and status-file serialization cost. Topology, status, timing, prompts, attachment state, notices, bounded returned-status fields, durable tool summaries, and child output counts are preserved; the existing `Store.snapshot()` / `Store.subscribe(snapshot)` contract is unchanged for external consumers ([#2100](https://github.com/bastani-inc/atomic/issues/2100)).
+- Fixed the memoized graph projection keeping whole run results in memory. Truncating a result field with `slice()` leaves a V8 SlicedString that points at its untruncated parent, so a 1 KiB projected field kept a multi-megabyte run result alive — inside the store's cached projection, and inside every long-lived holder of one — long after the run itself was removed. Truncated fields are now copied into fresh flat strings, so a session with large workflow results no longer grows heap ([#2100](https://github.com/bastani-inc/atomic/issues/2100)).
+- Fixed durable tool-result summaries retaining the payloads they summarize. `summarizeToolResult` and `summarizeCompletedToolResult` bounded a serialized value with `` `${serialized.slice(0, 237)}...` ``, which leaves a V8 SlicedString behind a ConsString, both pointing at the untruncated parent — so a 240-character summary written into a durable checkpoint or held in a completed-run catalog row kept the entire `JSON.stringify` output alive (measured at 8.4 MiB for one large tool result). Both summaries now copy into fresh flat strings via a shared `flattenTruncatedString` helper, which the memoized graph projection also uses ([#2100](https://github.com/bastani-inc/atomic/issues/2100)).
+- Fixed Escape in an attached workflow-stage chat restoring queued steering and follow-up messages into the editor instead of leaving them stuck in the pending-message queue.
+
 ## [0.9.11-alpha.9] - 2026-08-01
 
 ### Added

package/dist/builtin/workflows/builtin/goal-ledger.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { createWorkflowArtifactDirectory } from "../src/shared/workflow-artifacts.js";
 import { LEDGER_FILENAME, type GoalLedger, type GoalLifecycleEvent } from "./goal-types.js";
 
 type ModelVisibleGoalLedger = Omit<
@@ -55,11 +55,13 @@ export function appendLifecycleEvent(
 export async function createGoalLedger(
   objective: string,
   acceptanceCriteria = objective,
+  runId?: string,
 ): Promise<{ ledger: GoalLedger; ledgerPath: string; artifactDir: string }> {
-  const artifactDir = await mkdtemp(join(tmpdir(), "atomic-goal-runner-"));
+  const goalId = randomUUID();
+  const artifactDir = await createWorkflowArtifactDirectory(runId);
   const now = new Date().toISOString();
   const ledger: GoalLedger = {
-    goal_id: randomUUID(),
+    goal_id: goalId,
     objective,
     acceptance_criteria: acceptanceCriteria,
     status: "active",

package/dist/builtin/workflows/builtin/goal-runner.ts

@@ -64,6 +64,7 @@ function normalizeBranchInput(
 }
 type GoalRunnerContext = {
   readonly inputs: GoalWorkflowInputs;
+  readonly runId?: string;
   task(name: string, options: WorkflowTaskOptions): Promise<WorkflowTaskResult>;
   parallel(steps: readonly WorkflowTaskStep[], options: WorkflowParallelOptions): Promise<WorkflowTaskResult[]>;
 };
@@ -109,7 +110,7 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
     const reviewQuorum = DEFAULT_REVIEW_QUORUM;
     const blockerThreshold = Math.min(DEFAULT_BLOCKER_THRESHOLD, maxTurns);
     const comparisonBaseBranch = normalizeBranchInput(inputs.base_branch, "origin/main");
-    const { ledger, ledgerPath, artifactDir } = await createGoalLedger(objective, acceptanceCriteria);
+    const { ledger, ledgerPath, artifactDir } = await createGoalLedger(objective, acceptanceCriteria, ctx.runId);
 
     let latestReviews: ReviewRecord[] = [];
     let latestReviewArtifactPaths: string[] = [];

package/dist/builtin/workflows/builtin/goal.ts

@@ -47,7 +47,7 @@ export default workflow({
     goal_id: Type.Optional(Type.String({ description: "Per-run goal identifier stored in the ledger." })),
     objective: Type.Optional(Type.String({ description: "Raw goal objective used by the run." })),
     acceptance_criteria: Type.Optional(Type.String({ description: "Immutable acceptance criteria used by the run." })),
-    ledger_path: Type.Optional(Type.String({ description: "OS-temp path to goal-ledger.json with receipts, reviewer decisions, blockers, and lifecycle events." })),
+    ledger_path: Type.Optional(Type.String({ description: "Durable run-scoped path to goal-ledger.json with receipts, reviewer decisions, blockers, and lifecycle events." })),
     turns_completed: Type.Optional(Type.Number({ description: "Orchestrator/review turns completed." })),
     iterations_completed: Type.Optional(Type.Number({ description: "Orchestrator/review turns completed, retained for status summaries." })),
     receipts: Type.Optional(Type.Array(Type.Object({

package/dist/builtin/workflows/builtin/ralph-core.ts

@@ -1,8 +1,8 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { Type } from "typebox";
 import type { WorkflowTaskResult } from "../src/shared/types.js";
+import { createWorkflowArtifactDirectory } from "../src/shared/workflow-artifacts.js";
 import {
   E2E_VERIFICATION_GUIDANCE,
   LITERAL_OBJECTIVE_CONTRACT,
@@ -170,8 +170,8 @@ export function defaultResearchPath(prompt: string, now = new Date()): string {
   return join(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
 }
 
-export async function createImplementationNotesFile(prompt: string): Promise<string> {
-  const notesDir = await mkdtemp(join(tmpdir(), "atomic-ralph-notes-"));
+export async function createImplementationNotesFile(prompt: string, runId?: string): Promise<string> {
+  const notesDir = await createWorkflowArtifactDirectory(runId);
   const notesPath = join(notesDir, IMPLEMENTATION_NOTES_FILENAME);
   const initialNotes = [
     "# Implementation Notes",
@@ -195,8 +195,8 @@ export async function createImplementationNotesFile(prompt: string): Promise<str
 // write to it; the video file itself is produced by the orchestrator's QA pass
 // (and overwritten each iteration so it always reflects the latest state). The
 // final pull-request stage attaches it when it exists.
-export async function createQaEvidenceVideoPath(): Promise<string> {
-  const qaDir = await mkdtemp(join(tmpdir(), "atomic-ralph-qa-"));
+export async function createQaEvidenceVideoPath(runId?: string): Promise<string> {
+  const qaDir = await createWorkflowArtifactDirectory(runId);
   return join(qaDir, QA_E2E_VIDEO_FILENAME);
 }
 
@@ -367,7 +367,6 @@ export function renderResearchPrompt(args: {
   readonly acceptanceCriteria: string;
   readonly workflowCwdContext: PromptSection;
   readonly latestReviewReportPath: string | undefined;
-  readonly researchPath: string;
 }): string {
   return taggedPrompt([
     ["acceptance_criteria", args.acceptanceCriteria],
@@ -386,8 +385,7 @@ export function renderResearchPrompt(args: {
     [
       "research_artifact",
       [
-        "Return the complete research report as your final message. This workflow saves that final message verbatim as the run's research artifact; downstream implementation and review stages read it from that file.",
-        `Do not write ${args.researchPath} yourself. Anything written there during this stage is replaced by your final message, so a file you author is lost and a final message that only points at the path leaves later stages with no findings. Skill-owned notes under research/docs/ and research/web/ are unaffected.`,
+        "Return the complete research report as your final message. Downstream implementation and review stages read it from there.",
         "Produce a complete Markdown report with codebase and useful online/contextual findings, implementation guidance, relevant files/tests/docs, unresolved-finding analysis, and validation recommendations. Lead with conclusions; keep facts, caveats, and implementation-relevant next steps; drop background and repetition.",
         "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.",
         "Do not author an RFC/spec or implement code changes.",
@@ -417,6 +415,7 @@ export type RalphWorkflowOptions = {
   readonly comparisonBaseBranch: string;
   readonly workflowStartCwd: string;
   readonly createPr: boolean;
+  readonly runId?: string;
 };
 
 export type RalphWorkflowResult = {

package/dist/builtin/workflows/builtin/ralph-forked-prompts.ts

@@ -28,7 +28,6 @@ export function renderForkedResearchPromptRefinementPrompt(args: {
 export function renderForkedResearchPrompt(args: {
   readonly transformedResearchQuestion: string;
   readonly latestReviewReportPath: string | undefined;
-  readonly researchPath: string;
 }): string {
   return taggedPrompt([
     [
@@ -43,9 +42,8 @@ export function renderForkedResearchPrompt(args: {
     [
       "research_artifact",
       [
-        "Return the rewritten research report for this iteration as your final message. This workflow saves that final message verbatim as the run's research artifact; downstream implementation and review stages read it from that file.",
-        `Do not write ${args.researchPath} yourself. Anything written there during this stage is replaced by your final message, so a file you author is lost and a final message that only points at the path leaves later stages with no findings. Skill-owned notes under research/docs/ and research/web/ are unaffected.`,
-        "Restate the still-applicable findings in full rather than referring back to the previous iteration's artifact; it is overwritten by this message.",
+        "Return the rewritten research report for this iteration as your final message.",
+        "Restate the still-applicable findings in full rather than referring back to the previous iteration's artifact; the current artifact and transcript are the authoritative records for this iteration.",
         "Do not author an RFC/spec or implement code changes.",
       ].join("\n"),
     ],

package/dist/builtin/workflows/builtin/ralph-models.ts

@@ -48,10 +48,10 @@ export const promptEngineerModelConfig = {
 };
 
 export const researchModelConfig = {
-    model: "openai-codex/gpt-5.6-sol:medium",
+    model: "openai-codex/gpt-5.6-luna:max",
     fallbackModels: [
-      "github-copilot/gpt-5.6-sol:medium",
-      "openai/gpt-5.6-sol:medium",
+      "github-copilot/gpt-5.6-luna:max",
+      "openai/gpt-5.6-luna:max",
       "anthropic/claude-opus-5:low",
       "github-copilot/claude-opus-5:low",
       "anthropic/claude-fable-5:low",
@@ -64,7 +64,7 @@ export const researchModelConfig = {
       "xai/grok-4.5:high",
       "zai/glm-5.2:high",
       "zai-coding-cn/glm-5.2:high",
-      "openrouter/openai/gpt-5.6-sol:medium",
+      "openrouter/openai/gpt-5.6-luna:max",
       "openrouter/anthropic/claude-opus-5:low",
       "openrouter/openai/gpt-5.5:medium",
       "openrouter/anthropic/claude-fable-5:low",

package/dist/builtin/workflows/builtin/ralph-runner.ts

@@ -1,8 +1,7 @@
 import { existsSync } from "node:fs";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import type { WorkflowRunContext, WorkflowTaskResult } from "../src/shared/types.js";
+import { createWorkflowArtifactDirectory } from "../src/shared/workflow-artifacts.js";
 import {
   ACCEPTANCE_MATRIX_CONTRACT,
   CONTRACT_FIDELITY_AUDIT,
@@ -52,7 +51,7 @@ export async function runRalphWorkflow(
   ctx: WorkflowRunContext<RalphInputs>,
   options: RalphWorkflowOptions,
 ): Promise<RalphWorkflowResult> {
-  const { prompt, acceptanceCriteria, maxLoops, comparisonBaseBranch, workflowStartCwd, createPr } = options;
+  const { prompt, acceptanceCriteria, maxLoops, comparisonBaseBranch, workflowStartCwd, createPr, runId } = options;
   let latestReviewReportPath: string | undefined;
   let finalPlan = "";
   let finalPlanPath = "";
@@ -63,9 +62,9 @@ export async function runRalphWorkflow(
   const workflowCwdContext = workflowCwdContextSection(workflowStartCwd);
   const workflowPrompt = prompt;
   const workflowResearchPath = resolve(workflowStartCwd, defaultResearchPath(workflowPrompt));
-  const implementationNotesPath = await createImplementationNotesFile(workflowPrompt);
-  const qaVideoPath = await createQaEvidenceVideoPath();
-  const artifactDir = await mkdtemp(join(tmpdir(), "atomic-ralph-run-"));
+  const implementationNotesPath = await createImplementationNotesFile(workflowPrompt, runId);
+  const qaVideoPath = await createQaEvidenceVideoPath(runId);
+  const artifactDir = await createWorkflowArtifactDirectory(runId);
   let approved = false;
   let iterationsCompleted = 0;
   let previousResearchPromptRefinementSessionFile: string | undefined;
@@ -98,12 +97,10 @@ export async function runRalphWorkflow(
             acceptanceCriteria,
             workflowCwdContext,
             latestReviewReportPath,
-            researchPath: workflowResearchPath,
           })
         : renderForkedResearchPrompt({
             transformedResearchQuestion: researchPromptRefinement.text,
             latestReviewReportPath,
-            researchPath: workflowResearchPath,
           }),
       reads: latestReviewReportPath === undefined ? [] : [latestReviewReportPath],
       output: workflowResearchPath,

package/dist/builtin/workflows/builtin/ralph.ts

@@ -41,7 +41,7 @@ export default workflow({
     plan_path: Type.Optional(Type.String({ description: "Backward-compatible alias for research_path." })),
     research: Type.Optional(Type.String({ description: "Latest research report text or artifact reference." })),
     research_path: Type.Optional(Type.String({ description: "Path to the latest generated research artifact under research/." })),
-    implementation_notes_path: Type.Optional(Type.String({ description: "OS-temp notes file containing decisions, deviations, blockers, and validation notes." })),
+    implementation_notes_path: Type.Optional(Type.String({ description: "Durable run-scoped notes file containing decisions, deviations, blockers, and validation notes." })),
     qa_video_path: Type.Optional(Type.String({ description: "Absolute path to the reviewable QA end-to-end proof video recorded with playwright-cli for UI-applicable changes, when one was produced." })),
     pr_report: Type.Optional(Type.String({ description: "Pull-request report emitted only when create_pr=true and the final pull-request stage runs." })),
     approved: Type.Optional(Type.Boolean({ description: "Whether the reviewer loop approved before completion or optional final handoff." })),
@@ -72,6 +72,7 @@ export default workflow({
       comparisonBaseBranch,
       workflowStartCwd,
       createPr,
+      runId: workflowCtx.runId,
     });
   },
 });

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.11-alpha.9",
+  "version": "0.9.11",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

package/dist/builtin/workflows/src/durable/completed-catalog.ts

@@ -1,3 +1,4 @@
+import { flattenTruncatedString } from "../shared/flat-string.js";
 import { isReopenableSessionTranscript } from "../shared/session-transcript.js";
 import type { RunSnapshot, StageSnapshot, ToolNodeSnapshot } from "../shared/store-types.js";
 import type { WorkflowInputValues, WorkflowSerializableValue } from "../shared/types.js";
@@ -31,7 +32,7 @@ import {
 
 export type CompletedWorkflowResolution =
 	| { readonly kind: "found"; readonly entry: ResumableWorkflowEntry; readonly snapshot: RunSnapshot }
-	| { readonly kind: "ambiguous"; readonly matches: readonly ResumableWorkflowEntry[] }
+	| { readonly kind: "malformed"; readonly message: string }
 	| { readonly kind: "not_found" }
 	| { readonly kind: "stale"; readonly entry: ResumableWorkflowEntry };
 
@@ -54,13 +55,13 @@ export function listOpenableCompletedWorkflows(backend: DurableWorkflowBackend):
 }
 
 export function resolveCompletedWorkflow(
-	workflowIdOrPrefix: string,
+	workflowId: string,
 	backend: DurableWorkflowBackend,
 	openableCatalog: readonly ResumableWorkflowEntry[] = listOpenableCompletedWorkflows(backend),
 ): CompletedWorkflowResolution {
-	const resolved = resolveDurableEntry(workflowIdOrPrefix, openableCatalog);
+	const resolved = resolveDurableEntry(workflowId, openableCatalog);
 	if (resolved !== undefined) {
-		if ("kind" in resolved) return { kind: "ambiguous", matches: resolved.matches };
+		if ("kind" in resolved) return { kind: "malformed", message: resolved.message };
 		const snapshot = completedWorkflowSnapshot(backend, resolved);
 		if (snapshot === undefined) {
 			return { kind: "stale", entry: resolved };
@@ -68,9 +69,9 @@ export function resolveCompletedWorkflow(
 		return { kind: "found", entry: resolved, snapshot };
 	}
 
-	const authoritative = resolveDurableEntry(workflowIdOrPrefix, listCompletedFromBackend(backend));
+	const authoritative = resolveDurableEntry(workflowId, listCompletedFromBackend(backend));
 	if (authoritative === undefined) return { kind: "not_found" };
-	if ("kind" in authoritative) return { kind: "ambiguous", matches: authoritative.matches };
+	if ("kind" in authoritative) return { kind: "malformed", message: authoritative.message };
 	return { kind: "stale", entry: authoritative };
 }
 
@@ -208,10 +209,15 @@ function completedToolNodes(
 	});
 }
 
+/**
+ * Catalog rows are held for the lifetime of a completed-run listing, so this
+ * truncation must release the payload it summarizes rather than point into it.
+ * See `flattenTruncatedString`.
+ */
 function summarizeCompletedToolResult(value: WorkflowSerializableValue): string {
 	const serialized = JSON.stringify(value);
-	if (serialized === undefined) return String(value).slice(0, 240);
-	return serialized.length <= 240 ? serialized : `${serialized.slice(0, 237)}...`;
+	if (serialized === undefined) return flattenTruncatedString(String(value).slice(0, 240));
+	return serialized.length <= 240 ? serialized : `${flattenTruncatedString(serialized.slice(0, 237))}...`;
 }
 
 function runSnapshotsFromCheckpoints(

package/dist/builtin/workflows/src/durable/completed-inspection.ts

@@ -23,7 +23,7 @@ export type OpenCompletedDurableResult =
 			readonly name: string;
 			readonly message: string;
 	  }
-	| { readonly ok: false; readonly reason: "not_found" | "ambiguous" | "stale" | "active"; readonly message: string };
+	| { readonly ok: false; readonly reason: "not_found" | "malformed" | "stale" | "active"; readonly message: string };
 
 export interface OpenCompletedDurableDeps {
 	readonly durableBackend: DurableWorkflowBackend;
@@ -49,22 +49,21 @@ const completedChatRegistrations = new WeakMap<StageControlRegistry, Map<string,
  * conversation to its retained Atomic session without dispatching the workflow.
  */
 export function openCompletedDurableWorkflow(
-	workflowIdOrPrefix: string,
+	workflowId: string,
 	deps: OpenCompletedDurableDeps,
 	catalog: readonly ResumableWorkflowEntry[] = listOpenableCompletedWorkflows(deps.durableBackend),
 ): OpenCompletedDurableResult {
-	const resolved = resolveCompletedWorkflow(workflowIdOrPrefix, deps.durableBackend, catalog);
+	const resolved = resolveCompletedWorkflow(workflowId, deps.durableBackend, catalog);
 	if (resolved.kind === "not_found") {
-		return failure("not_found", `No completed durable workflow found for id/prefix: ${workflowIdOrPrefix}`);
+		return failure("not_found", `No completed durable workflow found for id: ${workflowId}`);
 	}
-	if (resolved.kind === "ambiguous") {
-		const matches = resolved.matches.map((entry) => `${entry.name} (${entry.workflowId.slice(0, 8)})`).join(", ");
-		return failure("ambiguous", `Ambiguous completed workflow prefix "${workflowIdOrPrefix}" matches: ${matches}`);
+	if (resolved.kind === "malformed") {
+		return failure("malformed", resolved.message);
 	}
 	if (resolved.kind === "stale") {
 		return failure(
 			"stale",
-			`Completed workflow ${resolved.entry.workflowId.slice(0, 8)} is stale or missing durable checkpoint/session data and cannot be opened.`,
+			`Completed workflow ${resolved.entry.workflowId} is stale or missing durable checkpoint/session data and cannot be opened.`,
 		);
 	}
 
@@ -72,7 +71,7 @@ export function openCompletedDurableWorkflow(
 	if (existing !== undefined && existing.status !== "completed") {
 		return failure(
 			"active",
-			`Workflow ${resolved.snapshot.id.slice(0, 8)} is already active in this session; attach with /workflow connect ${resolved.snapshot.id.slice(0, 8)} instead.`,
+			`Workflow ${resolved.snapshot.id} is already active in this session; attach with /workflow connect ${resolved.snapshot.id} instead.`,
 		);
 	}
 	const snapshots = completedWorkflowRunSnapshots(deps.durableBackend, resolved.entry);
@@ -90,11 +89,11 @@ export function openCompletedDurableWorkflow(
 		runId: snapshot.id,
 		workflowId: snapshot.id,
 		name: snapshot.name,
-		message: `Opened completed durable workflow "${snapshot.name}" (${snapshot.id.slice(0, 8)}) for read-only inspection${hasReopenableStage ? " and follow-up chat" : ""}.`,
+		message: `Opened completed durable workflow "${snapshot.name}" (${snapshot.id}) for read-only inspection${hasReopenableStage ? " and follow-up chat" : ""}.`,
 	};
 }
 
-function failure(reason: "not_found" | "ambiguous" | "stale" | "active", message: string): OpenCompletedDurableResult {
+function failure(reason: "not_found" | "malformed" | "stale" | "active", message: string): OpenCompletedDurableResult {
 	return { ok: false, reason, message };
 }
 

package/dist/builtin/workflows/src/durable/resume-catalog.ts

@@ -10,7 +10,7 @@ export function formatResumableWorkflowList(entries: readonly ResumableWorkflowE
 	if (entries.length === 0) return "No resumable or completed workflows found.";
 	const hasCompleted = entries.some((entry) => entry.status === "completed");
 	const lines = entries.map((entry, index) => {
-		const id = entry.workflowId.slice(0, 8);
+		const id = entry.workflowId;
 		const status = entry.status === "completed" ? "✓ completed" : entry.status.padEnd(8);
 		const checkpoints = `${entry.completedCheckpoints} checkpoint${entry.completedCheckpoints === 1 ? "" : "s"}`;
 		const label = entry.label ? ` "${entry.label}"` : "";

package/dist/builtin/workflows/src/durable/resume-eligibility.ts

@@ -1,3 +1,4 @@
+import type { RunSnapshot, RunStatus, WorkflowFailureRecoverability } from "../shared/store-types.js";
 import type { DurableWorkflowStatus } from "./types.js";
 
 /** Metadata required to classify a current DBOS workflow as resumable. */
@@ -10,6 +11,47 @@ export interface DurableResumeCandidate {
 	readonly resumable?: boolean;
 }
 
+/** Live snapshot fields used by every workflow resume surface. */
+export interface WorkflowRunResumeCandidate {
+	readonly status: RunStatus;
+	readonly endedAt?: number;
+	readonly resumable?: boolean;
+	readonly failureRecoverability?: WorkflowFailureRecoverability;
+	readonly exitReason?: string;
+	/** True when a descendant stage is paused/blocked even if the root is still running. */
+	readonly hasPausedState?: boolean;
+	/** Explicitly false when durable state or referenced artifacts are missing. */
+	readonly hasDurableCheckpoint?: boolean;
+	readonly artifactsIntact?: boolean;
+}
+
+/** Derive the paused/blocked state used by every workflow resume surface. */
+export function workflowRunHasPausedState(run: Pick<RunSnapshot, "status" | "exitReason" | "stages">): boolean {
+	return (
+		run.status === "paused" ||
+		run.exitReason === "quit" ||
+		run.stages.some((stage) => stage.status === "paused" || stage.status === "blocked")
+	);
+}
+
+/**
+ * Authoritative live-run resume rule shared by every workflow resume surface.
+ * Missing durable state or artifacts is never a resume target even when stale
+ * snapshot metadata still says resumable.
+ */
+export function isWorkflowRunResumable(candidate: WorkflowRunResumeCandidate): boolean {
+	if (candidate.hasDurableCheckpoint === false || candidate.artifactsIntact === false) return false;
+	if (candidate.hasPausedState === true || candidate.status === "paused" || candidate.exitReason === "quit") {
+		return candidate.resumable !== false;
+	}
+	return (
+		(candidate.status === "failed" && candidate.endedAt !== undefined && candidate.resumable !== false) ||
+		(candidate.endedAt === undefined &&
+			candidate.resumable === true &&
+			candidate.failureRecoverability === "recoverable")
+	);
+}
+
 /** Authoritative status/progress rules for durable workflow resume discovery. */
 export function isDurableWorkflowResumable(candidate: DurableResumeCandidate): boolean {
 	const isRoot = candidate.rootWorkflowId === undefined || candidate.rootWorkflowId === candidate.workflowId;