@bastani/atomic 0.9.16-alpha.1 → 0.9.16-alpha.3

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

@@ -1,11 +0,0 @@
-export const DEFAULT_PROMPT_GUIDANCE: string[] = [
-	`**Subagent orchestration**: Use subagents for focused specialist work inside workflows or as bounded delegation when a workflow would be unnecessary overhead.
-  - Because workflows are the default for non-trivial structured work with verifiable objectives, do not stretch parent-controlled subagent calls into an ad hoc implementation, review, or retry pipeline; use a workflow and let its stages delegate specialists.
-  - Use a single subagent for a focused specialty or parallel tasks for independent work. Keep substantial-overlap tasks together rather than duplicating investigation across agents.
-  - Delegate noisy or context-heavy command investigation when isolation helps, but run concise commands inline when that is simpler.
-  - Foreground execution is the only subagent execution mode; do not duplicate a delegated job while waiting. Workflow stages may still run their own durable work in the background.
-  - 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.
-  - Workflow stages automatically receive their invocation-scoped Intercom group, and delegated children inherit the launching session's group across single, parallel, 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/extension/schemas.ts

@@ -1,208 +0,0 @@
-/**
- * TypeBox schemas for subagent tool parameters
- */
-
-import { Type } from "typebox";
-import { MAX_PARALLEL_TASKS, SUBAGENT_ACTIONS } from "../shared/types.js";
-
-const SkillOverride = Type.Unsafe({
-	anyOf: [{ type: "array", items: { type: "string" } }, { type: "boolean" }, { type: "string" }],
-	description:
-		"Skill name(s) to inject (comma-separated), array of strings, or boolean (false disables, true uses default)",
-});
-
-const OutputOverride = Type.Unsafe({
-	anyOf: [{ type: "string" }, { type: "boolean" }],
-	description: "Output filename/path (string), or false to disable file output",
-});
-
-const OutputModeOverride = Type.String({
-	enum: ["inline", "file-only"],
-	description:
-		"Return saved output inline (default) or only a concise file reference. file-only requires output to be a path.",
-});
-
-const ReadsOverride = Type.Unsafe({
-	anyOf: [{ type: "array", items: { type: "string" } }, { type: "boolean" }],
-	description: "Files to read before running (array of filenames), or false to disable",
-});
-
-const RootReadsOverride = Type.Unsafe({
-	anyOf: [
-		{ type: "array", items: { type: "string" } },
-		{ type: "boolean", enum: [false] },
-	],
-	description:
-		"Files for a single agent to read before running, or false to disable. Relative paths resolve against the effective child cwd.",
-});
-
-const MaxOutputSchema = Type.Object(
-	{
-		bytes: Type.Optional(Type.Number()),
-		lines: Type.Optional(Type.Number()),
-	},
-	{ additionalProperties: false },
-);
-
-const GroupSchema = Type.Union([Type.String(), Type.Boolean()], {
-	description:
-		"Intercom group for spawned children. A named string joins that group; boolean `true` or the trimmed, case-insensitive string sentinel `true`/`auto` auto-generates one shared UUID group per parallel set. The names `true` and `auto` are reserved; use a different literal group name. Defaults to the current session/stage's group. Only applied when the child has intercom access; contact_supervisor still reaches the supervisor across groups.",
-});
-
-const TaskItem = Type.Object({
-	agent: Type.String(),
-	task: Type.String(),
-	cwd: Type.Optional(Type.String()),
-	count: Type.Optional(
-		Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." }),
-	),
-	output: Type.Optional(OutputOverride),
-	outputMode: Type.Optional(OutputModeOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
-	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
-	skill: Type.Optional(SkillOverride),
-	group: Type.Optional(GroupSchema),
-});
-
-const ControlOverrides = Type.Object({
-	enabled: Type.Optional(
-		Type.Boolean({ description: "Enable/disable subagent control attention tracking for this run" }),
-	),
-	needsAttentionAfterMs: Type.Optional(
-		Type.Integer({ minimum: 1, description: "No-observed-activity window before a run needs attention" }),
-	),
-	activeNoticeAfterMs: Type.Optional(
-		Type.Integer({ minimum: 1, description: "Active-long-running notice threshold by elapsed ms (default: 240000)" }),
-	),
-	activeNoticeAfterTurns: Type.Optional(
-		Type.Integer({
-			minimum: 1,
-			description: "Optional active-long-running notice threshold by assistant turns (disabled by default)",
-		}),
-	),
-	activeNoticeAfterTokens: Type.Optional(
-		Type.Integer({
-			minimum: 1,
-			description: "Optional active-long-running notice threshold by total tokens (disabled by default)",
-		}),
-	),
-	failedToolAttemptsBeforeAttention: Type.Optional(
-		Type.Integer({
-			minimum: 1,
-			description: "Consecutive mutating-tool failures before escalating to needs_attention (default: 3)",
-		}),
-	),
-	progressScores: Type.Optional(
-		Type.Array(Type.Number(), {
-			description: "Optional injected progress scores used only to raise attention priority; never a run outcome.",
-		}),
-	),
-	notifyOn: Type.Optional(
-		Type.Array(Type.String({ enum: ["active_long_running", "needs_attention"] }), {
-			description:
-				"Control event types that should notify the parent/orchestrator. Defaults to active_long_running and needs_attention.",
-		}),
-	),
-	notifyChannels: Type.Optional(
-		Type.Array(Type.String({ enum: ["event", "intercom"] }), {
-			description: "Notification channels to use when available. Defaults to event and intercom.",
-		}),
-	),
-});
-
-export const SubagentParams = Type.Object(
-	{
-		agent: Type.Optional(
-			Type.String({ description: "Agent name (SINGLE mode) or target for management get/update/delete" }),
-		),
-		task: Type.Optional(Type.String({ description: "Task (SINGLE mode, optional for self-contained agents)" })),
-		// Management action (when present, tool operates in management mode)
-		action: Type.Optional(
-			Type.String({
-				enum: [...SUBAGENT_ACTIONS],
-				description: "Management/control action. Omit for execution mode.",
-			}),
-		),
-		id: Type.Optional(Type.String({ description: "Run id or prefix for action='status' or action='interrupt'." })),
-		runId: Type.Optional(
-			Type.String({
-				description:
-					"Target run ID for action='interrupt'. Defaults to the most recently active controllable run. Prefer id for new calls.",
-			}),
-		),
-		config: Type.Optional(
-			Type.Unsafe({
-				anyOf: [{ type: "object", additionalProperties: true }, { type: "string" }],
-				description: `Agent config for create/update. Agent: name, package (optional namespace; runtime name becomes package.name), description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress. String values must be valid JSON.`,
-			}),
-		),
-		tasks: Type.Optional(
-			Type.Array(TaskItem, {
-				maxItems: MAX_PARALLEL_TASKS,
-				description: `PARALLEL mode: [{agent, task, count?, output?, outputMode?, reads?, progress?}, ...]. Maximum ${MAX_PARALLEL_TASKS} tasks after count expansion.`,
-			}),
-		),
-		concurrency: Type.Optional(
-			Type.Integer({
-				minimum: 1,
-				description:
-					"Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or 4.",
-			}),
-		),
-		group: Type.Optional(GroupSchema),
-		worktree: Type.Optional(
-			Type.Boolean({
-				description:
-					"Create isolated git worktrees for each parallel task. " +
-					"Prevents filesystem conflicts. Requires clean git state. " +
-					"Per-worktree diffs included in output.",
-			}),
-		),
-		context: Type.Optional(
-			Type.String({
-				enum: ["fresh", "fork"],
-				description:
-					"'fresh' or 'fork' to branch from parent session. If omitted, any requested agent with defaultContext: 'fork' makes the whole invocation forked; otherwise the default is 'fresh'.",
-			}),
-		),
-		agentScope: Type.Optional(
-			Type.String({
-				description:
-					"Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)",
-			}),
-		),
-		cwd: Type.Optional(Type.String()),
-		maxOutput: Type.Optional(MaxOutputSchema),
-		artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
-		includeProgress: Type.Optional(Type.Boolean({ description: "Include full progress in result (default: false)" })),
-		share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist for sharing (default: false)" })),
-		sessionDir: Type.Optional(
-			Type.String({
-				description: "Directory to store session logs (default: temp; enables sessions even if share=false)",
-			}),
-		),
-		control: Type.Optional(ControlOverrides),
-		// Solo agent overrides
-		output: Type.Optional(
-			Type.Unsafe({
-				anyOf: [{ type: "string" }, { type: "boolean" }],
-				description:
-					"Output file for single agent (string), or false to disable. Relative paths resolve against cwd.",
-			}),
-		),
-		outputMode: Type.Optional(OutputModeOverride),
-		reads: Type.Optional(RootReadsOverride),
-		progress: Type.Optional(
-			Type.Boolean({
-				description:
-					"Enable run-scoped progress.md tracking for a single agent under isolated artifact storage, without writing progress.md into the child cwd. This controls the child-maintained file; includeProgress separately controls whether detailed runtime telemetry is returned.",
-			}),
-		),
-		skill: Type.Optional(SkillOverride),
-		model: Type.Optional(
-			Type.String({ description: "Override model for single agent (e.g. 'anthropic/claude-sonnet-4')" }),
-		),
-	},
-	{ additionalProperties: false },
-);

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -1,133 +0,0 @@
-import * as path from "node:path";
-import type { ExtensionContext } from "@bastani/atomic";
-import { cleanupOldSubagentRuntimeDirs } from "../runs/inprocess/runtime-support/temp-cleanup.js";
-import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.js";
-import type { SubagentState } from "../shared/types.js";
-
-export interface SubagentStartupMaintenance {
-	scheduleStartupCleanup(): void;
-	cleanupSessionArtifactsDeferred(ctx: ExtensionContext): void;
-	stop(): void;
-}
-
-/** How long after startup to defer the slow global session-artifact scan. */
-export const STARTUP_ARTIFACT_SCAN_DELAY_MS = 10 * 60 * 1000;
-
-function scheduleMacrotask(task: () => void): () => void {
-	let cancelled = false;
-	const handle = setImmediate(() => {
-		if (!cancelled) task();
-	});
-	handle.unref?.();
-	return () => {
-		cancelled = true;
-		clearImmediate(handle);
-	};
-}
-
-function scheduleDelayedTask(task: () => void, delayMs: number): () => void {
-	let cancelled = false;
-	const handle = setTimeout(() => {
-		if (!cancelled) task();
-	}, delayMs);
-	handle.unref?.();
-	return () => {
-		cancelled = true;
-		clearTimeout(handle);
-	};
-}
-
-function swallowCleanup(task: () => void): void {
-	try {
-		task();
-	} catch {}
-}
-
-interface StartupMaintenanceOptions {
-	artifactCleanupDays: number;
-	resultsDir?: string;
-	resultTtlMs?: number;
-	scheduleMacrotask?: (task: () => void) => () => void;
-	scheduleDelayed?: (task: () => void, delayMs: number) => () => void;
-}
-
-export function createSubagentStartupMaintenance(
-	state: SubagentState,
-	options: StartupMaintenanceOptions,
-): SubagentStartupMaintenance;
-export function createSubagentStartupMaintenance(
-	_pi: unknown,
-	state: SubagentState,
-	options: StartupMaintenanceOptions,
-): SubagentStartupMaintenance;
-export function createSubagentStartupMaintenance(
-	_first: SubagentState | unknown,
-	second: StartupMaintenanceOptions | SubagentState,
-	third?: StartupMaintenanceOptions,
-): SubagentStartupMaintenance {
-	const options = third ?? (second as StartupMaintenanceOptions);
-	const cancelTasks = new Set<() => void>();
-	let contextSessionsRoots: readonly string[] | undefined;
-	const noteSessionContext = (ctx: ExtensionContext): void => {
-		try {
-			if (ctx.sessionManager.usesDefaultSessionDir()) {
-				contextSessionsRoots = undefined;
-				return;
-			}
-			const sessionDir = ctx.sessionManager.getSessionDir();
-			if (!sessionDir) return;
-			const parent = path.dirname(sessionDir);
-			const safeCwd = `--${path
-				.resolve(ctx.cwd)
-				.replace(/^[/\\]/, "")
-				.replace(/[/\\:]/g, "-")}--`;
-			contextSessionsRoots =
-				path.basename(parent) === "sessions" && path.basename(sessionDir) === safeCwd ? [parent] : [];
-		} catch {
-			// A stale or partial context leaves cleanup on the last validated root.
-		}
-	};
-	const schedule = (task: () => void): void => {
-		const cancel = (options.scheduleMacrotask ?? scheduleMacrotask)(() => {
-			cancelTasks.delete(cancel);
-			task();
-		});
-		cancelTasks.add(cancel);
-	};
-	const scheduleDelayed = (task: () => void, delayMs: number): void => {
-		const cancel = (options.scheduleDelayed ?? scheduleDelayedTask)(() => {
-			cancelTasks.delete(cancel);
-			task();
-		}, delayMs);
-		cancelTasks.add(cancel);
-	};
-
-	return {
-		scheduleStartupCleanup() {
-			schedule(() => {
-				swallowCleanup(() => cleanupOldSubagentRuntimeDirs(options.artifactCleanupDays));
-				scheduleDelayed(
-					() => swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays, contextSessionsRoots)),
-					STARTUP_ARTIFACT_SCAN_DELAY_MS,
-				);
-			});
-		},
-		cleanupSessionArtifactsDeferred(ctx) {
-			noteSessionContext(ctx);
-			let sessionFile: string | null | undefined;
-			try {
-				sessionFile = ctx.sessionManager.getSessionFile();
-			} catch {
-				return;
-			}
-			if (!sessionFile) return;
-			schedule(() =>
-				swallowCleanup(() => cleanupOldArtifacts(getArtifactsDir(sessionFile), options.artifactCleanupDays)),
-			);
-		},
-		stop() {
-			for (const cancel of cancelTasks) cancel();
-			cancelTasks.clear();
-		},
-	};
-}

package/dist/builtin/subagents/src/extension/tool-description.ts

@@ -1,19 +0,0 @@
-export const SUBAGENT_TOOL_DESCRIPTION = `Delegate bounded specialist work to subagents or manage agent definitions while the parent remains in control.
-EXECUTION (use exactly ONE mode):
-• Execution calls always start non-interactively.
-• Before executing, use { action: "list" } to inspect configured agents. Only execute agents listed as executable/non-disabled.
-• SINGLE: { agent, task?, progress? } - one focused task; progress:true maintains a run-scoped progress.md under isolated artifact storage without writing it into the child cwd (separate from includeProgress, which only returns runtime telemetry); omit task for self-contained agents
-• PARALLEL: { tasks: [{agent,task,count?,output?,reads?,progress?}, ...], concurrency?: number, worktree?: true } - independent concurrent tasks (worktree: isolate each task in a git worktree)
-• Optional context: { context: "fresh" | "fork" } (default: if any requested agent has defaultContext: "fork", the whole invocation uses fork; otherwise "fresh"; inspect agent defaults via { action: "list" })
-• group (string | true) sets the intercom group for spawned children so same-group subagents can intercom each other but stay isolated from other groups. Boolean true or the trimmed, case-insensitive string sentinel "true"/"auto" auto-generates one shared UUID group per parallel set; those names are reserved and cannot be literal group names. Defaults to the current session/stage's group (subagents inherit their launching stage's group). Only applied when the child has intercom access; contact_supervisor still reaches the supervisor across groups.
-MANAGEMENT (use action field, omit agent/task/tasks):
-• { action: "list" } - discover executable agents
-• { action: "get", agent: "name" } - full detail; packaged agents use dotted runtime names like "package.agent"
-• { action: "create", config: { name: "custom-agent", package: "code-analysis", systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext, ... } }
-• { action: "update", agent: "code-analysis.custom-agent", config: { package: "analysis", ... } } - merge
-• { action: "delete", agent: "code-analysis.custom-agent" }
-CONTROL:
-• { action: "status", id: "..." } - inspect an in-process run by id or prefix
-• { action: "interrupt", id?: "..." } - soft-interrupt the current child turn; the child is terminal for continuation, so follow-up work starts a fresh launch
-DIAGNOSTICS:
-• { action: "doctor" } - read-only report for runtime paths, discovery, sessions, and intercom`;

package/dist/builtin/subagents/src/extension/tool-rendering.ts

@@ -1,53 +0,0 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { type Component, Container, Text } from "@earendil-works/pi-tui";
-import { getBurstDisplay } from "../runs/foreground/subagent-executor-burst-display.js";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor-types.js";
-import type { Details } from "../shared/types.js";
-import { renderLiveSubagentResult } from "../tui/render.js";
-
-type Theme = Parameters<typeof renderLiveSubagentResult>[2];
-type RenderContext = Parameters<typeof renderLiveSubagentResult>[3] & { toolCallId: string };
-
-function effectiveParallelTaskCount(tasks: Array<{ count?: unknown }> | undefined): number {
-	if (!tasks || tasks.length === 0) return 0;
-	return tasks.reduce((total, task) => {
-		const count = typeof task.count === "number" && Number.isInteger(task.count) && task.count >= 1 ? task.count : 1;
-		return total + count;
-	}, 0);
-}
-
-export function renderSubagentToolCall(args: SubagentParamsLike, theme: Theme, context: RenderContext): Component {
-	const burst = getBurstDisplay(context.toolCallId);
-	if (burst && !burst.owner) return new Container();
-	if (args.action) {
-		const target = args.agent || "";
-		return new Text(
-			`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`,
-			0,
-			0,
-		);
-	}
-	if (burst) {
-		return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${burst.taskCount})`, 0, 0);
-	}
-	const isParallel = (args.tasks?.length ?? 0) > 0;
-	const parallelCount = effectiveParallelTaskCount(args.tasks as Array<{ count?: unknown }> | undefined);
-	return new Text(
-		isParallel
-			? `${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})`
-			: `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}`,
-		0,
-		0,
-	);
-}
-
-export function renderSubagentToolResult(
-	result: AgentToolResult<Details>,
-	options: { expanded: boolean; isPartial: boolean },
-	theme: Theme,
-	context: RenderContext,
-): Component {
-	const burst = getBurstDisplay(context.toolCallId);
-	if (burst && !burst.owner) return new Container();
-	return renderLiveSubagentResult(burst?.result ?? result, options, theme, context);
-}