@xopcai/xopc 0.0.179 → 0.0.187

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

@@ -1,92 +1,60 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { SHORT_TERM_PROMOTION_LOCK_RELATIVE, SHORT_TERM_RECALL_STORE_RELATIVE } from "../memory/dreaming/constants.js";
-import { clearStaleDreamingLock, loadDreamingStore, resetDreamingStore } from "../memory/dreaming/short-term-store.js";
+import { isXopcDatabaseOpen } from "../../storage/sqlite/connection.js";
+import { evaluateMemoryReadiness } from "../../user-context/memory-readiness.js";
+import { getMemoryReadiness } from "../../storage/sqlite/memory-readiness-repository.js";
+import { listDreamingRuns } from "../../storage/sqlite/dreaming-repository.js";
+import { listMemorySignals } from "../../storage/sqlite/memory-records-repository.js";
+import "../../storage/sqlite/index.js";
 import { resolveDreamingConfig } from "../memory/dreaming/config.js";
-import path from "node:path";
-import fs from "node:fs/promises";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/dreaming-tool.ts
-init_logger();
-const log = createLogger("DreamingTool");
-const DreamingSchema = Type.Object({ action: Type.Union([
-	Type.Literal("status"),
-	Type.Literal("reset_store"),
-	Type.Literal("clear_lock")
-]) });
-function textResult(text) {
-	return {
-		content: [{
-			type: "text",
-			text
-		}],
-		details: {}
-	};
-}
-function safeStatMs(ms) {
-	if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0) return null;
-	return Math.floor(ms);
-}
-function isoDay(isoLike) {
-	if (!isoLike) return null;
-	return isoLike.match(/^(\d{4}-\d{2}-\d{2})/)?.[1] ?? null;
-}
+const DreamingSchema = Type.Object({ action: Type.Literal("status") });
 function createDreamingTool(deps) {
 	return {
 		name: "dreaming",
 		label: "💤 Dreaming",
-		description: "Inspect and maintain the dreaming promotion state.\n\nActions:\n- status: show config gates and short-term store stats\n- reset_store: clear this agent short-term recall store (.dreams/short-term-recall.json)\n- clear_lock: remove this agent stale promotion lock file (.dreams/short-term-promotion.lock)",
+		description: "Show the structured Dreaming configuration and recent consolidation activity.",
 		parameters: DreamingSchema,
-		async execute(_toolCallId, params) {
-			const action = params.action;
-			const dreamingRoot = deps.getDreamingRoot();
-			const cfg = deps.getConfig();
+		async execute() {
 			const agentId = deps.getAgentId?.();
-			const resolved = resolveDreamingConfig(cfg, agentId);
-			const storePath = path.join(dreamingRoot, SHORT_TERM_RECALL_STORE_RELATIVE);
-			const lockPath = path.join(dreamingRoot, SHORT_TERM_PROMOTION_LOCK_RELATIVE);
-			if (action === "status") {
-				const { store } = await loadDreamingStore({ dreamingRoot });
-				const entries = Object.values(store.entries ?? {});
-				const total = entries.length;
-				const promoted = entries.filter((e) => Boolean(e.promotedAt)).length;
-				const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-				const promotedToday = entries.filter((e) => isoDay(e.promotedAt) === today).length;
-				const lastPromotedAt = entries.map((e) => e.promotedAt).filter((x) => typeof x === "string" && x.length > 0).sort().at(-1);
-				const lockStat = await fs.stat(lockPath).catch(() => null);
-				const lockAgeMs = lockStat && safeStatMs(lockStat.mtimeMs) ? Date.now() - Math.floor(lockStat.mtimeMs) : null;
-				return textResult([
-					"Dreaming status",
-					"",
-					`enabled: ${resolved.enabled ? "true" : "false"}`,
-					`deep.enabled: ${resolved.deep.enabled ? "true" : "false"}`,
-					`cron.frequency: ${resolved.frequency}`,
-					`cron.timezone: ${resolved.timezone ?? "(default)"}`,
-					`deep.minScore: ${resolved.deep.minScore}`,
-					`deep.minRecallCount: ${resolved.deep.minRecallCount}`,
-					`deep.limit: ${resolved.deep.limit}`,
-					"",
-					`agentId: ${agentId ?? "(unknown)"}`,
-					`storePath: ${storePath}`,
-					`entryCount: ${total}`,
-					`promotedCount: ${promoted}`,
-					`promotedToday: ${promotedToday}`,
-					`lastPromotedAt: ${lastPromotedAt ?? "(none)"}`,
-					"",
-					`lockPath: ${SHORT_TERM_PROMOTION_LOCK_RELATIVE}`,
-					`lockPresent: ${lockStat ? "true" : "false"}`,
-					`lockAgeMs: ${lockAgeMs ?? "(n/a)"}`
-				].join("\n"));
-			}
-			if (action === "reset_store") {
-				const before = await resetDreamingStore({ dreamingRoot });
-				log.info({
-					dreamingRoot,
-					before
-				}, "Dreaming store reset");
-				return textResult(`Reset short-term store. Removed ${before} entr${before === 1 ? "y" : "ies"}. Path: ${storePath}`);
-			}
-			return textResult(`${await clearStaleDreamingLock(dreamingRoot) ? "Cleared stale lock." : "No lock present."} Path: ${lockPath}`);
+			const workspaceId = deps.getWorkspace();
+			const readiness = agentId && isXopcDatabaseOpen() ? getMemoryReadiness({
+				agentId,
+				workspaceId
+			}) : evaluateMemoryReadiness({
+				evaluatedTurns: 0,
+				helpfulTurns: 0,
+				recordFeedback: 0,
+				recordErrors: 0,
+				sensitiveFeedback: 0,
+				dreamingRuns: 0,
+				dreamingFailures: 0
+			});
+			const resolved = resolveDreamingConfig(deps.getConfig(), { automaticReady: readiness.ready });
+			const signals = listMemorySignals({
+				workspaceId,
+				limit: 500
+			});
+			const runs = listDreamingRuns({
+				agentId,
+				workspaceId,
+				limit: 20
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						mode: resolved.mode,
+						phases: resolved.phases,
+						writeDisposition: resolved.writeDisposition,
+						readiness,
+						storage: "sqlite://memory_records",
+						signalCount: signals.length,
+						dreamingSignalCount: signals.filter((signal) => signal.source === "dreaming").length,
+						lastRun: runs[0] ?? null
+					}, null, 2)
+				}],
+				details: {}
+			};
 		}
 	};
 }

package/dist/src/agent/tools/exec-command.d.ts

@@ -1,5 +1,4 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { GoalEvidenceRecordInput } from './goal-evidence-recorder.js';
 export interface ExecCommandDetails {
     command: string;
     cwd: string;
@@ -25,6 +24,5 @@ export interface ExecCommandUpdateDetails {
 export interface CreateExecCommandToolOptions {
     /** Env var names allowed through prepareSafeToolEnv even if they match secret heuristics. */
     getSkillPassthroughEnvVarNames?: () => string[];
-    recordGoalEvidence?: (input: GoalEvidenceRecordInput) => Promise<void> | void;
 }
 export declare function createExecCommandTool(workspaceCwd: string, options?: CreateExecCommandToolOptions): AgentTool;

package/dist/src/agent/tools/exec-command.js

@@ -20,9 +20,6 @@ function clampTimeoutMs(raw) {
 function clampMaxOutputChars(raw) {
 	return Math.max(1e3, Math.min(5e5, Math.floor(typeof raw === "number" && Number.isFinite(raw) ? raw : DEFAULT_MAX_OUTPUT_CHARS)));
 }
-function isLikelyTestCommand(command) {
-	return /\b(test|vitest|jest|pytest|go test|cargo test|npm test|pnpm test|yarn test|typecheck|type-check|lint)\b/i.test(command);
-}
 function commandStatus(exitCode, timedOut) {
 	if (timedOut) return "timed_out";
 	if (exitCode === 0) return "success";
@@ -182,27 +179,13 @@ function createExecCommandTool(workspaceCwd, options) {
 						truncatedBy: formatted.truncatedBy,
 						outputBytes: formatted.outputBytes
 					};
-					const result = {
+					resolveTool({
 						content: [{
 							type: "text",
 							text: formatted.text
 						}],
 						details
-					};
-					Promise.resolve(options?.recordGoalEvidence?.({
-						kind: timedOut || exitCode !== 0 ? "command" : isLikelyTestCommand(command) ? "test" : "command",
-						title: `Command: ${command.slice(0, 120)}`,
-						summary: formatted.text.slice(0, 2e3),
-						data: {
-							command,
-							cwd: policy.effectiveCwd,
-							exitCode,
-							durationMs,
-							timedOut,
-							truncated: details.truncated,
-							outputBytes: details.outputBytes
-						}
-					})).finally(() => resolveTool(result));
+					});
 				};
 				const abort = () => {
 					timedOut = true;

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.d.ts

@@ -18,7 +18,6 @@ import type { AutomationService } from '../../automations/index.js';
 import type { BrowserRecipeService } from '../../browser/recipes/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 { WorkflowRunServiceLike } from '../../workflows/service/workflow-run-service.types.js';
 import type { SkillManager } from '../skills/skill-manager.js';
@@ -53,8 +52,9 @@ export interface ToolFactoryDeps {
     /** Gateway: enables the `xopc_use` product-object tool. */
     getNotesService?: () => NotesService | undefined;
     getProjectService?: () => ProjectService | undefined;
-    getWorkItemService?: () => WorkItemService | undefined;
     getLocalAppService?: () => LocalAppService | undefined;
+    /** Gateway: queues Task execution for xopc_use task start/resume/verify actions. */
+    dispatchTaskRuns?: () => void;
     /** Gateway: starts persisted workflow runs (dedicated chat session per run). */
     getWorkflowRunService?: () => WorkflowRunServiceLike | undefined;
     /** Current session skill indexing (tool gating + allowlist); used by skills_list / skill_view. */
@@ -85,8 +85,6 @@ export interface CreateCoreToolsOptions {
     /** Optional primary model for image tool heuristics. */
     getPrimaryModel?: () => Model<Api>;
     getMemoryManager?: () => MemoryManager;
-    /** Shared user memories directory used for dreaming state (`user/memories`). */
-    dreamingRoot?: string;
     agentId?: string;
     /** When set, registers local skill tools plus marketplace discovery for this workspace. */
     getSkillManager?: () => SkillManager;

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

@@ -10,7 +10,6 @@ import { createListDirTool } from "./list-dir.js";
 import { createExecCommandTool } from "./exec-command.js";
 import { createApplyPatchTool } from "./apply-patch.js";
 import { createMemoryGetTool, createMemorySearchTool } from "./memory-tool.js";
-import { createCuratedMemoryTool } from "./curated-memory-tool.js";
 import { createSessionSearchTool } from "./session-search-tool.js";
 import { createGrepTool } from "./grep.js";
 import { createFindTool } from "./find.js";
@@ -24,7 +23,6 @@ import { createCreateShareTool, isShareToolAvailable } from "./create-share-tool
 import { createTodoTool } from "./todo-tool.js";
 import { createUpdatePlanTool } from "./update-plan-tool.js";
 import { createSessionStatusTool } from "./session-status-tool.js";
-import { resolveDreamingConfig } from "../memory/dreaming/config.js";
 import { createDreamingTool } from "./dreaming-tool.js";
 import { createClarifyTool } from "./clarify-tool.js";
 import { BrowserManager } from "../../browser/manager.js";
@@ -37,7 +35,6 @@ import { createWorkflowTool } from "./workflow-tool.js";
 import "./execute-code-tool.js";
 import { createAutomationTool } from "./automation-tool.js";
 import { createBrowserRecipeTool } from "./browser-recipe-tool.js";
-import { createGoalTool } from "./goal-tool.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
 import { createSkillViewTool, createSkillsListTool } from "./skills-tools.js";
 import { createSkillManageTool } from "./skill-manage-tool.js";
@@ -46,17 +43,15 @@ 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";
-import { shouldRegisterCuratedMemoryTool } from "../memory/memory-config.js";
 import { createBrowserUseTool } from "./browser/tool/browser-use-tool.js";
 import { createWorkflowCatalog } from "../workflow/catalog.js";
-import { resolveDreamingRoot } from "../memory/dreaming/scope.js";
 import { wrapToolsWithProtection } from "./executor.js";
 import { mergeTtsConfigFromAppConfig } from "../../voice/tts/merge-config.js";
 import { createTextToSpeechTool } from "./tts-tool.js";
-import { createGoalEvidenceRecorder } from "./goal-evidence-recorder.js";
 import { getAgentCapabilityToolNames } from "../capabilities/registry.js";
 import "../capabilities/index.js";
 import { isCodeIntelligenceEnabledForAgent } from "../code-intelligence/tool-gating.js";
@@ -168,9 +163,7 @@ var AgentToolsFactory = class {
 		const primary = getPrimary?.();
 		const modelHasVision = primary?.input?.includes("image") ?? false;
 		const cfg = this.deps.getConfig?.();
-		const dreamingRoot = options?.dreamingRoot ?? (cfg ? resolveDreamingRoot() : workspace);
 		const browserEnabled = cfg?.browser?.enabled !== false;
-		const recordGoalEvidence = createGoalEvidenceRecorder({ getSessionKey: () => this.deps.getCurrentContext()?.sessionKey });
 		const imageTool = createImageTool({
 			config: cfg,
 			workspace,
@@ -195,11 +188,8 @@ var AgentToolsFactory = class {
 			})
 		].filter((t) => t != null);
 		const readTool = createReadFileTool(workspace, { profileMarkdownRoot: options?.profileMarkdownRoot });
-		const writeTool = createWriteFileTool(workspace, {
-			profileMarkdownRoot: options?.profileMarkdownRoot,
-			recordGoalEvidence
-		});
-		const applyPatchTool = createApplyPatchTool(workspace, { recordGoalEvidence });
+		const writeTool = createWriteFileTool(workspace, { profileMarkdownRoot: options?.profileMarkdownRoot });
+		const applyPatchTool = createApplyPatchTool(workspace);
 		const listDir = createListDirTool(workspace);
 		const grep = createGrepTool(workspace);
 		const find = createFindTool(workspace);
@@ -207,7 +197,6 @@ var AgentToolsFactory = class {
 			createSessionStatusTool(),
 			createDreamingTool({
 				getWorkspace: () => workspace,
-				getDreamingRoot: () => dreamingRoot,
 				getConfig: () => this.deps.getConfig?.(),
 				getAgentId: () => options?.agentId
 			}),
@@ -266,10 +255,8 @@ var AgentToolsFactory = class {
 			listDir,
 			grep,
 			find,
-			createExecCommandTool(workspace, {
-				getSkillPassthroughEnvVarNames: this.deps.getSkillPassthroughEnvVarNames,
-				recordGoalEvidence
-			}),
+			createExecCommandTool(workspace, { getSkillPassthroughEnvVarNames: this.deps.getSkillPassthroughEnvVarNames }),
+			createManagedJobTool(workspace, () => this.deps.getCurrentContext()?.sessionKey, this.deps.getSkillPassthroughEnvVarNames),
 			createWebSearchTool(() => this.deps.getConfig?.()),
 			createWebFetchTool(() => this.deps.getConfig?.()),
 			createWebExtractTool({ getConfig: () => this.deps.getConfig?.() }),
@@ -286,18 +273,13 @@ var AgentToolsFactory = class {
 				getConfig: () => this.deps.getConfig?.()
 			})] : [],
 			...getMemMgr ? [createMemorySearchTool({
-				workspaceDir: workspace,
-				dreamingRoot,
 				getMemoryManager: () => getMemMgr(),
 				getScope: () => ({
 					...options?.agentId ? { agentId: options.agentId } : {},
 					workspaceId: workspace,
 					...this.deps.getCurrentContext?.()?.sessionKey ? { sessionKey: this.deps.getCurrentContext().sessionKey } : {}
-				}),
-				shouldRecordDreamingRecalls: () => resolveDreamingConfig(this.deps.getConfig?.(), options?.agentId).enabled
+				})
 			}), createMemoryGetTool({
-				workspaceDir: workspace,
-				dreamingRoot,
 				getMemoryManager: () => getMemMgr(),
 				getScope: () => ({
 					...options?.agentId ? { agentId: options.agentId } : {},
@@ -305,7 +287,6 @@ var AgentToolsFactory = class {
 					...this.deps.getCurrentContext?.()?.sessionKey ? { sessionKey: this.deps.getCurrentContext().sessionKey } : {}
 				})
 			})] : [],
-			...getMemMgr && shouldRegisterCuratedMemoryTool(this.deps.getConfig?.()) ? [createCuratedMemoryTool(() => getMemMgr())] : [],
 			...getMemMgr?.().getAdditionalTools() ?? [],
 			...this.deps.getSessionStore && getPrimary ? [createSessionSearchTool({
 				getSessionStore: this.deps.getSessionStore,
@@ -314,16 +295,16 @@ var AgentToolsFactory = class {
 			})] : [],
 			...this.deps.getAutomationService ? [createAutomationTool({ getAutomationService: this.deps.getAutomationService })] : [],
 			...browserEnabled && this.deps.getBrowserRecipeService ? [createBrowserRecipeTool({ getBrowserRecipeService: this.deps.getBrowserRecipeService })] : [],
-			...this.deps.getProjectService || this.deps.getNotesService || this.deps.getWorkItemService || this.deps.getLocalAppService ? [createXopcUseTool({
+			...this.deps.getAutomationService || this.deps.getProjectService || this.deps.getNotesService || this.deps.getLocalAppService || this.deps.dispatchTaskRuns ? [createXopcUseTool({
 				getConfig: () => this.deps.getConfig?.(),
 				getCurrentAgentId: () => options.agentId,
 				getCurrentSessionKey: () => this.deps.getCurrentContext()?.sessionKey,
+				getAutomationService: this.deps.getAutomationService,
 				getNotesService: this.deps.getNotesService,
 				getProjectService: this.deps.getProjectService,
-				getWorkItemService: this.deps.getWorkItemService,
-				getLocalAppService: this.deps.getLocalAppService
+				getLocalAppService: this.deps.getLocalAppService,
+				dispatchTaskRuns: this.deps.dispatchTaskRuns
 			})] : [],
-			createGoalTool({ getCurrentSessionKey: () => this.deps.getCurrentContext()?.sessionKey }),
 			...browserEnabled ? [createBrowserUseTool({
 				getManager: () => this.ensureBrowserManager(),
 				getPageForTask: () => this.acquireBrowserPage(),

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

@@ -6,7 +6,6 @@ export { createListDirTool, listDirTool } from './list-dir.js';
 export { createExecCommandTool, type ExecCommandDetails, type ExecCommandUpdateDetails, } from './exec-command.js';
 export { createApplyPatchTool, type AppliedPatchChange, type ApplyPatchDetails, } from './apply-patch.js';
 export { createMemorySearchTool, createMemoryGetTool, type MemoryToolOptions, } from './memory-tool.js';
-export { createCuratedMemoryTool } from './curated-memory-tool.js';
 export { createSessionSearchTool } from './session-search-tool.js';
 export { grepTool, createGrepTool, type GrepToolInput, type GrepToolDetails, } from './grep.js';
 export { findTool, createFindTool, type FindToolInput, type FindToolDetails, } from './find.js';
@@ -28,7 +27,6 @@ export { createWorkflowTool, type WorkflowToolDeps, type WorkflowToolInput } fro
 export { createExecuteCodeTool, buildSandboxToolMap, SANDBOX_ALLOWED_TOOLS, } from './execute-code-tool.js';
 export { createAutomationTool, type AutomationToolDeps } from './automation-tool.js';
 export { createBrowserRecipeTool } from './browser-recipe-tool.js';
-export { createGoalTool, type GoalToolOptions } from './goal-tool.js';
 export { createXopcUseTool, type XopcUseToolDeps, type XopcUseToolInput } from './xopc-use-tool.js';
 export { createSkillsListTool, createSkillViewTool, type SkillsToolsDeps } from './skills-tools.js';
 export { createSkillManageTool, type SkillManageToolDeps } from './skill-manage-tool.js';
@@ -37,6 +35,7 @@ export { createSkillInstallTool, type SkillInstallToolDeps, type SkillInstallToo
 export { createToolManualTool } from './tool-manual-tool.js';
 export { createDesktopPetTool, type DesktopPetCreateDetails } from './desktop-pet-tool.js';
 export { createCodeIntelligenceTools } from '../code-intelligence/tools.js';
+export { createManagedJobTool } from './managed-job-tool.js';
 export { createImageTool, resolveImageModelConfigForTool } from './image-tool.js';
 export { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from './image-generate-tool.js';
 export { truncateHead, truncateTail, truncateLine, formatSize, type TruncationResult, type TruncationOptions, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES, GREP_MAX_LINE_LENGTH, } from './truncate.js';

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

@@ -8,7 +8,6 @@ import { createExecCommandTool } from "./exec-command.js";
 import { fuzzyFindText, generateDiffString, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom } from "./edit-diff.js";
 import { createApplyPatchTool } from "./apply-patch.js";
 import { createMemoryGetTool, createMemorySearchTool } from "./memory-tool.js";
-import { createCuratedMemoryTool } from "./curated-memory-tool.js";
 import { createSessionSearchTool } from "./session-search-tool.js";
 import { createGrepTool, grepTool } from "./grep.js";
 import { createFindTool, findTool } from "./find.js";
@@ -32,7 +31,6 @@ import { createWorkflowTool } from "./workflow-tool.js";
 import { SANDBOX_ALLOWED_TOOLS, buildSandboxToolMap, createExecuteCodeTool } from "./execute-code-tool.js";
 import { createAutomationTool } from "./automation-tool.js";
 import { createBrowserRecipeTool } from "./browser-recipe-tool.js";
-import { createGoalTool } from "./goal-tool.js";
 import { createXopcUseTool } from "./xopc-use-tool.js";
 import { createSkillViewTool, createSkillsListTool } from "./skills-tools.js";
 import { createSkillManageTool } from "./skill-manage-tool.js";
@@ -41,7 +39,8 @@ 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 { resolveImageModelConfigForTool } from "../image/tool-model-config.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from "./image-generate-tool.js";
-export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCodeIntelligenceTools, createComposioTools, createCreateShareTool, createCuratedMemoryTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGoalTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };
+export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCodeIntelligenceTools, createComposioTools, createCreateShareTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createManagedJobTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };

package/dist/src/agent/tools/managed-job-tool.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export declare function createManagedJobTool(workspace: string, getSessionKey: () => string | undefined, getSkillPassthroughEnvVarNames?: () => string[]): AgentTool;

package/dist/src/agent/tools/managed-job-tool.js

@@ -0,0 +1,160 @@
+import { resolveGlobalSingleton } from "../../utils/global-singleton.js";
+import { evaluateExecPolicy } from "../sandbox/exec-policy.js";
+import { resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/managed-job-tool.ts
+const MANAGED_JOB_REGISTRY_KEY = Symbol.for("xopc.managedJobRegistry");
+const DEFAULT_MAX_RUNTIME_MS = 60 * 6e4;
+const MAX_RUNTIME_MS = 1440 * 6e4;
+const MAX_CAPTURE_CHARS = 2e5;
+var ManagedJobRegistry = class {
+	jobs = /* @__PURE__ */ new Map();
+	start(owner, command, cwd, env, maxRuntimeMs) {
+		this.prune();
+		const id = randomUUID();
+		const child = spawn(command, [], {
+			shell: true,
+			cwd,
+			env,
+			detached: process.platform !== "win32"
+		});
+		const job = {
+			id,
+			owner,
+			command,
+			cwd,
+			status: "running",
+			process: child,
+			pid: child.pid,
+			createdAtMs: Date.now(),
+			stdout: "",
+			stderr: "",
+			timeout: setTimeout(() => this.stop(job, "timed_out"), maxRuntimeMs)
+		};
+		job.timeout.unref?.();
+		const append = (stream, value) => {
+			const next = `${job[stream]}${String(value)}`;
+			job[stream] = next.length > MAX_CAPTURE_CHARS ? next.slice(-MAX_CAPTURE_CHARS) : next;
+		};
+		child.stdout?.on("data", (value) => append("stdout", value));
+		child.stderr?.on("data", (value) => append("stderr", value));
+		child.on("error", (error) => append("stderr", `\n${error.message}`));
+		child.on("close", (exitCode) => {
+			if (job.status === "running") job.status = exitCode === 0 ? "succeeded" : "failed";
+			job.exitCode = exitCode;
+			job.endedAtMs = Date.now();
+			clearTimeout(job.timeout);
+		});
+		this.jobs.set(id, job);
+		return this.view(job);
+	}
+	get(owner, id) {
+		const job = this.jobs.get(id);
+		return job?.owner === owner ? this.view(job) : void 0;
+	}
+	list(owner) {
+		return [...this.jobs.values()].filter((job) => job.owner === owner).toSorted((a, b) => b.createdAtMs - a.createdAtMs).slice(0, 50).map((job) => this.view(job));
+	}
+	cancel(owner, id) {
+		const job = this.jobs.get(id);
+		if (!job || job.owner !== owner) return void 0;
+		if (job.status === "running") this.stop(job, "cancelled");
+		return this.view(job);
+	}
+	stop(job, status) {
+		if (job.status !== "running") return;
+		job.status = status;
+		job.endedAtMs = Date.now();
+		clearTimeout(job.timeout);
+		if (job.pid && process.platform !== "win32") try {
+			process.kill(-job.pid, "SIGTERM");
+			return;
+		} catch {}
+		job.process.kill("SIGTERM");
+	}
+	view(job) {
+		const outputLength = job.stdout.length + job.stderr.length;
+		return {
+			id: job.id,
+			command: job.command,
+			cwd: job.cwd,
+			status: job.status,
+			pid: job.pid,
+			createdAtMs: job.createdAtMs,
+			endedAtMs: job.endedAtMs,
+			exitCode: job.exitCode,
+			stdout: job.stdout,
+			stderr: job.stderr,
+			durationMs: (job.endedAtMs ?? Date.now()) - job.createdAtMs,
+			outputTruncated: outputLength >= MAX_CAPTURE_CHARS
+		};
+	}
+	prune() {
+		if (this.jobs.size < 500) return;
+		const removable = [...this.jobs.values()].filter((job) => job.status !== "running").toSorted((a, b) => a.createdAtMs - b.createdAtMs).slice(0, Math.max(1, this.jobs.size - 400));
+		for (const job of removable) this.jobs.delete(job.id);
+	}
+};
+const ManagedJobSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("start"),
+		command: Type.String(),
+		cwd: Type.Optional(Type.String()),
+		maxRuntimeMs: Type.Optional(Type.Number())
+	}),
+	Type.Object({
+		action: Type.Literal("status"),
+		jobId: Type.String()
+	}),
+	Type.Object({ action: Type.Literal("list") }),
+	Type.Object({
+		action: Type.Literal("cancel"),
+		jobId: Type.String()
+	})
+], { type: "object" });
+function registry() {
+	return resolveGlobalSingleton(MANAGED_JOB_REGISTRY_KEY, () => new ManagedJobRegistry());
+}
+function result(value) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value, null, 2)
+		}],
+		details: {}
+	};
+}
+function createManagedJobTool(workspace, getSessionKey, getSkillPassthroughEnvVarNames) {
+	return {
+		name: "managed_job",
+		label: "Managed Job",
+		description: "Start and manage commands expected to outlive a single tool call. Start returns a jobId immediately; use status/list/cancel to observe or stop it.",
+		parameters: ManagedJobSchema,
+		supportsParallel: true,
+		idempotent: false,
+		async execute(_toolCallId, input) {
+			const owner = getSessionKey() ?? "default";
+			if (input.action === "list") return result(registry().list(owner));
+			if (input.action === "status") return result(registry().get(owner, input.jobId) ?? { error: "Managed job not found" });
+			if (input.action === "cancel") return result(registry().cancel(owner, input.jobId) ?? { error: "Managed job not found" });
+			const command = String(input.command ?? "").trim();
+			if (!command) return result({ error: "command is required" });
+			const policy = evaluateExecPolicy({
+				command,
+				cwd: input.cwd?.trim() ? resolve(workspace, input.cwd.trim()) : workspace,
+				allowedEnvVars: getSkillPassthroughEnvVarNames?.() ?? []
+			});
+			if (!policy.allowed) return result({ error: `Sandbox blocked command: ${policy.reason}` });
+			const rawMax = Number(input.maxRuntimeMs ?? DEFAULT_MAX_RUNTIME_MS);
+			const maxRuntimeMs = Math.min(MAX_RUNTIME_MS, Math.max(1e3, Number.isFinite(rawMax) ? rawMax : DEFAULT_MAX_RUNTIME_MS));
+			return result(registry().start(owner, command, policy.effectiveCwd, {
+				...policy.sanitizedEnv,
+				COLUMNS: "200"
+			}, maxRuntimeMs));
+		}
+	};
+}
+//#endregion
+export { createManagedJobTool };

package/dist/src/agent/tools/memory-tool.d.ts

@@ -2,11 +2,8 @@ import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { MemoryManager } from '../memory/manager.js';
 import type { MemoryScope } from '../memory/types.js';
 export interface MemoryToolOptions {
-    workspaceDir: string;
-    dreamingRoot: string;
     getMemoryManager: () => MemoryManager;
     getScope?: () => Partial<MemoryScope>;
-    shouldRecordDreamingRecalls?: () => boolean;
 }
 export declare function createMemorySearchTool(options: MemoryToolOptions): AgentTool;
 export declare function createMemoryGetTool(options: MemoryToolOptions): AgentTool;