@xl0/pi-lovely-agents 0.1.0 → 0.1.2

package/extensions/lovely-agents/lifecycle.ts

@@ -4,9 +4,8 @@ import { appendTaskNotification, prepareTaskNotification } from "./notifications
 import {
 	acquireParentLease,
 	appendHistoryLog,
-	archivedTaskStoragePaths,
-	archiveTaskStorage,
 	mutateTaskMetadata,
+	type ParentLease,
 	parentStoragePaths,
 	readTaskIdentity,
 	readTaskMetadata,
@@ -16,6 +15,7 @@ import {
 	type TaskStoragePaths,
 	taskStoragePaths
 } from "./state.js"
+import { readTaskDiscardMarker, rebuildActiveTaskLinks, syncActiveTaskLink, writeTaskDiscardMarker } from "./storage.js"
 
 export type ReconciliationResult = {
 	interrupted: number
@@ -29,7 +29,7 @@ export type RecoveryResult = {
 
 const DISCARD_OPERATIONS = Symbol.for("@xl0/pi-lovely-agents/discards/v1")
 
-/** Stops and archives an owned subtree, decoding only identity for unsupported versions. */
+/** Stops and tombstones an owned subtree without changing its canonical paths. */
 export function discardTask(paths: TaskStoragePaths, visited = new Set([paths.parentSessionId])): Promise<void> {
 	const global = globalThis as typeof globalThis & { [DISCARD_OPERATIONS]?: Map<string, Promise<void>> }
 	global[DISCARD_OPERATIONS] ??= new Map()
@@ -38,11 +38,9 @@ export function discardTask(paths: TaskStoragePaths, visited = new Set([paths.pa
 	if (existing) return existing
 	const pending = (async () => {
 		const identity = await readTaskIdentity(paths)
-		if (!identity) {
-			if (await readTaskIdentity(archivedTaskStoragePaths(paths))) return
-			throw new Error(`Unknown Task Reference: ${paths.taskRef}`)
-		}
+		if (!identity) throw new Error(`Unknown Task Reference: ${paths.taskRef}`)
 		if (identity.kind === "agent" && visited.has(identity.childSessionId)) throw new Error("Cyclic task ownership")
+		const marked = await readTaskDiscardMarker(paths)
 		const loaded = await readTaskMetadata(paths)
 		if (loaded.status === "ok") {
 			await stopTask(paths)
@@ -54,23 +52,25 @@ export function discardTask(paths: TaskStoragePaths, visited = new Set([paths.pa
 			}))
 			// Fence input that raced the first stop before the tombstone committed.
 			await stopTask(paths)
-		} else if (loaded.status === "invalid" && loaded.diagnostic.code === "unsupported-version") {
-			await getAgentCoordinator().getResident(paths.taskDirectory)?.stop()
+		} else if (marked || (loaded.status === "invalid" && loaded.diagnostic.code === "unsupported-version")) {
+			if (!marked) {
+				await getAgentCoordinator().getResident(paths.taskDirectory)?.stop()
+				await writeTaskDiscardMarker(paths)
+			}
 		} else {
 			throw new Error(loaded.status === "invalid" ? loaded.diagnostic.message : `Missing metadata: ${paths.metadata}`)
 		}
 		if (identity.kind === "agent") {
 			const descendants = new Set([...visited, identity.childSessionId])
 			const lease = await acquireParentLease(paths.workspace, identity.childSessionId)
-			try {
-				for (const child of await directTaskPaths(paths.workspace, identity.childSessionId)) {
-					await discardTask(child, descendants)
-				}
-			} finally {
-				await releaseParentLease(lease)
+			for (const child of await directTaskPaths(paths.workspace, identity.childSessionId, true)) {
+				await discardTask(child, descendants)
 			}
+			// Failed cleanup may leave residents using this borrowed partition lease.
+			await releaseParentLease(lease)
 		}
-		await archiveTaskStorage(paths)
+		const warning = await syncActiveTaskLink(paths, true)
+		if (warning) throw new Error(warning)
 	})().finally(() => {
 		if (operations.get(paths.taskDirectory) === pending) operations.delete(paths.taskDirectory)
 	})
@@ -85,13 +85,27 @@ export async function reconcileParentTasks(cwd: string, parentSessionId: string)
 	await acquireParentLease(cwd, parentSessionId)
 
 	const result: ReconciliationResult = { interrupted: 0, diagnostics: [] }
+	try {
+		result.diagnostics.push(...(await rebuildActiveTaskLinks(parent)))
+	} catch (error) {
+		result.diagnostics.push(`Active task index: ${errorMessage(error)}`)
+	}
 	for (const paths of await directTaskPaths(cwd, parentSessionId)) {
+		try {
+			if (await readTaskDiscardMarker(paths)) continue
+		} catch (error) {
+			result.diagnostics.push(`${paths.taskDirectory}: ${errorMessage(error)}`)
+			continue
+		}
 		const loaded = await readTaskMetadata(paths)
 		if (loaded.status !== "ok") {
-			if (loaded.status === "invalid") result.diagnostics.push(`${paths.taskDirectory}: ${loaded.diagnostic.message}`)
+			if (loaded.status === "invalid") {
+				const diagnostic = `${paths.taskDirectory}: ${loaded.diagnostic.message}`
+				if (!result.diagnostics.includes(diagnostic)) result.diagnostics.push(diagnostic)
+			}
 			continue
 		}
-		if (getAgentCoordinator().getResident(paths.taskDirectory)) continue
+		if (loaded.metadata.discardedAt !== null || getAgentCoordinator().getResident(paths.taskDirectory)) continue
 		if (loaded.metadata.state === "idle" || loaded.metadata.state === "interrupted") {
 			if (loaded.metadata.queuedFollowUps.length > 0) {
 				await mutateTaskMetadata(paths, metadata => ({ ...metadata, queuedFollowUps: [], updatedAt: Date.now() }))
@@ -135,7 +149,10 @@ export async function reconcileParentTasks(cwd: string, parentSessionId: string)
 
 /** Stops active work and clears queued input throughout an owned task tree. */
 export async function stopOwnedTaskTree(cwd: string, parentSessionId: string): Promise<void> {
-	await stopPartition(cwd, parentSessionId, new Set())
+	const leases: ParentLease[] = []
+	await stopPartition(cwd, parentSessionId, new Set(), leases)
+	// A failed owner can remain live even when stopping its descendants succeeded.
+	for (const lease of leases.reverse()) await releaseParentLease(lease)
 }
 
 /** Requeues resident suspended work in the exact owned descendant tree. */
@@ -152,31 +169,32 @@ export async function stopTask(paths: TaskStoragePaths): Promise<void> {
 	else await settleStopped(paths)
 }
 
-async function stopPartition(cwd: string, parentSessionId: string, visited: Set<string>): Promise<void> {
+async function stopPartition(cwd: string, parentSessionId: string, visited: Set<string>, leases: ParentLease[]): Promise<void> {
 	if (visited.has(parentSessionId)) return
 	visited.add(parentSessionId)
 	const parent = parentStoragePaths(cwd, parentSessionId)
 	if (!(await isDirectory(parent.parentDirectory))) return
-	const lease = await acquireParentLease(cwd, parentSessionId)
+	leases.push(await acquireParentLease(cwd, parentSessionId))
 	const errors: unknown[] = []
 
-	try {
-		for (const paths of await directTaskPaths(cwd, parentSessionId)) {
-			const loaded = await readTaskMetadata(paths)
-			if (loaded.status !== "ok") continue
-			try {
-				await stopTask(paths)
-			} catch (error) {
-				errors.push(error)
-			}
-			try {
-				if (loaded.metadata.kind === "agent") await stopPartition(cwd, loaded.metadata.childSessionId, visited)
-			} catch (error) {
-				errors.push(error)
+	for (const paths of await directTaskPaths(cwd, parentSessionId)) {
+		const loaded = await readTaskMetadata(paths)
+		if (loaded.status !== "ok") {
+			if (getAgentCoordinator().getResident(paths.taskDirectory)) {
+				errors.push(new Error(`Cannot validate live task ownership: ${paths.metadata}`))
 			}
+			continue
+		}
+		try {
+			await stopTask(paths)
+		} catch (error) {
+			errors.push(error)
+		}
+		try {
+			if (loaded.metadata.kind === "agent") await stopPartition(cwd, loaded.metadata.childSessionId, visited, leases)
+		} catch (error) {
+			errors.push(error)
 		}
-	} finally {
-		await releaseParentLease(lease)
 	}
 	if (errors.length > 0) throw new AggregateError(errors, `Failed to stop ${errors.length} owned task operation(s)`)
 }
@@ -188,13 +206,19 @@ async function recoverPartition(cwd: string, parentSessionId: string, visited: S
 	if (!(await isDirectory(parent.parentDirectory))) return
 
 	for (const paths of await directTaskPaths(cwd, parentSessionId)) {
+		try {
+			if (await readTaskDiscardMarker(paths)) continue
+		} catch (error) {
+			result.diagnostics.push(`${paths.taskDirectory}: ${errorMessage(error)}`)
+			continue
+		}
 		const loaded = await readTaskMetadata(paths)
 		if (loaded.status !== "ok") {
 			if (loaded.status === "invalid") result.diagnostics.push(`${paths.taskDirectory}: ${loaded.diagnostic.message}`)
 			continue
 		}
-		if (loaded.metadata.kind !== "agent") continue
-		if (loaded.metadata.discardedAt === null && loaded.metadata.state === "suspended" && loaded.metadata.activeRun?.background) {
+		if (loaded.metadata.discardedAt !== null || loaded.metadata.kind !== "agent") continue
+		if (loaded.metadata.state === "suspended" && loaded.metadata.activeRun?.background) {
 			const resident = getAgentCoordinator().getResident(paths.taskDirectory)
 			if (!resident?.recover) result.diagnostics.push(`${paths.taskDirectory}: suspended task has no recoverable resident`)
 			else if (await resident.recover()) result.resumed++
@@ -223,9 +247,16 @@ async function settleStopped(paths: TaskStoragePaths): Promise<void> {
 	}
 }
 
-async function directTaskPaths(cwd: string, parentSessionId: string): Promise<TaskStoragePaths[]> {
+async function directTaskPaths(cwd: string, parentSessionId: string, strict = false): Promise<TaskStoragePaths[]> {
 	const parent = parentStoragePaths(cwd, parentSessionId)
 	const entries = await readdir(parent.parentDirectory, { withFileTypes: true })
+	if (strict) {
+		for (const entry of entries) {
+			if (TASK_REFERENCE_PATTERN.test(entry.name) && (!entry.isDirectory() || entry.isSymbolicLink())) {
+				throw new Error(`Unsafe descendant task path: ${parent.parentDirectory}/${entry.name}`)
+			}
+		}
+	}
 	return entries
 		.filter(entry => entry.isDirectory() && !entry.isSymbolicLink() && TASK_REFERENCE_PATTERN.test(entry.name))
 		.map(entry => taskStoragePaths(parent, entry.name))

package/extensions/lovely-agents/management.ts

@@ -276,7 +276,7 @@ async function manageTask(ctx: ExtensionContext, id: string, options: Management
 						{ value: "steer", label: "Steer", description: "Redirect running work; otherwise becomes a Follow-up" }
 					]),
 			{ value: "stop", label: "Stop", description: "Stop work and preserve retained files" },
-			{ value: "discard", label: "Discard", description: "Stop and archive this task and its descendants" }
+			{ value: "discard", label: "Discard", description: "Stop and remove from active work; keep files in place" }
 		])
 		if (!choice) return
 		if (choice === "details") await showText(ctx, task.label, renderTask(task))
@@ -302,7 +302,9 @@ async function manageTask(ctx: ExtensionContext, id: string, options: Management
 			) {
 				await options.controlTask(task.id, "stop")
 			}
-		} else if (await ctx.ui.confirm(`Discard ${task.id}?`, "Files move to the archive. Later model I/O is rejected.")) {
+		} else if (
+			await ctx.ui.confirm(`Discard ${task.id}?`, "Files stay at their original paths. Results remain readable; further input is rejected.")
+		) {
 			await options.controlTask(task.id, "discard")
 			return
 		}
@@ -344,6 +346,10 @@ async function showLiveTaskOutput(ctx: ExtensionContext, task: TaskListRow): Pro
 		let closed = false
 		let loading = false
 		let refreshAgain = false
+		let offset = 0
+		let pageSize = 1
+		let total = 0
+		let follow = task.kind === "bash"
 		const refresh = async () => {
 			if (closed) return
 			refreshAgain = true
@@ -364,26 +370,58 @@ async function showLiveTaskOutput(ctx: ExtensionContext, task: TaskListRow): Pro
 		const unbind = bindTaskUpdateRoute(ctx.cwd, ctx.sessionManager.getSessionId(), refresh)
 		return {
 			render(width: number) {
+				const exitStatus =
+					output.exitCode !== undefined ? ` · Exit code: ${output.exitCode ?? "unknown"} · Signal: ${output.signal ?? "none"}` : ""
 				const heading = theme.fg(
 					"accent",
 					theme.bold(
-						`${task.id} · ${output.state}${output.latestOutcome ? `/${output.latestOutcome}` : ""}${output.streaming ? " · streaming" : ""}`
+						`${task.id} · ${output.state}${output.latestOutcome ? `/${output.latestOutcome}` : ""}${output.streaming ? " · streaming" : ""}${exitStatus}`
 					)
 				)
-				const progress = [
+				const progressLines = [
 					`Capacity: ${output.capacity.active}/${output.capacity.limit} execution permits`,
+					...(output.progress ? [`Progress: ${JSON.stringify(output.progress)}`] : []),
 					...(output.queueReason ? [`Waiting: ${output.queueReason}`] : []),
 					...(output.lastActivity ? [`${output.lastActivity.action} · ${relativeTime(output.lastActivity.at, Date.now())}`] : [])
-				].join("\n")
-				return new Text(
-					`${heading}\n${progress}\n\n${output.text || "(no output)"}\n\n${theme.fg("dim", "Esc or Enter to go back")}`,
-					1,
-					0
-				).render(width)
+				]
+				const bodyLines = new Text(output.text || "(no output)", 0, 0).render(width)
+				total = bodyLines.length
+				pageSize = Math.max(1, Math.floor(tui.terminal.rows * 0.6) - (1 + progressLines.length + 2))
+				const maxOffset = Math.max(0, total - pageSize)
+				if (follow) offset = maxOffset
+				else offset = Math.max(0, Math.min(offset, maxOffset))
+				const position = `${Math.min(offset + 1, total)}-${Math.min(offset + pageSize, total)}/${total}${follow ? " · follow" : ""}`
+				return [
+					truncateToWidth(heading, width),
+					...progressLines.map(line => truncateToWidth(line, width)),
+					"",
+					...bodyLines.slice(offset, offset + pageSize).map(line => truncateToWidth(line, width)),
+					truncateToWidth(theme.fg("dim", `Enter/Esc back · ↑↓ PgUp/PgDn Home/End · ${position}`), width)
+				]
 			},
 			invalidate() {},
 			handleInput(data: string) {
 				if (matchesKey(data, Key.enter) || matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) done(undefined)
+				else if (matchesKey(data, Key.up)) {
+					offset--
+					follow = false
+				} else if (matchesKey(data, Key.down)) {
+					offset++
+				} else if (matchesKey(data, Key.pageUp)) {
+					offset -= pageSize
+					follow = false
+				} else if (matchesKey(data, Key.pageDown)) {
+					offset += pageSize
+				} else if (matchesKey(data, Key.home)) {
+					offset = 0
+					follow = false
+				} else if (matchesKey(data, Key.end)) {
+					offset = Math.max(0, total - pageSize)
+					follow = true
+				} else return
+				offset = Math.max(0, Math.min(offset, total - pageSize))
+				if (offset >= Math.max(0, total - pageSize)) follow = true
+				tui.requestRender()
 			},
 			dispose() {
 				closed = true
@@ -610,6 +648,7 @@ function renderTask(task: TaskListRow): string {
 		`Task: ${task.id}`,
 		`State: ${task.state}`,
 		`Outcome: ${task.latestOutcome ?? "none"}`,
+		...(task.progress ? [`Progress: ${JSON.stringify(task.progress)}`] : []),
 		...(task.kind === "bash"
 			? [
 					`Command: ${task.command}`,

package/extensions/lovely-agents/notifications.ts

@@ -12,8 +12,10 @@ import {
 	TASK_REFERENCE_PATTERN,
 	type TaskMetadata,
 	type TaskStoragePaths,
-	taskStoragePaths
+	taskStoragePaths,
+	truncateUtf8Tail
 } from "./state.js"
+import { readTaskDiscardMarker } from "./storage.js"
 import { loadTaskList } from "./tools.js"
 
 export const NOTIFICATION_CUSTOM_TYPE = "lovely-agents:notification"
@@ -46,7 +48,10 @@ export async function prepareTaskNotification(
 	type: NotificationType,
 	outcome?: TaskMetadata["latestOutcome"]
 ): Promise<TaskNotification> {
-	const output = truncateUtf8(metadata.latestReply?.text ?? "", NOTIFICATION_OUTPUT_PREVIEW_BYTES)
+	const output =
+		metadata.kind === "bash"
+			? truncateUtf8Tail(metadata.latestReply?.text ?? "", NOTIFICATION_OUTPUT_PREVIEW_BYTES)
+			: truncateUtf8(metadata.latestReply?.text ?? "", NOTIFICATION_OUTPUT_PREVIEW_BYTES)
 	const taskList = await loadTaskList(paths.workspace, metadata.parentSessionId).catch(() => undefined)
 	const descendants = taskList?.details.tasks.find(task => task.id === metadata.taskRef)?.descendants
 	const descendantText = descendants && descendants.total > 0 ? `\nDescendants: ${JSON.stringify(descendants)}` : ""
@@ -55,11 +60,12 @@ export async function prepareTaskNotification(
 	const content = truncateUtf8(
 		[
 			`[Lovely ${metadata.kind === "bash" ? "Bash" : "Agent"} ${metadata.taskRef}:${run.id}:${type}]`,
-			`Task ${metadata.taskRef} ${JSON.stringify(metadata.label)} ${status}`,
+			`Task ${metadata.taskRef} run=${run.sequence} ${JSON.stringify(metadata.label)} ${status}`,
 			metadata.kind === "bash"
 				? `Command: ${truncateUtf8(metadata.command, 1024)}\nExit: ${metadata.exitCode ?? "unknown"}${metadata.signal ? ` signal=${metadata.signal}` : ""}`
 				: `Model: ${metadata.model.provider}/${metadata.model.id}:${metadata.thinking}`,
-			output ? `Output:\n${output}` : "Output: (empty)",
+			`Read: task_output(id: "${metadata.taskRef}", run: ${run.sequence})`,
+			output ? `Output preview:\n${output}` : "Output preview: (empty)",
 			`Files: history=${pathsForDisplay.history} ${metadata.kind === "bash" ? `output=${pathsForDisplay.output}` : `session=${pathsForDisplay.session}`}${descendantText}`
 		].join("\n"),
 		MAX_NOTIFICATION_CONTENT_BYTES
@@ -85,7 +91,8 @@ export function appendTaskNotification(notifications: TaskNotification[], notifi
 /** Sends every pending notification for one task, without marking delivery. */
 export async function deliverTaskNotifications(paths: TaskStoragePaths): Promise<number> {
 	const loaded = await readTaskMetadata(paths)
-	if (loaded.status !== "ok" || loaded.metadata.discardedAt !== null) return 0
+	// Discard leaves result paths intact; accepted notices still reconcile normally.
+	if (loaded.status !== "ok") return 0
 	const routeKey = notificationRouteKey(paths.workspace, loaded.metadata.parentSessionId)
 	const route = getAgentCoordinator().getNotificationRoute(routeKey)
 	if (!route) return 0
@@ -118,6 +125,12 @@ export async function reconcileParentNotifications(
 	for (const paths of await directTaskPaths(cwd, parentSessionId)) {
 		const loaded = await readTaskMetadata(paths)
 		if (loaded.status !== "ok") {
+			try {
+				if (await readTaskDiscardMarker(paths)) continue
+			} catch (error) {
+				result.diagnostics.push(`${paths.taskDirectory}: ${errorMessage(error)}`)
+				continue
+			}
 			if (loaded.status === "invalid") result.diagnostics.push(`${paths.taskDirectory}: ${loaded.diagnostic.message}`)
 			continue
 		}