@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/agent/tools/knowledge-memory-tool.js

@@ -0,0 +1,129 @@
+import { getKnowledgeItem, searchKnowledgeItems, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
+import "../../knowledge-memory/index.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/knowledge-memory-tool.ts
+const SearchSchema = Type.Object({
+	query: Type.String(),
+	maxResults: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 50
+	}))
+});
+const GetSchema = Type.Object({ id: Type.String() });
+const WriteSchema = Type.Object({
+	kind: Type.Union([
+		Type.Literal("project_fact"),
+		Type.Literal("workspace_fact"),
+		Type.Literal("decision"),
+		Type.Literal("task_lesson"),
+		Type.Literal("commitment"),
+		Type.Literal("open_question"),
+		Type.Literal("episode"),
+		Type.Literal("note")
+	]),
+	content: Type.String(),
+	canonicalKey: Type.String(),
+	scope: Type.Union([Type.Literal("workspace"), Type.Literal("session")]),
+	importance: Type.Optional(Type.Number({
+		minimum: 0,
+		maximum: 1
+	}))
+});
+function visibility(options) {
+	return {
+		agentId: options.agentId,
+		workspaceId: options.workspaceId,
+		sessionId: options.getSessionId() ?? ""
+	};
+}
+function createKnowledgeSearchTool(options) {
+	return {
+		name: "knowledge_search",
+		label: "Knowledge Search",
+		description: "Search project, workspace, and session knowledge for prior decisions, facts, lessons, and commitments.",
+		parameters: SearchSchema,
+		async execute(_toolCallId, raw) {
+			const input = raw;
+			const results = searchKnowledgeItems({
+				query: input.query,
+				context: visibility(options),
+				limit: input.maxResults ?? 12
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ results }, null, 2)
+				}],
+				details: { results }
+			};
+		}
+	};
+}
+function visibleItem(options, item) {
+	return item.scope.type === "global" || item.scope.type === "agent" && item.scope.id === options.agentId || item.scope.type === "workspace" && item.scope.id === options.workspaceId || item.scope.type === "session" && item.scope.id === options.getSessionId();
+}
+function createKnowledgeGetTool(options) {
+	return {
+		name: "knowledge_get",
+		label: "Knowledge Get",
+		description: "Read one knowledge item returned by knowledge_search.",
+		parameters: GetSchema,
+		async execute(_toolCallId, raw) {
+			const id = raw.id;
+			const item = getKnowledgeItem(id);
+			return item && visibleItem(options, item) ? {
+				content: [{
+					type: "text",
+					text: JSON.stringify(item, null, 2)
+				}],
+				details: { item }
+			} : {
+				content: [{
+					type: "text",
+					text: `Knowledge item not found: ${id}`
+				}],
+				details: { id }
+			};
+		}
+	};
+}
+function createKnowledgeWriteTool(options) {
+	return {
+		name: "knowledge_write",
+		label: "Knowledge Write",
+		description: "Store a scoped knowledge candidate with provenance for later review and retrieval.",
+		parameters: WriteSchema,
+		async execute(_toolCallId, raw) {
+			const input = raw;
+			const sessionId = options.getSessionId();
+			if (input.scope === "session" && !sessionId) throw new Error("A current session is required for session knowledge.");
+			const result = writeKnowledgeItem({
+				kind: input.kind,
+				scope: input.scope === "workspace" ? {
+					type: "workspace",
+					id: options.workspaceId
+				} : {
+					type: "session",
+					id: sessionId
+				},
+				content: input.content,
+				canonicalKey: input.canonicalKey,
+				confidence: .7,
+				importance: input.importance ?? .5,
+				originClass: "agent",
+				sourceAgentId: options.agentId,
+				...sessionId ? { sourceSessionId: sessionId } : {},
+				source: { tool: "knowledge_write" }
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				details: result
+			};
+		}
+	};
+}
+//#endregion
+export { createKnowledgeGetTool, createKnowledgeSearchTool, createKnowledgeWriteTool };

package/dist/src/agent/tools/{dreaming-tool.d.ts → memory-maintenance-tool.d.ts}

@@ -1,6 +1,6 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
-export interface DreamingToolDeps {
+export interface MemoryMaintenanceToolDeps {
     getConfig: () => Config | undefined;
 }
-export declare function createDreamingTool(deps: DreamingToolDeps): AgentTool;
+export declare function createMemoryMaintenanceTool(deps: MemoryMaintenanceToolDeps): AgentTool;

package/dist/src/agent/tools/memory-maintenance-tool.js

@@ -0,0 +1,31 @@
+import { resolveMemoryMaintenanceSchedules } from "../../memory-maintenance/schedule.js";
+import { listMemoryMaintenanceRuns } from "../../memory-maintenance/service.js";
+import "../../memory-maintenance/index.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/memory-maintenance-tool.ts
+const StatusSchema = Type.Object({ action: Type.Literal("status") });
+function createMemoryMaintenanceTool(deps) {
+	return {
+		name: "memory_maintenance",
+		label: "Memory maintenance",
+		description: "Show deterministic user-model and knowledge-memory maintenance schedules and runs.",
+		parameters: StatusSchema,
+		async execute() {
+			const config = deps.getConfig();
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						enabled: Boolean(config && resolveMemoryMaintenanceSchedules(config).length),
+						schedules: config ? resolveMemoryMaintenanceSchedules(config) : [],
+						policy: "deterministic",
+						recentRuns: listMemoryMaintenanceRuns(20)
+					}, null, 2)
+				}],
+				details: {}
+			};
+		}
+	};
+}
+//#endregion
+export { createMemoryMaintenanceTool };

package/dist/src/agent/tools/user-context-tool.d.ts

@@ -0,0 +1,8 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export interface UserContextToolOptions {
+    agentId: string;
+    workspaceId: string;
+    getSessionId: () => string | undefined;
+}
+export declare function createUserContextSearchTool(options: UserContextToolOptions): AgentTool;
+export declare function createUserContextGetTool(options: UserContextToolOptions): AgentTool;

package/dist/src/agent/tools/user-context-tool.js

@@ -0,0 +1,81 @@
+import { retrievalLexicalSimilarity } from "../../retrieval/textFeatures.js";
+import { getAssertionSlot, getUserAssertion, listUserAssertions } from "../../user-model/repository.js";
+import "../../user-model/index.js";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/user-context-tool.ts
+const SearchSchema = Type.Object({
+	query: Type.String(),
+	maxResults: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 50
+	}))
+});
+const GetSchema = Type.Object({ id: Type.String() });
+function visible(options, slotId) {
+	const scope = getAssertionSlot(slotId)?.scope;
+	return scope?.type === "global" || scope?.type === "agent" && scope.id === options.agentId || scope?.type === "workspace" && scope.id === options.workspaceId || scope?.type === "session" && scope.id === options.getSessionId();
+}
+function createUserContextSearchTool(options) {
+	return {
+		name: "user_context_search",
+		label: "User Context Search",
+		description: "Search typed user assertions such as identity, preferences, routines, and current state.",
+		parameters: SearchSchema,
+		async execute(_toolCallId, raw) {
+			const input = raw;
+			const results = listUserAssertions({
+				statuses: ["active", "needs_review"],
+				limit: 1e3
+			}).filter((assertion) => visible(options, assertion.slotId)).map((assertion) => ({
+				assertion,
+				score: retrievalLexicalSimilarity(input.query, `${assertion.statement} ${assertion.normalizedValue}`)
+			})).filter((item) => item.score > 0).sort((left, right) => right.score - left.score).slice(0, input.maxResults ?? 12).map(({ assertion, score }) => ({
+				id: assertion.id,
+				kind: assertion.kind,
+				statement: assertion.statement,
+				status: assertion.status,
+				authority: assertion.authority,
+				score
+			}));
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ results }, null, 2)
+				}],
+				details: { results }
+			};
+		}
+	};
+}
+function createUserContextGetTool(options) {
+	return {
+		name: "user_context_get",
+		label: "User Context Get",
+		description: "Read one typed user assertion and its subject, predicate, and scope.",
+		parameters: GetSchema,
+		async execute(_toolCallId, raw) {
+			const id = raw.id;
+			const assertion = getUserAssertion(id);
+			if (!assertion || !visible(options, assertion.slotId)) return {
+				content: [{
+					type: "text",
+					text: `User assertion not found: ${id}`
+				}],
+				details: { id }
+			};
+			const result = {
+				assertion,
+				slot: getAssertionSlot(assertion.slotId)
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				details: result
+			};
+		}
+	};
+}
+//#endregion
+export { createUserContextGetTool, createUserContextSearchTool };

package/dist/src/agent/tools/xopc-use-tool.js

@@ -2,14 +2,14 @@ import { runWithActivityContext } from "../../activity/context.js";
 import { runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
 import { TaskCommandSchema, TaskContextInputSchema } from "../../../packages/gateway-contract/src/tasks.js";
 import { appendProductDeliveryText } from "../../../packages/gateway-contract/src/product-delivery.js";
+import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
+import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import "../../storage/sqlite/index.js";
 import { ObjectLinkService } from "../../activity/service.js";
 import "../../activity/index.js";
 import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
 import { TaskRepository } from "../../tasks/task-repository.js";
-import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
-import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
 import { isValidProjectAgentId, normalizeProjectAgentId, resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";

package/dist/src/agent/workflow/catalog.d.ts

@@ -3,7 +3,6 @@ export type WorkflowSource = 'user' | 'builtin';
 export interface CatalogEntry {
     name: string;
     source: WorkflowSource;
-    path: string | null;
     description: string;
     title: string;
     version: string;
@@ -32,21 +31,16 @@ export interface WorkflowCatalog {
     list(): CatalogEntry[];
     load(name: string): WorkflowDefinition;
     save(input: SaveWorkflowInput): {
-        path: string;
         definition: WorkflowDefinition;
     };
     listRevisions(name: string): WorkflowRevisionSummary[];
     loadRevision(name: string, revision: number): WorkflowDefinition;
     restore(name: string, revision: number, expectedRevision: number): {
-        path: string;
         definition: WorkflowDefinition;
     };
     remove(name: string): boolean;
-    userDir: string;
 }
-export declare function createWorkflowCatalog(opts?: {
-    userDir?: string;
-}): WorkflowCatalog;
+export declare function createWorkflowCatalog(): WorkflowCatalog;
 export declare class WorkflowRevisionConflictError extends Error {
     readonly currentRevision: number;
     constructor(currentRevision: number);
@@ -56,4 +50,3 @@ export declare class WorkflowNameConflictError extends Error {
     readonly currentRevision: number;
     constructor(workflowName: string, currentRevision: number);
 }
-export declare function defaultUserDir(): string;

package/dist/src/agent/workflow/catalog.js

@@ -1,36 +1,19 @@
-import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
+import { requireXopcDatabase } from "../../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { DurableState } from "../../storage/sqlite/durable-state.js";
 import { buildWorkflowDefinition } from "../../workflows/domain/definition-utils.js";
 import { validateWorkflowGraph } from "../../workflows/domain/validation.js";
 import { BUILTIN_WORKFLOWS } from "./builtins/index.js";
-import { join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
 //#region src/agent/workflow/catalog.ts
-init_paths_state();
 const NAME_RE = /^[a-z][a-z0-9_-]*$/;
-function createWorkflowCatalog(opts = {}) {
-	const userDir = opts.userDir ?? defaultUserDir();
-	const loadUser = (name) => {
-		const path = join(userDir, `${name}.json`);
-		if (!existsSync(path)) return null;
-		const parsed = JSON.parse(readFileSync(path, "utf-8"));
-		assertStoredDefinition(parsed, name, path);
-		return parsed;
-	};
+function createWorkflowCatalog() {
+	const definitions = new DurableState("workflow-definitions");
+	const revisions = (name) => new DurableState("workflow-revisions", name);
+	const loadUser = (name) => definitions.get(name) ?? null;
 	const list = () => {
-		const definitions = /* @__PURE__ */ new Map();
-		for (const definition of BUILTIN_WORKFLOWS) definitions.set(definition.name, {
-			definition,
-			path: null
-		});
-		for (const name of listUserNames(userDir)) try {
-			const definition = loadUser(name);
-			if (definition) definitions.set(name, {
-				definition,
-				path: join(userDir, `${name}.json`)
-			});
-		} catch {}
-		return [...definitions.values()].map(({ definition, path }) => toCatalogEntry(definition, path)).sort((left, right) => left.name.localeCompare(right.name));
+		const items = new Map(BUILTIN_WORKFLOWS.map((definition) => [definition.name, definition]));
+		for (const definition of definitions.values()) items.set(definition.name, definition);
+		return [...items.values()].map(toCatalogEntry).sort((a, b) => a.name.localeCompare(b.name));
 	};
 	const load = (name) => {
 		requireValidName(name);
@@ -45,56 +28,40 @@ function createWorkflowCatalog(opts = {}) {
 		requireValidName(name);
 		const validation = validateWorkflowGraph(input.graph);
 		if (!validation.valid) throw new Error(validation.errors.map((issue) => issue.message).join(" "));
-		const existing = loadUser(name);
-		const builtin = BUILTIN_WORKFLOWS.find((definition) => definition.name === name);
-		if (input.intent === "create" && (existing || builtin)) throw new WorkflowNameConflictError(name, existing?.revision ?? builtin?.revision ?? 0);
-		if (input.expectedRevision !== void 0 && input.expectedRevision !== (existing?.revision ?? 0)) throw new WorkflowRevisionConflictError(existing?.revision ?? 0);
-		const definition = buildWorkflowDefinition({
-			name,
-			source: "user",
-			graph: input.graph,
-			manifest: input.manifest,
-			revision: (existing?.revision ?? 0) + 1,
-			createdAtMs: existing?.metadata.createdAtMs
+		requireXopcDatabase();
+		return runSqliteWriteTransaction(() => {
+			const existing = loadUser(name);
+			const builtin = BUILTIN_WORKFLOWS.find((definition) => definition.name === name);
+			if (input.intent === "create" && (existing || builtin)) throw new WorkflowNameConflictError(name, existing?.revision ?? builtin?.revision ?? 0);
+			if (input.expectedRevision !== void 0 && input.expectedRevision !== (existing?.revision ?? 0)) throw new WorkflowRevisionConflictError(existing?.revision ?? 0);
+			const definition = buildWorkflowDefinition({
+				name,
+				source: "user",
+				graph: input.graph,
+				manifest: input.manifest,
+				revision: (existing?.revision ?? 0) + 1,
+				createdAtMs: existing?.metadata.createdAtMs
+			});
+			revisions(name).set(String(definition.revision), definition);
+			definitions.set(name, definition);
+			return { definition };
 		});
-		if (!existsSync(userDir)) mkdirSync(userDir, { recursive: true });
-		const path = join(userDir, `${name}.json`);
-		const revisionsDir = join(userDir, ".revisions", name);
-		mkdirSync(revisionsDir, { recursive: true });
-		writeJsonAtomic(join(revisionsDir, `${definition.revision}.json`), definition);
-		writeJsonAtomic(path, definition);
-		return {
-			path,
-			definition
-		};
 	};
 	const listRevisions = (name) => {
 		requireValidName(name);
-		const dir = join(userDir, ".revisions", name);
-		if (!existsSync(dir)) return [];
-		return readdirSync(dir).filter((file) => /^\d+\.json$/.test(file)).map((file) => {
-			try {
-				const definition = JSON.parse(readFileSync(join(dir, file), "utf-8"));
-				assertStoredDefinition(definition, name, join(dir, file));
-				return {
-					revision: definition.revision,
-					title: definition.title,
-					contentHash: definition.contentHash,
-					createdAtMs: definition.metadata.updatedAtMs
-				};
-			} catch {
-				return null;
-			}
-		}).filter((item) => item !== null).sort((left, right) => right.revision - left.revision);
+		return revisions(name).values().map((definition) => ({
+			revision: definition.revision,
+			title: definition.title,
+			contentHash: definition.contentHash,
+			createdAtMs: definition.metadata.updatedAtMs
+		})).sort((a, b) => b.revision - a.revision);
 	};
 	const loadRevision = (name, revision) => {
 		requireValidName(name);
 		if (!Number.isSafeInteger(revision) || revision < 1) throw new Error("invalid workflow revision");
-		const path = join(userDir, ".revisions", name, `${revision}.json`);
-		if (!existsSync(path)) throw new Error(`workflow revision not found: ${name}@${revision}`);
-		const definition = JSON.parse(readFileSync(path, "utf-8"));
-		assertStoredDefinition(definition, name, path);
-		return structuredClone(definition);
+		const definition = revisions(name).get(String(revision));
+		if (!definition) throw new Error(`workflow revision not found: ${name}@${revision}`);
+		return definition;
 	};
 	const restore = (name, revision, expectedRevision) => {
 		const selected = loadRevision(name, revision);
@@ -107,15 +74,12 @@ function createWorkflowCatalog(opts = {}) {
 	};
 	const remove = (name) => {
 		requireValidName(name);
-		const path = join(userDir, `${name}.json`);
-		if (!existsSync(path)) return false;
-		unlinkSync(path);
-		const revisionsDir = join(userDir, ".revisions", name);
-		if (existsSync(revisionsDir)) rmSync(revisionsDir, {
-			recursive: true,
-			force: true
+		requireXopcDatabase();
+		return runSqliteWriteTransaction(() => {
+			const deleted = definitions.delete(name);
+			for (const [key] of revisions(name).entries()) revisions(name).delete(key);
+			return deleted;
 		});
-		return true;
 	};
 	return {
 		list,
@@ -124,8 +88,7 @@ function createWorkflowCatalog(opts = {}) {
 		listRevisions,
 		loadRevision,
 		restore,
-		remove,
-		userDir
+		remove
 	};
 }
 var WorkflowRevisionConflictError = class extends Error {
@@ -143,26 +106,10 @@ var WorkflowNameConflictError = class extends Error {
 		this.name = "WorkflowNameConflictError";
 	}
 };
-function defaultUserDir() {
-	return join(resolveStateDir(), "workflows");
-}
-function listUserNames(dir) {
-	try {
-		if (!existsSync(dir) || !statSync(dir).isDirectory()) return [];
-		return readdirSync(dir).filter((file) => file.endsWith(".json")).map((file) => file.slice(0, -5)).filter((name) => NAME_RE.test(name));
-	} catch {
-		return [];
-	}
-}
-function assertStoredDefinition(value, name, path) {
-	if (!value || typeof value !== "object" || value.name !== name || value.metadata?.source !== "user") throw new Error(`invalid workflow definition: ${path}`);
-	if (!validateWorkflowGraph(value.graph).valid) throw new Error(`invalid workflow graph: ${path}`);
-}
-function toCatalogEntry(definition, path) {
+function toCatalogEntry(definition) {
 	return {
 		name: definition.name,
 		source: definition.metadata.source,
-		path,
 		description: definition.description,
 		title: definition.title,
 		version: definition.version,
@@ -175,11 +122,6 @@ function toCatalogEntry(definition, path) {
 function requireValidName(name) {
 	if (!NAME_RE.test(name)) throw new Error(`invalid workflow name "${name}"; use lowercase letters, numbers, underscores, or hyphens`);
 }
-function writeJsonAtomic(path, value) {
-	const temporaryPath = `${path}.${randomUUID()}.tmp`;
-	writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
-	renameSync(temporaryPath, path);
-}
 function definitionToManifest(definition) {
 	return {
 		title: definition.title,
@@ -199,4 +141,4 @@ function definitionToManifest(definition) {
 	};
 }
 //#endregion
-export { WorkflowNameConflictError, WorkflowRevisionConflictError, createWorkflowCatalog, defaultUserDir };
+export { WorkflowNameConflictError, WorkflowRevisionConflictError, createWorkflowCatalog };

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

@@ -1,6 +1,6 @@
 export { applySubagentProgress } from './agent-progress.js';
 export { BUILTIN_WORKFLOWS } from './builtins/index.js';
-export { createWorkflowCatalog, defaultUserDir, type CatalogEntry, type SaveWorkflowInput, type WorkflowCatalog, type WorkflowSource, } from './catalog.js';
+export { createWorkflowCatalog, type CatalogEntry, type SaveWorkflowInput, type WorkflowCatalog, type WorkflowSource, } from './catalog.js';
 export type { ChannelProgressCapability, WorkflowProgressMode, WorkflowProgressPostInput, WorkflowProgressPostResult, } from './channel-capability.js';
 export { WorkflowProgressBroker, getWorkflowProgressBroker, _resetWorkflowProgressBrokerForTests, type BrokerListenerHandle, type SessionBusLike, } from './progress-broker.js';
 export { emptySnapshotFor } from './snapshot-empty.js';

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

@@ -1,9 +1,9 @@
 import { BUILTIN_WORKFLOWS } from "./builtins/index.js";
-import { createWorkflowCatalog, defaultUserDir } from "./catalog.js";
+import { createWorkflowCatalog } from "./catalog.js";
 import { applySubagentProgress } from "./agent-progress.js";
 import { emptySnapshotFor } from "./snapshot-empty.js";
 import { createWorkflowSnapshot, previewValue, recomputeCounts, renderWorkflowText } from "./snapshot.js";
 import { WorkflowProgressBroker, _resetWorkflowProgressBrokerForTests, getWorkflowProgressBroker } from "./progress-broker.js";
 import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
 import { DelegateSubagentRunner } from "./subagent-runner.js";
-export { BUILTIN_WORKFLOWS, DelegateSubagentRunner, STRUCTURED_OUTPUT_TOOL_NAME, WorkflowProgressBroker, _resetWorkflowProgressBrokerForTests, applySubagentProgress, createStructuredOutputTool, createWorkflowCatalog, createWorkflowSnapshot, defaultUserDir, emptySnapshotFor, getWorkflowProgressBroker, previewValue, recomputeCounts, renderWorkflowText };
+export { BUILTIN_WORKFLOWS, DelegateSubagentRunner, STRUCTURED_OUTPUT_TOOL_NAME, WorkflowProgressBroker, _resetWorkflowProgressBrokerForTests, applySubagentProgress, createStructuredOutputTool, createWorkflowCatalog, createWorkflowSnapshot, emptySnapshotFor, getWorkflowProgressBroker, previewValue, recomputeCounts, renderWorkflowText };

package/dist/src/automations/domain/types.d.ts

@@ -163,6 +163,7 @@ export interface AutomationMetrics {
     };
 }
 export interface PrepareAutomationAgentSessionInput {
+    automationName?: string;
     sessionKey: string;
     projectId?: string;
     agentId: string;

package/dist/src/automations/service/action-executor.js

@@ -3,7 +3,6 @@ import { init_logger } from "../../utils/logger.js";
 import { init_agent_scope, normalizeAgentId } from "../../agent/agent-scope.js";
 import { buildSessionKey, init_session_key } from "../../routing/session-key.js";
 import { resolveAutomationTimeoutSeconds } from "../domain/defaults.js";
-import crypto from "node:crypto";
 //#region src/automations/service/action-executor.ts
 init_agent_scope();
 init_session_key();
@@ -158,7 +157,7 @@ var AutomationActionExecutor = class {
 			error: "Agent service is not available"
 		};
 		const agentId = normalizeAgentId(action.agentId || this.deps.getDefaultAgentId?.() || "main");
-		const peerId = automation.conversationMode === "continuous" ? automation.id : `${automation.id}-${crypto.randomUUID().slice(0, 8)}`;
+		const peerId = automation.conversationMode === "continuous" ? automation.id : `${automation.id}-${run.id}`;
 		const sessionKey = buildSessionKey({
 			agentId,
 			source: "automation",
@@ -171,6 +170,7 @@ var AutomationActionExecutor = class {
 			currentPhase: "action"
 		});
 		await this.deps.prepareAgentSession?.({
+			automationName: automation.name,
 			sessionKey,
 			projectId: automation.projectId,
 			agentId,

package/dist/src/automations/service/automation-service.js

@@ -365,7 +365,7 @@ var AutomationService = class {
 			this.appendRunEvent(run, status === "succeeded" ? "action.completed" : "action.failed", status === "succeeded" ? `${automation.action.kind} action completed` : `${automation.action.kind} action ${status}`, {
 				summary: task.summary,
 				error: task.error,
-				sessionKey: task.sessionKey,
+				sessionKey: task.sessionKey ?? run.sessionKey,
 				workflowRunId: task.workflowRunId,
 				model: task.model
 			});
@@ -374,7 +374,7 @@ var AutomationService = class {
 				status,
 				summary: task.summary,
 				error,
-				sessionKey: task.sessionKey,
+				sessionKey: task.sessionKey ?? run.sessionKey,
 				workflowRunId: task.workflowRunId,
 				model: task.model,
 				deadlineAtMs: task.deadlineAtMs ?? run.deadlineAtMs,

package/dist/src/channels/manager.d.ts

@@ -32,7 +32,7 @@ export declare class ChannelManager {
     setOutboundHooks(hooks: OutboundChannelHooks): void;
     /** Call before `initialize()` so plugins can persist per-session model overrides. */
     setSessionModelHooks(hooks: ChannelPluginSessionModelHooks | undefined): void;
-    enableOutboundPersistence(agentDir: string): void;
+    enableOutboundPersistence(agentId: string): void;
     registerPlugin(plugin: ChannelPlugin): void;
     getPlugin(id: string): ChannelPlugin | undefined;
     getAllPlugins(): ChannelPlugin[];

package/dist/src/channels/manager.js

@@ -45,8 +45,8 @@ var ChannelManager = class {
 	setSessionModelHooks(hooks) {
 		this.sessionModelHooks = hooks;
 	}
-	enableOutboundPersistence(agentDir) {
-		this.outbound.enablePersistence(agentDir);
+	enableOutboundPersistence(agentId) {
+		this.outbound.enablePersistence(agentId);
 	}
 	registerPlugin(plugin) {
 		this.registry.register(plugin);

package/dist/src/channels/outbound/persist-store.d.ts

@@ -1,6 +1,3 @@
-/**
- * Durable outbound queue (crash recovery): JSON file under agent internal dir.
- */
 import type { OutboundMessage } from '../transport-types.js';
 export interface PendingOutbound {
     id: string;
@@ -8,11 +5,8 @@ export interface PendingOutbound {
     message: OutboundMessage;
 }
 export declare class OutboundPersistStore {
-    private readonly filePath;
-    private pending;
-    constructor(agentDir: string);
-    private load;
-    private flush;
+    private readonly queue;
+    constructor(scope: string);
     enqueue(message: OutboundMessage): string;
     ack(id: string): void;
     peek(): readonly PendingOutbound[];