@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-projection.ts

@@ -89,8 +89,6 @@ export function nestedSummaryFromAsyncStatus(
 		...(status.sessionId ? { sessionId: status.sessionId } : {}),
 		mode: status.mode ?? fallback.mode,
 		state: status.state,
-		...(status.currentStep !== undefined ? { currentStep: status.currentStep } : {}),
-		...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
 		...(status.activityState ? { activityState: status.activityState } : {}),
 		...(status.lastActivityAt !== undefined ? { lastActivityAt: status.lastActivityAt } : {}),
 		...(status.currentTool ? { currentTool: status.currentTool } : {}),

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-sanitize.ts

@@ -109,7 +109,7 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 			: {}),
 		...(stringValue(raw.controlInbox, 2048) ? { controlInbox: stringValue(raw.controlInbox, 2048) } : {}),
 		...(stringValue(raw.capabilityToken, 128) ? { capabilityToken: stringValue(raw.capabilityToken, 128) } : {}),
-		...(raw.mode === "single" || raw.mode === "parallel" || raw.mode === "chain" ? { mode: raw.mode } : {}),
+		...(raw.mode === "single" || raw.mode === "parallel" ? { mode: raw.mode } : {}),
 		...(stringValue(raw.agent, 128) ? { agent: stringValue(raw.agent, 128) } : {}),
 		...(Array.isArray(raw.agents)
 			? {
@@ -119,8 +119,6 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 						.slice(0, MAX_NESTED_STEPS),
 				}
 			: {}),
-		...(clampNumber(raw.currentStep) !== undefined ? { currentStep: clampNumber(raw.currentStep) } : {}),
-		...(clampNumber(raw.chainStepCount) !== undefined ? { chainStepCount: clampNumber(raw.chainStepCount) } : {}),
 		...(raw.activityState === "active_long_running" || raw.activityState === "needs_attention"
 			? { activityState: raw.activityState }
 			: {}),

package/dist/builtin/subagents/src/runs/shared/intercom-group.ts

@@ -1,8 +1,5 @@
 import { randomUUID } from "node:crypto";
-
-interface OrchestrationCarrier {
-	orchestrationContext?: { intercomGroup?: string } | undefined;
-}
+import { readRuntimeIntercomGroup } from "@bastani/atomic";
 
 /** Normalize agent-serialized auto-group sentinels without changing real group names. */
 export function normalizeAutoGroupSentinel(group: string | true | undefined): string | true | undefined {
@@ -11,15 +8,34 @@ export function normalizeAutoGroupSentinel(group: string | true | undefined): st
 	return sentinel === "true" || sentinel === "auto" ? true : group;
 }
 
-/** Read the inherited stage/session intercom group from the extension context (never from process.env). */
+/** Runtime joins are intentionally inherited before static child policy and stage context. */
+function runtimeIntercomGroup(sessionId: string | undefined): string | undefined {
+	return readRuntimeIntercomGroup(sessionId);
+}
+
+interface OrchestrationCarrier {
+	orchestrationContext?: { intercomGroup?: string } | undefined;
+	subagentPolicy?: { intercomGroup?: string } | undefined;
+	sessionManager?: { getSessionId(): string } | undefined;
+}
+
+/**
+ * Read the live joined group before the admitted child or static stage group. The runtime env
+ * entry is a deliberate exception to the no-process-env rule for admission capabilities: it
+ * carries only the current group so children launched after `join` follow their parent.
+ */
 export function inheritedIntercomGroup(ctx: OrchestrationCarrier | undefined): string | undefined {
+	const runtimeGroup = runtimeIntercomGroup(ctx?.sessionManager?.getSessionId());
+	if (runtimeGroup !== undefined) return runtimeGroup;
+	const policyGroup = ctx?.subagentPolicy?.intercomGroup;
+	if (typeof policyGroup === "string" && policyGroup.trim().length > 0) return policyGroup.trim();
 	const group = ctx?.orchestrationContext?.intercomGroup;
 	return typeof group === "string" && group.trim().length > 0 ? group.trim() : undefined;
 }
 
 /**
- * Resolve the intercom group for a spawned subagent child. Precedence:
- * explicit task/parallel/chain group > inherited current-session (stage) group.
+ * Resolve the intercom group for a spawned subagent child. Explicit task group
+ * takes precedence over the inherited current-session group.
  * `true` resolves to `sharedAutoGroup` (a single UUID minted once per parallel
  * set) so every child in the set shares one isolated group. Returns undefined
  * when nothing applies, so the child inherits env/config/default itself.

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

@@ -1,89 +1,3 @@
-import type { CodexFastModeResolvedSettings, CodexFastModeScope } from "@bastani/atomic";
-import type { ModelAttempt } from "../../shared/types.ts";
-
-export interface RunnerSubagentStep {
-	agent: string;
-	task: string;
-	phase?: string;
-	label?: string;
-	outputName?: string;
-	structured?: boolean;
-	intercomGroup?: string;
-	cwd?: string;
-	model?: string;
-	thinking?: string;
-	fastMode?: boolean;
-	modelFastModes?: Record<string, boolean>;
-	modelCandidates?: string[];
-	modelAttempts?: ModelAttempt[];
-	codexFastModeSettings?: CodexFastModeResolvedSettings;
-	codexFastModeScope?: CodexFastModeScope;
-	tools?: string[];
-	extensions?: string[];
-	mcpDirectTools?: string[];
-	systemPrompt?: string | null;
-	systemPromptMode?: "append" | "replace";
-	inheritProjectContext: boolean;
-	inheritSkills: boolean;
-	skills?: string[];
-	outputPath?: string;
-	outputMode?: "inline" | "file-only";
-	sessionFile?: string;
-	maxSubagentDepth?: number;
-	workflowStageSubagentGuard?: boolean;
-	structuredOutput?: {
-		schema: import("../../shared/types.ts").JsonSchemaObject;
-		schemaPath: string;
-		outputPath: string;
-	};
-	structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
-}
-
-export interface ParallelStepGroup {
-	parallel: RunnerSubagentStep[];
-	concurrency?: number;
-	failFast?: boolean;
-	worktree?: boolean;
-}
-
-export interface DynamicRunnerGroup {
-	expand: import("../../shared/settings.ts").DynamicExpandSpec;
-	parallel: RunnerSubagentStep;
-	collect: import("../../shared/settings.ts").DynamicCollectSpec;
-	concurrency?: number;
-	failFast?: boolean;
-	phase?: string;
-	label?: string;
-}
-
-export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;
-
-export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
-	return "parallel" in step && Array.isArray(step.parallel);
-}
-
-export function isDynamicRunnerGroup(step: RunnerStep): step is DynamicRunnerGroup {
-	return (
-		"expand" in step &&
-		"collect" in step &&
-		"parallel" in step &&
-		!Array.isArray((step as { parallel?: unknown }).parallel)
-	);
-}
-
-export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
-	const flat: RunnerSubagentStep[] = [];
-	for (const step of steps) {
-		if (isParallelGroup(step)) {
-			for (const task of step.parallel) flat.push(task);
-		} else if (isDynamicRunnerGroup(step)) {
-		} else {
-			flat.push(step);
-		}
-	}
-	return flat;
-}
-
 export async function mapConcurrent<T, R>(
 	items: T[],
 	limit: number,

package/dist/builtin/subagents/src/runs/shared/worktree.ts

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { createGitEnvironment } from "@bastani/atomic";
+import { createChildProcessEnvironment, createGitEnvironment } from "@bastani/atomic";
 import { performPostCreationSetup } from "./worktree-post-create.js";
 import { findCanonicalGitRoot } from "./worktree-root.js";
 export interface WorktreeSetup {
@@ -70,9 +70,13 @@ interface RepoState {
 	baseCommit: string;
 	baseRef: string;
 }
+
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", env: createGitEnvironment() });
+	const result = spawnSync("git", ["-C", cwd, ...args], {
+		encoding: "utf-8",
+		env: createGitEnvironment({}, createChildProcessEnvironment()),
+	});
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",
@@ -268,6 +272,7 @@ function runWorktreeSetupHook(hook: ResolvedWorktreeSetupHook, input: WorktreeSe
 		cwd: input.worktreePath,
 		encoding: "utf-8",
 		input: JSON.stringify(input),
+		env: createChildProcessEnvironment(),
 		timeout: hook.timeoutMs,
 		shell: false,
 	});

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

@@ -2,12 +2,8 @@
  * Formatting utilities for display output
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
 import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
-import type { ChainStep } from "./settings.ts";
-import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
-import type { SingleResult, Usage } from "./types.ts";
+import type { Usage } from "./types.ts";
 
 /**
  * Format token count with k suffix for large numbers
@@ -33,7 +29,7 @@ export function formatModelThinking(model?: string, thinking?: string, fastMode?
 /**
  * Format usage statistics into a compact string
  */
-export function formatUsage(u: Usage, model?: string): string {
+export function formatUsage(u: Usage): string {
 	const parts: string[] = [];
 	if (u.turns) parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
 	if (u.input) parts.push(`in:${formatTokens(u.input)}`);
@@ -41,7 +37,6 @@ export function formatUsage(u: Usage, model?: string): string {
 	if (u.cacheRead) parts.push(`R${formatTokens(u.cacheRead)}`);
 	if (u.cacheWrite) parts.push(`W${formatTokens(u.cacheWrite)}`);
 	if (u.cost) parts.push(`$${u.cost.toFixed(4)}`);
-	if (model) parts.push(model);
 	return parts.join(" ");
 }
 
@@ -59,55 +54,6 @@ export function formatDuration(ms: number): string {
 	return `${seconds}s`;
 }
 
-/**
- * Build a summary string for a completed/failed chain
- */
-export function buildChainSummary(
-	steps: ChainStep[],
-	results: SingleResult[],
-	chainDir: string,
-	status: "completed" | "failed",
-	failedStep?: { index: number; error: string },
-): string {
-	const stepNames = steps
-		.map((step) =>
-			isParallelStep(step)
-				? `parallel[${step.parallel.length}]`
-				: isDynamicParallelStep(step)
-					? `expand:${step.parallel.agent}`
-					: step.agent,
-		)
-		.join(" → ");
-
-	const totalDuration = results.reduce((sum, r) => sum + (r.progress?.durationMs || 0), 0);
-	const durationStr = formatDuration(totalDuration);
-
-	const progressPath = path.join(chainDir, "progress.md");
-	const hasProgress = fs.existsSync(progressPath);
-	const allSkills = new Set<string>();
-	for (const r of results) {
-		if (r.skills) {
-			for (const skill of r.skills) allSkills.add(skill);
-		}
-	}
-	const skillsLine = allSkills.size > 0 ? `🔧 Skills: ${[...allSkills].join(", ")}` : "";
-
-	if (status === "completed") {
-		const stepWord = results.length === 1 ? "step" : "steps";
-		return `✅ Chain completed: ${stepNames} (${results.length} ${stepWord}, ${durationStr})${skillsLine ? `\n${skillsLine}` : ""}
-
-📋 Progress: ${hasProgress ? progressPath : "(none)"}
-📁 Artifacts: ${chainDir}`;
-	} else {
-		const stepInfo = failedStep ? ` at step ${failedStep.index + 1}` : "";
-		const errorInfo = failedStep?.error ? `: ${failedStep.error}` : "";
-		return `❌ Chain failed${stepInfo}${errorInfo}${skillsLine ? `\n${skillsLine}` : ""}
-
-📋 Progress: ${hasProgress ? progressPath : "(none)"}
-📁 Artifacts: ${chainDir}`;
-	}
-}
-
 /**
  * Format a tool call for display
  */