@nghyane/arcane 0.1.8 → 0.1.11

package/src/prompts/tools/task.md

@@ -1,18 +1,12 @@
 # Task
 
-Launch subagents to execute parallel, well-scoped tasks.
+Launch a fire-and-forget subagent to execute well-scoped work. Think of it as a productive junior engineer who cannot ask follow-ups once started.
+- **Use for**: Multi-file implementations, cross-layer refactors, mass migrations, boilerplate generation
+- **Don't use for**: Exploratory work, architectural decisions, single-file edits, reading a file
 
-## What subagents inherit automatically
-Subagents receive the **full system prompt**, including AGENTS.md, context files, and skills. Do NOT repeat project rules, coding conventions, or style guidelines in `context` — they already have them.
+## Subagent capabilities
 
-## What subagents do NOT have
-Subagents have no access to your conversation history. They don't know:
-- Decisions you made but didn't write down
-- Which approach you chose among alternatives
-- What you learned from reading files during this session
-- Requirements the user stated only in conversation
-
-Subagents CAN grep the parent conversation file for supplementary details.
+Subagents receive the **full system prompt**, including AGENTS.md, context files, and skills. They have no access to your conversation history — they don't know decisions you made, approaches you chose, or requirements stated only in conversation. Subagents CAN grep the parent conversation file for supplementary details.
 ---
 
 ## Parameters
@@ -22,35 +16,18 @@ Subagents CAN grep the parent conversation file for supplementary details.
 Shared background prepended verbatim to every task `assignment`. Use only for session-specific information subagents lack.
 
 <critical>
-Do NOT include project rules, coding conventions, or style guidelines — subagents already have AGENTS.md and context files in their system prompt. Repeating them wastes tokens and inflates context. Restating any rule from AGENTS.md in `context` is a bug — treat it like a lint error.
+Do NOT include project rules, coding conventions, or style guidelines — subagents already have AGENTS.md. Restating any rule from AGENTS.md in `context` is a bug.
 </critical>
-**Before writing each line of context, ask:** "Would this sentence be true for ANY task in this repo, or only for THIS specific batch?" If it applies to any task → it's a project rule → the subagent already has it → delete the line.
-
-WRONG — restating project rules the subagent already has:
-```
-## Constraints
-- Use X import style, not Y (per AGENTS.md)
-- Use Z for private fields per AGENTS.md
-- Run the formatter after changes
-- Follow the logging convention
-```
-Every line above restates a project convention. The subagent reads AGENTS.md. Delete them all.
-
-RIGHT — only session-specific decisions the subagent cannot infer from project files:
-```
-## Constraints
-- We decided to use approach A over B (session decision)
-- The migration target type is `Foo` from `bar` package (looked up this session)
-```
+**Before writing each line of context, ask:** "Would this sentence be true for ANY task in this repo, or only for THIS specific batch?" If it applies to any task → the subagent already has it → delete the line.
 
 Use template; omit non-applicable sections:
 
 ````
 ## Goal
-One sentence: batch accomplishes together.
+One sentence: what the batch accomplishes together.
 
 ## Non-goals
-Explicitly exclude tempting scope — what tasks must not touch/attempt.
+Explicitly exclude tempting scope — what tasks must not touch.
 
 ## Constraints
 - Task-specific MUST / MUST NOT rules not already in AGENTS.md
@@ -58,49 +35,43 @@ Explicitly exclude tempting scope — what tasks must not touch/attempt.
 
 ## Reference Files
 - `path/to/file.ext` — pattern demo
-- `path/to/other.ext` — reuse or avoid
 
 ## API Contract (if tasks produce/consume shared interface)
 ```language
-// Exact type definitions, function signatures, interface shapes
+// Exact type definitions, function signatures
 ```
 
 ## Acceptance (global)
 - Definition of "done" for batch
-- Note: build/test/lint verification happens AFTER all tasks complete — not inside tasks (see below)
+- For parallel tasks, build/test/lint verification happens AFTER all tasks complete — not inside tasks. Single tasks may self-verify.
 ````
-**Belongs in `context`**: task-specific goal, non-goals, session decisions, reference paths, shared type definitions, API contracts, global acceptance commands — anything 2+ tasks need that isn't already in AGENTS.md.
-**Rule of thumb:** if repeat in 2+ tasks, belongs in `context`.
-**Does NOT belong in `context`**: project rules already in AGENTS.md/context files, per-task file lists, one-off requirements (go in `assignment`), and strict response contracts that only apply to one task.
+**Belongs in `context`**: session decisions, reference paths, shared type definitions, API contracts, global acceptance — anything 2+ tasks need that isn't in AGENTS.md.
+**Does NOT belong**: project rules from AGENTS.md, per-task file lists, one-off requirements (go in `assignment`).
 
 ### `tasks` (required)
 
-Array tasks execute in parallel.
+Array of tasks that execute in parallel.
 
 |Field|Required|Purpose|
 |---|---|---|
-|`id`|✓|CamelCase identifier, max 32 chars|
-|`description`|✓|Short one-liner for UI display only — not seen by subagent|
-|`assignment`|✓|Complete per-task instructions. See [Writing an assignment](#writing-an-assignment).|
-|`skills`||Skill names preload. Use only when changes correctness — don’t spam every task.|
-
-Outputs are free-form text/JSON from each subtask. If you need strict structure, define it clearly inside each `assignment` and validate at the caller.
+|`id`|yes|CamelCase identifier, max 32 chars|
+|`description`|yes|Short one-liner for UI display only — not seen by subagent|
+|`assignment`|yes|Complete per-task instructions (see below)|
+|`skills`||Skill names to preload. Use only when it changes correctness.|
 ---
 
 ## Writing an assignment
 
-<critical>## Task scope
-
-`assignment` must contain enough info for agent to act **without asking a clarifying question**.
-**Minimum bar:** assignment under ~8 lines or missing acceptance criteria = too vague. One-liners guaranteed failure.
+<critical>
+`assignment` must contain enough info for the subagent to act **without asking a clarifying question**. One-liners guarantee failure.
 
-Use structure every assignment:
+Use this structure:
 
 ```
 ## Target
 - Files: exact path(s)
 - Symbols/entrypoints: specific functions, types, exports
-- Non-goals: what task must NOT touch (prevents scope creep)
+- Non-goals: what task must NOT touch
 
 ## Change
 - Step-by-step: add/remove/rename/restructure
@@ -108,168 +79,68 @@ Use structure every assignment:
 
 ## Edge Cases / Don't Break
 - Tricky case 1: ...
-- Tricky case 2: ...
-- Existing behavior must survive: ...
+- Existing behavior that must survive: ...
 
 ## Acceptance (task-local)
 - Expected behavior or observable result
-- DO NOT include project-wide build/test/lint commands (see below)
+- For parallel tasks: DO NOT include project-wide build/test/lint commands
 ```
 
-`context` carries shared background. `assignment` carries only delta: file-specific instructions, local edge cases, per-task acceptance checks. Never duplicate shared constraints across assignments.
-
-### Anti-patterns (ban these)
-**Vague assignments** — agent guesses wrong or stalls:
-- "Refactor this to be cleaner."
-- "Migrate to N-API."
-- "Fix the bug in streaming."
-- "Update all constructors in `src/**/*.ts`."
-**Vague context** — forces agent invent conventions:
-- "Use existing patterns."
-- "Follow conventions."
-- "No WASM."
-**Redundant context** — wastes tokens repeating what subagents already have:
-- Restating AGENTS.md rules (coding style, import conventions, formatting commands, logger usage, etc.)
-- Repeating project constraints from context files
-- Listing tool/framework preferences already documented in the repo
-
-If a constraint appears in AGENTS.md, it MUST NOT appear in `context`. The subagent has the full system prompt.
-
-If tempted to write above, expand using templates.
-**Test/lint commands in parallel tasks** — edit wars:
-Parallel agents share working tree. If two agents run `bun check` or `bun test` concurrently, they see each other's half-finished edits, "fix" phantom errors, loop. **Never tell parallel tasks run project-wide build/test/lint commands.** Each task edits, stops. Caller verifies after all tasks complete.
-**If you can't specify scope yet**, create **Discovery task** first: enumerate files, find callsites, list candidates. Then fan out with explicit paths.
+`context` carries shared background. `assignment` carries only delta: file-specific instructions, local edge cases, per-task acceptance.
 
 ### Delegate intent, not keystrokes
 
-Your role as tech lead: set direction, define boundaries, call out pitfalls — then get out of way. Don’t read every file, decide every edit, dictate line-by-line. That makes you bottleneck; agent typist.
-**Be specific about:** constraints, naming conventions, API contracts, "don’t break" items, acceptance criteria.
-**Delegate:** code reading, approach selection, exact edit locations, implementation details. Agent has tools, can reason about code.
-
-Micromanaging (you think, agent types):
-```
-assignment: "In src/api/handler.ts, line 47, change `throw err` to `throw new ApiError(err.message, 500)`.
-On line 63, wrap fetch call try/catch return 502 on failure.
-On line 89, add null check before accessing resp.body..."
-```
-
-Delegating (agent thinks within constraints):
-```
-assignment: "## Target\n- Files: src/api/handler.ts\n\n## Change\nImprove error handling: replace raw throws
-with typed ApiError instances, add try/catch around external calls, guard against null responses.\n\n
-## Edge Cases / Don't Break\n- Existing error codes in tests must still match\n
-- Don't change public function signatures"
-```
-
-First style wastes your time, brittle if code shifts. Second gives agent room to do work.
+Your role is tech lead: set direction, define boundaries, call out pitfalls — then get out of the way. Don't dictate line-by-line edits.
+**Be specific about:** constraints, naming, API contracts, "don't break" items, acceptance criteria.
+**Delegate:** code reading, approach selection, exact edit locations, implementation details.
 </critical>
 
-## Example
-
-<example type="bad" label="Duplicated context inflates tokens">
-<tasks>
-  <task name="Grep">
-    <description>Port grep module from WASM to N-API...</description>
-    <assignment>Port grep module from WASM to N-API... (same blob repeated)</assignment>
-</task>
-</tasks>
-</example>
-
-<example type="good" label="Shared rules in context, only deltas in assignment">
-<context>
-## Goal
-Port WASM modules to N-API, matching existing arcane-natives conventions.
-
-## Non-goals
-Do not touch TS bindings or downstream consumers — separate phase.
-
-## Constraints
-- MUST use `#[napi]` attribute macro on all exports
-- MUST return `napi::Result<T>` for fallible ops; never panic
-- MUST use `spawn_blocking` for filesystem I/O or >1ms work
-...
-
-## Acceptance (global)
-- Caller verifies after all tasks: `cargo test -p arcane-natives` and `cargo build -p arcane-natives` with no warnings
-- Individual tasks must NOT run these commands themselves
-</context>
-
-<tasks>
-  <task name="PortGrep">
-    <description>Port grep module to N-API</description>
-    <assignment>
-## Target
-- Files: `src/grep.rs`, `src/lib.rs` (registration only)
-- Symbols: search, search_multi, compile_pattern
-
-## Change
-- Implement three N-API exports in grep.rs:
-  - `search(pattern: JsString, path: JsString, env: Env) -> napi::Result<Vec<Match>>`
-...
-
-## Acceptance (task-local)
-- Three functions exported with correct signatures (caller verifies build after all tasks)
-</assignment>
-</task>
-
-  <task name="PortHighlight">
-    <description>Port highlight module to N-API</description>
-    <assignment>
-## Target
-- Files: `src/highlight.rs`, `src/lib.rs` (registration only)
-...
-</assignment>
-</task>
-</tasks>
-</example>
+### Anti-patterns
+**Vague assignments** — subagent guesses wrong or stalls:
+- "Refactor this to be cleaner."
+- "Fix the bug in streaming."
+- "Update all constructors in `src/**/*.ts`."
+**Test/lint in parallel tasks** — edit wars:
+Parallel agents share working tree. If two agents run `bun check` concurrently, they see each other's half-finished edits, "fix" phantom errors, loop. **Never tell parallel tasks to run project-wide build/test/lint.** Each task edits, stops. Caller verifies after all complete. Single-task launches may include verification.
+**If you can't specify scope yet**, create a **Discovery task** first: enumerate files, find callsites, list candidates. Then fan out with explicit paths.
 ---
 
 ## Task scope
 
-Each task small, well-defined scope — **at most 3–5 files**.
-**Signs task too broad:**
-- File paths use globs (`src/**/*.ts`) instead of explicit names
-- Assignment says "update all" / "migrate everything" / "refactor across"
-- Scope covers entire package or directory tree
-**Fix:** enumerate files first (grep/glob discovery), then fan out one task per file or small cluster.
+Each task: small, well-defined — **at most 3-5 files**.
+**Signs task is too broad:** file paths use globs, assignment says "update all" / "migrate everything", scope covers entire package.
+**Fix:** enumerate files first (grep/glob), then fan out one task per file or small cluster.
 ---
 
 ## Parallelization
 **Test:** Can task B produce correct output without seeing task A's result?
 - **Yes** → parallelize
-- **No** → run sequentially (A completes, then launch B with A output in context)
+- **No** → sequential (A completes, then launch B with A's output in context)
 
 ### Must be sequential
 
 |First|Then|Reason|
 |---|---|---|
 |Define types/interfaces|Implement consumers|Consumers need contract|
-|Create API exports|Write bindings/callers|Callers need export names/signatures|
-|Scaffold structure|Implement bodies|Bodies need shape|
+|Create API exports|Write bindings/callers|Callers need signatures|
 |Core module|Dependent modules|Dependents import from core|
-|Schema/DB migration|Application logic|Logic depends on new schema shape|
 
 ### Safe to parallelize
 - Independent modules, no cross-imports
 - Tests for already-implemented code
 - Isolated file-scoped refactors
-- Documentation for stable APIs
-
-### Phased execution
 
-Layered work with dependencies:
-**Phase 1 — Foundation** (do yourself or single task): define interfaces, create scaffolds, establish API shape. Never fan out until contract known.
-**Phase 2 — Parallel implementation**: fan out tasks consuming same known interface. Include Phase 1 API contract in `context`.
+### Multi-phase pattern
+**Phase 1 — Sequential**: define shared contracts (types, interfaces, schemas).
+**Phase 2 — Parallel**: fan out tasks consuming same known interface.
 **Phase 3 — Integration** (do yourself): wire modules, fix mismatches, verify builds.
-**Phase 4 — Dependent layer**: fan out tasks consuming Phase 2 outputs.
 ---
 
 ## Pre-flight checklist
 
 Before calling tool, verify:
-- [ ] `context` includes only session-specific info not already in AGENTS.md/context files
-- [ ] Each `assignment` follows assignment template — not one-liner
-- [ ] Each `assignment` includes edge cases / "don’t break" items
-- [ ] Tasks truly parallel (no hidden dependencies)
-- [ ] Scope small, file paths explicit (no globs)
-- [ ] No task runs project-wide build/test/lint — you do after all tasks complete
+- [ ] `context` includes only session-specific info not already in AGENTS.md
+- [ ] Each assignment has Target, Change, Edge Cases, Acceptance sections
+- [ ] Assignments reference exact file paths (no globs)
+- [ ] Scope small, file paths explicit
+- [ ] Parallel tasks don't run project-wide build/test/lint — you do after all tasks complete (single tasks may self-verify)

package/src/prompts/tools/todo-write.md

@@ -18,11 +18,11 @@ Use proactively:
 	 - in_progress: working
 	 - completed: finished
 2. **Task Management**:
-   - Update status in real time
-   - Mark complete IMMEDIATELY after finishing (no batching)
-   - Keep exactly ONE task in_progress at a time
+   - Update status each turn
+   - Mark completed after each code execution finishes — do not defer to a later turn
+   - Multiple tasks may be in_progress simultaneously when working in parallel
    - Remove tasks no longer relevant
-   - Complete tasks in list order (do not mark later tasks completed while earlier tasks remain incomplete)
+   - Mark tasks completed as they finish, regardless of list order
 3. **Task Completion Requirements**:
    - ONLY mark completed when FULLY accomplished
    - On errors/blockers/inability to finish, keep in_progress

package/src/sdk.ts

@@ -72,6 +72,7 @@ import {
 	loadSshTool,
 	PythonTool,
 	ReadTool,
+	type SubagentContext,
 	setPreferredImageProvider,
 	setPreferredSearchProvider,
 	type Tool,
@@ -157,12 +158,8 @@ export interface CreateAgentSessionOptions {
 	/** Tool names explicitly requested (enables disabled-by-default tools) */
 	toolNames?: string[];
 
-	/** Output schema for structured completion (subagents) */
-	outputSchema?: unknown;
-	/** Whether to include the submit_result tool by default */
-	requireSubmitResultTool?: boolean;
-	/** Task recursion depth (for subagent sessions). Default: 0 */
-	taskDepth?: number;
+	/** Whether this is a subagent session. Default: false */
+	isSubagent?: boolean;
 	/** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */
 	parentTaskPrefix?: string;
 
@@ -223,6 +220,7 @@ export {
 	PythonTool,
 	ReadTool,
 	WriteTool,
+	type SubagentContext,
 	type ToolSession,
 };
 
@@ -629,8 +627,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// For subagent sessions using GitHub Copilot, add X-Initiator header
 	// to ensure proper billing (agent-initiated vs user-initiated)
-	const taskDepth = options.taskDepth ?? 0;
-	const forceCopilotAgentInitiator = taskDepth > 0;
+	const isSubagent = options.isSubagent ?? false;
+	const forceCopilotAgentInitiator = isSubagent;
 	if (forceCopilotAgentInitiator && model?.provider === "github-copilot") {
 		model = {
 			...model,
@@ -722,9 +720,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		contextFiles,
 		skills,
 		eventBus,
-		outputSchema: options.outputSchema,
-		requireSubmitResultTool: options.requireSubmitResultTool,
-		taskDepth: options.taskDepth ?? 0,
+		isSubagent: options.isSubagent ?? false,
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
 		getSessionId: () => sessionManager.getSessionId?.() ?? null,
 		getSessionSpawns: () => options.spawns ?? "*",
@@ -736,10 +732,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (model) return formatModelString(model);
 			return undefined;
 		},
-		getCompactContext: () => session.formatCompactContext(),
+		subagentContext: {
+			getCompactContext: () => session.formatCompactContext(),
+			authStorage,
+			modelRegistry,
+		},
 		settings,
-		authStorage,
-		modelRegistry,
 	};
 
 	// Initialize internal URL router for internal protocols (agent://, artifact://, memory://, skill://, rule://)
@@ -798,7 +796,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
-		toolSession.mcpManager = mcpManager;
+		if (!toolSession.subagentContext) toolSession.subagentContext = {};
+		toolSession.subagentContext.mcpManager = mcpManager;
 
 		// If we extracted Exa API keys from MCP configs and EXA_AARCANE_KEY isn't set, use the first one
 		if (mcpResult.exaApiKeys.length > 0 && !$env.EXA_AARCANE_KEY) {
@@ -1273,7 +1272,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		settings,
 		modelRegistry,
 		agentDir,
-		taskDepth,
+		isSubagent,
 	});
 
 	return {

package/src/session/session-manager.ts

@@ -124,8 +124,6 @@ export interface SessionInitEntry extends SessionEntryBase {
 	task: string;
 	/** Tools available to the agent */
 	tools: string[];
-	/** Output schema if structured output was requested */
-	outputSchema?: unknown;
 }
 
 /** Mode change entry - tracks agent mode transitions. */
@@ -1685,7 +1683,7 @@ export class SessionManager {
 	}
 
 	/** Append session init metadata (for subagent debugging/replay). Returns entry id. */
-	appendSessionInit(init: { systemPrompt: string; task: string; tools: string[]; outputSchema?: unknown }): string {
+	appendSessionInit(init: { systemPrompt: string; task: string; tools: string[] }): string {
 		const entry: SessionInitEntry = {
 			type: "session_init",
 			id: generateId(this.#byId),

package/src/task/executor.ts

@@ -107,7 +107,7 @@ export interface ExecutorOptions {
 	id: string;
 	modelOverride?: string | string[];
 	thinkingLevel?: ThinkingLevel;
-	taskDepth?: number;
+	isSubagent?: boolean;
 	enableLsp?: boolean;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
@@ -682,7 +682,7 @@ export async function runAgent(options: ExecutorOptions): Promise<SingleResult>
 				sessionManager,
 				hasUI: false,
 				spawns: "",
-				taskDepth: (options.taskDepth ?? 0) + 1,
+				isSubagent: true,
 				parentTaskPrefix: id,
 				enableLsp: lspEnabled,
 				skipPythonPreflight,

package/src/task/index.ts

@@ -93,7 +93,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 
 		try {
 			await fs.mkdir(effectiveArtifactsDir, { recursive: true });
-			const compactContext = this.session.getCompactContext?.();
+			const compactContext = this.session.subagentContext?.getCompactContext?.();
 			let contextFilePath: string | undefined;
 			if (compactContext) {
 				contextFilePath = path.join(effectiveArtifactsDir, "context.md");
@@ -164,7 +164,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 				description: rendered.description,
 				index: 0,
 				id: uniqueId,
-				taskDepth: this.session.taskDepth ?? 0,
+				isSubagent: true,
 				modelOverride,
 				sessionFile,
 				persistArtifacts: !!artifactsDir,
@@ -177,10 +177,10 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 					progressMap.set(0, { ...structuredClone(progress) });
 					emitProgress();
 				},
-				authStorage: this.session.authStorage,
-				modelRegistry: this.session.modelRegistry,
+				authStorage: this.session.subagentContext?.authStorage,
+				modelRegistry: this.session.subagentContext?.modelRegistry,
 				settings: this.session.settings,
-				mcpManager: this.session.mcpManager,
+				mcpManager: this.session.subagentContext?.mcpManager,
 				contextFiles,
 				skills: resolvedSkills,
 				preloadedSkills,

package/src/task/types.ts

@@ -24,26 +24,13 @@ export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
 /** EventBus channel for aggregated subagent progress */
 export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
 
-/** Single task item for parallel execution */
-export const taskItemSchema = Type.Object({
-	id: Type.String({
-		description: "CamelCase identifier, max 32 chars",
-		maxLength: 32,
-	}),
-	description: Type.String({
-		description: "Short one-liner for UI display only — not seen by the subagent",
-	}),
-	assignment: Type.String({
-		description:
-			"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.",
-	}),
-	skills: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "Skill names to preload into the subagent. Use only where it changes correctness.",
-		}),
-	),
-});
-export type TaskItem = Static<typeof taskItemSchema>;
+/** Single task item for execution */
+export interface TaskItem {
+	id: string;
+	description: string;
+	assignment: string;
+	skills?: string[];
+}
 
 /** Task schema — single task with optional context */
 export const taskSchema = Type.Object({

package/src/tools/index.ts

@@ -31,7 +31,6 @@ import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { ReviewerTool } from "./reviewer-tool";
 import { loadSshTool } from "./ssh";
-import { SubmitResultTool } from "./submit-result";
 import { TodoWriteTool } from "./todo-write";
 import { UndoEditTool } from "./undo-edit";
 import { WriteTool } from "./write";
@@ -94,7 +93,6 @@ export { OracleTool } from "./oracle";
 export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
 export { ReadTool, type ReadToolDetails, type ReadToolInput } from "./read";
 export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
-export { SubmitResultTool } from "./submit-result";
 export { type TodoItem, TodoWriteTool, type TodoWriteToolDetails } from "./todo-write";
 export { UndoEditTool, type UndoEditToolDetails } from "./undo-edit";
 export { WriteTool, type WriteToolDetails, type WriteToolInput } from "./write";
@@ -108,6 +106,14 @@ export type ContextFileEntry = {
 	depth?: number;
 };
 
+/** Forwarded context for spawning subagent processes */
+export interface SubagentContext {
+	authStorage?: import("../session/auth-storage").AuthStorage;
+	modelRegistry?: import("../config/model-registry").ModelRegistry;
+	mcpManager?: import("../mcp/manager").MCPManager;
+	getCompactContext?: () => string;
+}
+
 /** Session context for tool factories */
 export interface ToolSession {
 	/** Current working directory */
@@ -128,12 +134,8 @@ export interface ToolSession {
 	hasEditTool?: boolean;
 	/** Event bus for tool/extension communication */
 	eventBus?: EventBus;
-	/** Output schema for structured completion (subagents) */
-	outputSchema?: unknown;
-	/** Whether to include the submit_result tool by default */
-	requireSubmitResultTool?: boolean;
-	/** Task recursion depth (0 = top-level, 1 = first child, etc.) */
-	taskDepth?: number;
+	/** Whether this session is a subagent (spawned by task tool) */
+	isSubagent?: boolean;
 	/** Get session file */
 	getSessionFile: () => string | null;
 	/** Get session ID */
@@ -148,20 +150,14 @@ export interface ToolSession {
 	getModelString?: () => string | undefined;
 	/** Get the current session model string, regardless of how it was chosen */
 	getActiveModelString?: () => string | undefined;
-	/** Auth storage for passing to subagents (avoids re-discovery) */
-	authStorage?: import("../session/auth-storage").AuthStorage;
-	/** Model registry for passing to subagents (avoids re-discovery) */
-	modelRegistry?: import("../config/model-registry").ModelRegistry;
-	/** MCP manager for proxying MCP calls through parent */
-	mcpManager?: import("../mcp/manager").MCPManager;
+	/** Context for spawning subagent processes (only used by task/subagent tools) */
+	subagentContext?: SubagentContext;
 	/** Internal URL router for agent:// and skill:// URLs */
 	internalRouter?: InternalUrlRouter;
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
-	/** Get compact conversation context for subagents (excludes tool results, system prompts) */
-	getCompactContext?: () => string;
 }
 
 type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
@@ -191,10 +187,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	write: s => new WriteTool(s),
 };
 
-export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
-	submit_result: s => new SubmitResultTool(s),
-};
-
 export type ToolName = keyof typeof BUILTIN_TOOLS;
 
 export type PythonToolMode = "ipy-only" | "bash-only" | "both";
@@ -232,7 +224,6 @@ function getPythonModeFromEnv(): PythonToolMode | null {
  */
 export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
 	time("createTools:start");
-	const includeSubmitResult = session.requireSubmitResultTool === true;
 	const enableLsp = session.enableLsp ?? true;
 	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
 	const pythonMode = getPythonModeFromEnv() ?? session.settings.get("python.toolMode");
@@ -278,12 +269,12 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	) {
 		requestedTools.push("bash");
 	}
-	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS };
 	const isToolAllowed = (name: string) => {
 		if (name === "lsp") return enableLsp;
 		if (name === "bash") return allowBash;
 		if (name === "python") return allowPython;
-		if (name === "todo_write") return !includeSubmitResult && session.settings.get("todo.enabled");
+		if (name === "todo_write") return session.settings.get("todo.enabled");
 		if (name === "find") return session.settings.get("find.enabled");
 		if (name === "grep") return session.settings.get("grep.enabled");
 		if (name === "notebook") return session.settings.get("notebook.enabled");
@@ -295,25 +286,17 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "librarian") return session.settings.get("librarian.enabled");
 		if (name === "oracle") return session.settings.get("oracle.enabled");
 		if (name === "task") {
-			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
-			const currentDepth = session.taskDepth ?? 0;
-			return maxDepth < 0 || currentDepth < maxDepth;
+			return !session.isSubagent;
 		}
 		return true;
 	};
-	if (includeSubmitResult && requestedTools && !requestedTools.includes("submit_result")) {
-		requestedTools.push("submit_result");
-	}
 
 	const filteredRequestedTools = requestedTools?.filter(name => name in allTools && isToolAllowed(name));
 
 	const entries =
 		filteredRequestedTools !== undefined
 			? filteredRequestedTools.map(name => [name, allTools[name]] as const)
-			: [
-					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
-					...(includeSubmitResult ? ([["submit_result", HIDDEN_TOOLS.submit_result]] as const) : []),
-				];
+			: [...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name))];
 
 	const results = await Promise.all(
 		entries.map(async ([name, factory]) => {