@gajae-code/coding-agent 0.3.0 → 0.3.1

package/src/session/agent-session.ts

@@ -172,6 +172,7 @@ import { requestGjcWorkerIntegrationAttempt } from "../gjc-runtime/team-runtime"
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
+import { ensureWorkflowSkillActivationState } from "../hooks/skill-state";
 import { type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
 import { resolveMemoryBackend } from "../memory-backend";
 import { getCurrentThemeName, theme } from "../modes/theme/theme";
@@ -297,7 +298,7 @@ function isUnderProjectGjc(cwd: string, targetPath: string): boolean {
 
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "metadata">;
 
 export interface AsyncJobSnapshot {
 	running: AsyncJobSnapshotItem[];
@@ -872,6 +873,7 @@ export class AgentSession {
 	#activeRetryFallback: ActiveRetryFallbackState | undefined = undefined;
 	// Todo completion reminder state
 	#todoReminderCount = 0;
+	#lastGoalReminderAssistantTimestamp: number | undefined = undefined;
 	#todoPhases: TodoPhase[] = [];
 	#toolChoiceQueue = new ToolChoiceQueue();
 
@@ -972,6 +974,12 @@ export class AgentSession {
 	 *  without producing an aborted message_end). */
 	#planCompactAbortPending = false;
 
+	/** One-shot flag armed by `abort({ silent: true })` (e.g. Esc consuming a
+	 *  queued steer). Consumed in #handleAgentEvent to stamp `SILENT_ABORT_MARKER`
+	 *  on the resulting aborted assistant `message_end` so the interrupt does not
+	 *  surface a red "Operation aborted" line; cleared by a later non-silent abort
+	 *  or by `abort`'s safety net when no aborted message_end is produced. */
+	#silentAbortPending = false;
 	/** Monotonic counter for `enqueueCustomMessageDisplay` tag generation;
 	 *  combined with `Date.now()` so tags stay unique even across rapid
 	 *  same-tick enqueues. */
@@ -1050,6 +1058,7 @@ export class AgentSession {
 		this.#promptInFlightCount = Math.max(0, this.#promptInFlightCount - 1);
 		if (this.#promptInFlightCount === 0) {
 			this.#releasePowerAssertion();
+			this.#flushPendingBackgroundExchanges();
 			this.#flushPendingAgentEnd();
 		}
 	}
@@ -1057,6 +1066,7 @@ export class AgentSession {
 	#resetInFlight(): void {
 		this.#promptInFlightCount = 0;
 		this.#releasePowerAssertion();
+		this.#flushPendingBackgroundExchanges();
 		this.#flushPendingAgentEnd();
 	}
 
@@ -1485,6 +1495,10 @@ export class AgentSession {
 		return tag;
 	}
 
+	getAgentId(): string | undefined {
+		return this.#agentId;
+	}
+
 	getAsyncJobSnapshot(options?: { recentLimit?: number }): AsyncJobSnapshot | null {
 		const manager = AsyncJobManager.instance();
 		if (!manager) return null;
@@ -1495,6 +1509,7 @@ export class AgentSession {
 			status: job.status,
 			label: job.label,
 			startTime: job.startTime,
+			metadata: job.metadata,
 		}));
 		const recent = manager.getRecentJobs(options?.recentLimit ?? 5, ownerFilter).map(job => ({
 			id: job.id,
@@ -1502,6 +1517,7 @@ export class AgentSession {
 			status: job.status,
 			label: job.label,
 			startTime: job.startTime,
+			metadata: job.metadata,
 		}));
 		const delivery = manager.getDeliveryState(ownerFilter);
 		return { running, recent, delivery };
@@ -1644,10 +1660,11 @@ export class AgentSession {
 			event.type === "message_end" &&
 			event.message.role === "assistant" &&
 			event.message.stopReason === "aborted" &&
-			this.#planCompactAbortPending
+			(this.#planCompactAbortPending || this.#silentAbortPending)
 		) {
 			(event.message as AssistantMessage).errorMessage = SILENT_ABORT_MARKER;
 			this.#planCompactAbortPending = false;
+			this.#silentAbortPending = false;
 		}
 
 		// Deobfuscate assistant message content for display emission — the LLM echoes back
@@ -2015,6 +2032,9 @@ export class AgentSession {
 
 			if (this.#assistantEndedWithSuccessfulYield(msg)) {
 				this.#lastSuccessfulYieldToolCallId = undefined;
+				if (msg.stopReason !== "error" && msg.stopReason !== "aborted" && (await this.#checkGoalCompletion(msg))) {
+					return;
+				}
 				return;
 			}
 			this.#lastSuccessfulYieldToolCallId = undefined;
@@ -2050,6 +2070,9 @@ export class AgentSession {
 				if (this.#enforceRewindBeforeYield()) {
 					return;
 				}
+				if (await this.#checkGoalCompletion(msg)) {
+					return;
+				}
 				await this.#checkTodoCompletion();
 			}
 		}
@@ -2138,13 +2161,23 @@ export class AgentSession {
 		delayMs?: number;
 		generation?: number;
 		shouldContinue?: () => boolean;
-		onSkip?: () => void;
-		onError?: () => void;
+		onSkip?: (reason: "generation_changed" | "aborted_signal" | "queue_drained") => void;
+		onError?: (error: unknown) => void;
 	}): void {
+		const scheduledGeneration = options?.generation;
+		const signal = this.#postPromptTasksAbortController.signal;
 		this.#schedulePostPromptTask(
 			async () => {
+				if (signal.aborted) {
+					options?.onSkip?.("aborted_signal");
+					return;
+				}
+				if (scheduledGeneration !== undefined && this.#promptGeneration !== scheduledGeneration) {
+					options?.onSkip?.("generation_changed");
+					return;
+				}
 				if (options?.shouldContinue && !options.shouldContinue()) {
-					options.onSkip?.();
+					options.onSkip?.("queue_drained");
 					return;
 				}
 				try {
@@ -2154,17 +2187,45 @@ export class AgentSession {
 					logger.warn("agent.continue failed after scheduling", {
 						error: error instanceof Error ? error.message : String(error),
 					});
-					options?.onError?.();
+					options?.onError?.(error);
 				}
 			},
-			{
-				delayMs: options?.delayMs,
-				generation: options?.generation,
-				onSkip: options?.onSkip,
-			},
+			{ delayMs: options?.delayMs },
 		);
 	}
 
+	#logCompactionContinuationSkipped(
+		source: "auto_continue_prompt" | "queued_continue" | "overflow_retry",
+		reason: string,
+	): void {
+		logger.warn("Auto-compaction continuation skipped", { source, reason });
+	}
+
+	#logCompactionContinuationError(
+		source: "auto_continue_prompt" | "queued_continue" | "overflow_retry",
+		error: unknown,
+	): void {
+		logger.warn("Auto-compaction continuation failed", {
+			source,
+			reason: error instanceof Error && error.name === "AgentBusyError" ? "queue_drained" : "not_resumable_tail",
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+
+	#isResumableAgentTail(): boolean {
+		const lastMsg = this.agent.state.messages.at(-1);
+		return lastMsg !== undefined && lastMsg.role !== "assistant";
+	}
+
+	#stripOverflowFailedTurnForRetry(): void {
+		const messages = this.agent.state.messages;
+		const lastMsg = messages.at(-1);
+		const contextWindow = this.model?.contextWindow ?? 0;
+		if (lastMsg?.role === "assistant" && isContextOverflow(lastMsg as AssistantMessage, contextWindow)) {
+			this.agent.replaceMessages(messages.slice(0, -1));
+		}
+	}
+
 	#scheduleAutoContinuePrompt(generation: number): void {
 		const continuePrompt = async () => {
 			await this.#promptWithMessage(
@@ -2175,16 +2236,28 @@ export class AgentSession {
 					timestamp: Date.now(),
 				},
 				autoContinuePrompt,
-				{ skipPostPromptRecoveryWait: true },
+				{ skipPostPromptRecoveryWait: true, skipCompactionCheck: true },
 			);
 		};
-		this.#schedulePostPromptTask(
-			async signal => {
+		const scheduledGeneration = generation;
+		const signal = this.#postPromptTasksAbortController.signal;
+		this.#trackPostPromptTask(
+			(async () => {
 				await Promise.resolve();
-				if (signal.aborted) return;
-				await continuePrompt();
-			},
-			{ generation },
+				if (signal.aborted) {
+					this.#logCompactionContinuationSkipped("auto_continue_prompt", "aborted_signal");
+					return;
+				}
+				if (this.#promptGeneration !== scheduledGeneration) {
+					this.#logCompactionContinuationSkipped("auto_continue_prompt", "generation_changed");
+					return;
+				}
+				try {
+					await continuePrompt();
+				} catch (error) {
+					this.#logCompactionContinuationError("auto_continue_prompt", error);
+				}
+			})(),
 		);
 	}
 
@@ -4327,12 +4400,17 @@ export class AgentSession {
 		// Canonical GJC workflow skills (deep-interview, ralplan, ultragoal, team)
 		// own their `.gjc/state/skill-active-state.json` row through the
 		// `gjc state handoff` and `gjc state clear` runtime verbs. The prompt
-		// observer here used to overwrite the row with `phase: running` and
-		// later remove it with `active:false`, which clobbered handoff lineage
-		// (`handoff_from`/`handoff_at`) and made the HUD inconsistent with
-		// mode-state. The observational filesystem write is now skipped for
-		// canonical skills; the in-memory `#activeSkillState` tracking below
-		// keeps `getActiveSkillState` accurate for the chain guard.
+		// observer must not overwrite an existing row (that clobbered handoff
+		// lineage `handoff_from`/`handoff_at` and desynced the HUD). But a fresh
+		// `/skill:<name>` invocation has no row yet, so seed `.gjc/state`
+		// idempotently here: `ensureWorkflowSkillActivationState` writes the
+		// initial mode-state + active row only when the skill is not already
+		// active, so the mutation guard and Stop hook engage immediately instead
+		// of relying on the skill prompt to run its own state-init steps.
+		if (active) {
+			await ensureWorkflowSkillActivationState({ cwd: this.sessionManager.getCwd(), skill, sessionId });
+		}
+		// In-memory tracking keeps `getActiveSkillState` accurate for the chain guard.
 		this.#activeSkillState = active ? { skill, sessionId } : undefined;
 	}
 
@@ -4978,6 +5056,13 @@ export class AgentSession {
 		return this.#steeringMessages.length + this.#followUpMessages.length + this.#pendingNextTurnMessages.length;
 	}
 
+	/** Whether the agent has queued steering messages that a `user_interrupt`
+	 *  abort would resume into (steer-on-interrupt). Drives the Esc-on-steer UX:
+	 *  the first Esc consumes the steer and auto-continues, a second Esc aborts. */
+	get hasQueuedSteering(): boolean {
+		return this.agent.hasQueuedSteering();
+	}
+
 	/** Get pending messages (read-only). Returns the public text-only view;
 	 *  internal `{text, tag?}` records are mapped to `.text` so callers
 	 *  (`updatePendingMessagesDisplay`, `restoreQueuedMessagesToEditor`) see
@@ -5074,7 +5159,17 @@ export class AgentSession {
 			| "handoff"
 			| "tool_abort"
 			| "internal";
+		/** Suppress the "Operation aborted" line on the resulting aborted message
+		 *  by stamping `SILENT_ABORT_MARKER`. Used when Esc consumes a queued steer
+		 *  and resumes via steer-on-interrupt, so the interrupt reads as a quiet
+		 *  hand-off rather than a failure. */
+		silent?: boolean;
 	}): Promise<void> {
+		if (options?.silent) {
+			this.#silentAbortPending = true;
+		} else {
+			this.#silentAbortPending = false;
+		}
 		this.abortRetry();
 		this.#promptGeneration++;
 		this.#scheduledHiddenNextTurnGeneration = undefined;
@@ -5114,6 +5209,10 @@ export class AgentSession {
 		// block runs, but nested prompt setup/finalizers may still be unwinding. Without this,
 		// a subsequent prompt() can incorrectly observe the session as busy after an abort.
 		this.#resetInFlight();
+		// Safety net: clear the silent-abort flag if it was never consumed (the
+		// abort produced no aborted assistant message_end to stamp). Prevents the
+		// marker from leaking onto a later, unrelated abort.
+		this.#silentAbortPending = false;
 		// Safety net: if the agent loop aborted without producing an assistant
 		// message (e.g. failed before the first stream), the in-flight yield was
 		// never resolved or rejected by the normal message_end path. Reject it now
@@ -5188,6 +5287,9 @@ export class AgentSession {
 		this.#scheduledHiddenNextTurnGeneration = undefined;
 
 		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+		if (this.model) {
+			this.sessionManager.appendModelChange(`${this.model.provider}/${this.model.id}`);
+		}
 		this.sessionManager.appendServiceTierChange(this.serviceTier ?? null);
 		if (nextDiscoverySessionToolNames) {
 			await this.#applyActiveToolsByName(nextDiscoverySessionToolNames, { persistMCPSelection: false });
@@ -5979,6 +6081,11 @@ export class AgentSession {
 			this.#pendingNextTurnMessages = [];
 			this.#scheduledHiddenNextTurnGeneration = undefined;
 			this.#todoReminderCount = 0;
+			if (model) {
+				this.sessionManager.appendModelChange(`${model.provider}/${model.id}`);
+			}
+			this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+			this.sessionManager.appendServiceTierChange(this.serviceTier ?? null);
 
 			// Inject the handoff document as a custom message
 			const handoffContent = createHandoffContext(handoffText);
@@ -6266,6 +6373,39 @@ export class AgentSession {
 			toolChoice: todoWriteToolChoice,
 		};
 	}
+
+	async #checkGoalCompletion(assistantMessage: AssistantMessage): Promise<boolean> {
+		const state = this.getGoalModeState();
+		if (!state?.enabled || state.goal.status !== "active") {
+			this.#lastGoalReminderAssistantTimestamp = undefined;
+			return false;
+		}
+		if (this.#lastGoalReminderAssistantTimestamp === assistantMessage.timestamp) {
+			return false;
+		}
+		this.#lastGoalReminderAssistantTimestamp = assistantMessage.timestamp;
+
+		const continuationPrompt = this.#goalRuntime.buildContinuationPrompt();
+		if (!continuationPrompt) return false;
+		const reminder = [
+			"<system-reminder>",
+			"You stopped while a goal is still active and uncleared.",
+			"Continue working on the active goal until it is verified complete, paused, or dropped.",
+			"",
+			continuationPrompt,
+			"</system-reminder>",
+		].join("\n");
+
+		logger.debug("Goal completion: sending active-goal reminder", { goalId: state.goal.id });
+		this.agent.appendMessage({
+			role: "developer",
+			content: [{ type: "text", text: reminder }],
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		this.#scheduleAgentContinue({ generation: this.#promptGeneration });
+		return true;
+	}
 	/**
 	 * Check if agent stopped with incomplete todos and prompt to continue.
 	 */
@@ -6909,12 +7049,34 @@ export class AgentSession {
 					willRetry: false,
 					skipped: true,
 				});
-				if (!willRetry && this.agent.hasQueuedMessages()) {
+				if (willRetry) {
+					this.#stripOverflowFailedTurnForRetry();
+					if (this.#isResumableAgentTail()) {
+						this.#scheduleAgentContinue({
+							delayMs: 100,
+							generation,
+							onSkip: skipReason => this.#logCompactionContinuationSkipped("overflow_retry", skipReason),
+							onError: error => this.#logCompactionContinuationError("overflow_retry", error),
+						});
+					} else {
+						const tail = this.agent.state.messages.at(-1) as AssistantMessage | undefined;
+						logger.warn("Auto-compaction continuation skipped", {
+							source: "overflow_retry",
+							reason: "not_resumable_tail",
+							role: tail?.role,
+							stopReason: tail?.stopReason,
+						});
+					}
+				} else if (reason !== "idle" && this.agent.hasQueuedMessages()) {
 					this.#scheduleAgentContinue({
 						delayMs: 100,
 						generation,
 						shouldContinue: () => this.agent.hasQueuedMessages(),
+						onSkip: skipReason => this.#logCompactionContinuationSkipped("queued_continue", skipReason),
+						onError: error => this.#logCompactionContinuationError("queued_continue", error),
 					});
+				} else if (reason !== "idle" && compactionSettings.autoContinue !== false) {
+					this.#scheduleAutoContinuePrompt(generation);
 				}
 				return;
 			}
@@ -7116,26 +7278,36 @@ export class AgentSession {
 			};
 			await this.#emitSessionEvent({ type: "auto_compaction_end", action, result, aborted: false, willRetry });
 
-			if (!willRetry && reason !== "idle" && compactionSettings.autoContinue !== false) {
-				this.#scheduleAutoContinuePrompt(generation);
-			}
-
 			if (willRetry) {
-				const messages = this.agent.state.messages;
-				const lastMsg = messages[messages.length - 1];
-				if (lastMsg?.role === "assistant" && (lastMsg as AssistantMessage).stopReason === "error") {
-					this.agent.replaceMessages(messages.slice(0, -1));
+				this.#stripOverflowFailedTurnForRetry();
+				if (!this.#isResumableAgentTail()) {
+					const tail = this.agent.state.messages.at(-1) as AssistantMessage | undefined;
+					logger.warn("Auto-compaction continuation skipped", {
+						source: "overflow_retry",
+						reason: "not_resumable_tail",
+						role: tail?.role,
+						stopReason: tail?.stopReason,
+					});
+				} else {
+					this.#scheduleAgentContinue({
+						delayMs: 100,
+						generation,
+						onSkip: reason => this.#logCompactionContinuationSkipped("overflow_retry", reason),
+						onError: error => this.#logCompactionContinuationError("overflow_retry", error),
+					});
 				}
-
-				this.#scheduleAgentContinue({ delayMs: 100, generation });
-			} else if (this.agent.hasQueuedMessages()) {
+			} else if (reason !== "idle" && this.agent.hasQueuedMessages()) {
 				// Auto-compaction can complete while follow-up/steering/custom messages are waiting.
 				// Kick the loop so queued messages are actually delivered.
 				this.#scheduleAgentContinue({
 					delayMs: 100,
 					generation,
 					shouldContinue: () => this.agent.hasQueuedMessages(),
+					onSkip: reason => this.#logCompactionContinuationSkipped("queued_continue", reason),
+					onError: error => this.#logCompactionContinuationError("queued_continue", error),
 				});
+			} else if (reason !== "idle" && compactionSettings.autoContinue !== false) {
+				this.#scheduleAutoContinuePrompt(generation);
 			}
 		} catch (error) {
 			if (autoCompactionSignal.aborted) {
@@ -8377,13 +8549,17 @@ export class AgentSession {
 				return;
 			}
 			if (this.isStreaming) {
-				setTimeout(attempt, 50);
+				// Re-poll while streaming, but do not let this housekeeping timer
+				// keep the event loop alive on its own (CPU-7).
+				const pollTimer = setTimeout(attempt, 50);
+				pollTimer.unref?.();
 				return;
 			}
 			this.#scheduledBackgroundExchangeFlush = false;
 			this.#flushPendingBackgroundExchanges();
 		};
-		setTimeout(attempt, 0);
+		const kickoff = setTimeout(attempt, 0);
+		kickoff.unref?.();
 	}
 
 	#flushPendingBackgroundExchanges(): void {

package/src/skill-state/deep-interview-mutation-guard.ts

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import type { AgentTool } from "@gajae-code/agent-core";
 import { expandApplyPatchToEntries } from "../edit/modes/apply-patch";
+import { ModeStateSchema } from "../gjc-runtime/state-schema";
 import { LocalProtocolHandler, resolveLocalUrlToPath } from "../internal-urls/local-protocol";
 import { resolveToCwd } from "../tools/path-utils";
 import { ToolError } from "../tools/tool-errors";
@@ -76,19 +77,37 @@ function modeStatePath(cwd: string, skill: string, sessionId?: string): string {
 	return path.join(stateDir, fileName);
 }
 
-async function readJsonFile<T>(filePath: string): Promise<T | null> {
+function warnInvalidModeState(filePath: string, error: string): void {
+	console.warn(`gjc skill-state: invalid mode-state at ${filePath}: ${error}`);
+}
+
+async function readValidatedModeState(filePath: string): Promise<ModeState | null> {
+	let raw: string;
 	try {
-		return JSON.parse(await Bun.file(filePath).text()) as T;
+		raw = await Bun.file(filePath).text();
 	} catch {
 		return null;
 	}
+	let state: ModeState;
+	try {
+		state = JSON.parse(raw) as ModeState;
+	} catch (error) {
+		warnInvalidModeState(filePath, `invalid JSON: ${(error as Error).message}`);
+		return null;
+	}
+	const parsed = ModeStateSchema.safeParse(state);
+	if (!parsed.success) {
+		warnInvalidModeState(filePath, parsed.error.message);
+		return null;
+	}
+	return state;
 }
 async function readVisibleModeState(cwd: string, skill: string, sessionId?: string): Promise<ModeState | null> {
 	if (sessionId) {
-		const sessionState = await readJsonFile<ModeState>(modeStatePath(cwd, skill, sessionId));
+		const sessionState = await readValidatedModeState(modeStatePath(cwd, skill, sessionId));
 		if (sessionState) return sessionState;
 	}
-	return await readJsonFile<ModeState>(modeStatePath(cwd, skill));
+	return await readValidatedModeState(modeStatePath(cwd, skill));
 }
 
 function isTerminalModeState(state: ModeState | null): boolean {

package/src/skill-state/workflow-state-contract.ts

@@ -1,11 +1,14 @@
 import * as path from "node:path";
 import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill, SKILL_ACTIVE_STATE_FILE } from "./active-state";
+import { WORKFLOW_STATE_RECEIPT_FRESH_MS, WORKFLOW_STATE_RECEIPT_VERSION } from "./workflow-state-version";
 
-export type { CanonicalGjcWorkflowSkill };
-
-export const WORKFLOW_STATE_RECEIPT_VERSION = 1;
-export const WORKFLOW_STATE_RECEIPT_FRESH_MS = 30 * 60 * 1000;
+export {
+	WORKFLOW_STATE_RECEIPT_FRESH_MS,
+	WORKFLOW_STATE_RECEIPT_VERSION,
+	WORKFLOW_STATE_VERSION,
+} from "./workflow-state-version";
 
+export type { CanonicalGjcWorkflowSkill };
 export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
 export type WorkflowStateReceiptStatus = "fresh" | "stale";
 

package/src/skill-state/workflow-state-version.ts

@@ -0,0 +1,3 @@
+export const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export const WORKFLOW_STATE_VERSION = 2;
+export const WORKFLOW_STATE_RECEIPT_FRESH_MS = 30 * 60 * 1000;

package/src/slash-commands/builtin-registry.ts

@@ -586,6 +586,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "monitors",
+		description: "Open the monitor/cron jobs overlay",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showJobsOverlay();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "tree",
 		description: "Navigate session tree (switch branches)",

package/src/task/executor.ts

@@ -4,6 +4,8 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
 import path from "node:path";
 import type { AgentEvent, AgentIdentity, AgentTelemetryConfig, ThinkingLevel } from "@gajae-code/agent-core";
 import { recordHandoff, resolveTelemetry } from "@gajae-code/agent-core";
@@ -1189,6 +1191,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					hasUI: false,
 					spawns: spawnsEnv,
 					taskDepth: childDepth,
+					currentAgentType: agent.name,
 					parentHindsightSessionState: options.parentHindsightSessionState,
 					parentTaskPrefix: id,
 					agentId: id,
@@ -1536,18 +1539,39 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	// Write output artifact (input and jsonl already written in real-time)
 	// Compute output metadata for agent:// URL integration
-	let outputMeta: { lineCount: number; charCount: number } | undefined;
+	let outputMeta: { lineCount: number; charCount: number; byteSize?: number; sha256?: string } | undefined;
 	let outputPath: string | undefined;
 	if (options.artifactsDir) {
-		outputPath = path.join(options.artifactsDir, `${id}.md`);
+		const candidateOutputPath = path.join(options.artifactsDir, `${id}.md`);
 		try {
-			await Bun.write(outputPath, rawOutput);
+			await Bun.write(candidateOutputPath, rawOutput);
+			const byteSize = Buffer.byteLength(rawOutput, "utf8");
+			const lineCount = rawOutput.split("\n").length;
+			const sha256 = createHash("sha256").update(rawOutput).digest("hex");
+			const createdAt = new Date().toISOString();
+			await Bun.write(
+				`${candidateOutputPath}.meta.json`,
+				JSON.stringify({ id, kind: "agent-output", sizeBytes: byteSize, lineCount, sha256, createdAt }, null, 2),
+			);
+			outputPath = candidateOutputPath;
 			outputMeta = {
-				lineCount: rawOutput.split("\n").length,
+				lineCount,
 				charCount: rawOutput.length,
+				byteSize,
+				sha256,
 			};
 		} catch {
-			// Non-fatal
+			// Output or metadata write failed: never advertise an unverifiable
+			// artifact. Best-effort remove any orphaned `.md`/sidecar so a later
+			// agent:// read cannot serve unverified content. Non-fatal.
+			outputPath = undefined;
+			outputMeta = undefined;
+			try {
+				await fs.rm(candidateOutputPath, { force: true });
+				await fs.rm(`${candidateOutputPath}.meta.json`, { force: true });
+			} catch {
+				// best-effort cleanup; ignore
+			}
 		}
 	}
 

package/src/task/id.ts

@@ -0,0 +1,33 @@
+export const TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,47}$/;
+export const TASK_ID_DESCRIPTION = "filesystem-safe identifier matching ^[A-Za-z0-9][A-Za-z0-9_-]{0,47}$";
+
+const ALLOCATED_TASK_ID_PATTERN = new RegExp(
+	`^\\d+-${TASK_ID_PATTERN.source.slice(1, -1)}(?:\\.\\d+-${TASK_ID_PATTERN.source.slice(1, -1)})*$`,
+);
+
+export function isValidTaskId(id: string): boolean {
+	return TASK_ID_PATTERN.test(id);
+}
+
+export function getTaskIdValidationError(id: unknown): string | undefined {
+	if (typeof id !== "string") return "Task id must be a string.";
+	if (isValidTaskId(id)) return undefined;
+	return `Task id ${JSON.stringify(id)} is invalid. Use ${TASK_ID_DESCRIPTION}.`;
+}
+
+export function validateTaskId(id: string): string {
+	const error = getTaskIdValidationError(id);
+	if (error) throw new Error(error);
+	return id;
+}
+
+export function isValidAllocatedTaskId(id: string): boolean {
+	return ALLOCATED_TASK_ID_PATTERN.test(id);
+}
+
+export function validateAllocatedTaskId(id: string): string {
+	if (!isValidAllocatedTaskId(id)) {
+		throw new Error(`Allocated task id ${JSON.stringify(id)} is invalid for filesystem artifact paths.`);
+	}
+	return id;
+}