@xopcai/xopc 0.0.179 → 0.0.187

package/dist/src/agent/service/direct-turn-helpers.js

@@ -1,5 +1,7 @@
+import { buildTaskExecutionDirective } from "../../tasks/task-context-assembler.js";
 import { resolveImageHandlingStrategy } from "../image/vision-detection.js";
 import { hydrateUserTurnForLlm } from "../inbound/attachment-pipeline.js";
+import { prependAgentContext } from "../memory/context/planner.js";
 import { extractAgentUserPlainText } from "../memory/user-message-text.js";
 import { shouldSkipResetOverlapCommand } from "../../session/reset-triggers.js";
 import { parseSlashCommand } from "../../chat-commands/command-parse.js";
@@ -74,12 +76,13 @@ async function tryRunSlashCommand(deps, ctx, content, options) {
 * prefetch + background-review nudge wiring used by every direct entry point.
 */
 async function runDirectAgentTurn(deps, input) {
+	const turnId = input.runId ?? crypto.randomUUID();
 	const userPlain = extractAgentUserPlainText(input.userMessage);
-	const userContext = await deps.agentManager.prepareUserTurnContext(input.userMessage, input.sessionKey);
-	const userMessageForModel = userContext.modelMessage;
+	const userContext = await deps.agentManager.prepareUserTurnContext(input.userMessage, input.sessionKey, turnId);
+	const userMessageForModel = prependAgentContext(userContext.modelMessage, buildTaskExecutionDirective(input.sessionKey));
 	if (userContext.consentRequests.length > 0) input.onEvent?.({
 		type: "memory_consent_required",
-		runId: input.runId,
+		runId: turnId,
 		requests: userContext.consentRequests
 	});
 	const modelRef = deps.modelManager.getModelForSession(input.sessionKey);
@@ -91,7 +94,7 @@ async function runDirectAgentTurn(deps, input) {
 	const llmImages = [...llmTurn.images, ...sourceImages];
 	const result = await runEmbeddedTurnForSession({
 		sessionKey: input.sessionKey,
-		runId: input.runId ?? crypto.randomUUID(),
+		runId: turnId,
 		userMessage: userMessageForModel,
 		llmImages,
 		sessionStore: deps.sessionStore,
@@ -99,13 +102,14 @@ async function runDirectAgentTurn(deps, input) {
 		modelManager: deps.modelManager,
 		getConfig: () => deps.config,
 		abortSignal: input.abortSignal,
+		deadlineAtMs: input.deadlineAtMs,
 		beforeTurn: () => deps.agentManager.beginBackgroundReviewUserTurn(input.sessionKey),
 		onEvent: input.onEvent
 	});
 	const understandingReview = await deps.agentManager.afterAgentTurn(input.sessionKey, userPlain);
 	if (understandingReview?.createdRecords.length) input.onEvent?.({
 		type: "memory_captured",
-		runId: input.runId,
+		runId: turnId,
 		records: understandingReview.createdRecords
 	});
 	deps.agentManager.scheduleBackgroundReviewAfterUserTurn(input.sessionKey);

package/dist/src/agent/service/process-direct-one-shot.d.ts

@@ -33,4 +33,7 @@ export declare function runProcessDirect(deps: RunProcessDirectDeps, input: {
     sessionKey: string;
     attachments?: InboundAttachmentInput[];
     thinking?: string;
+    signal?: AbortSignal;
+    runId?: string;
+    deadlineAtMs?: number;
 }): Promise<string>;

package/dist/src/agent/service/process-direct-one-shot.js

@@ -61,7 +61,10 @@ async function runProcessDirect(deps, input) {
 					config: deps.config
 				}, {
 					sessionKey: input.sessionKey,
-					userMessage
+					runId: input.runId,
+					userMessage,
+					abortSignal: input.signal,
+					deadlineAtMs: input.deadlineAtMs
 				}));
 			} finally {
 				clearPendingTranscriptUserMessage(input.sessionKey, pendingUserMessage);

package/dist/src/agent/service/process-direct-streaming.d.ts

@@ -36,8 +36,8 @@ export interface ProcessDirectStreamingDeps {
     commandHandler: Pick<CommandHandler, 'executeCommandAndAggregateReply'>;
     prepareInboundAttachments: (sessionKey: string, attachments?: DirectStreamInboundAttachment[]) => Promise<MediaRef[] | undefined>;
     buildTranscriptUserMessage: (content: string, prepared: MediaRef[] | undefined, sessionKey: string) => Promise<TranscriptUserMessage>;
-    recordPersistentGoalStreamOutcome?: (sessionKey: string, outcome: {
-        skipPersistentGoalPostTurn: boolean;
+    recordTaskReviewStreamHint?: (sessionKey: string, task: {
+        skipTaskReview: boolean;
     }) => void;
     onTurnComplete?: (sessionKey: string, lastAssistantText?: string) => void;
     enqueueProvisionalSessionTitle?: (sessionKey: string, userText: string) => void;

package/dist/src/agent/service/process-direct-streaming.js

@@ -237,7 +237,7 @@ async function* runProcessDirectStreaming(deps, input) {
 					webchatSlashReceipt = text;
 					pushAssistantReceipt(queue, text, input.runId, slashCommandMetadata);
 				} else if (channel === "webchat") {
-					webchatSlashReceipt = "Command finished with no assistant text. If you used `/goal`, a follow-up turn may still be scheduled automatically.";
+					webchatSlashReceipt = "Command finished with no assistant text. An Task continuation may still be scheduled automatically.";
 					pushAssistantReceipt(queue, webchatSlashReceipt, input.runId);
 				}
 				const workflowRun = slash.metadata?.workflowRun;
@@ -350,7 +350,7 @@ async function* runProcessDirectStreaming(deps, input) {
 				sessionKey
 			}, "Failed to persist webchat slash command receipt");
 		}
-		deps.recordPersistentGoalStreamOutcome?.(sessionKey, { skipPersistentGoalPostTurn: ranSlashCommand });
+		deps.recordTaskReviewStreamHint?.(sessionKey, { skipTaskReview: ranSlashCommand });
 	} finally {
 		if (channel === "webchat") deps.unregisterWebchatSsePublisher(sessionKey);
 		deps.endDirectRequestContext();

package/dist/src/agent/service.d.ts

@@ -9,7 +9,7 @@ import { type AgentSkillAvailabilityPayload, type SkillCatalogEntry, type SkillC
 import type { SkillMarkdownPreviewPayload } from './skills/types.js';
 import type { AgentCapabilityCatalogEntry } from './capabilities/index.js';
 import type { AgentServiceConfig, StreamHandle } from './service.types.js';
-import { PersistentGoalService } from './goals/persistent-goal-service.js';
+import { TaskJudgeService } from './tasks/task-judge-service.js';
 import type { SkillInstallToolOptions, SkillInstallToolResult, MarketplaceSkillInstallToolOptions, MarketplaceSkillInstallToolResult } from './tools/skill-install-tool.js';
 import { type InboundAttachmentInput, type MediaRef } from '../channels/attachments/inbound-persist.js';
 export type { AgentServiceConfig, AgentContext, StreamHandle } from './service.types.js';
@@ -55,12 +55,8 @@ export declare class AgentService {
      * TUI, CLI, and automations do not need to thread every call through `AgentService`.
      */
     readonly turnDispatcher: TurnDispatcher;
-    /**
-     * `/goal` runtime: continuation scheduling, persistent-goal API factory,
-     * stream-outcome state, post-turn verdict. Public so the gateway can wire
-     * the webchat continuation scheduler and read stream outcomes directly.
-     */
-    readonly persistentGoals: PersistentGoalService;
+    /** Independent acceptance review for the active Task after an agent turn. */
+    readonly taskJudge: TaskJudgeService;
     /**
      * Per-session config writes (model / thinking / reasoning / working directory).
      * Public so REST endpoints and CLI flows can hit it without going through a
@@ -88,8 +84,8 @@ export declare class AgentService {
     private agentManager;
     /**
      * Unified per-session state container (replaces six ad-hoc Maps). Owns webchat
-     * publishers, last assistant text, embedded stream buffer, persistent-goal stream
-     * outcomes, concurrent-turn depth, and event-listener unsubscribers; runs a TTL
+     * publishers, last assistant text, embedded stream buffer, Task review stream
+     * tasks, concurrent-turn depth, and event-listener unsubscribers; runs a TTL
      * sweep for slots that have no explicit owner.
      */
     private sessionState;
@@ -113,6 +109,7 @@ export declare class AgentService {
     getCapabilityCatalog(sessionKey?: string): AgentCapabilityCatalogEntry[];
     getSkillMarkdownSource(skillName: string): SkillMarkdownPreviewPayload | null;
     refreshSkillsAfterDiskChange(): void;
+    refreshSkillsAfterTrustChange(): void;
     installSkillFromSource(opts: SkillInstallToolOptions): Promise<SkillInstallToolResult>;
     installSkillFromMarketplace(opts: MarketplaceSkillInstallToolOptions): Promise<MarketplaceSkillInstallToolResult>;
     refreshSkillsAfterSkillConfigChange(): void;
@@ -133,6 +130,7 @@ export declare class AgentService {
     beginInboundTurn(sessionKey: string): void;
     endInboundTurn(sessionKey: string): void;
     getInboundTurnDepth(sessionKey: string): number;
+    takeTaskReviewStreamHint(sessionKey: string): import("./session/session-state-bag.js").TaskReviewStreamHint;
     start(): Promise<void>;
     stop(): Promise<void>;
     reconcileDreamingNow(): Promise<void>;

package/dist/src/agent/service.js

@@ -9,6 +9,7 @@ import { init_paths, resolveUserProfilePath } from "../config/paths.js";
 import { extractTextContent } from "./context/workspace.js";
 import { effectiveWorkspacePathForSession } from "../session/session-workspace.js";
 import { getProjectForSession } from "../projects/workspace.js";
+import { resolveResponseLanguageForSession } from "./prompt/response-language.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "./skills/workspace-skills-dir.js";
 import { removeSkillsLockEntry } from "./skills/hub-lock.js";
 import { installSkillFromZip } from "./skills/managed-store.js";
@@ -63,7 +64,8 @@ import { getWorkflowProgressBroker } from "./workflow/progress-broker.js";
 import "./workflow/index.js";
 import { FeedbackCoordinator } from "./feedback/feedback-coordinator.js";
 import "./feedback/index.js";
-import { PersistentGoalService } from "./goals/persistent-goal-service.js";
+import { TaskJudgeService } from "./tasks/task-judge-service.js";
+import { analyzeResponseLanguage } from "../i18n/language-consistency.js";
 import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 //#region src/agent/service.ts
@@ -124,12 +126,8 @@ var AgentService = class {
 	* TUI, CLI, and automations do not need to thread every call through `AgentService`.
 	*/
 	turnDispatcher;
-	/**
-	* `/goal` runtime: continuation scheduling, persistent-goal API factory,
-	* stream-outcome state, post-turn verdict. Public so the gateway can wire
-	* the webchat continuation scheduler and read stream outcomes directly.
-	*/
-	persistentGoals;
+	/** Independent acceptance review for the active Task after an agent turn. */
+	taskJudge;
 	/**
 	* Per-session config writes (model / thinking / reasoning / working directory).
 	* Public so REST endpoints and CLI flows can hit it without going through a
@@ -157,8 +155,8 @@ var AgentService = class {
 	agentManager;
 	/**
 	* Unified per-session state container (replaces six ad-hoc Maps). Owns webchat
-	* publishers, last assistant text, embedded stream buffer, persistent-goal stream
-	* outcomes, concurrent-turn depth, and event-listener unsubscribers; runs a TTL
+	* publishers, last assistant text, embedded stream buffer, Task review stream
+	* tasks, concurrent-turn depth, and event-listener unsubscribers; runs a TTL
 	* sweep for slots that have no explicit owner.
 	*/
 	sessionState = new SessionStateBag();
@@ -243,8 +241,8 @@ var AgentService = class {
 			getBrowserRecipeService: config.getBrowserRecipeService,
 			getNotesService: config.getNotesService,
 			getProjectService: config.getProjectService,
-			getWorkItemService: config.getWorkItemService,
 			getLocalAppService: config.getLocalAppService,
+			dispatchTaskRuns: config.dispatchTaskRuns,
 			getWorkflowRunService: config.getWorkflowRunService,
 			onSkillsUpdated: config.onSkillsUpdated,
 			installSkillFromSource: (opts) => this.installSkillFromSource(opts),
@@ -270,6 +268,18 @@ var AgentService = class {
 			const changedPaths = readChangedPathsFromToolEnd(e.toolName, e.args, e.result);
 			this.agentManager.markCodeIntelligenceDirty(context.sessionKey, changedPaths);
 		});
+		this.agentEventHandler.registerListener("message_end", (event, context) => {
+			const message = event.message;
+			if (message.role !== "assistant") return;
+			const analysis = analyzeResponseLanguage(assistantMessageText(message), resolveResponseLanguageForSession(this.effectiveAppConfig(), context.sessionKey));
+			const fields = {
+				phase: "response_language_check",
+				sessionKey: context.sessionKey,
+				...analysis
+			};
+			if (analysis.compliant) log.debug(fields, "Assistant response language check passed");
+			else log.warn(fields, "Assistant response language did not match the active preference");
+		});
 		this.workflowProgressBrokerHandle = getWorkflowProgressBroker().attachTo(this.agentEventHandler);
 		this.sessionHydrator = new SessionHydrator({
 			sessionConfigStore: this.sessionConfigStore,
@@ -311,7 +321,6 @@ var AgentService = class {
 			bus,
 			sessionStore: this.sessionStore,
 			sessionConfigStore: this.sessionConfigStore,
-			getPersistentGoalApisForCommand: (routing) => this.persistentGoals.buildApisForRouting(routing),
 			getWorkflowRunService: config.getWorkflowRunService,
 			applySessionThinkingLevel: (sessionKey, level) => {
 				this.agentManager.setThinkingLevel(sessionKey, level);
@@ -333,16 +342,10 @@ var AgentService = class {
 			getSessionContextReport: (sessionKey, mode) => this.sessionInspector.report(sessionKey, mode)
 		});
 		this.sessionLifecycleManager = new SessionLifecycleManager(this.sessionStore, this.sessionTracker, this.lifecycleManager);
-		this.persistentGoals = new PersistentGoalService({
-			bus,
+		this.taskJudge = new TaskJudgeService({
 			sessionStore: this.sessionStore,
 			modelManager: this.modelManager,
-			sessionState: this.sessionState,
-			getConfig: () => this.effectiveAppConfig(),
-			getResolvedWorkspaceForSession: (sk) => this.agentManager.getResolvedWorkspaceForSession(sk),
-			onSessionMetadataUpdated: this.onSessionMetadataUpdated,
-			onGoalStatusUpdated: config.onGoalStatusUpdated,
-			notifyWebchatTranscriptAppend: (sk, text) => this.turnDispatcher.notifyWebchatTranscriptAppend(sk, text)
+			getConfig: () => this.effectiveAppConfig()
 		});
 		this.sessionConfig = new SessionConfigService({
 			sessionStore: this.sessionStore,
@@ -366,7 +369,7 @@ var AgentService = class {
 			streamManager: this.streamManager,
 			getConfig: () => this.effectiveAppConfig(),
 			getLastAssistantPlainText: (sk) => this.getLastAssistantPlainText(sk),
-			runPersistentGoalPostTurn: (payload) => this.persistentGoals.runPostTurn(payload)
+			reviewTaskTurn: (payload) => this.taskJudge.reviewTurn(payload)
 		});
 		this.turnDispatcher = new TurnDispatcher({
 			log,
@@ -532,6 +535,9 @@ var AgentService = class {
 	refreshSkillsAfterDiskChange() {
 		this.agentManager.refreshSkillsAfterDiskChange();
 	}
+	refreshSkillsAfterTrustChange() {
+		this.agentManager.refreshSkillsAfterTrustChange();
+	}
 	async installSkillFromSource(opts) {
 		const target = normalizeSkillInstallTarget(opts.target);
 		const workspace = opts.workspace?.trim() || (opts.sessionKey ? this.agentManager.getResolvedWorkspaceForSession(opts.sessionKey) : void 0) || this.workspaceDir;
@@ -622,6 +628,9 @@ var AgentService = class {
 	getInboundTurnDepth(sessionKey) {
 		return this.sessionState.getInboundTurnDepth(sessionKey);
 	}
+	takeTaskReviewStreamHint(sessionKey) {
+		return this.sessionState.takeTaskReviewStreamHint(sessionKey);
+	}
 	async start() {
 		await this.sessionConfigStore.initialize();
 		await this.hookHandler.trigger("gateway_start", {
@@ -759,14 +768,14 @@ var AgentService = class {
 		const { abortEmbeddedRun } = await import("./embedded/runs.js");
 		const { retireSessionMcpRuntimeForSessionKey } = await import("./mcp/bundle-mcp-tools.js");
 		await abortEmbeddedRun(key);
-		const outcome = await this.sessionStore.reset(key);
-		if (!outcome) return null;
+		const task = await this.sessionStore.reset(key);
+		if (!task) return null;
 		this.agentManager.removeAgent(key);
 		await retireSessionMcpRuntimeForSessionKey({
 			sessionKey: key,
 			reason: "session-reset"
 		});
-		return outcome;
+		return task;
 	}
 	/**
 	* Drop in-memory agent so the next turn reloads transcript from disk (e.g. after checkpoint restore).

package/dist/src/agent/service.types.d.ts

@@ -5,7 +5,6 @@ import type { AutomationService } from '../automations/index.js';
 import type { ExtensionRegistryImpl as ExtensionRegistry } from '../extensions/index.js';
 import type { NotesService } from '../notes/index.js';
 import type { ProjectService } from '../projects/index.js';
-import type { WorkItemService } from '../work-items/index.js';
 import type { LocalAppService } from '../local-apps/index.js';
 import type { GatewayClarifyRequestFn } from './tools/clarify-tool.js';
 import type { ProgressStage } from './lifecycle/progress.js';
@@ -32,30 +31,18 @@ export interface AgentServiceConfig {
     /** Gateway: exposes first-class xopc product objects for the `xopc_use` tool. */
     getNotesService?: () => NotesService | undefined;
     getProjectService?: () => ProjectService | undefined;
-    getWorkItemService?: () => WorkItemService | undefined;
     getLocalAppService?: () => LocalAppService | undefined;
+    dispatchTaskRuns?: () => void;
     /**
      * Gateway: reuse the gateway `SessionManager` store so web API and agent share one index + files.
      * When omitted, `AgentService` creates its own `SessionStore` (CLI / embedded).
      */
     sessionStore?: SessionStore;
-    /**
-     * Gateway: invoked after `sessionStore.updateMetadata` from built-in `/goal` APIs (store does not emit).
-     * Wire to `sessionManager.emit('sessionUpdated', { key })` so the console refetches.
-     */
     onSessionMetadataUpdated?: (sessionKey: string, patch?: {
         name?: string;
     }) => void;
-    /** Gateway: transcript JSONL append (goal verdict, slash receipt, background turns). */
+    /** Gateway: transcript append notification. */
     onSessionTranscriptUpdated?: (sessionKey: string) => void;
-    /** Gateway: durable goal status changed after post-turn judge. */
-    onGoalStatusUpdated?: (payload: {
-        goalId: string;
-        sessionKey: string;
-        previousStatus: string;
-        status: string;
-        goal: import('../goals/types.js').GoalWithDetails;
-    }) => void;
     /** Gateway/TUI: local skill catalog changed or skill config toggles changed. */
     onSkillsUpdated?: (payload: {
         reason: 'disk' | 'config';

package/dist/src/agent/session/index.d.ts

@@ -3,7 +3,7 @@
  */
 export { SessionContextManager, type SessionContext, } from './session-context.js';
 export { SessionLifecycleManager, type SessionLifecycleEvents, type SessionStats, } from './session-lifecycle.js';
-export { SessionStateBag, type SessionStateBagOptions, type WebchatSsePublisher, type PersistentGoalStreamOutcome, } from './session-state-bag.js';
+export { SessionStateBag, type SessionStateBagOptions, type WebchatSsePublisher, type TaskReviewStreamHint, } from './session-state-bag.js';
 export { SessionConfigService, type SessionConfigServiceOptions, type PatchSessionAgentConfigInput, type PatchSessionAgentConfigResult, } from './session-config-service.js';
 export { SessionHydrator, type SessionHydratorOptions, } from './session-hydrator.js';
 export { SessionInspector, type SessionInspectorOptions, type SessionContextUsage, type SessionAgentConfigView, } from './session-inspector.js';

package/dist/src/agent/session/session-config-service.d.ts

@@ -34,6 +34,7 @@ export interface PatchSessionAgentConfigInput {
     reasoningLevel?: string | null;
     verboseLevel?: string;
     workingDirectory?: string;
+    responseLanguage?: string | null;
 }
 export interface PatchSessionAgentConfigResult {
     ok: boolean;

package/dist/src/agent/session/session-config-service.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { ResponseLanguageSchema, init_response_language } from "../../i18n/response-language.js";
 import { normalizeWorkingDirectoryInput } from "../../session/session-workspace.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
 import { normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel } from "../transcript/thinking-types.js";
@@ -21,6 +22,7 @@ import { mkdir } from "node:fs/promises";
 * "session config write" concerns, and so future additions to the patch API
 * (e.g. new per-session overrides) only touch this file.
 */
+init_response_language();
 init_logger();
 const log = createLogger("SessionConfigService");
 var SessionConfigService = class {
@@ -71,6 +73,18 @@ var SessionConfigService = class {
 			};
 			await this.opts.sessionConfigStore.update(sessionKey, { verboseLevel: normalized });
 		}
+		if (partial.responseLanguage !== void 0) {
+			if (partial.responseLanguage === null) await this.opts.sessionConfigStore.update(sessionKey, { responseLanguage: void 0 });
+			else {
+				const parsed = ResponseLanguageSchema.safeParse(partial.responseLanguage);
+				if (!parsed.success) return {
+					ok: false,
+					error: "Invalid response language"
+				};
+				await this.opts.sessionConfigStore.update(sessionKey, { responseLanguage: parsed.data });
+			}
+			this.opts.agentManager.removeAgent(sessionKey);
+		}
 		if (partial.workingDirectory !== void 0) {
 			if (!this.opts.getConfig()) return {
 				ok: false,

package/dist/src/agent/session/session-state-bag.d.ts

@@ -12,7 +12,7 @@
  * - Hard upper bound for the same TTL'd slots to bound worst-case memory.
  *
  * Slots whose lifetime is fully owned by explicit lifecycle calls
- * (`inboundTurnDepth`, `directStreamOutcome`, `embeddedStreamText`,
+ * (`inboundTurnDepth`, `taskReviewHintBySession`, `embeddedStreamText`,
  * `sessionEventUnsubscribers`) are still cleared via `disposeSession`, but they
  * are NOT subject to TTL — sweeping them would race with their owners.
  */
@@ -20,8 +20,8 @@ export type WebchatSsePublisher = (event: {
     type: string;
     [key: string]: unknown;
 }) => void;
-export interface PersistentGoalStreamOutcome {
-    skipPersistentGoalPostTurn: boolean;
+export interface TaskReviewStreamHint {
+    skipTaskReview: boolean;
 }
 export interface SessionStateBagOptions {
     /** Idle TTL for TTL-managed slots. Defaults to 1 hour. Set to 0 to disable sweeping. */
@@ -40,8 +40,8 @@ export declare class SessionStateBag {
     private readonly lastAssistantText;
     /** Stream text for the in-flight embedded turn (managed by turn). */
     private readonly embeddedStreamText;
-    /** Persistent-goal stream outcome (take-and-delete). */
-    private readonly directStreamOutcome;
+    /** Task review stream state (take-and-delete). */
+    private readonly taskReviewHintBySession;
     /** Concurrent inbound turn depth (counter). */
     private readonly inboundTurnDepth;
     /** Agent-event subscription tear-downs (run on dispose). */
@@ -58,8 +58,8 @@ export declare class SessionStateBag {
     getLastAssistantText(sessionKey: string): string | undefined;
     appendEmbeddedStreamText(sessionKey: string, chunk: string): string;
     clearEmbeddedStreamText(sessionKey: string): void;
-    recordPersistentGoalStreamOutcome(sessionKey: string, outcome: PersistentGoalStreamOutcome): void;
-    takePersistentGoalStreamOutcome(sessionKey: string): PersistentGoalStreamOutcome | undefined;
+    recordTaskReviewStreamHint(sessionKey: string, task: TaskReviewStreamHint): void;
+    takeTaskReviewStreamHint(sessionKey: string): TaskReviewStreamHint | undefined;
     beginInboundTurn(sessionKey: string): void;
     endInboundTurn(sessionKey: string): void;
     getInboundTurnDepth(sessionKey: string): number;
@@ -74,7 +74,7 @@ export declare class SessionStateBag {
         webchatPublishers: number;
         lastAssistantText: number;
         embeddedStreamText: number;
-        directStreamOutcome: number;
+        taskReviewHintBySession: number;
         inboundTurnDepth: number;
         sessionEventUnsubscribers: number;
     };

package/dist/src/agent/session/session-state-bag.js

@@ -13,8 +13,8 @@ var SessionStateBag = class {
 	lastAssistantText = /* @__PURE__ */ new Map();
 	/** Stream text for the in-flight embedded turn (managed by turn). */
 	embeddedStreamText = /* @__PURE__ */ new Map();
-	/** Persistent-goal stream outcome (take-and-delete). */
-	directStreamOutcome = /* @__PURE__ */ new Map();
+	/** Task review stream state (take-and-delete). */
+	taskReviewHintBySession = /* @__PURE__ */ new Map();
 	/** Concurrent inbound turn depth (counter). */
 	inboundTurnDepth = /* @__PURE__ */ new Map();
 	/** Agent-event subscription tear-downs (run on dispose). */
@@ -72,12 +72,12 @@ var SessionStateBag = class {
 	clearEmbeddedStreamText(sessionKey) {
 		this.embeddedStreamText.delete(sessionKey);
 	}
-	recordPersistentGoalStreamOutcome(sessionKey, outcome) {
-		this.directStreamOutcome.set(sessionKey, outcome);
+	recordTaskReviewStreamHint(sessionKey, task) {
+		this.taskReviewHintBySession.set(sessionKey, task);
 	}
-	takePersistentGoalStreamOutcome(sessionKey) {
-		const v = this.directStreamOutcome.get(sessionKey);
-		this.directStreamOutcome.delete(sessionKey);
+	takeTaskReviewStreamHint(sessionKey) {
+		const v = this.taskReviewHintBySession.get(sessionKey);
+		this.taskReviewHintBySession.delete(sessionKey);
 		return v;
 	}
 	beginInboundTurn(sessionKey) {
@@ -123,7 +123,7 @@ var SessionStateBag = class {
 		this.webchatPublishers.delete(sessionKey);
 		this.lastAssistantText.delete(sessionKey);
 		this.embeddedStreamText.delete(sessionKey);
-		this.directStreamOutcome.delete(sessionKey);
+		this.taskReviewHintBySession.delete(sessionKey);
 		this.inboundTurnDepth.delete(sessionKey);
 	}
 	/** Tear down every session (process stop / hot reload). */
@@ -140,7 +140,7 @@ var SessionStateBag = class {
 		this.webchatPublishers.clear();
 		this.lastAssistantText.clear();
 		this.embeddedStreamText.clear();
-		this.directStreamOutcome.clear();
+		this.taskReviewHintBySession.clear();
 		this.inboundTurnDepth.clear();
 		if (this.sweepTimer) clearInterval(this.sweepTimer);
 	}
@@ -150,7 +150,7 @@ var SessionStateBag = class {
 			webchatPublishers: this.webchatPublishers.size,
 			lastAssistantText: this.lastAssistantText.size,
 			embeddedStreamText: this.embeddedStreamText.size,
-			directStreamOutcome: this.directStreamOutcome.size,
+			taskReviewHintBySession: this.taskReviewHintBySession.size,
 			inboundTurnDepth: this.inboundTurnDepth.size,
 			sessionEventUnsubscribers: this.sessionEventUnsubscribers.size
 		};

package/dist/src/agent/skills/config.js

@@ -162,6 +162,12 @@ function isSkillEnabled(skill, skillsConfig) {
 */
 function validateSkillConfig(config) {
 	const errors = [];
+	const extraDirs = config.load?.extraDirs;
+	if (extraDirs !== void 0 && (!Array.isArray(extraDirs) || !extraDirs.every((dir) => typeof dir === "string"))) errors.push("load.extraDirs must contain only strings");
+	const agentsGlobalSource = config.load?.sources?.agentsGlobal;
+	if (agentsGlobalSource !== void 0 && (typeof agentsGlobalSource !== "object" || agentsGlobalSource === null || Array.isArray(agentsGlobalSource) || "enabled" in agentsGlobalSource && typeof agentsGlobalSource.enabled !== "boolean")) errors.push("load.sources.agentsGlobal.enabled must be a boolean");
+	const agentsWorkspaceSource = config.load?.sources?.agentsWorkspace;
+	if (agentsWorkspaceSource !== void 0 && (typeof agentsWorkspaceSource !== "object" || agentsWorkspaceSource === null || Array.isArray(agentsWorkspaceSource) || "enabled" in agentsWorkspaceSource && typeof agentsWorkspaceSource.enabled !== "boolean")) errors.push("load.sources.agentsWorkspace.enabled must be a boolean");
 	if (config.toolGating !== void 0 && typeof config.toolGating !== "boolean") errors.push("toolGating must be a boolean");
 	if (config.agentWritePolicy !== void 0 && config.agentWritePolicy !== "global" && config.agentWritePolicy !== "workspace" && config.agentWritePolicy !== "both") errors.push("agentWritePolicy must be \"global\", \"workspace\", or \"both\"");
 	const limits = config.limits;

package/dist/src/agent/skills/filesystem-watcher.d.ts

@@ -3,13 +3,17 @@ export interface SkillFilesystemWatcherOptions {
         reason: 'watch';
         changedPath?: string;
     }) => void;
+    /** Dependency-injection override for the ~/.agents/skills compatibility root. */
+    agentsSkillsDir?: string;
 }
 export declare class SkillFilesystemWatcher {
     private readonly targets;
     private readonly onChange;
+    private readonly agentsSkillsDir;
     private disposed;
     constructor(options: SkillFilesystemWatcherOptions);
     watchGlobalSkillsDir(): void;
+    watchAgentsGlobalSkillsDir(): void;
     watchWorkspace(workspaceDir: string): void;
     refreshPrimaryWorkspace(workspaceDir: string): void;
     dispose(): void;

package/dist/src/agent/skills/filesystem-watcher.js

@@ -4,6 +4,7 @@ import { init_logger } from "../../utils/logger.js";
 import { init_paths, resolveSkillsDir } from "../../config/paths.js";
 import { createSkillConfigManager } from "./config.js";
 import { resolveWorkspaceSkillsDir } from "./workspace-skills-dir.js";
+import { resolveAgentsSkillsDir, resolveWorkspaceAgentsSkillsDir } from "./skill-sources.js";
 import { isManagedSkillTransientDirName } from "./managed-store.js";
 import path from "node:path";
 import chokidar from "chokidar";
@@ -41,11 +42,11 @@ function isSameOrInside(parent, child) {
 	return rel === "" || !!rel && !rel.startsWith("..") && !path.isAbsolute(rel);
 }
 function isWorkspaceSkillPath(workspaceRoot, candidate) {
-	const skillsRoot = resolveWorkspaceSkillsDir(workspaceRoot);
-	return candidate === workspaceRoot || isSameOrInside(skillsRoot, candidate) || isSameOrInside(candidate, skillsRoot);
+	const skillsRoots = [resolveWorkspaceSkillsDir(workspaceRoot), resolveWorkspaceAgentsSkillsDir(workspaceRoot)];
+	return candidate === workspaceRoot || skillsRoots.some((skillsRoot) => isSameOrInside(skillsRoot, candidate) || isSameOrInside(candidate, skillsRoot));
 }
 function isWorkspaceSkillsRoot(workspaceRoot, candidate) {
-	return candidate === resolveWorkspaceSkillsDir(workspaceRoot);
+	return candidate === resolveWorkspaceSkillsDir(workspaceRoot) || candidate === resolveWorkspaceAgentsSkillsDir(workspaceRoot);
 }
 function isSkillMdPath(candidate) {
 	return path.basename(candidate).toLowerCase() === "skill.md";
@@ -55,20 +56,27 @@ function readWatcherConfig() {
 	const rawDebounce = cfg.load?.watchDebounceMs;
 	return {
 		enabled: cfg.load?.watch !== false,
+		agentsGlobalEnabled: cfg.load?.sources?.agentsGlobal?.enabled !== false,
 		debounceMs: typeof rawDebounce === "number" && Number.isFinite(rawDebounce) ? Math.max(0, rawDebounce) : DEFAULT_DEBOUNCE_MS
 	};
 }
 var SkillFilesystemWatcher = class {
 	targets = /* @__PURE__ */ new Map();
 	onChange;
+	agentsSkillsDir;
 	disposed = false;
 	constructor(options) {
 		this.onChange = options.onChange;
+		this.agentsSkillsDir = options.agentsSkillsDir ?? resolveAgentsSkillsDir();
 		this.watchGlobalSkillsDir();
+		this.watchAgentsGlobalSkillsDir();
 	}
 	watchGlobalSkillsDir() {
 		this.watchRoot(resolveSkillsDir(), "global");
 	}
+	watchAgentsGlobalSkillsDir() {
+		this.watchRoot(this.agentsSkillsDir, "agents-global");
+	}
 	watchWorkspace(workspaceDir) {
 		const resolved = normalizePath(workspaceDir);
 		if (!resolved) return;
@@ -76,6 +84,7 @@ var SkillFilesystemWatcher = class {
 	}
 	refreshPrimaryWorkspace(workspaceDir) {
 		this.watchGlobalSkillsDir();
+		this.watchAgentsGlobalSkillsDir();
 		this.watchWorkspace(workspaceDir);
 	}
 	dispose() {
@@ -93,10 +102,10 @@ var SkillFilesystemWatcher = class {
 	}
 	watchRoot(root, kind) {
 		if (this.disposed) return;
-		const { enabled, debounceMs } = readWatcherConfig();
+		const { enabled, agentsGlobalEnabled, debounceMs } = readWatcherConfig();
 		const resolvedRoot = normalizePath(root);
 		const key = `${kind}:${resolvedRoot}`;
-		if (!enabled) {
+		if (!enabled || kind === "agents-global" && !agentsGlobalEnabled) {
 			this.unwatch(key);
 			return;
 		}
@@ -159,8 +168,8 @@ var SkillFilesystemWatcher = class {
 		this.targets.delete(key);
 	}
 	scheduleRefresh(target, changedPath) {
-		const { enabled, debounceMs } = readWatcherConfig();
-		if (!enabled) {
+		const { enabled, agentsGlobalEnabled, debounceMs } = readWatcherConfig();
+		if (!enabled || target.kind === "agents-global" && !agentsGlobalEnabled) {
 			this.unwatch(target.key);
 			return;
 		}

package/dist/src/agent/skills/index.d.ts

@@ -1,9 +1,8 @@
-import type { Skill, SkillDiagnostic, LoadSkillsResult, SkillConfig } from './types.js';
-export declare function loadSkills(options: {
-    workspaceDir?: string;
-    globalDir?: string;
-    builtinDir?: string;
-    extraDirs?: string[];
+import { type ResolveSkillSourcesOptions } from './skill-sources.js';
+import type { Skill, SkillConfig, SkillDiagnostic, LoadSkillsResult } from './types.js';
+export declare function loadSkills(options: ResolveSkillSourcesOptions & {
+    /** Dependency-injection override for the ~/.agents/skills compatibility root. */
+    agentsDir?: string;
 }): LoadSkillsResult;
 /** Discover only skills owned by a workspace, without global or bundled skills. */
 export declare function loadWorkspaceSkills(workspaceDir: string): LoadSkillsResult;
@@ -20,7 +19,11 @@ export interface SkillLoader {
     getSkillByName: (name: string) => Skill | undefined;
     getEnabledSkills: (config?: Record<string, SkillConfig>) => Skill[];
 }
-export declare function createSkillLoader(): SkillLoader;
+export interface SkillLoaderOptions {
+    /** Re-evaluated on every load so trust changes take effect without recreating the runtime. */
+    isWorkspaceTrusted?: (workspaceDir: string) => boolean;
+}
+export declare function createSkillLoader(options?: SkillLoaderOptions): SkillLoader;
 export type { Skill, SkillMetadata, SkillConfig, SkillInstallSpec, SkillInstallResult, SkillInstallRequest, LoadSkillsResult, SkillSnapshot, } from './types.js';
 export { installSkill, findInstallSpec, hasBinary, getDefaultInstallerPreferences, type InstallerPreferences, type InstallContext, } from './installer.js';
 export { scanSkillDirectory, formatScanSummary, collectSkillInstallWarnings, type ScanSummary, type SecurityFinding, type Severity, } from './scanner.js';