@xl0/pi-lovely-agents 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [0.1.2] - 2026-09-10
+
+### Breaking Changes
+
+- Keep discarded task files at their original paths and return `taskDirectory` with `state: "discarded"` from `task_discard`.
+
+### Added
+
+- Retrieve retained results by run index with `task_output(run: N)`, including after discard, and identify runs in results and completion notices.
+- Browse non-discarded tasks through an `active/` index and safely prune discarded tasks with the dry-run-first `scripts/prune-tasks.ts` command.
+- Report child progress in task inspection and the panel with `task_update` without notifying the parent.
+- Scroll live output with keyboard navigation, Bash tail-following, and visible exit codes or termination signals.
+- Read shorter Bash output tails with `task_output(lines: N)`.
+
+### Changed
+
+- Group Agents and Bash separately and list active tasks first.
+- Show the latest Bash output in UTF-8-safe completion previews.
+- Clarify Steer acceptance and Follow-up conversion, and expose process-wide capacity and Bash queue reasons.
+- Guide agents to delegate independent implementation work and keep coupled changes in the parent.
+
+### Fixed
+
+- Keep output waits attached to the selected run across Follow-ups.
+- Deliver pending completion notifications for discarded tasks.
+- Prevent another Pi process from claiming tasks whose cleanup failed.
+
 ## [0.1.1] - 2026-09-06
 
 - Publish through GitHub Actions with npm provenance.

package/README.md

@@ -83,14 +83,19 @@ agents get the normal tools and extensions; a role description is not a sandbox.
 
 Open **`/lovely-agents` → Tasks**, or press **Down with an empty editor** to focus
 the task list below it.
+Agents and Bash appear in separate groups, active tasks first within each group.
 
 - **Arrow keys** select a task; **Enter** opens its actions.
-- **Live output** shows what it has produced so far.
+- **Live output** scrolls with arrows, PgUp/PgDn, Home/End. Bash opens at the
+  bottom and follows new output; scrolling up pauses following, End resumes it.
+  Its fixed header includes the exit code and termination signal.
 - **Inputs / history** shows earlier requests and results.
 - **Follow-up** adds another request after the agent's current work.
-- **Steer** redirects work already in progress.
+- **Steer** queues input for a live streaming run. Without a live target it becomes
+  a Follow-up; foreground busy tasks reject it. Queued input can be lost on stop.
 - **Stop** cancels the work but keeps its files. An agent can take a new request later.
-- **Discard** stops and archives it, removing it from the list. It does not delete the files.
+- **Discard** stops it and removes it from active work. Files stay in place and
+  results remain readable, but it cannot receive new input.
 - **Esc** returns to the editor.
 
 You can also ask Pi directly:
@@ -102,6 +107,14 @@ You can also ask Pi directly:
 Tool calls and notifications are compact by default. **Ctrl+O** expands their
 full contents.
 
+Children can call `task_update({ progress: "Root cause found; testing the fix" })`
+to report meaningful milestones or blockers in up to 240 characters. Progress
+replaces the initial-input preview in the panel and appears in task inspection.
+It does not rename the task, change its lifecycle state, notify or wake the parent.
+Each new run clears the report; earlier reports remain with their run's result.
+Default-tool children get this tool automatically. If a Definition has an explicit
+`tools` list, include `task_update` to allow progress reporting.
+
 ## Background Bash
 
 Ask Pi to run a long command in the background:
@@ -110,6 +123,8 @@ Ask Pi to run a long command in the background:
 
 The command appears alongside agent tasks. You can inspect its output or stop
 it from the same menu. Normal, short Bash commands still work as before.
+Detached completion automatically notifies Pi and wakes an idle parent.
+Synchronous completion and explicit stops do not send a completion notice.
 
 For a command that needs input, **Write stdin** sends exactly what you type;
 include a newline if the command expects one. **Close stdin** sends EOF: “there
@@ -131,6 +146,8 @@ work running. Turning either switch off does not stop tasks already accepted.
 Agent work and Bash jobs have separate concurrency limits, both initially 4.
 Extra work queues until a slot is free. Pi initially waits up to 30 seconds for
 an agent result before leaving it in the background.
+These limits are shared process-wide, not per conversation. The roster reports
+held/max execution permits; task lists show only the current parent's tasks.
 
 Under **Models**, choose additional models Pi may use for agents. You can also
 configure these optional shortcuts:
@@ -152,10 +169,16 @@ Long results aren't lost. Pi's output-reading tool returns at most **2,000 lines
 or 50 KiB** at a time, with a truncation notice and a file path when capped.
 These are snapshots, not pages to assemble by repeatedly reading. Full agent
 replies are in `history.md`; full Bash output is in `output.log`.
+Each agent assignment has a 1-based run index, shown in tool results and notices.
+`task_output(id, run: 2)` retrieves that run even after later Follow-ups start.
+Omit `run` for the current snapshot; `lines: 20` requests a shorter Bash tail.
+Older runs completed before this feature may require reading `history.md`.
 
 If Pi asks to wait for a result, the wait ends when the run finishes, pauses on
 a provider limit, or reaches the requested timeout. A timeout returns the
 latest output—it does not stop the task.
+The wait stays attached to the selected run; a later Follow-up cannot replace
+its answer. Prefer completion notices or a meaningful wait over short polling.
 
 Tasks belong to the Pi conversation that started them. **`/reload` keeps work
 running; quitting or switching conversations stops it.** After a crash, lost
@@ -168,8 +191,24 @@ an error or was aborted, **`/continue`** resumes it and eligible paused agents.
 
 Task files live in `.pi/lovely-agents/` under your working directory and are
 ignored by Git. They include conversation history and command output, so treat
-them as potentially sensitive. Discarded tasks move to its `archive/` directory;
-there is no automatic deletion.
+them as potentially sensitive. Each task keeps its original
+`<parent-session>/<task-id>/` path. The parent's `active/` directory links to all
+non-discarded tasks, including idle specialists. It is a browsing index, rebuilt
+when that parent is reopened—not the authority for execution or deletion.
+Keep tasks until dependent work is integrated, then discard what is no longer
+needed. Existing old `archive/` contents are left untouched.
+
+There is no automatic deletion. From the package checkout/install directory:
+
+```bash
+bun scripts/prune-tasks.ts /path/to/workspace          # dry-run
+bun scripts/prune-tasks.ts /path/to/workspace --apply  # permanently delete eligible tasks
+```
+
+Pruning requires closed parent sessions and retains non-discarded tasks, pending
+notifications, unknown/corrupt records, and unsafe or still-needed descendants.
+Missing `active/` links never authorize deletion. Crash leftovers stay until
+their parent is reopened; abandoned sessions are not automatically collected.
 
 ## Development
 

package/extensions/lovely-agents/agent.ts

@@ -29,7 +29,6 @@ import {
 	type AgentTaskMetadata,
 	acquireParentLease,
 	appendHistoryLog,
-	archivedTaskStoragePaths,
 	displayWorkspacePath,
 	ensureParentStorage,
 	initializeRetainedLogs,
@@ -82,6 +81,7 @@ export function recoverProviderTuple(tuple: ModelTuple): number {
 
 export type AgentCreationResult = {
 	id: string
+	run: number
 	label: string
 	definition: string
 	state: TaskMetadata["state"]
@@ -98,8 +98,10 @@ export type AgentCreationResult = {
 
 export type TaskInputResult = {
 	id: string
+	run: number
 	requestedDelivery: "followup" | "steer" | undefined
 	effectiveDelivery: "followup" | "steer" | "stdin"
+	conversionReason?: string
 	queuePosition: number | null
 	state: TaskMetadata["state"]
 	latestOutcome: TaskMetadata["latestOutcome"]
@@ -304,7 +306,7 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 				const detached = waitMs === 0 ? await wait() : await coordinator.withLentPermit(wait, signal)
 				const loaded = await readTaskMetadata(paths)
 				if (loaded.status !== "ok") throw new Error(`Could not read accepted task ${paths.taskRef}`)
-				const output = await readRetainedOutput(paths)
+				const output = await readRetainedOutput(paths, { run: 1 })
 				const tasks = (await loadTaskList(ctx.cwd, parentSessionId)).details
 				return buildAgentCreationToolResult(loaded.metadata, detached, output, tasks)
 			} finally {
@@ -340,7 +342,11 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 				? "Write literal stdin to a running Bash task"
 				: "Send input to an owned task",
 		promptGuidelines: [
-			...(agentInput ? ["Use Follow-up for later work; use Steer only to redirect a currently running agent."] : []),
+			...(agentInput
+				? [
+						"Use task_input Follow-up for a new run; Steer queues input for a live streaming run. Without a live steering target, Steer becomes a Follow-up (foreground busy tasks reject it). Acceptance does not guarantee observation before stop."
+					]
+				: []),
 			...(bashInput ? ["For Bash, omit delivery and write literal stdin; eof closes stdin without restarting the command."] : [])
 		],
 		parameters: Type.Object(
@@ -383,12 +389,12 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 						type: "text",
 						text:
 							result.effectiveDelivery === "stdin"
-								? `${result.id}: stdin delivered${params.eof ? " (EOF)" : ""}`
+								? `${result.id} run=${result.run}: stdin delivered${params.eof ? " (EOF)" : ""}`
 								: result.effectiveDelivery === "steer"
-									? `${result.id}: steer delivered (${result.state}; ${result.queuedFollowUps} Follow-ups queued)`
+									? `${result.id} run=${result.run}: steer queued for current run`
 									: result.output
-										? `${result.id}: followup ${result.latestOutcome}\n${result.output.text}`
-										: `${result.id}: followup accepted (position ${result.queuePosition}; ${result.state}; ${result.queuedFollowUps} queued)`
+										? `${result.id} run=${result.run}: ${result.conversionReason ? `requested steer -> followup (${result.conversionReason}); ` : ""}followup ${result.latestOutcome}\n${result.output.text}`
+										: `${result.id} run=${result.run}: ${result.conversionReason ? `requested steer -> ` : ""}followup accepted${result.conversionReason ? `; ${result.conversionReason}` : ""} (position ${result.queuePosition}; task=${result.state}; ${result.queuedFollowUps} queued)`
 					}
 				],
 				details: result
@@ -403,12 +409,12 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 			description:
 				action === "stop"
 					? "Stop active or queued work for an owned Agent or Bash task while preserving its files."
-					: "Stop and permanently discard an owned task subtree, archiving its files. Unsupported metadata versions can also be archived.",
+					: "Stop and permanently discard an owned task subtree from active work. Files stay at their original paths for read-only inspection. Unsupported metadata versions can also be discarded.",
 			promptSnippet: action === "stop" ? "Stop work for a durable task" : "Discard a durable task",
 			promptGuidelines:
 				action === "discard"
 					? [
-							"After consuming an agent's results, use task_discard if no Follow-up is expected. Keep reusable specialists; do not discard agents whose results are still needed."
+							"Use task_discard after dependent work is integrated and no Follow-up is expected. Keep reusable specialists and tasks whose results are still needed; idle agents already unload."
 						]
 					: [],
 			parameters: Type.Object(
@@ -426,7 +432,7 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 							type: "text",
 							text:
 								action === "discard"
-									? `${details.id}: discarded (files archived at ${details.archiveDirectory})`
+									? `${details.id}: discarded (files retained at ${details.taskDirectory})`
 									: `${details.id}: stop complete (${details.state}; outcome ${details.latestOutcome ?? "none"}; ${details.queuedFollowUps} queued)`
 						}
 					],
@@ -472,6 +478,7 @@ export async function sendTaskInput(
 		if (current.status !== "ok") throw new Error(`Could not read accepted task ${id}`)
 		return {
 			id,
+			run: accepted.run,
 			requestedDelivery,
 			effectiveDelivery: accepted.delivery,
 			queuePosition: accepted.queuePosition,
@@ -500,6 +507,8 @@ export async function sendTaskInput(
 	if (current.status !== "ok") throw new Error(`Could not read accepted task ${id}`)
 	return {
 		id,
+		run: accepted.run,
+		...(accepted.conversionReason ? { conversionReason: accepted.conversionReason } : {}),
 		requestedDelivery: delivery,
 		effectiveDelivery: accepted.delivery,
 		queuePosition: accepted.queuePosition,
@@ -515,15 +524,14 @@ export async function controlTaskLifecycle(ctx: ExtensionContext, id: string, ac
 	const paths = taskStoragePaths(lease.paths, id)
 	if (action === "discard") {
 		await discardTask(paths)
-		const archived = archivedTaskStoragePaths(paths)
 		return {
 			id,
 			action,
-			state: "archived",
+			state: "discarded",
 			latestOutcome: null,
 			discarded: true,
 			queuedFollowUps: 0,
-			archiveDirectory: displayWorkspacePath(ctx.cwd, archived.taskDirectory)
+			taskDirectory: displayWorkspacePath(ctx.cwd, paths.taskDirectory)
 		}
 	}
 	let loaded = await readTaskMetadata(paths)
@@ -542,7 +550,7 @@ export async function controlTaskLifecycle(ctx: ExtensionContext, id: string, ac
 		latestOutcome: metadata.latestOutcome,
 		discarded: metadata.discardedAt !== null,
 		queuedFollowUps: metadata.queuedFollowUps.length,
-		archiveDirectory: undefined,
+		taskDirectory: displayWorkspacePath(ctx.cwd, paths.taskDirectory),
 		paths: retainedPaths(paths)
 	}
 }
@@ -716,7 +724,12 @@ class AgentRuntime implements ResidentAgent {
 						if (index >= 0) this.#pendingSteers.splice(index, 1)
 						throw error
 					}
-					result = { delivery: "steer", queuePosition: null, queuedFollowUps: metadata.queuedFollowUps.length }
+					result = {
+						run: metadata.activeRun.sequence,
+						delivery: "steer",
+						queuePosition: null,
+						queuedFollowUps: metadata.queuedFollowUps.length
+					}
 					return metadata
 				}
 				if (
@@ -733,7 +746,13 @@ class AgentRuntime implements ResidentAgent {
 				const runId = createRunId()
 				const acceptanceOrder = getAgentCoordinator().nextAcceptanceOrder()
 				const queuePosition = metadata.activeRun ? metadata.queuedFollowUps.length + 1 : 1
-				result = { delivery: "followup", queuePosition, queuedFollowUps: metadata.queuedFollowUps.length + 1 }
+				result = {
+					run: sequence,
+					delivery: "followup",
+					queuePosition,
+					queuedFollowUps: metadata.queuedFollowUps.length + 1,
+					...(delivery === "steer" ? { conversionReason: `task ${metadata.state}, no live stream to steer` } : {})
+				}
 				acceptedRun = {
 					id: runId,
 					sequence,
@@ -892,7 +911,8 @@ class AgentRuntime implements ResidentAgent {
 						})
 					}
 					this.#awaitingPrimaryInput = true
-					await this.#child.session.prompt(
+					await this.#child.prompt(
+						run.id,
 						recovering ? "Continue." : run.input,
 						childPromptOptions(recovering ? false : this.#expandPromptTemplates)
 					)
@@ -1003,7 +1023,15 @@ class AgentRuntime implements ResidentAgent {
 			const activeRun = metadata.activeRun
 			if (activeRun?.id !== run.id) return clearFollowUps ? { ...metadata, queuedFollowUps: [], updatedAt: timestamp } : metadata
 			won = true
-			completed = { ...metadata, state: "idle", latestOutcome: outcome, activeRun: null, queuedFollowUps: [], updatedAt: timestamp }
+			completed = {
+				...metadata,
+				state: "idle",
+				latestOutcome: outcome,
+				lastSettledRun: run.sequence,
+				activeRun: null,
+				queuedFollowUps: [],
+				updatedAt: timestamp
+			}
 			if (
 				activeRun.background &&
 				(outcome === "succeeded" || outcome === "failed") &&
@@ -1285,10 +1313,11 @@ function buildAgentCreationToolResult(
 	if (metadata.kind !== "agent") throw new Error("Expected an Agent task")
 	const result: AgentCreationResult = {
 		id: metadata.taskRef,
+		run: 1,
 		label: metadata.label,
 		definition: metadata.definitionName,
-		state: metadata.state,
-		latestOutcome: metadata.latestOutcome,
+		state: output.state,
+		latestOutcome: output.latestOutcome,
 		model: `${metadata.model.provider}/${metadata.model.id}`,
 		thinking: metadata.thinking,
 		depth: metadata.depth,
@@ -1305,6 +1334,7 @@ function buildAgentCreationToolResult(
 				type: "text",
 				text: [
 					`task: ${result.id}`,
+					`run: ${result.run}`,
 					`state: ${result.state}`,
 					...(output.queueReason
 						? [`waiting: ${output.queueReason} (${output.capacity.active}/${output.capacity.limit} execution permits)`]

package/extensions/lovely-agents/bash.ts

@@ -51,6 +51,7 @@ const BashParameters = Type.Object(
 export type BashToolInput = Static<typeof BashParameters>
 export type BashCreationResult = {
 	id: string
+	run: number
 	label: string
 	state: BashTaskMetadata["state"]
 	latestOutcome: BashTaskMetadata["latestOutcome"]
@@ -69,6 +70,7 @@ export function registerBashTool(pi: ExtensionAPI, options: { getConfig: () => A
 		promptSnippet: "Run a background Bash command with durable output and task controls",
 		promptGuidelines: [
 			"Use bash_bg for background shell work, not as a replacement for normal bash. Use task_list/task_output/task_stop/task_discard with its b_ ID.",
+			"Detached bash_bg tasks automatically notify you on success or failure and wake an idle parent; no completion polling is needed. Synchronous completion and explicit stops do not notify.",
 			"Use task_input on a running bash_bg task for literal stdin, optionally eof:true to close stdin; agent Follow-up/Steer modes are not supported. Commands never restart automatically."
 		],
 		parameters: BashParameters,
@@ -176,6 +178,7 @@ export function registerBashTool(pi: ExtensionAPI, options: { getConfig: () => A
 				if (loaded.status !== "ok" || loaded.metadata.kind !== "bash") throw new Error(`Could not read accepted task ${paths.taskRef}`)
 				const result: BashCreationResult = {
 					id: paths.taskRef,
+					run: 1,
 					label: loaded.metadata.label,
 					state: loaded.metadata.state,
 					latestOutcome: loaded.metadata.latestOutcome,
@@ -188,7 +191,7 @@ export function registerBashTool(pi: ExtensionAPI, options: { getConfig: () => A
 					content: [
 						{
 							type: "text" as const,
-							text: `${result.id} ${JSON.stringify(result.label)}: ${result.state}${result.latestOutcome ? ` / ${result.latestOutcome}` : ""}${detached ? " (detached)" : ""}\n${result.output.text}`
+							text: `${result.id} run=1 ${JSON.stringify(result.label)}: ${result.state}${result.latestOutcome ? ` / ${result.latestOutcome}` : ""}${detached ? " (detached)" : ""}${result.output.queueReason ? ` waiting=${result.output.queueReason}` : ""}\n${result.output.text}`
 						}
 					],
 					details: result
@@ -346,7 +349,7 @@ class BashRuntime implements ResidentAgent {
 				this.fail(error)
 				throw error
 			}
-			return { delivery: "stdin" as const, queuePosition: null, queuedFollowUps: 0 }
+			return { run: 1, delivery: "stdin" as const, queuePosition: null, queuedFollowUps: 0 }
 		})
 		this.#inputLane = operation.catch(() => {})
 		if (!options.signal) return operation

package/extensions/lovely-agents/child-session.ts

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks"
 import { lstat, open } from "node:fs/promises"
 import {
 	type AgentSession,
@@ -12,10 +13,12 @@ import {
 	SettingsManager,
 	type Skill
 } from "@earendil-works/pi-coding-agent"
+import { Type } from "typebox"
+import { Value } from "typebox/value"
 import { MODEL_ALIASES, type ModelAliasChoice } from "./config.js"
 import { getAgentCoordinator } from "./coordinator.js"
 import type { AgentDefinition, AgentThinkingLevel } from "./definitions.js"
-import type { TaskStoragePaths } from "./state.js"
+import { mutateTaskMetadata, TaskProgressSchema, type TaskStoragePaths } from "./state.js"
 
 const PROMPT_EXTENSION_PATH = "<inline:lovely-agent-prompt>"
 const CREATION_TOOL_NAMES = new Set(["agent"])
@@ -51,6 +54,8 @@ export type ChildSessionHandle = {
 	extensionsResult: LoadExtensionsResult
 	depth: number
 	allowAgents: boolean
+	/** Binds tool execution to this immutable run, including delayed async callbacks. */
+	prompt(runId: string, text: string, options?: PromptOptions): Promise<void>
 	dispose(): void
 }
 
@@ -126,6 +131,8 @@ export async function createChildSession(options: CreateChildSessionOptions): Pr
 	const agentDir = options.agentDir ?? getAgentDir()
 	const settingsManager = SettingsManager.create(options.cwd, agentDir)
 	settingsManager.setProjectTrusted(options.projectTrusted)
+	const runContext = new AsyncLocalStorage<string>()
+	const lifetime = new AbortController()
 	const resourceLoader = new DefaultResourceLoader({
 		cwd: options.cwd,
 		agentDir,
@@ -137,6 +144,40 @@ export async function createChildSession(options: CreateChildSessionOptions): Pr
 				name: "lovely-agent-prompt",
 				hidden: true,
 				factory(pi) {
+					pi.registerTool({
+						name: "task_update",
+						label: "Task Update",
+						description:
+							"Report a short progress line for your own current task run (up to 240 characters). Does not change its label or lifecycle state, or notify the parent.",
+						promptSnippet: "Update your task's progress in the panel and task inspection",
+						promptGuidelines: [
+							"Use task_update for meaningful phase changes or blockers: what is achieved and what remains. Do not report every tool call or invent percentages. Updates do not interrupt or wake the parent."
+						],
+						parameters: Type.Object({ progress: TaskProgressSchema }, { additionalProperties: false }),
+						async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+							const runId = runContext.getStore()
+							if (!runId) throw new Error("task_update requires a managed task run")
+							if (!Value.Check(TaskProgressSchema, params.progress)) throw new Error("progress must be 1–240 characters")
+							const progress = params.progress.replace(/\s+/g, " ").trim()
+							if (!progress || /\p{Cc}/u.test(progress)) throw new Error("progress must be nonempty text without control characters")
+							const childSessionId = ctx.sessionManager.getSessionId()
+							await mutateTaskMetadata(options.paths, metadata => {
+								signal?.throwIfAborted()
+								lifetime.signal.throwIfAborted()
+								if (
+									metadata.kind !== "agent" ||
+									metadata.childSessionId !== childSessionId ||
+									metadata.activeRun?.id !== runId ||
+									metadata.state !== "running" ||
+									metadata.discardedAt !== null
+								) {
+									throw new Error("task_update can only update its own active run")
+								}
+								return { ...metadata, progress, updatedAt: Date.now() }
+							})
+							return { content: [{ type: "text", text: "Progress updated." }], details: { progress } }
+						}
+					})
 					pi.on("before_agent_start", event => ({
 						systemPrompt: buildDefinitionSystemPrompt(event.systemPromptOptions)
 					}))
@@ -173,7 +214,6 @@ export async function createChildSession(options: CreateChildSessionOptions): Pr
 		throw new Error(`Child session identity mismatch: expected ${options.expectedSessionId}, found ${result.session.sessionId}`)
 	}
 
-	const lifetime = new AbortController()
 	const unbindContext = getAgentCoordinator().bindSessionContext(result.session.sessionId, {
 		depth: policy.depth,
 		allowAgents: policy.allowAgents,
@@ -193,6 +233,7 @@ export async function createChildSession(options: CreateChildSessionOptions): Pr
 		extensionsResult: result.extensionsResult,
 		depth: policy.depth,
 		allowAgents: policy.allowAgents,
+		prompt: (runId, text, promptOptions) => runContext.run(runId, () => result.session.prompt(text, promptOptions)),
 		dispose() {
 			if (disposed) return
 			disposed = true

package/extensions/lovely-agents/coordinator.ts

@@ -39,7 +39,9 @@ export type ResidentAgent = {
 export type ResidentInputOptions = { background?: boolean; signal?: AbortSignal; eof?: boolean }
 
 export type ResidentInputResult = {
+	run: number
 	delivery: "followup" | "steer" | "stdin"
+	conversionReason?: string
 	queuePosition: number | null
 	queuedFollowUps: number
 	completed?: TaskMetadata

package/extensions/lovely-agents/definitions.ts

@@ -290,7 +290,8 @@ function parseTools(value: unknown, knownTools: readonly string[]): { value?: st
 	const tools = raw.map(tool => (tool as string).trim())
 	const duplicate = tools.find((tool, index) => tools.indexOf(tool) !== index)
 	if (duplicate) return { error: `duplicate tool "${duplicate}"` }
-	const unknown = tools.filter(tool => !knownTools.includes(tool))
+	// This tool is registered only inside managed children, not in the parent's roster.
+	const unknown = tools.filter(tool => tool !== "task_update" && !knownTools.includes(tool))
 	if (unknown.length > 0) return { error: `unknown tools: ${unknown.sort(compareText).join(", ")}` }
 	return { value: tools }
 }

package/extensions/lovely-agents/index.ts

@@ -164,7 +164,7 @@ export default function lovelyAgentsExtension(pi: ExtensionAPI) {
 				pi.sendMessage(
 					{
 						customType: NOTIFICATION_CUSTOM_TYPE,
-						content: `User manually discarded task ${id} and its descendants.\nFiles are archived; these tasks cannot receive further input.`,
+						content: `User manually discarded task ${id} and its descendants.\nFiles stay at their original paths for read-only inspection; these tasks cannot receive further input.`,
 						display: true
 					},
 					{ deliverAs: "steer", triggerTurn: false }