@xopcai/xopc 0.0.178 → 0.0.180

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';

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

@@ -9,11 +9,11 @@ import { parseSkillToolConditions } from "./skill-tool-gating.js";
 import { formatSkillsForPrompt } from "./format-skills-prompt.js";
 import { parseRequiredEnvVarNames } from "./required-env-vars.js";
 import { parseSkillMetadata } from "./parse-skill-metadata.js";
-import { resolveWorkspaceSkillsDir } from "./workspace-skills-dir.js";
+import { resolveSkillSources, resolveWorkspaceSkillSource } from "./skill-sources.js";
 import { collectSkillInstallWarnings, formatScanSummary, scanSkillDirectory } from "./scanner.js";
 import { SkillTestFramework, SkillTestRunner, formatTestResults, formatTestResultsJson, formatTestResultsTap } from "./test-framework.js";
 import { basename, dirname, join, relative, sep } from "path";
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 //#region src/agent/skills/index.ts
 init_paths();
 init_logger();
@@ -23,6 +23,11 @@ const IGNORE_FILES = [
 	".ignore",
 	".fdignore"
 ];
+const DEFAULT_MAX_SKILL_FILE_BYTES = 1024 * 1024;
+function resolveMaxSkillFileBytes(skillsConfig) {
+	const configured = skillsConfig.limits?.maxSkillFileBytes;
+	return typeof configured === "number" && Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_MAX_SKILL_FILE_BYTES;
+}
 function toPosixPath(p) {
 	return p.split(sep).join("/");
 }
@@ -67,7 +72,8 @@ function shouldIgnore(path, ignoredPaths) {
 	} else if (path === pattern || path.startsWith(`${pattern}/`)) return true;
 	return false;
 }
-function discoverSkills(dir, source) {
+function discoverSkills(source, maxSkillFileBytes) {
+	const dir = source.rootDir;
 	const skills = [];
 	const diagnostics = [];
 	if (!existsSync(dir)) return {
@@ -91,7 +97,7 @@ function discoverSkills(dir, source) {
 						for (const rule of subRules) subIgnoredPaths.add(`${skillRelPath}${rule}`);
 					}
 					if (existsSync(skillMdPath) && !shouldIgnore(skillRelPath, currentIgnoredPaths)) {
-						const { skill, diagnostic } = loadSkillFromFile(skillMdPath, source, dir);
+						const { skill, diagnostic } = loadSkillFromFile(skillMdPath, source, dir, maxSkillFileBytes);
 						if (diagnostic) diagnostics.push(diagnostic);
 						if (skill) skills.push(skill);
 					}
@@ -127,8 +133,17 @@ function deriveDescriptionFromMarkdown(content) {
 	}
 	return fallbackHeading || void 0;
 }
-function loadSkillFromFile(filePath, source, rootDir) {
+function loadSkillFromFile(filePath, source, rootDir, maxSkillFileBytes = DEFAULT_MAX_SKILL_FILE_BYTES) {
 	try {
+		const fileSize = statSync(filePath).size;
+		if (fileSize > maxSkillFileBytes) return {
+			skill: null,
+			diagnostic: {
+				type: "error",
+				message: `Skill file exceeds size limit (${fileSize} > ${maxSkillFileBytes} bytes)`,
+				path: filePath
+			}
+		};
 		const { frontmatter, content } = parseFrontmatter(readFileSync(filePath, "utf-8"));
 		const skillDir = dirname(filePath);
 		const parentDirName = basename(skillDir);
@@ -159,7 +174,8 @@ function loadSkillFromFile(filePath, source, rootDir) {
 			category,
 			filePath,
 			baseDir: skillDir,
-			source,
+			source: source.scope,
+			origin: source,
 			disableModelInvocation: frontmatter["disable-model-invocation"] === true,
 			metadata,
 			toolConditions,
@@ -178,32 +194,29 @@ function loadSkillFromFile(filePath, source, rootDir) {
 	}
 }
 function loadSkills(options) {
-	const { workspaceDir, builtinDir, extraDirs = [] } = options;
+	const skillsConfig = createSkillConfigManager(resolveStateDir()).load();
+	const resolvedSources = resolveSkillSources(options, skillsConfig);
+	const maxSkillFileBytes = resolveMaxSkillFileBytes(skillsConfig);
 	const skillMap = /* @__PURE__ */ new Map();
-	const diagnostics = [];
-	if (builtinDir) {
-		const discovered = discoverSkills(builtinDir, "builtin");
+	const diagnostics = [...resolvedSources.diagnostics];
+	for (const source of resolvedSources.sources) {
+		const discovered = discoverSkills(source, maxSkillFileBytes);
 		diagnostics.push(...discovered.diagnostics);
-		for (const skill of discovered.skills) if (!skillMap.has(skill.name)) skillMap.set(skill.name, skill);
-	}
-	const globalDirs = [options.globalDir, join(resolveStateDir(), "skills")].filter((d) => !!d && existsSync(d));
-	for (const dir of globalDirs) {
-		const discovered = discoverSkills(dir, "global");
-		diagnostics.push(...discovered.diagnostics);
-		for (const skill of discovered.skills) skillMap.set(skill.name, skill);
-	}
-	if (workspaceDir) {
-		const discovered = loadWorkspaceSkills(workspaceDir);
-		diagnostics.push(...discovered.diagnostics);
-		const workspaceSkills = discovered.skills;
-		for (const skill of workspaceSkills) skillMap.set(skill.name, skill);
-	}
-	for (const extraDir of extraDirs) if (existsSync(extraDir)) {
-		const discovered = discoverSkills(extraDir, "global");
-		diagnostics.push(...discovered.diagnostics);
-		for (const skill of discovered.skills) if (!skillMap.has(skill.name)) skillMap.set(skill.name, skill);
+		for (const skill of discovered.skills) {
+			const previous = skillMap.get(skill.name);
+			if (previous) {
+				const winner = skill.origin.priority > previous.origin.priority ? skill : previous;
+				const shadowed = winner === skill ? previous : skill;
+				diagnostics.push({
+					type: "collision",
+					skillName: skill.name,
+					path: winner.filePath,
+					message: `Skill "${skill.name}" from ${winner.origin.id} (${winner.filePath}) shadows ${shadowed.origin.id} (${shadowed.filePath})`
+				});
+			}
+			if (!previous || skill.origin.priority > previous.origin.priority) skillMap.set(skill.name, skill);
+		}
 	}
-	const skillsConfig = createSkillConfigManager(resolveStateDir()).load();
 	const merged = Array.from(skillMap.values());
 	return {
 		skills: merged,
@@ -213,21 +226,21 @@ function loadSkills(options) {
 }
 /** Discover only skills owned by a workspace, without global or bundled skills. */
 function loadWorkspaceSkills(workspaceDir) {
-	const discovered = discoverSkills(resolveWorkspaceSkillsDir(workspaceDir), "workspace");
+	const maxSkillFileBytes = resolveMaxSkillFileBytes(createSkillConfigManager(resolveStateDir()).load());
+	const discovered = discoverSkills(resolveWorkspaceSkillSource(workspaceDir), maxSkillFileBytes);
 	return {
 		skills: discovered.skills,
 		prompt: formatSkillsForPrompt(discovered.skills),
 		diagnostics: discovered.diagnostics
 	};
 }
-function createSkillLoader() {
+function createSkillLoader(options = {}) {
 	let cachedSkills = [];
 	let cachedPrompt = "";
 	let cachedDiagnostics = [];
 	let lastLoadTime = 0;
 	let workspaceDir;
 	let builtinDir;
-	let extraDirs = [];
 	function updateCache(result) {
 		cachedSkills = result.skills;
 		cachedPrompt = result.prompt;
@@ -235,30 +248,26 @@ function createSkillLoader() {
 		lastLoadTime = Date.now();
 		return result;
 	}
+	function loadCurrentSkills() {
+		const workspaceTrust = workspaceDir && options.isWorkspaceTrusted?.(workspaceDir) === true ? "trusted" : "untrusted";
+		return loadSkills({
+			workspaceDir,
+			builtinDir,
+			workspaceTrust
+		});
+	}
 	return {
 		init: (workspace, builtin) => {
 			workspaceDir = workspace;
 			builtinDir = builtin || void 0;
-			return updateCache(loadSkills({
-				workspaceDir,
-				builtinDir,
-				extraDirs
-			}));
+			return updateCache(loadCurrentSkills());
 		},
 		load: () => {
-			return updateCache(loadSkills({
-				workspaceDir,
-				builtinDir,
-				extraDirs
-			}));
+			return updateCache(loadCurrentSkills());
 		},
 		reload: () => {
 			log.info("Reloading skills");
-			return updateCache(loadSkills({
-				workspaceDir,
-				builtinDir,
-				extraDirs
-			}));
+			return updateCache(loadCurrentSkills());
 		},
 		refreshPromptFromConfig: () => {
 			const skillsConfig = createSkillConfigManager(resolveStateDir()).load();

package/dist/src/agent/skills/skill-manage-ops.js

@@ -116,7 +116,7 @@ function canWriteToPath(skillBaseDir, workspace, policy) {
 }
 function mutatableSkillOrNull(skill, workspace, policy) {
 	if (!skill) return null;
-	if (skill.source === "builtin" || skill.source === "extra") return null;
+	if (!skill.origin?.managed || !skill.origin.writable) return null;
 	if (!canWriteToPath(skill.baseDir, workspace, policy)) return null;
 	return skill;
 }

package/dist/src/agent/skills/skill-manager.d.ts

@@ -9,6 +9,9 @@ export interface SkillLoadResult {
     prompt: string;
     diagnostics: SkillDiagnostic[];
 }
+export interface SkillManagerOptions {
+    isWorkspaceTrusted?: (workspaceDir: string) => boolean;
+}
 export declare class SkillManager {
     private skillPrompt;
     private skills;
@@ -24,7 +27,7 @@ export declare class SkillManager {
     private lastReloadReason;
     private lastReloadOk;
     private lastReloadError;
-    constructor(workspace: string, bundledSkillsDir?: string);
+    constructor(workspace: string, bundledSkillsDir?: string, options?: SkillManagerOptions);
     /**
      * Initialize skills from workspace and bundled directories
      */
@@ -36,7 +39,7 @@ export declare class SkillManager {
     /**
      * Reload skills from disk
      */
-    reload(): void;
+    reload(reason?: 'disk' | 'trust'): void;
     private runReload;
     private applyLoadResult;
     /**

package/dist/src/agent/skills/skill-manager.js

@@ -18,7 +18,7 @@ const SKILL_TOKEN_RE = /\/skill:([A-Za-z0-9][A-Za-z0-9._-]*)/g;
 var SkillManager = class {
 	skillPrompt = "";
 	skills = [];
-	skillLoader = createSkillLoader();
+	skillLoader;
 	workspace;
 	bundledSkillsDir;
 	version = 0;
@@ -30,9 +30,10 @@ var SkillManager = class {
 	lastReloadReason;
 	lastReloadOk;
 	lastReloadError;
-	constructor(workspace, bundledSkillsDir) {
+	constructor(workspace, bundledSkillsDir, options = {}) {
 		this.workspace = workspace;
 		this.bundledSkillsDir = bundledSkillsDir || resolveBundledSkillsDir();
+		this.skillLoader = createSkillLoader({ isWorkspaceTrusted: options.isWorkspaceTrusted });
 		this.initialize();
 	}
 	/**
@@ -56,8 +57,8 @@ var SkillManager = class {
 	/**
 	* Reload skills from disk
 	*/
-	reload() {
-		this.runReload("disk", () => this.skillLoader.reload());
+	reload(reason = "disk") {
+		this.runReload(reason, () => this.skillLoader.reload());
 	}
 	runReload(reason, load) {
 		if (this.reloadInProgress) {
@@ -97,7 +98,11 @@ var SkillManager = class {
 		this.skills = result.skills;
 		this.version += 1;
 		this.loadedAt = Date.now();
-		for (const diag of result.diagnostics) if (diag.type === "warning") log.warn({
+		for (const diag of result.diagnostics) if (diag.type === "skipped") log.debug({
+			path: diag.path,
+			message: diag.message
+		}, "Skill source skipped");
+		else if (diag.type === "warning" || diag.type === "collision") log.warn({
 			skill: diag.skillName,
 			path: diag.path,
 			message: diag.message

package/dist/src/agent/skills/skill-sources.d.ts

@@ -0,0 +1,18 @@
+import type { SkillDiagnostic, SkillSourceDescriptor, SkillsConfig } from './types.js';
+export interface ResolveSkillSourcesOptions {
+    workspaceDir?: string;
+    globalDir?: string;
+    builtinDir?: string;
+    agentsDir?: string;
+    extraDirs?: string[];
+    /** Project compatibility sources fail closed unless trust is explicitly granted. */
+    workspaceTrust?: 'trusted' | 'untrusted';
+}
+export interface ResolveSkillSourcesResult {
+    sources: SkillSourceDescriptor[];
+    diagnostics: SkillDiagnostic[];
+}
+export declare function resolveSkillSources(options: ResolveSkillSourcesOptions, skillsConfig: SkillsConfig): ResolveSkillSourcesResult;
+export declare function resolveAgentsSkillsDir(env?: NodeJS.ProcessEnv): string;
+export declare function resolveWorkspaceAgentsSkillsDir(workspaceDir: string): string;
+export declare function resolveWorkspaceSkillSource(workspaceDir: string): SkillSourceDescriptor;

package/dist/src/agent/skills/skill-sources.js

@@ -0,0 +1,143 @@
+import { init_paths, resolveSkillsDir } from "../../config/paths.js";
+import { resolveWorkspaceSkillsDir } from "./workspace-skills-dir.js";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+//#region src/agent/skills/skill-sources.ts
+init_paths();
+const PRIORITY = {
+	extra: 100,
+	bundled: 200,
+	agentsGlobal: 300,
+	xopcGlobalCustom: 390,
+	xopcGlobal: 400,
+	agentsWorkspace: 450,
+	xopcWorkspace: 500
+};
+function canonicalRoot(rootDir) {
+	const absolute = resolve(rootDir);
+	if (!existsSync(absolute)) return absolute;
+	try {
+		return realpathSync(absolute);
+	} catch {
+		return absolute;
+	}
+}
+function descriptor(options) {
+	return {
+		...options,
+		rootDir: canonicalRoot(options.rootDir)
+	};
+}
+function dedupeSources(sources) {
+	const byRoot = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const existing = byRoot.get(source.rootDir);
+		if (!existing || source.priority > existing.priority) byRoot.set(source.rootDir, source);
+	}
+	return [...byRoot.values()].sort((a, b) => a.priority - b.priority);
+}
+function isSameOrInside(parent, child) {
+	const rel = relative(parent, child);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolveSkillSources(options, skillsConfig) {
+	const configuredExtraDirs = Array.isArray(skillsConfig.load?.extraDirs) ? skillsConfig.load.extraDirs.filter((dir) => typeof dir === "string" && dir.trim().length > 0) : [];
+	const optionExtraDirs = Array.isArray(options.extraDirs) ? options.extraDirs.filter((dir) => typeof dir === "string" && dir.trim().length > 0) : [];
+	const extraDirs = [...configuredExtraDirs, ...optionExtraDirs];
+	const sources = [];
+	const diagnostics = [];
+	for (const rootDir of extraDirs) sources.push(descriptor({
+		id: "extra",
+		rootDir,
+		priority: PRIORITY.extra,
+		scope: "extra",
+		managed: false,
+		writable: false
+	}));
+	if (options.builtinDir) sources.push(descriptor({
+		id: "bundled",
+		rootDir: options.builtinDir,
+		priority: PRIORITY.bundled,
+		scope: "builtin",
+		managed: false,
+		writable: false
+	}));
+	if (skillsConfig.load?.sources?.agentsGlobal?.enabled !== false) sources.push(descriptor({
+		id: "agents-global",
+		rootDir: options.agentsDir ?? resolveAgentsSkillsDir(),
+		priority: PRIORITY.agentsGlobal,
+		scope: "global",
+		managed: false,
+		writable: false
+	}));
+	if (options.globalDir) sources.push(descriptor({
+		id: "custom-global",
+		rootDir: options.globalDir,
+		priority: PRIORITY.xopcGlobalCustom,
+		scope: "global",
+		managed: false,
+		writable: false
+	}));
+	sources.push(descriptor({
+		id: "xopc-global",
+		rootDir: resolveSkillsDir(),
+		priority: PRIORITY.xopcGlobal,
+		scope: "global",
+		managed: true,
+		writable: true
+	}));
+	if (options.workspaceDir) {
+		const canonicalWorkspace = canonicalRoot(options.workspaceDir);
+		const agentsGlobalRoot = canonicalRoot(options.agentsDir ?? resolveAgentsSkillsDir());
+		const workspaceAgentsRoot = canonicalRoot(resolveWorkspaceAgentsSkillsDir(options.workspaceDir));
+		if (skillsConfig.load?.sources?.agentsWorkspace?.enabled !== false && workspaceAgentsRoot !== agentsGlobalRoot && existsSync(workspaceAgentsRoot)) if (!isSameOrInside(canonicalWorkspace, workspaceAgentsRoot)) diagnostics.push({
+			type: "warning",
+			path: workspaceAgentsRoot,
+			message: `Skipped agents-workspace skill source outside workspace: ${workspaceAgentsRoot}`
+		});
+		else if (options.workspaceTrust !== "trusted") diagnostics.push({
+			type: "skipped",
+			path: workspaceAgentsRoot,
+			message: `Skipped agents-workspace skill source because workspace is not trusted: ${workspaceAgentsRoot}`
+		});
+		else sources.push(descriptor({
+			id: "agents-workspace",
+			rootDir: workspaceAgentsRoot,
+			priority: PRIORITY.agentsWorkspace,
+			scope: "workspace",
+			managed: false,
+			writable: false
+		}));
+		sources.push(descriptor({
+			id: "xopc-workspace",
+			rootDir: resolveWorkspaceSkillsDir(options.workspaceDir),
+			priority: PRIORITY.xopcWorkspace,
+			scope: "workspace",
+			managed: true,
+			writable: true
+		}));
+	}
+	return {
+		sources: dedupeSources(sources),
+		diagnostics
+	};
+}
+function resolveAgentsSkillsDir(env = process.env) {
+	return join(env.HOME || homedir(), ".agents", "skills");
+}
+function resolveWorkspaceAgentsSkillsDir(workspaceDir) {
+	return join(workspaceDir, ".agents", "skills");
+}
+function resolveWorkspaceSkillSource(workspaceDir) {
+	return descriptor({
+		id: "xopc-workspace",
+		rootDir: resolveWorkspaceSkillsDir(workspaceDir),
+		priority: PRIORITY.xopcWorkspace,
+		scope: "workspace",
+		managed: true,
+		writable: true
+	});
+}
+//#endregion
+export { resolveAgentsSkillsDir, resolveSkillSources, resolveWorkspaceAgentsSkillsDir, resolveWorkspaceSkillSource };

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

@@ -80,11 +80,32 @@ export interface SkillConfig {
 export interface SkillsLoadConfig {
     /** Additional skill folders to scan */
     extraDirs?: string[];
+    /** Built-in compatibility sources. */
+    sources?: {
+        /** Read user-installed skills from ~/.agents/skills. Defaults to enabled. */
+        agentsGlobal?: {
+            enabled?: boolean;
+        };
+        /** Read project skills from <workspace>/.agents/skills. Defaults to enabled for trusted workspaces. */
+        agentsWorkspace?: {
+            enabled?: boolean;
+        };
+    };
     /** Watch skill folders for changes */
     watch?: boolean;
     /** Debounce for the skills watcher (ms) */
     watchDebounceMs?: number;
 }
+export type SkillOriginId = 'extra' | 'bundled' | 'agents-global' | 'agents-workspace' | 'custom-global' | 'xopc-global' | 'xopc-workspace';
+export interface SkillSourceDescriptor {
+    id: SkillOriginId;
+    rootDir: string;
+    priority: number;
+    scope: 'builtin' | 'workspace' | 'global' | 'extra';
+    managed: boolean;
+    writable: boolean;
+}
+export type SkillOrigin = SkillSourceDescriptor;
 export interface SkillsInstallConfig {
     /** Prefer brew for package installation */
     preferBrew?: boolean;
@@ -137,6 +158,8 @@ export interface Skill {
     baseDir: string;
     /** Source of the skill */
     source: 'builtin' | 'workspace' | 'global' | 'extra';
+    /** Concrete source root and its management policy. */
+    origin: SkillOrigin;
     /** Disable model invocation for this skill */
     disableModelInvocation: boolean;
     /** Parsed metadata */
@@ -207,7 +230,7 @@ export interface LoadSkillsResult {
     diagnostics: SkillDiagnostic[];
 }
 export interface SkillDiagnostic {
-    type: 'warning' | 'collision' | 'error';
+    type: 'skipped' | 'warning' | 'collision' | 'error';
     skillName?: string;
     message: string;
     path?: string;
@@ -219,7 +242,7 @@ export interface SkillRuntimeStatus {
     reloadPending: boolean;
     lastReloadStartedAt?: number;
     lastReloadFinishedAt?: number;
-    lastReloadReason?: 'initial' | 'disk' | 'config';
+    lastReloadReason?: 'initial' | 'disk' | 'config' | 'trust';
     lastReloadOk?: boolean;
     lastReloadError?: string;
 }

package/dist/src/agent/tools/delegate-tool.js

@@ -30,7 +30,8 @@ const DELEGATE_BLOCKED_TOOLS = new Set([
 	"skill_manage",
 	"skills_marketplace_search",
 	"skill_install",
-	"bundle-mcp"
+	"bundle-mcp",
+	"managed_job"
 ]);
 const DelegateTaskSchema = Type.Object({
 	goal: Type.String({ description: "Clear description of what the sub-agent should accomplish" }),

package/dist/src/agent/tools/executor.d.ts

@@ -18,6 +18,8 @@ import type { ToolConcurrencyController as ToolConcurrencyControllerType } from
 export interface ToolExecutorConfig {
     /** Default per-tool timeout when the tool does not declare its own `timeoutMs`. */
     defaultTimeoutMs: number;
+    /** Per-session policy override resolved from the effective agent manifest. */
+    resolveTimeoutMs?: (toolName: string) => number | undefined;
     /** Max retry attempts for tools opted into retry via `idempotent: true`. */
     maxRetries: number;
     /** Initial backoff between retries (passed straight to `withRetry`). */

package/dist/src/agent/tools/executor.js

@@ -21,7 +21,9 @@ function readToolHints(tool) {
 	};
 }
 function resolveTimeoutMs(tool, config) {
-	return readToolHints(tool).timeoutMs ?? config.defaultTimeoutMs;
+	const hints = readToolHints(tool);
+	const policyTimeoutMs = config.resolveTimeoutMs?.(tool.name);
+	return policyTimeoutMs && policyTimeoutMs > 0 ? policyTimeoutMs : hints.timeoutMs ?? config.defaultTimeoutMs;
 }
 /**
 * Execute tool with timeout (always) and retry (only for idempotent tools).
@@ -34,22 +36,27 @@ async function executeToolWithProtection(tool, toolCallId, params, signal, onUpd
 	};
 	const toolName = tool.name;
 	const hints = readToolHints(tool);
-	const runOnce = () => tool.execute(toolCallId, params, signal, onUpdate);
-	let operation = runOnce;
-	if (fullConfig.enableTimeout) {
-		const timeoutMs = resolveTimeoutMs(tool, fullConfig);
-		const inner = operation;
-		operation = () => executeWithTimeout(inner, {
+	const runOnce = () => {
+		const controller = new AbortController();
+		const onParentAbort = () => controller.abort(signal?.reason);
+		if (signal?.aborted) onParentAbort();
+		else signal?.addEventListener("abort", onParentAbort, { once: true });
+		const execute = () => tool.execute(toolCallId, params, controller.signal, onUpdate);
+		return (fullConfig.enableTimeout ? executeWithTimeout(execute, {
 			toolName,
-			timeoutMs,
-			description: `Executing ${toolName}`
-		});
-	}
+			timeoutMs: resolveTimeoutMs(tool, fullConfig),
+			description: `Executing ${toolName}`,
+			signal,
+			onTimeout: (error) => controller.abort(error)
+		}) : execute()).finally(() => signal?.removeEventListener("abort", onParentAbort));
+	};
+	let operation = runOnce;
 	if (fullConfig.enableRetry && fullConfig.maxRetries > 0 && hints.idempotent) {
 		const inner = operation;
 		operation = () => withRetry(inner, {
 			attempts: fullConfig.maxRetries + 1,
 			minDelayMs: fullConfig.retryDelayMs,
+			shouldRetry: (error) => !signal?.aborted && error?.name !== "AbortError",
 			onRetry: (info) => {
 				log.warn({
 					tool: toolName,

package/dist/src/agent/tools/factory.js

@@ -1,5 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { isXopcDatabaseOpen } from "../../storage/sqlite/connection.js";
+import { getSessionTaskPlan, setSessionTaskPlan } from "../../storage/sqlite/session-task-plan-repository.js";
+import "../../storage/sqlite/index.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../agent-scope.js";
 import { createReadFileTool } from "./read.js";
 import { createWriteFileTool } from "./write.js";
@@ -43,6 +46,7 @@ import { createSkillInstallTool } from "./skill-install-tool.js";
 import { createToolManualTool } from "./tool-manual-tool.js";
 import { createDesktopPetTool } from "./desktop-pet-tool.js";
 import { createCodeIntelligenceTools } from "../code-intelligence/tools.js";
+import { createManagedJobTool } from "./managed-job-tool.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool } from "./image-generate-tool.js";
 import "./index.js";
@@ -217,7 +221,19 @@ var AgentToolsFactory = class {
 				if (!CLARIFY_SUPPORTED_CHANNELS.has(ctx.channel)) return null;
 				return (r) => req(ctx.sessionKey, r);
 			} }),
-			createTodoTool({ getSessionKey: () => this.deps.getCurrentContext()?.sessionKey }),
+			createTodoTool({
+				getSessionKey: () => this.deps.getCurrentContext()?.sessionKey,
+				repository: {
+					isAvailable: isXopcDatabaseOpen,
+					read: (sessionKey) => getSessionTaskPlan(sessionKey)?.items ?? [],
+					write: (sessionKey, items) => {
+						setSessionTaskPlan({
+							sessionKey,
+							items
+						});
+					}
+				}
+			}),
 			createUpdatePlanTool(),
 			...getSkillMgr ? [
 				createSkillsListTool({
@@ -255,6 +271,7 @@ var AgentToolsFactory = class {
 				getSkillPassthroughEnvVarNames: this.deps.getSkillPassthroughEnvVarNames,
 				recordGoalEvidence
 			}),
+			createManagedJobTool(workspace, () => this.deps.getCurrentContext()?.sessionKey, this.deps.getSkillPassthroughEnvVarNames),
 			createWebSearchTool(() => this.deps.getConfig?.()),
 			createWebFetchTool(() => this.deps.getConfig?.()),
 			createWebExtractTool({ getConfig: () => this.deps.getConfig?.() }),

package/dist/src/agent/tools/goal-tool.js

@@ -3,6 +3,8 @@ import "../../storage/sqlite/index.js";
 import { GoalService } from "../../goals/goal-service.js";
 import "../../goals/index.js";
 import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
+import { OutcomeExecutionService } from "../../work/outcome-execution-service.js";
+import "../../work/index.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/goal-tool.ts
 const GoalToolSchema = Type.Object({
@@ -92,8 +94,8 @@ function createGoalTool(options = {}) {
 				if (!title) return textResult("Error: title is required.");
 				const sessionKey = params.sessionKey?.trim() || options.getCurrentSessionKey?.()?.trim();
 				const projectId = params.projectId?.trim() || (sessionKey ? getSessionMetadata(sessionKey)?.projectId : void 0);
-				const goal = goals.create({
-					title,
+				const goal = new OutcomeExecutionService().create({
+					objective: title,
 					description: params.description,
 					agentId: params.agentId,
 					sessionKey,
@@ -103,7 +105,7 @@ function createGoalTool(options = {}) {
 					judgeModelRef: params.judgeModelRef,
 					maxTurns: params.maxTurns,
 					source: "workflow"
-				});
+				}).goal;
 				return textResult(`Created goal ${goal.id}\n${goal.title}`, {
 					goal,
 					delivery: goalDelivery(goal, "created")