@bastani/atomic 0.9.11-alpha.5 → 0.9.11-alpha.7

package/dist/builtin/subagents/src/extension/prompt-guidance.ts

@@ -7,6 +7,6 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - Use the debugger subagent for actual failures that need reproduction, root-cause diagnosis, and a validated fix; additional debugger or research delegates are optional when they add a distinct useful angle.
   - Let each named agent use its declared model and fallback policy: omit the explicit model argument unless the user requests an exact model or a documented task requirement needs one, and record the reason for any override before launch. Do not choose an ad hoc model merely for diversity.
   - If an agent has no declared model or fallback policy, consult packages/coding-agent/docs/models/model-selection.md for the role's Pareto-efficient recommendations, then use workflow({ action: "models" }) when available to inspect the configured catalog. Pin only a returned fullId and only append a thinking level listed for that entry. If the catalog tool is unavailable, the catalog is empty, or no recommended model is present, leave the child unpinned and state the limitation rather than inventing a model. Do not inspect credentials or infer why a model is absent.
-  - For each workflow or orchestrator invocation that delegates subagents, create one invocation-scoped literal Intercom group that is not default and pass that same group to every child, including parallel and follow-up work. Keep contact_supervisor available for cross-group escalation.`,
+  - Workflow stages automatically receive their invocation-scoped Intercom group, and delegated children inherit the launching session's group across single, parallel, chain, async, and follow-up work. Do not create or propagate group identifiers for ordinary workflow-stage delegation; use an explicit group only for an intentional topology override. Keep contact_supervisor available for cross-group escalation.`,
 ];
 

package/dist/builtin/subagents/src/runs/background/async-execution-chain.ts

@@ -18,6 +18,7 @@ import { NESTED_RUNS_DIR, nestedResultsPath, resolveInheritedNestedRouteFromEnv,
 import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
 import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.ts";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
+import { resolveChildIntercomGroup, sharedAutoGroupForSet } from "../shared/intercom-group.ts";
 import {
 	AsyncStartValidationError,
 	UnavailableSubagentSkillError,
@@ -25,7 +26,7 @@ import {
 	formatAsyncStartedMessage,
 	formatAsyncStartError,
 	piPackageRoot,
-	spawnRunner,
+	spawnRunner as defaultSpawnRunner,
 } from "./async-execution-common.ts";
 import type { AsyncChainParams, AsyncExecutionResult, AsyncSpawnResult } from "./async-execution-types.ts";
 
@@ -57,6 +58,7 @@ export function executeAsyncChain(
 		supervisorAuthorizations,
 		dynamicSupervisorAuthorizations,
 		nestedRoute,
+		spawnRunner = defaultSpawnRunner,
 	} = params;
 	const resultMode = params.resultMode ?? "chain";
 	const chainSkills = params.chainSkills ?? [];
@@ -125,7 +127,15 @@ export function executeAsyncChain(
 			...(s.model ? { model: s.model } : {}),
 		};
 	};
-	const buildSeqStep = (s: SequentialStep, sessionFile?: string, behaviorCwd?: string, progressPrecreated = false, resolvedBehavior?: ResolvedStepBehavior) => {
+	const buildSeqStep = (
+		s: SequentialStep,
+		sessionFile?: string,
+		behaviorCwd?: string,
+		progressPrecreated = false,
+		resolvedBehavior?: ResolvedStepBehavior,
+		setGroup?: string | true,
+		sharedAutoGroup?: string,
+	) => {
 		const a = agents.find((x) => x.name === s.agent)!;
 		const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
 		const instructionCwd = behaviorCwd ?? stepCwd;
@@ -172,6 +182,11 @@ export function executeAsyncChain(
 			label: s.label,
 			outputName: s.as,
 			structured: Boolean(s.outputSchema),
+			intercomGroup: resolveChildIntercomGroup(
+				s.group ?? setGroup ?? params.group,
+				ctx.intercomGroup,
+				sharedAutoGroup,
+			),
 			cwd: stepCwd,
 			model,
 			thinking: resolveEffectiveThinking(model, a.thinking),
@@ -209,6 +224,8 @@ export function executeAsyncChain(
 	try {
 		steps = chain.map((s, stepIndex) => {
 			if (isParallelStep(s)) {
+				const setGroup = s.group ?? params.group;
+				const sharedAutoGroup = sharedAutoGroupForSet(setGroup, s.parallel);
 				const parallelBehaviors = s.parallel.map((task) => {
 					const agent = agents.find((candidate) => candidate.name === task.agent)!;
 					return suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(task), chainSkills), task.task, originalTask);
@@ -228,7 +245,7 @@ export function executeAsyncChain(
 								behaviorCwd = undefined;
 							}
 						}
-						return buildSeqStep(t, nextSessionFile(), behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex]);
+						return buildSeqStep(t, nextSessionFile(), behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex], setGroup, sharedAutoGroup);
 					}),
 					concurrency: s.concurrency,
 					failFast: s.failFast,
@@ -236,6 +253,8 @@ export function executeAsyncChain(
 				};
 			}
 			if (isDynamicParallelStep(s)) {
+				const setGroup = s.group ?? params.group;
+				const sharedAutoGroup = sharedAutoGroupForSet(setGroup, [s.parallel]);
 				const agent = agents.find((candidate) => candidate.name === s.parallel.agent)!;
 				const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(s.parallel), chainSkills), s.parallel.task, originalTask);
 				const progressPrecreated = behavior.progress;
@@ -245,7 +264,7 @@ export function executeAsyncChain(
 				}
 				return {
 					expand: s.expand,
-					parallel: buildSeqStep(s.parallel as SequentialStep, undefined, undefined, progressPrecreated, behavior),
+					parallel: buildSeqStep(s.parallel as SequentialStep, undefined, undefined, progressPrecreated, behavior, setGroup, sharedAutoGroup),
 					collect: s.collect,
 					concurrency: s.concurrency,
 					failFast: s.failFast,

package/dist/builtin/subagents/src/runs/background/async-execution-single.ts

@@ -13,6 +13,7 @@ import { injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSi
 import { buildModelCandidates, resolveModelCandidate } from "../shared/model-fallback.ts";
 import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
 import { NESTED_RUNS_DIR, nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.ts";
+import { resolveChildIntercomGroup } from "../shared/intercom-group.ts";
 import {
 	UNAVAILABLE_SUBAGENT_SKILL_ERROR,
 	formatAsyncStartedMessage,
@@ -120,6 +121,7 @@ export function executeAsyncSingle(
 					{
 						agent,
 						task: taskWithOutputInstruction,
+						intercomGroup: resolveChildIntercomGroup(params.group, ctx.intercomGroup, undefined),
 						cwd: runnerCwd,
 						model,
 						thinking: resolveEffectiveThinking(model, agentConfig.thinking),

package/dist/builtin/subagents/src/runs/background/async-execution-types.ts

@@ -18,12 +18,14 @@ export interface AsyncExecutionContext {
 	currentSessionId: string;
 	currentModelProvider?: string;
 	currentModel?: string;
+	intercomGroup?: string;
 	workflowSessionMetadata?: SessionWorkflowMetadata;
 }
 
 export interface AsyncChainParams {
 	chain: ChainStep[];
 	task?: string;
+	group?: string | true;
 	resultMode?: Exclude<SubagentRunMode, "single">;
 	agents: AgentConfig[];
 	ctx: AsyncExecutionContext;
@@ -47,12 +49,20 @@ export interface AsyncChainParams {
 	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 	supervisorAuthorizations?: Array<SupervisorAuthorization | undefined>;
 	dynamicSupervisorAuthorizations?: Record<number, SupervisorAuthorization[]>;
+	/** Internal launch seam used by focused runtime tests. */
+	spawnRunner?: (
+		config: object,
+		suffix: string,
+		cwd: string,
+		env?: Record<string, string>,
+	) => AsyncSpawnResult;
 	nestedRoute?: NestedRouteInfo;
 }
 
 export interface AsyncSingleParams {
 	agent: string;
 	task?: string;
+	group?: string | true;
 	agentConfig: AgentConfig;
 	ctx: AsyncExecutionContext;
 	cwd?: string;

package/dist/builtin/subagents/src/runs/background/subagent-runner-step.ts

@@ -123,6 +123,7 @@ export async function runSingleStep(
 				promptFileStem: step.agent,
 				intercomSessionName: ctx.childIntercomTarget,
 				orchestratorIntercomTarget: ctx.supervisorAuthorization ? ctx.orchestratorIntercomTarget : undefined,
+				intercomGroup: step.intercomGroup,
 				supervisorAuthorization: ctx.supervisorAuthorization,
 				runId: ctx.id,
 				childAgentName: step.agent,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-dynamic-step.ts

@@ -70,6 +70,7 @@ export async function runDynamicParallelChainStep(input: {
 		parallel: materialized.parallel,
 		concurrency: step.concurrency,
 		failFast: step.failFast,
+		group: step.group,
 	};
 	const parallelTemplates = materialized.parallel.map((task) => task.task ?? "{previous}");
 	const parallelBehaviors = resolveParallelBehaviors(dynamicParallelStep.parallel, context.agents, stepIndex, context.chainSkills)
@@ -91,6 +92,7 @@ export async function runDynamicParallelChainStep(input: {
 	createParallelDirs(context.chainDir, stepIndex, dynamicParallelStep.parallel.length, dynamicParallelStep.parallel.map((task) => task.agent));
 	const parallelResults = await runParallelChainTasks({
 		step: dynamicParallelStep,
+		chainIntercomGroup: context.params.group,
 		parallelTemplates,
 		parallelBehaviors,
 		agents: context.agents,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-parallel-runner.ts

@@ -15,6 +15,7 @@ import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
 import { diffWorktrees, formatWorktreeDiffSummary, type WorktreeSetup } from "../shared/worktree.ts";
 import { resolveOutputReferences } from "../shared/chain-outputs.ts";
 import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup, sharedAutoGroupForSet } from "../shared/intercom-group.ts";
 import type { ParallelChainRunInput } from "./chain-execution-types.ts";
 
 export function ensureParallelProgressFile(
@@ -44,6 +45,8 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 	const failFast = input.step.failFast ?? false;
 	let aborted = false;
 	const intercomDetachController = new AbortController();
+	const setGroup = input.step.group ?? input.chainIntercomGroup;
+	const sharedAutoGroup = sharedAutoGroupForSet(setGroup, input.step.parallel);
 
 	return mapConcurrent(input.step.parallel, concurrency, async (task, taskIndex) => {
 		if (intercomDetachController.signal.aborted) {
@@ -135,6 +138,11 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 			onControlEvent: input.onControlEvent,
 			intercomSessionName: input.childIntercomTarget?.(task.agent, input.globalTaskIndex + taskIndex),
 			orchestratorIntercomTarget: input.orchestratorIntercomTarget,
+			intercomGroup: resolveChildIntercomGroup(
+				task.group ?? setGroup,
+				inheritedIntercomGroup(input.ctx),
+				sharedAutoGroup,
+			),
 			nestedRoute: input.nestedRoute,
 			onDetachedExit: (recovered) => input.onDetachedExit?.(input.globalTaskIndex + taskIndex, recovered),
 			intercomDetachSignal: intercomDetachController.signal,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-parallel-step.ts

@@ -81,6 +81,7 @@ export async function runStaticParallelChainStep(input: {
 
 		const parallelResults = await runParallelChainTasks({
 			step,
+			chainIntercomGroup: context.params.group,
 			parallelTemplates,
 			parallelBehaviors,
 			agents: context.agents,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-sequential-step.ts

@@ -17,6 +17,7 @@ import { workflowSessionMetadataFromContext } from "../../shared/types-depth.ts"
 import { outputEntryFromResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
 import { recordRun } from "../shared/run-history.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
 import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
@@ -122,6 +123,11 @@ export async function runSequentialChainStep(input: {
 		onControlEvent: context.onControlEvent,
 		intercomSessionName: context.childIntercomTarget?.(seqStep.agent, flatIndex),
 		orchestratorIntercomTarget: context.orchestratorIntercomTarget,
+		intercomGroup: resolveChildIntercomGroup(
+			seqStep.group ?? context.params.group,
+			inheritedIntercomGroup(context.ctx),
+			undefined,
+		),
 		nestedRoute: context.params.nestedRoute,
 		onDetachedExit: (recovered) => context.onDetachedExit?.(flatIndex, recovered),
 		modelOverride: effectiveModel,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-types.ts

@@ -60,6 +60,7 @@ export interface ChainExecutionDetailsInput {
 export interface ChainExecutionParams {
 	chain: ChainStep[];
 	task?: string;
+	group?: string | true;
 	agents: AgentConfig[];
 	ctx: ExtensionContext;
 	intercomEvents?: IntercomEventBus;
@@ -98,6 +99,7 @@ export interface ChainExecutionResult {
 
 export interface ParallelChainRunInput {
 	step: ParallelStep;
+	chainIntercomGroup?: string | true;
 	parallelTemplates: string[];
 	parallelBehaviors: ResolvedStepBehavior[];
 	agents: AgentConfig[];

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-async.ts

@@ -18,6 +18,7 @@ import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-exec
 import { collectChainSessionFiles, wrapChainTasksForFork } from "./subagent-executor-input.ts";
 import { buildChainWorktreeTaskCwdError, buildParallelModeError, buildParallelWorktreeTaskCwdError } from "./subagent-executor-worktree.ts";
 import { requestSupervisorAuthorization, type SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
+import { inheritedIntercomGroup } from "../shared/intercom-group.ts";
 
 async function authorizeChild(deps: ResolvedExecutorDeps, childName: string | undefined): Promise<SupervisorAuthorization | undefined> {
 	return await requestSupervisorAuthorization(deps.pi.events, childName);
@@ -118,6 +119,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		currentModelProvider: ctx.model?.provider,
 		currentModel: currentModelFullId(ctx.model),
 		workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
+		intercomGroup: inheritedIntercomGroup(ctx),
 	};
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
@@ -138,6 +140,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 			agent: task.agent,
 			task: params.context === "fork" ? wrapForkTask(task.task) : task.task,
 			cwd: task.cwd,
+			group: task.group,
 			...(modelOverrides[index] ? { model: modelOverrides[index] } : {}),
 			...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
 			...(task.output === true ? (agentConfigs[index]?.output ? { output: agentConfigs[index]!.output } : {}) : task.output !== undefined ? { output: task.output } : {}),
@@ -151,10 +154,12 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		return deps.runtime.executeAsyncChain(id, {
 			chain: [{
 				parallel: parallelTasks,
+				group: params.group,
 				concurrency: resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency),
 				worktree: params.worktree,
 			}],
 			resultMode: "parallel",
+			group: params.group,
 			agents,
 			ctx: asyncCtx,
 			availableModels,
@@ -192,6 +197,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		return deps.runtime.executeAsyncChain(id, {
 			chain,
 			task: params.task,
+			group: params.group,
 			agents,
 			ctx: asyncCtx,
 			availableModels,
@@ -241,6 +247,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		return deps.runtime.executeAsyncSingle(id, {
 			agent: params.agent!,
 			task: params.context === "fork" ? wrapForkTask(params.task ?? "") : (params.task ?? ""),
+			group: params.group,
 			agentConfig: a,
 			ctx: asyncCtx,
 			availableModels,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-chain.ts

@@ -37,6 +37,7 @@ export async function runChainPath(data: ExecutionContextData, deps: ResolvedExe
 	const chainResult = await executeChain({
 		chain,
 		task: params.task,
+		group: params.group,
 		agents,
 		ctx,
 		intercomEvents: deps.pi.events,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-resume.ts

@@ -7,6 +7,7 @@ import { readStatus } from "../../shared/utils.ts";
 import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../background/async-resume.ts";
 import { resolveSubagentRunId, type ResolvedSubagentRunId } from "../background/run-id-resolver.ts";
 import { toModelInfo } from "../../shared/model-info.ts";
+import { inheritedIntercomGroup } from "../shared/intercom-group.ts";
 import { resolveSingleProgress } from "../../shared/settings.ts";
 import {
 	createNestedRoute,
@@ -425,6 +426,7 @@ export async function resumeAsyncRun(input: {
 	const result = input.deps.runtime.executeAsyncSingle(runId, {
 		agent: target.agent,
 		task: buildRevivedAsyncTask(target, followUp),
+		group: input.params.group,
 		agentConfig,
 		progress: resolveSingleProgress(agentConfig, input.params.progress, followUp),
 		ctx: {
@@ -433,6 +435,7 @@ export async function resumeAsyncRun(input: {
 			currentSessionId: input.deps.state.currentSessionId,
 			currentModelProvider: input.ctx.model?.provider,
 			currentModel: currentModelFullId(input.ctx.model),
+			intercomGroup: inheritedIntercomGroup(input.ctx),
 			workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
 		},
 		cwd: effectiveCwd,

package/dist/builtin/subagents/src/runs/shared/mcp-direct-tool-allowlist.ts

@@ -10,7 +10,6 @@ const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "search", "ls", "mcp"]);
 const GENERIC_GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".config", "mcp", "mcp.json");
 const IMPORT_PATHS = {
-	cursor: [path.join(os.homedir(), ".cursor", "mcp.json")],
 	"claude-code": [
 		path.join(os.homedir(), ".claude", "mcp.json"),
 		path.join(os.homedir(), ".claude.json"),
@@ -193,7 +192,7 @@ function resolveImportPath(importKind: ImportKind, cwd: string): string | null {
 function extractServers(config: unknown, kind: ImportKind): Record<string, ServerEntry> {
 	if (!config || typeof config !== "object" || Array.isArray(config)) return {};
 	const obj = config as Record<string, unknown>;
-	const servers = kind === "cursor" || kind === "windsurf" || kind === "vscode"
+	const servers = kind === "windsurf" || kind === "vscode"
 		? obj.mcpServers ?? obj["mcp-servers"]
 		: obj.mcpServers;
 	return servers && typeof servers === "object" && !Array.isArray(servers) ? servers as Record<string, ServerEntry> : {};

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -8,6 +8,7 @@ export interface RunnerSubagentStep {
 	label?: string;
 	outputName?: string;
 	structured?: boolean;
+	intercomGroup?: string;
 	cwd?: string;
 	model?: string;
 	thinking?: string;

package/dist/builtin/subagents/src/runs/shared/pi-args.ts

@@ -272,10 +272,12 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	// own supervisor authority to a descendant that lacks a freshly issued grant.
 	env[SUBAGENT_SUPERVISOR_CAPABILITY_ENV] = input.supervisorAuthorization?.capability ?? "";
 	env[SUBAGENT_SUPERVISOR_SESSION_ID_ENV] = input.supervisorAuthorization?.supervisorSessionId ?? "";
-	// Only assign an intercom group when the child actually has intercom access
-	// (peer intercom session name OR contact_supervisor orchestrator target).
+	// Assign a workflow/explicit group only when the child has Intercom access;
+	// otherwise clear ambient group state so a restricted child receives none.
 	const hasIntercomAccess = Boolean(input.intercomSessionName || input.orchestratorIntercomTarget);
-	if (input.intercomGroup && hasIntercomAccess) {
+	if (!hasIntercomAccess) {
+		env[INTERCOM_GROUP_ENV] = "";
+	} else if (input.intercomGroup) {
 		env[INTERCOM_GROUP_ENV] = input.intercomGroup;
 	}
 	if (input.runId) {

package/dist/builtin/subagents/src/shared/settings.ts

@@ -55,6 +55,7 @@ export interface SequentialStep {
 	progress?: boolean;
 	skill?: string | string[] | false;
 	model?: string;
+	group?: string | true;
 }
 
 /** Parallel task item within a parallel step */
@@ -73,6 +74,7 @@ export interface ParallelTaskItem {
 	progress?: boolean;
 	skill?: string | string[] | false;
 	model?: string;
+	group?: string | true;
 }
 
 export interface DynamicExpandSpec {
@@ -101,6 +103,7 @@ export interface DynamicParallelStep {
 	failFast?: boolean;
 	phase?: string;
 	label?: string;
+	group?: string | true;
 }
 
 /** Parallel step: multiple agents running concurrently */
@@ -110,6 +113,7 @@ export interface ParallelStep {
 	concurrency?: number;
 	failFast?: boolean;
 	worktree?: boolean;
+	group?: string | true;
 }
 
 /** Union type for chain steps */

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.11-alpha.5",
+  "version": "0.9.11-alpha.7",
   "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": [
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.81.1"
+    "@earendil-works/pi-tui": "^0.82.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,49 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.11-alpha.6] - 2026-07-28
+
+### Added
+
+- Added opt-in `ctx.tool(..., { failureMode: "return" })` outcomes for checks that may fail during repair flows. Exhausted callback failures now preserve bounded, best-effort redacted `exitCode`, `stdout`, and `stderr` as typed durable data; replay returns the same outcome without rerunning the callback; failed tool nodes remain truthful while explicit downstream repair and bounded reruns continue; and default failures, cancellation, admission errors, and storage faults still throw ([#1993](https://github.com/bastani-inc/atomic/issues/1993)).
+- Re-added the built-in Goal and Ralph workflows, including their typed composition exports, command metadata, focused tests, and user-facing docs.
+- Added a run-contract discipline to every builtin workflow. Only the user may change a run's contract: mid-run steering, follow-ups, and resume text are authoritative amendments, while agents may never widen the contract themselves. A new steering propagation contract requires each stage to restate the amendments it received under a `Contract amendments received` heading in its handoff, keep them separate from its own observations, treat inherited amendments as contract clauses rather than out-of-scope work, and resolve ambiguity through `intercom` before implementing. Every bundled workflow wraps its run context once through `withSteeringPropagationContext` (exported from `@bastani/workflows/builtin/steering-context`), so `ctx.task`, `ctx.chain`, and `ctx.parallel` prompts carry the contract automatically and a stage added later inherits it. Without propagation an implementer builds to an amended contract while reviewers still score the launch contract and mark the added work as unrequested scope.
+- Added a scope discipline contract to builtin implementation stages: freeze the acceptance criteria before writing code, stop when they pass, trace every addition to a criterion, keep a deferred list instead of a growing diff, prefer the smallest diff that satisfies the contract, and report the contract, per-criterion evidence, and deferred items at the end.
+- Added a draft handoff for `ralph` runs that exhaust their review budget. When `create_pr` is enabled and the loop ends without unanimous approval, the run now opens a provider-native draft pull request that reproduces every unresolved blocking finding with priority, objective alignment, and cited `file:line`, states the iteration count, and requests no reviewers. Previously the branch was left unpushed with no handoff. Runs without `create_pr` still never touch a pull request, approved or not.
+
+### Removed
+
+- Removed the parenthesized context-window authoring token from workflow model strings. `(1m)`, `(1.1m)`, `(936k)`, and the generic `(long)` marker are no longer parsed from `model` / `fallbackModels` entries, and the `contextWindow` / `contextWindowStrict` stage options are gone. Builtin workflow model policies now use plain ids such as `github-copilot/claude-opus-4.8:high`, and every stage session uses its model's catalog context window.
+
+### Changed
+
+- Cleaned up workflow overlay status chrome. The orchestrator pane no longer echoes the host `MCP: <n>/<n> servers` count in its statusline, and attaching to a stage no longer adds a `pi-workflows/<workflow>/<stage>` tag next to the footer statuses in stage chat. Other extension statuses, such as async subagent progress, still render in the orchestrator statusline.
+- Changed workflow stage chat to render Atomic's exact one-cell `∀` with a pronounced, theme-aware dark → accent → bright/bold → accent → dark luminance ramp at 88ms and the ordinary one-row working geometry, while preserving `NO_COLOR` weight activity, reduced-motion static accent styling, blocked/prompt chrome suppression, composer space, and factual-state precedence.
+- Workflow invocations now assign a stable, non-`default` Intercom group from the persistent top-level run identity and apply it to every Intercom-capable stage by default. Nested workflows, model fallback, pause/resume, durable replay, and subagent inheritance retain the group; separate runs remain isolated; explicit stage/task/parallel groups (including `"default"`) still override it; and stages without Intercom access remain ungrouped. Workflow authors no longer need to mint and thread group names manually ([#1999](https://github.com/bastani-inc/atomic/issues/1999)).
+- Strengthened workflow-authoring prompts and docs to require every dynamically materialized execution topology to remain a DAG, reject self-edges and ancestor back-edges before launch, unroll bounded loops into distinct tracked work, distinguish discovery diagnostics from runtime/replay/DBOS topology validation, and require topology sketches for branches, loops, and nested workflow boundaries ([#2012](https://github.com/bastani-inc/atomic/issues/2012)).
+- Changed model-visible workflow routing to triage multi-item implementation queues before launch, run independent items as bounded concurrent top-level workflows with separate worktrees and root failure boundaries, preserve ordered composition for real dependencies and clusters, and report per-item run/worktree/branch/results ([#2010](https://github.com/bastani-inc/atomic/issues/2010)).
+- 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 `github-copilot/claude-opus-5` and `openrouter/anthropic/claude-opus-5` mirrors added to every affected chain. Ralph's research and reviewer-B chains keep their GPT-5.6 primaries and gain Opus 5 fallbacks. Anthropic candidates now list the direct `anthropic/...` entry ahead of its `github-copilot/...` mirror, and `claude-fable-5` gains its missing Copilot mirror. Goal's orchestrator remains an exact local copy of Ralph's.
+- Reworked the shipped Goal, Ralph, Open Claude Design, and six pattern-workflow stage prompts for GPT-5.6, Claude Opus 5, and Claude Fable 5. Prompts now put artifacts before the final query, use explicit output and stop contracts, ground status claims in current tool evidence, damp unnecessary delegation, and request commands, observed results, and file:line evidence instead of internal reasoning; shared reviewer, acceptance, E2E/QA-video, and `stop_review_loop` derivation rules now have canonical definitions. This reduces repetition and avoids Claude Fable 5 `reasoning_extraction` refusals that could force model fallback while preserving schemas, convergence semantics, and exports.
+- Rewrote the bundled `prompt-engineer` skill and its three progressive-disclosure references for current GPT-5.6, Claude Opus 5, and Claude Fable 5 behavior, reducing them from 864 to 396 lines. Removed response-prefilling guidance that errors on Claude 4.6+, visible chain-of-thought as a primary technique, and generic self-check loops; added a delete-first optimization workflow, model-family guidance, agentic prompt structure, tool routing, adaptive-thinking effort and response-length controls, query-last long-context ordering, delegation damping, grounded reporting, and the Fable 5 `reasoning_extraction` hazard.
+
+### Fixed
+
+- Fixed the Ralph research stage destroying its own research artifact. The stage prompt told the agent to write the run's research file while the stage also declared that same path as its runner-owned `output`, so the runner overwrote the authored report with the stage's final chat message once the stage ended. Because `reads` passes a path rather than file content, the orchestrator and both reviewers then read a short pointer stub instead of the findings, and each loop re-derived context the research stage had already paid for. Research stages now return the full report as their final message and are explicitly told not to write the artifact path themselves; skill-owned notes under `research/docs/` and `research/web/` are unaffected.
+- Fixed the Classify-and-act, Fan-out-and-synthesize, Generate-and-filter, Loop-until-done, and Tournament workflows returning a whole terminal artifact into the calling session's context window. The first three set `outputMode: "file-only"` to keep the parent result compact and then read the saved file back with `readFile` before returning it, cancelling the saving; the last two declared `output` without `outputMode: "file-only"`, so the runner returned the full report text alongside the saved-file reference. Each `result` output is now the compact artifact reference, and the existing `action_path`, `synthesis_path`, `final_path`, and `result_path` outputs carry the full report for callers that want it. Passing file references rather than content is now the documented default for stage handoffs and workflow outputs alike.
+- Fixed admitted durable `ctx.tool(...)` callback and command failures being misclassified as killed/cancelled when no run cancellation won, including cancellation-shaped errors and wrappers with nested process evidence. First-event arbitration now preserves the first observed failure error and node even for concurrent same-value errors. Once the workflow body settles, an ordinary failure winner closes tool admission and cancels non-cooperative sibling nodes without needing an external kill; cancellation-first races still end killed. Failed resumable roots remain on the execution-resume path and win direct same-ID collisions with completed read-only history. Awaited and unawaited failures, concise nested command errors, root metadata, and selected tool links survive session and fresh DBOS inspection without becoming replay cache hits. Named interactive launches emit one failed lifecycle card and hidden reconciliation turn; prompt-start retries and restores reuse the card's atomic recovery marker, while status inspection and repeated startup binding do not duplicate it. Failed physical session appends now roll back partial single-entry and initial-batch writes to the exact prior file state, preventing malformed JSONL tails, duplicate IDs, phantom parents, and lost retry entries after reopen ([#2021](https://github.com/bastani-inc/atomic/issues/2021)).
+- Fixed durable nested `ctx.workflow(...)` resume and completed hydration across fresh processes. Atomic now persists an awaited, input-bound boundary-start identity before child dispatch, reuses stable boundary/child ids across reversed parallel ordering, keeps identical calls distinct by ordinal, scopes child checkpoint reads symmetrically at every nesting depth, and preserves source stage ids/order/parents/status and exact owner targets. Active and completed topology, boundary lifecycle transitions, and child results are validated atomically before cache/control/child dispatch; stale, aliased, cyclic, poisoned, or nonreciprocal records fail closed without repair execution. Completed child work and `ctx.tool(...)` effects remain exactly once, completed graphs remain root-catalog-only/read-only, retained child chat stays detached from execution, and ambiguous local stage ids or names no longer route to the first match.
+- Fixed workflow-supplied working-indicator palettes to quantize through Atomic's detected terminal color mode, preserving the intended phase progression in 256-color and conhost-like environments instead of forcing truecolor output.
+- Fixed controlled workflow pauses allowing queued or late-arriving work and continuation to run after a stage was visibly paused. Atomic's native session now establishes a synchronous raw queue hold before one serialized abort boundary; repeated pause and early resume share that boundary, abort failure rollback is explicitly observed and retried, and the existing resume action releases preserved steering, follow-up, duplicate, custom, async, and user-message entries exactly once. Clearing the final item never opens the gate. Existing custom adapters remain compatible without the optional native queue-pause methods and retain fallback abort/suspension behavior, including deferring runner-admitted public deliveries until resume. Fallback replacement installs an acyclic retirement forwarding fence before atomically moving raw/display/protected ownership source-first within each queue kind, serializes source and replacement interrupts through the live owner, clears the source, and leaves the target paused. Completed post-mortem stage chat resumes only its retained conversation queue on the next ordinary submission and never changes terminal workflow state ([#1983](https://github.com/bastani-inc/atomic/issues/1983)).
+- Fixed `ctx.tool()` calls durably completing side effects before a late empty-stage rejection. Tools now create ordered, inspectable, non-chat graph nodes with live, failed, completed, cancelled, and cached states; root completion waits for every admitted tool and promotes the first observed admitted failure left by a fulfilled body, while ordinary body rejections keep their exact error and link the selected matching failed tool when available; tool-only workflows complete normally; durable replay reconstructs and migrates topology without repeating callbacks; and completed tool-only runs open read-only without appearing stale or treating inspection as a new lifecycle transition. Terminal publication now atomically closes tool admission after admitted settlement continuations drain, so retained post-terminal calls reject before callbacks, retries, nodes, or checkpoints; rejected legacy child-topology annotation writes remain best-effort cache hits, do not poison DBOS flush, and retry on later replay; top-level status/session projections include nested tools with rewritten graph identity and explicit ownership; and completed retained-session stages remain chat-openable while tool nodes stay non-chat ([#1991](https://github.com/bastani-inc/atomic/issues/1991)).
+- Fixed live and restored nested `ctx.workflow()` graphs flattening valid child stages without preserving the authored composition topology. Hidden import boundaries now connect every boundary parent to every child root and every child terminal to downstream parent stages regardless of snapshot order; recursive one-level and deeper composition preserves sibling, sequential, parallel, and repeated child workflows; and boundaries with invalid, missing, empty, stale, mismatched, or recursively unusable child graphs, plus failed or skipped boundaries, retain the boundary summary rather than flattening an unrelated run. Duplicate child-local stage IDs and names keep distinct virtual IDs and exact owning `{runId, stageId}` targets across attach, messaging, pause, interrupt, resume, inspection, selection, and post-mortem chat, while nested runs remain excluded from top-level listings and ordinary workflow graph behavior is unchanged.
+- Fixed retained terminal stage chats dropping the Working indicator after Enter and before the follow-up agent turn started; the indicator now remains visible and animated throughout prompt attachment and processing without reviving stale terminal activity ([#1982](https://github.com/bastani-inc/atomic/issues/1982)).
+- Fixed programmatic `workflow send` reopening retained stage conversations after the authoritative root workflow had terminated. Completed, failed, skipped, cancelled, killed, and terminal-blocked roots now return a structured `WORKFLOW_TERMINAL` failure before stage or nested-owner resolution, prompt inspection, session probing/revival, handle lookup, admission, or delivery. Atomic rechecks the shared terminal authority at final synchronous SDK admission, including after awaited retained-session creation and paused or isolated-session resume setup; unsafe legacy handle delivery has no fallback. Terminal publication promptly unregisters and disposes an unclaimed provisional handle without waiting for hung session creation, late-created sessions are disposed, and handle replacement revokes stale admission while settling every provisional lease against one disposal. Prompt, model, tool, file, transcript, and workflow-snapshot side effects remain blocked. Live idle/streaming sends, pending-input answers, and explicit paused/interrupted resume remain available, while `/workflow attach` and Intercom can claim the retained handle and keep their explicit post-mortem chat paths ([#2009](https://github.com/bastani-inc/atomic/issues/2009)).
+
+### Removed
+
+- Removed Cursor model fallbacks and Cursor-branded Impeccable harness compatibility from shipped workflows and skills ([#1994](https://github.com/bastani-inc/atomic/issues/1994)).
+- Removed the built-in `deep-research-codebase` workflow.
+
 ## [0.9.11-alpha.5] - 2026-07-23
 
 ### Changed
@@ -58,6 +101,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - Fixed `workflow({ action: "resume", runId })` returning `Run not found` for eligible durably paused workflows after session-local run state was cleared. Explicit tool resume now resolves exact IDs and unique or ambiguous prefixes through the authoritative DBOS catalog before refusing the target, preserves original workflow IDs and checkpoint replay, and surfaces resource or durable lookup failures without making ordinary status listing hydrate durable history. ([#1924](https://github.com/bastani-inc/atomic/issues/1924))
 - Fixed session teardown crashing the process (exit code 1) after DBOS durability provisioning had failed: `shutdownDbos` re-awaited the memoized rejected configuration promise and rethrew the original provisioning error out of session dispose and the `beforeExit` hook, turning otherwise-successful `--print` runs into nonzero exits (surfacing as `NonZeroAgentExitCodeError` in eval harnesses). Shutdown is now a no-op for a backend that never reached readiness, and genuine teardown failures are logged instead of thrown.
 
+
 ## [0.9.10] - 2026-07-20
 
 ### Breaking Changes