@gajae-code/coding-agent 0.13.3 → 0.14.0

package/src/tools/browser.ts

@@ -1,9 +1,13 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import { prompt, untilAborted } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { type BrowserActionStep, compileActionSteps } from "./browser/actions";
+import { isChromeProfileExecutableForLaunch, isEdgeExecutable, resolveSystemChromeForProfile } from "./browser/launch";
+import { chromeUserDataRoots, type DiscoveryEnv, defaultDiscoveryEnv } from "./browser/profile-discovery";
 import { acquireBrowser, type BrowserHandle, type BrowserKind, type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import { acquireTab, dropHeadlessTabs, getTab, releaseAllTabs, releaseTab, runInTab } from "./browser/tab-supervisor";
@@ -19,11 +23,17 @@ export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 const DEFAULT_TAB_NAME = "main";
 
 const appSchema = z.object({
-	path: z.string().describe("binary path to spawn").optional(),
+	path: z.string().describe("binary path to spawn (default: the installed Chrome/Chromium)").optional(),
 	cdp_url: z.string().describe("existing cdp endpoint").optional(),
 	browser: z.enum(["chrome"]).describe("existing browser profile mode").optional(),
-	user_data_dir: z.string().describe("Chrome user data directory containing profiles").optional(),
-	profile_directory: z.string().describe("Chrome profile directory name, e.g. Profile 10").optional(),
+	user_data_dir: z
+		.string()
+		.describe("non-default Chrome user data directory containing profiles (required for Chrome 136+ CDP)")
+		.optional(),
+	profile_directory: z
+		.string()
+		.describe('Chrome profile directory name, e.g. "Profile 10" (default "Default")')
+		.optional(),
 	background: z.boolean().describe("prefer background/hidden Chrome profile launch when supported").optional(),
 	no_focus: z.boolean().describe("avoid focusing Chrome during profile launch when supported").optional(),
 	cdp_port: z.number().int().positive().describe("local CDP port for launched Chrome profile").optional(),
@@ -116,30 +126,129 @@ export interface BrowserToolDetails {
 	meta?: OutputMeta;
 }
 
-export function resolveBrowserKindForTest(params: BrowserParams, session: ToolSession): BrowserKind {
-	return resolveBrowserKind(params, session);
+export function resolveBrowserKindForTest(
+	params: BrowserParams,
+	session: ToolSession,
+	signal?: AbortSignal,
+	discoveryEnv?: DiscoveryEnv,
+): Promise<BrowserKind> {
+	return resolveBrowserKind(params, session, signal, discoveryEnv);
+}
+
+/**
+ * Resolve guarded Chrome profile mode. The executable falls back to the
+ * installed Chrome/Chromium and the profile directory to `"Default"`.
+ * Chrome 136+ refuses remote debugging against its default data directory, so
+ * callers must explicitly provide a non-default user data directory.
+ */
+async function resolveChromeProfileKind(
+	app: NonNullable<BrowserParams["app"]>,
+	session: ToolSession,
+	signal?: AbortSignal,
+	discoveryEnv?: DiscoveryEnv,
+): Promise<BrowserKind> {
+	const profileDirectory = app.profile_directory ?? "Default";
+	const exe = app.path ? resolveToCwd(app.path, session.cwd) : resolveSystemChromeForProfile();
+	if (!exe) {
+		throw new ToolError(
+			'No Chrome/Chromium executable found for app.browser "chrome". Install Chrome, or pass app.path with the binary path.',
+		);
+	}
+	const canonicalExe = await canonicalPath(exe, process.platform, signal);
+	if (!isChromeProfileExecutableForLaunch(exe, canonicalExe)) {
+		throw new ToolError(
+			isEdgeExecutable(canonicalExe)
+				? 'app.path for app.browser "chrome" must be Google Chrome or Chromium, not Microsoft Edge. Use Edge with app.path spawn mode and a separate profile, or pass a Chrome/Chromium executable.'
+				: 'app.path for app.browser "chrome" must be a Google Chrome or Chromium executable. Other Chromium-based browsers must use app.path spawn mode with their own separate profile.',
+		);
+	}
+	if (!app.user_data_dir) {
+		throw new ToolError(
+			'app.user_data_dir is required for app.browser "chrome". Chrome 136+ disables remote debugging for the default Chrome data directory; pass a separate non-default user data directory, or attach to an already-authorized browser with app.cdp_url.',
+		);
+	}
+	const userDataDir = resolveChromeProfileUserDataDir(app.user_data_dir, session.cwd, discoveryEnv?.platform);
+	if (await isDefaultChromeUserDataDir(userDataDir, signal, discoveryEnv)) {
+		throw new ToolError(
+			`Refusing Chrome's default user data directory ${JSON.stringify(userDataDir)}. Chrome 136+ disables remote debugging there; pass a separate non-default app.user_data_dir, or use app.cdp_url for an already-authorized browser.`,
+		);
+	}
+	return {
+		kind: "chrome-profile",
+		path: exe,
+		userDataDir,
+		profileDirectory,
+		background: app.background ?? false,
+		noFocus: app.no_focus ?? false,
+		cdpPort: app.cdp_port,
+	};
 }
 
-function resolveBrowserKind(params: BrowserParams, session: ToolSession): BrowserKind {
+async function canonicalPath(
+	candidate: string,
+	platform: NodeJS.Platform = process.platform,
+	signal?: AbortSignal,
+): Promise<string> {
+	const platformPath = platform === "win32" ? path.win32 : path.posix;
+	let resolved = platformPath.resolve(candidate);
+	if (platform === process.platform) {
+		throwIfAborted(signal);
+		try {
+			resolved = signal ? await untilAborted(signal, () => fs.realpath(resolved)) : await fs.realpath(resolved);
+		} catch {}
+		throwIfAborted(signal);
+	}
+	return platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function isDefaultChromeUserDataDir(
+	candidate: string,
+	signal?: AbortSignal,
+	discoveryEnv: DiscoveryEnv = defaultDiscoveryEnv(() => false),
+): Promise<boolean> {
+	return isDefaultChromeUserDataDirForTest(
+		candidate,
+		chromeUserDataRoots(discoveryEnv),
+		discoveryEnv.platform,
+		signal,
+	);
+}
+
+function resolveChromeProfileUserDataDir(
+	candidate: string,
+	cwd: string,
+	platform: NodeJS.Platform = process.platform,
+): string {
+	if (platform === process.platform) return resolveToCwd(candidate, cwd);
+	const platformPath = platform === "win32" ? path.win32 : path.posix;
+	return platformPath.isAbsolute(candidate) ? platformPath.resolve(candidate) : platformPath.resolve(cwd, candidate);
+}
+
+export async function isDefaultChromeUserDataDirForTest(
+	candidate: string,
+	roots: readonly string[],
+	platform: NodeJS.Platform = process.platform,
+	signal?: AbortSignal,
+): Promise<boolean> {
+	const canonicalCandidate = await canonicalPath(candidate, platform, signal);
+	for (const root of roots) {
+		if ((await canonicalPath(root, platform, signal)) === canonicalCandidate) return true;
+	}
+	return false;
+}
+
+async function resolveBrowserKind(
+	params: BrowserParams,
+	session: ToolSession,
+	signal?: AbortSignal,
+	discoveryEnv?: DiscoveryEnv,
+): Promise<BrowserKind> {
 	const app = params.app;
 	if (app?.cdp_url) {
 		return { kind: "connected", cdpUrl: app.cdp_url.replace(/\/+$/, "") };
 	}
 	if (app?.browser === "chrome") {
-		if (!app.path) throw new ToolError('app.path is required when app.browser is "chrome".');
-		if (!app.user_data_dir) throw new ToolError('app.user_data_dir is required when app.browser is "chrome".');
-		if (!app.profile_directory)
-			throw new ToolError('app.profile_directory is required when app.browser is "chrome".');
-		const exe = resolveToCwd(app.path, session.cwd);
-		return {
-			kind: "chrome-profile",
-			path: exe,
-			userDataDir: resolveToCwd(app.user_data_dir, session.cwd),
-			profileDirectory: app.profile_directory,
-			background: app.background ?? false,
-			noFocus: app.no_focus ?? false,
-			cdpPort: app.cdp_port,
-		};
+		return resolveChromeProfileKind(app, session, signal, discoveryEnv);
 	}
 	if (app?.path) {
 		const exe = resolveToCwd(app.path, session.cwd);
@@ -217,7 +326,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		timeoutMs: number,
 		signal?: AbortSignal,
 	): Promise<AgentToolResult<BrowserToolDetails>> {
-		const kind = resolveBrowserKind(params, this.session);
+		const kind = await resolveBrowserKind(params, this.session, signal);
 		details.browser = kind.kind;
 
 		// If a tab with this name already exists on a different browser kind, fail fast — caller must close first.

package/src/tools/computer.enforcement.test.ts

@@ -153,7 +153,7 @@ describe("computer enforcement red-team probes", () => {
 				observed: `code=${resultCode(permission)} message=${resultMessage(permission)} nativeScreenshotCalls=${permissionCalls}`,
 				verdict:
 					resultCode(permission) === "COMPUTER_PERMISSION_REQUIRED" &&
-					resultMessage(permission).includes("screen-recording or accessibility permission")
+					resultMessage(permission).includes("Screen & System Audio Recording or Accessibility")
 						? "passed"
 						: "failed",
 			});

package/src/tools/computer.ts

@@ -1120,10 +1120,11 @@ function mapComputerError(error: unknown, hotkey?: string): { code: string; mess
 		COMPUTER_SUSPENDED: `Stop and wait for the user${hotkey ? ` (kill-switch hotkey: ${hotkey})` : ""}.`,
 		COMPUTER_CANCELLED: `Stop and wait for the user${hotkey ? ` (kill-switch hotkey: ${hotkey})` : ""}.`,
 		COMPUTER_PERMISSION_REQUIRED:
-			"The host needs screen-recording or accessibility permission. Ask the user to grant it.",
+			"Grant Screen & System Audio Recording or Accessibility to the exact GJC launcher named in the diagnostic, then fully quit and relaunch GJC.",
 		COMPUTER_DISABLED:
 			"The computer tool is disabled or unsupported. Do not retry without enabling it on Apple Silicon macOS.",
-		COMPUTER_SCREENSHOT_FAILED: "Capture failed. Check screen-recording permission and retry the screenshot.",
+		COMPUTER_SCREENSHOT_FAILED:
+			"Capture failed after the current-process permission preflight passed. Check display availability and retry the screenshot.",
 		COMPUTER_CURSOR_RESTORE_FAILED:
 			"Input may have completed, but the cursor could not be restored. Stop and ask the user to inspect the desktop before retrying.",
 	};

package/src/tools/cron.ts

@@ -589,8 +589,19 @@ export class CronTool implements AgentTool<typeof cronSchema, CronToolDetails> {
 		}
 	}
 
+	#resolveOwnedJobManager(): AsyncJobManager | undefined {
+		const endpointId = this.session.getSessionId?.() ?? undefined;
+		return (
+			this.session.getAsyncJobManager?.() ?? AsyncJobManager.forEndpoint(endpointId) ?? AsyncJobManager.instance()
+		);
+	}
+
 	async #create(params: CronParams): Promise<AgentToolResult<CronToolDetails>> {
-		const manager = AsyncJobManager.instance();
+		// Cron cleanup is consumed by the owning AgentSession's lifecycle
+		// manager. A concurrent top-level session can be the process-global
+		// instance, so registering there would leave this session's timer
+		// running after new-session, switch, or disposal (review thread P1).
+		const manager = this.#resolveOwnedJobManager();
 		if (!manager) {
 			throw new ToolError("Async execution is disabled; cron is unavailable in this session.");
 		}

package/src/tools/image-gen.ts

@@ -166,7 +166,7 @@ const ALIBABA_IMAGE_GENERATION_URL = `${ALIBABA_TOKEN_PLAN_HOST}/api/v1/services
 const IMAGE_SYSTEM_INSTRUCTION =
 	"You are an AI image generator. Generate images based on user descriptions. Focus on creating high-quality, visually appealing images that match the user's request.";
 
-type ImageProvider = "alibaba" | "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter" | (string & {});
+type ImageProvider = "alibaba" | "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
 interface ImageApiKey {
 	provider: ImageProvider;
 	apiKey: string;
@@ -175,6 +175,19 @@ interface ImageApiKey {
 	authCredentialType?: "api_key" | "oauth";
 }
 
+export class UnsupportedImageProviderError extends Error {
+	readonly code = "unsupported_image_provider" as const;
+
+	constructor(
+		readonly provider: string,
+		readonly modelId: string,
+		readonly api: Model["api"],
+	) {
+		super(`Image generation is not supported for provider "${provider}" with transport "${api}".`);
+		this.name = "UnsupportedImageProviderError";
+	}
+}
+
 const responseModalitySchema = z.enum(["IMAGE", "TEXT"] as const);
 const aspectRatioSchema = z.enum(["1:1", "3:4", "4:3", "9:16", "16:9"] as const).describe("aspect ratio");
 const imageSizeSchema = z.enum(["1024x1024", "1536x1024", "1024x1536"] as const).describe("image size");
@@ -935,8 +948,9 @@ async function findImageApiKey(
 }
 
 /**
- * Map a resolved image model to its provider credentials. Each provider
- * branch mirrors the original credential-resolution path.
+ * Map a resolved image model to its provider credentials. Transport and image
+ * capability are validated before any credential lookup; unsupported models
+ * fail without forwarding their provider credential to another endpoint.
  */
 async function resolveCredentialsForImageModel(
 	model: Model,
@@ -958,19 +972,23 @@ async function resolveCredentialsForImageModel(
 		};
 	}
 
-	if (provider === "antigravity" || provider === "google-antigravity") {
+	if (
+		(provider === "antigravity" || provider === "google-antigravity") &&
+		model.api === "google-gemini-cli" &&
+		model.output?.includes("image")
+	) {
 		return await findAntigravityCredentials(modelRegistry, sessionId);
 	}
-	if (provider === "alibaba" || provider === "alibaba-token-plan") {
+	if ((provider === "alibaba" || provider === "alibaba-token-plan") && model.output?.includes("image")) {
 		return await findAlibabaImageCredentials(modelRegistry, sessionId);
 	}
-	if (provider === "openrouter") {
+	if (provider === "openrouter" && model.output?.includes("image")) {
 		const openRouterKey = await modelRegistry.getApiKey(model, sessionId);
 		if (isAuthenticated(openRouterKey)) return { provider: "openrouter", apiKey: openRouterKey };
 		const envKey = getEnvApiKey("openrouter");
 		return envKey ? { provider: "openrouter", apiKey: envKey } : null;
 	}
-	if (provider === "gemini" || provider === "google") {
+	if (provider === "google" && model.api === "google-generative-ai" && model.output?.includes("image")) {
 		const googleKey = await modelRegistry.getApiKey(model, sessionId);
 		if (isAuthenticated(googleKey)) return { provider: "gemini", apiKey: googleKey };
 		const envKey = getEnvApiKey("google");
@@ -979,14 +997,7 @@ async function resolveCredentialsForImageModel(
 		return fallbackKey ? { provider: "gemini", apiKey: fallbackKey } : null;
 	}
 
-	// Fallback: try the model's own API key via the registry.
-	const apiKey = await modelRegistry.getApiKey(model, sessionId);
-	if (!isAuthenticated(apiKey)) return null;
-	return {
-		provider: provider as ImageProvider,
-		apiKey,
-		model,
-	};
+	throw new UnsupportedImageProviderError(model.provider, model.id, model.api);
 }
 
 async function loadImageFromPath(imagePath: string, cwd: string): Promise<InlineImageData> {
@@ -1085,7 +1096,7 @@ function collectInlineImages(parts: GeminiPart[]): InlineImageData[] {
 	return images;
 }
 
-export function isOpenAIHostedImageModel(model: Model | undefined): model is Model {
+export function isOpenAIHostedImageModel(model: Model | undefined): boolean {
 	if (!model) return false;
 	// The hosted image_generation tool is only available over the Responses API.
 	if (model.api !== "openai-responses" && model.api !== "openai-codex-responses") return false;

package/src/tools/index.ts

@@ -1,6 +1,7 @@
 import type { AgentTelemetryConfig, AgentTool } from "@gajae-code/agent-core";
 import type { Model, ServiceTier, ToolChoice } from "@gajae-code/ai/core";
 import { $env, logger } from "@gajae-code/utils";
+import type { AsyncJobManager } from "../async";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -217,6 +218,8 @@ export interface ToolSession {
 	hasForegroundBashBackgroundRequestHandler?: () => boolean;
 	/** Request that the active managed foreground bash call fold into a background job, if supported. */
 	requestForegroundBashBackground?: () => boolean;
+	/** Get the session-owned or inherited async job manager. */
+	getAsyncJobManager?: () => AsyncJobManager | undefined;
 	/** Get session ID */
 	getSessionId?: () => string | null;
 	/** Get credential-selection session identity. */
@@ -279,6 +282,11 @@ export interface ToolSession {
 	agentOutputManager?: AgentOutputManager;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
+	/**
+	 * The session's REQUESTED effective agent directory, independent of the
+	 * global Settings singleton (which can be reused across sessions).
+	 */
+	getSessionAgentDir?: () => string;
 	/** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
 	serviceTier?: ServiceTier;
 	/** Whether the effective subagent tier grants fast mode for a resolved provider. */

package/src/tools/job.ts

@@ -7,6 +7,7 @@ import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled, jobElaps
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import jobDescription from "../prompts/tools/job.md" with { type: "text" };
+import { lookupOwnedRegistration, unregisterOwnedRegistration } from "../session/terminal-abort";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from "./index";
 import {
@@ -100,7 +101,10 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<JobToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<JobToolDetails>> {
-		const manager = AsyncJobManager.instance();
+		const manager =
+			this.session.getAsyncJobManager?.() ??
+			AsyncJobManager.forEndpoint(this.session.getSessionId?.() ?? undefined) ??
+			AsyncJobManager.instance();
 		if (!manager) {
 			return {
 				content: [{ type: "text", text: "Async execution is disabled; no background jobs are available." }],
@@ -237,7 +241,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		const PROGRESS_INTERVAL_MS = 500;
 		const emitProgress = () => {
 			if (!onUpdate) return;
-			const snapshot = this.#snapshotJobs(allTrackedJobs);
+			const snapshot = this.#snapshotJobs(manager, allTrackedJobs);
 			onUpdate({
 				content: [{ type: "text", text: "" }],
 				details: {
@@ -318,6 +322,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	}
 
 	#snapshotJobs(
+		manager: AsyncJobManager,
 		jobs: {
 			id: string;
 			type: "bash" | "task";
@@ -331,7 +336,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	): JobSnapshot[] {
 		const now = Date.now();
 		return jobs.map(j => {
-			const current = AsyncJobManager.instance()?.getJob(j.id);
+			const current = manager.getJob(j.id);
 			const latest = current ?? j;
 			return {
 				id: latest.id,
@@ -366,9 +371,31 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			seen.add(j.id);
 			return true;
 		});
-		const jobResults = this.#snapshotJobs(uniqueJobs);
-
-		manager.acknowledgeDeliveries(jobResults.filter(j => j.status !== "running").map(j => j.id));
+		const jobResults = this.#snapshotJobs(manager, uniqueJobs);
+
+		// Only COMPLETED/FAILED/CANCELLED jobs are terminal for ownership
+		// retirement: a paused subagent is not quiescent (settleOwnedWork
+		// cancels paused jobs before it can claim stopped_owned), so its
+		// ownership tuple must stay registered until it is actually cancelled
+		// — otherwise a scope:"owned" abort could find an empty causal set and
+		// report stopped_owned while the job remains visibly paused (review
+		// thread P2).
+		const terminalJobs = jobResults.filter(
+			j => j.status === "completed" || j.status === "failed" || j.status === "cancelled",
+		);
+		manager.acknowledgeDeliveries(terminalJobs.map(j => j.id));
+		// A terminal job whose deliveries were just acknowledged is
+		// synchronously consumed: its owned registration is settled and must
+		// not occupy the registry, otherwise the retained-policy tombstone
+		// treats it as a live policy occupant forever and its FIFO fallback can
+		// evict a genuinely running job's policy (review thread P2).
+		for (const job of terminalJobs) {
+			const generation = manager.getJob?.(job.id)?.generation;
+			if (!generation) continue;
+			// The endpoint disambiguates concurrent sessions' same job ids (review P1).
+			const registration = lookupOwnedRegistration(job.id, generation, this.session.getSessionId?.() ?? "local");
+			if (registration) unregisterOwnedRegistration(registration);
+		}
 
 		const completed = jobResults.filter(j => j.status !== "running");
 		const running = jobResults.filter(j => j.status === "running");

package/src/tools/monitor.ts

@@ -4,6 +4,7 @@ import * as z from "zod/v4";
 import { AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
 import monitorDescription from "../prompts/tools/monitor.md" with { type: "text" };
 import { truncateTail } from "../session/streaming-output";
+import { lookupOwnedRegistration } from "../session/terminal-abort";
 import { BashTool } from "./bash";
 import type { ToolSession } from "./index";
 import { ToolError } from "./tool-errors";
@@ -106,13 +107,20 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 	}
 
 	async execute(
-		_toolCallId: string,
+		toolCallId: string,
 		params: MonitorParams,
 		_signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<MonitorToolDetails>,
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<MonitorToolDetails>> {
-		const manager = AsyncJobManager.instance();
+		// The session's ENDPOINT-owned manager first: the monitor job is created
+		// in it, its generation is read from it, and non-persistent cancel must
+		// stop that exact job — the process-global instance may belong to a
+		// different concurrent top-level session (review thread P1).
+		const manager =
+			this.session.getAsyncJobManager?.() ??
+			AsyncJobManager.forEndpoint(this.session.getSessionId?.() ?? undefined) ??
+			AsyncJobManager.instance();
 		if (!manager) {
 			throw new ToolError("Async execution is disabled; the monitor tool is unavailable in this session.");
 		}
@@ -169,8 +177,38 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 			const suffix = count > 0 ? `\n(+${count} earlier lines)` : "";
 			const notificationLine = formatMonitorNotificationLine(line);
 			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${notificationLine.content}${suffix}\n</task-notification>`;
+			// Route the notification through the SAME owned-completion envelope
+			// and fresh-admission path as async results: a scope:"turn" abort
+			// that left this monitor running must resume the agent with a FRESH
+			// lineage (never the aborted attempt's), and scope:"owned" must drop
+			// it. The envelope is built from the tool-call lineage binding and
+			// the exact registered tuple; monitors without a registration stay
+			// ordinary. The standalone generation is NOT persisted — it lives in
+			// the envelope, which INTERNAL_DETAILS_FIELDS strips (review threads
+			// P1/P2).
+			const generation = manager.getJob(jobId)?.generation;
+			// Build the envelope from the RETAINED registration (which carries the
+			// complete lineage tuple), not the tool-call binding: the binding map
+			// is separately bounded and can evict a long-lived monitor's entry,
+			// but the registration keeps the lineage for owned classification
+			// (review thread P2).
+			// The lookup is ENDPOINT-scoped to THIS monitor's session: concurrent
+			// sessions have monitors with the same manager-local job id, and an
+			// endpoint-less fallback scan could attach a foreign session's
+			// registration (review thread P2).
+			const registration = generation
+				? lookupOwnedRegistration(jobId, generation, this.session.getSessionId?.() ?? "local")
+				: undefined;
+			const ownedCompletion = registration
+				? {
+						lineageIdHash: registration.lineageIdHash,
+						promptAttemptEpoch: registration.promptAttemptEpoch,
+						registration,
+					}
+				: undefined;
 			const details = {
 				taskId: jobId,
+				...(ownedCompletion ? { ownedCompletions: [ownedCompletion] } : {}),
 				kind: params.kind,
 				description: params.description,
 				monitor: true,
@@ -219,6 +257,7 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 				ownerId,
 				label,
 				ctx: context,
+				toolCallId,
 				shouldAcceptRawLine: () => !controller.closed,
 				lifecycle: {
 					onCancel: () => closeMonitor("purge"),

package/src/tools/skill-discovery.ts

@@ -1,7 +1,11 @@
 import type { AgentTool, AgentToolResult } from "@gajae-code/agent-core";
 import { prompt, untilAborted } from "@gajae-code/utils";
 import * as z from "zod/v4";
-import { discoverRuntimeSkills, type RuntimeSkillDiscoveryCandidate } from "../extensibility/runtime-skill-discovery";
+import {
+	describeDisabledSkillScopes,
+	discoverRuntimeSkills,
+	type RuntimeSkillDiscoveryCandidate,
+} from "../extensibility/runtime-skill-discovery";
 import skillDiscoveryDescription from "../prompts/tools/skill-discovery.md" with { type: "text" };
 import type { ToolSession } from ".";
 
@@ -23,11 +27,18 @@ export interface SkillDiscoveryToolDetails {
 	count: number;
 	/**
 	 * Present only when zero candidates were returned AND discovery config gates
-	 * (`skills.enabled` / `skills.enablePiProject` / `skills.enablePiUser`)
+	 * (`skills.enabled` / `skills.trustProjectSkills` / `skills.trustUserSkills`)
 	 * prevented some or all of the requested scope from being searched. Without
 	 * this, a disabled config is indistinguishable from "no skills exist".
 	 */
 	notice?: string;
+	/**
+	 * Human-readable diagnostics for skills that were scanned but not
+	 * advertised (protected-name collisions with bundled workflow skills,
+	 * include/ignore/disable policy filters, invalid frontmatter, shadowing,
+	 * scan failures). Bounded; empty when nothing was filtered.
+	 */
+	diagnostics?: string[];
 }
 
 export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
@@ -65,16 +76,20 @@ export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema
 	): Promise<AgentToolResult<SkillDiscoveryToolDetails>> {
 		return untilAborted(signal, async () => {
 			const source = input.source ?? "all";
-			const candidates = await discoverRuntimeSkills({
+			const result = await discoverRuntimeSkills({
 				cwd: this.#session.cwd,
 				query: input.query,
 				source,
 				limit: input.limit,
 				policy: this.#getRuntimeSkillPolicy(),
 			});
-			const details: SkillDiscoveryToolDetails = { candidates, count: candidates.length };
-			if (candidates.length === 0) {
-				const notice = this.#disabledPolicyNotice(source);
+			const details: SkillDiscoveryToolDetails = {
+				candidates: result.candidates,
+				count: result.candidates.length,
+			};
+			if (result.diagnostics.messages.length > 0) details.diagnostics = result.diagnostics.messages;
+			if (result.candidates.length === 0) {
+				const notice = describeDisabledSkillScopes(source, this.#getRuntimeSkillPolicy());
 				if (notice) details.notice = notice;
 			}
 			return {
@@ -83,27 +98,4 @@ export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema
 			};
 		});
 	}
-
-	/**
-	 * Explain an empty result that is caused by disabled discovery config rather
-	 * than by an actually empty skill catalog.
-	 */
-	#disabledPolicyNotice(source: "all" | "project" | "user"): string | undefined {
-		const policy = this.#getRuntimeSkillPolicy();
-		if (policy.enabled !== true) {
-			return "Runtime skill discovery is disabled: `skills.enabled` is false, so no skill directories were searched. Enable it with `gjc config set skills.enabled true` (project and user scopes additionally require `skills.enablePiProject` / `skills.enablePiUser`).";
-		}
-		const skipped: string[] = [];
-		const commands: string[] = [];
-		if ((source === "all" || source === "project") && policy.enablePiProject !== true) {
-			skipped.push("project (`skills.enablePiProject` is false)");
-			commands.push("`gjc config set skills.enablePiProject true`");
-		}
-		if ((source === "all" || source === "user") && policy.enablePiUser !== true) {
-			skipped.push("user (`skills.enablePiUser` is false)");
-			commands.push("`gjc config set skills.enablePiUser true`");
-		}
-		if (skipped.length === 0) return undefined;
-		return `Skill discovery skipped disabled scope(s): ${skipped.join(", ")}. Enable them with ${commands.join(" and ")}.`;
-	}
 }