@xopcai/xopc 0.0.330 → 0.0.332

package/dist/src/automations/capabilities/write.js

@@ -10,8 +10,28 @@ import { AutomationAlreadyExistsError, AutomationAlreadyRunningError } from "../
 import { z } from "zod";
 //#region src/automations/capabilities/write.ts
 init_src();
-const AutomationCreateCapabilityInputSchema = CreateAutomationSchema.omit({ state: true });
-const AutomationUpdatePatchSchema = UpdateAutomationSchema.safeExtend({ state: z.never().optional() });
+const AutomationCreateCapabilityInputSchema = CreateAutomationSchema.omit({
+	state: true,
+	management: true
+}).refine((input) => input.action.kind !== "system", { message: "System actions can only be created by the runtime" });
+const AutomationUpdatePatchSchema = UpdateAutomationSchema.safeExtend({
+	state: z.never().optional(),
+	management: z.never().optional()
+});
+function assertManagedOperation(automation, operation, patch) {
+	const management = automation.management;
+	if (!management) return;
+	if (operation === "run") {
+		if (!management.runnable) throw new CapabilityError("FORBIDDEN", "This managed automation cannot be run manually");
+		return;
+	}
+	if (operation === "delete") {
+		if (!management.deletable) throw new CapabilityError("FORBIDDEN", "This managed automation cannot be deleted");
+		return;
+	}
+	const forbidden = Object.entries(patch ?? {}).filter(([key, value]) => JSON.stringify(automation[key]) !== JSON.stringify(value)).map(([key]) => key).filter((field) => !management.editable.includes(field));
+	if (forbidden.length > 0) throw new CapabilityError("FORBIDDEN", `Managed fields cannot be changed: ${forbidden.join(", ")}`);
+}
 function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 	const policy = {
 		majorVersion: 1,
@@ -75,6 +95,7 @@ function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 			const automationId = command === "run" ? id : getAutomationRun(id)?.automationId;
 			const automation = automationId ? getAutomation(automationId) : null;
 			if (!automation) throw new CapabilityError("NOT_FOUND", "Automation or source run not found");
+			assertManagedOperation(automation, "run");
 			try {
 				const run = command === "run" ? service.queueRunAtomically(id) : service.queueRerunAtomically(id);
 				return {
@@ -98,6 +119,7 @@ function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 		execute({ id, expectedRevision }) {
 			const current = getAutomation(id);
 			if (current && current.updatedAtMs !== expectedRevision) throw new CapabilityError("REVISION_CONFLICT", "Automation changed");
+			if (current) assertManagedOperation(current, "delete");
 			const result = service.removeAtomically(id);
 			return {
 				ok: true,
@@ -138,6 +160,7 @@ function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 			const current = getAutomation(id);
 			if (!current) throw new CapabilityError("NOT_FOUND", "Automation not found");
 			if (current.updatedAtMs !== expectedRevision) throw new CapabilityError("REVISION_CONFLICT", "Automation changed");
+			assertManagedOperation(current, "update", patch);
 			requireProject(patch.projectId);
 			return {
 				ok: true,
@@ -158,6 +181,7 @@ function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 			const current = getAutomation(id);
 			if (!current) throw new CapabilityError("NOT_FOUND", "Automation not found");
 			if (current.updatedAtMs !== expectedRevision) throw new CapabilityError("REVISION_CONFLICT", "Automation changed");
+			assertManagedOperation(current, "update", { enabled });
 			const automation = service.updateAtomically(id, { enabled });
 			if (!automation) throw new CapabilityError("NOT_FOUND", "Automation not found");
 			return {

package/dist/src/automations/domain/defaults.js

@@ -2,7 +2,7 @@
 const DEFAULT_AUTOMATION_TIMEOUT_SECONDS = 1800;
 const DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS = 600;
 function defaultAutomationTimeoutSeconds(action) {
-	return action.kind === "browser_automation" ? 600 : DEFAULT_AUTOMATION_TIMEOUT_SECONDS;
+	return action.kind === "system" ? 60 : action.kind === "browser_automation" ? 600 : DEFAULT_AUTOMATION_TIMEOUT_SECONDS;
 }
 function resolveAutomationTimeoutSeconds(action, reliability) {
 	return reliability?.executionTimeoutSeconds ?? ("timeoutSeconds" in action ? action.timeoutSeconds : void 0) ?? reliability?.timeoutSeconds ?? defaultAutomationTimeoutSeconds(action);

package/dist/src/automations/domain/index.js

@@ -1,4 +1,4 @@
-import { AutomationActionSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./validation.js";
+import { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./validation.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./schedule.js";
 import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./defaults.js";
-export { AutomationActionSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds, timerDelayUntil };
+export { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds, timerDelayUntil };

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

@@ -54,7 +54,17 @@ export type AutomationAction = {
     kind: 'task_command';
     taskId: string;
     command: TaskCommand;
+} | {
+    kind: 'system';
+    capability: 'home.advisor.refresh' | 'memory.temporal_sweep' | 'memory.daily_reconciliation' | 'memory.weekly_knowledge';
 };
+export type AutomationEditableField = 'enabled' | 'trigger';
+export interface AutomationManagement {
+    owner: string;
+    editable: AutomationEditableField[];
+    runnable: boolean;
+    deletable: boolean;
+}
 export type AutomationConversationMode = 'new_session' | 'continuous';
 export type AutomationNotificationPolicy = 'attention' | 'all' | 'none';
 export interface AutomationReliability {
@@ -97,6 +107,7 @@ export interface Automation {
     notificationPolicy: AutomationNotificationPolicy;
     completionWebhookUrl?: string;
     reliability?: AutomationReliability;
+    management?: AutomationManagement;
     state: AutomationState;
     createdAtMs: number;
     updatedAtMs: number;
@@ -210,6 +221,17 @@ export interface AutomationDeps {
         reason?: string;
         runId?: string;
     };
+    executeSystemAction?: (input: {
+        capability: Extract<AutomationAction, {
+            kind: 'system';
+        }>['capability'];
+        automationId: string;
+        runId: string;
+    }) => Promise<{
+        summary?: string;
+    }> | {
+        summary?: string;
+    };
 }
 export interface AutomationActionTask {
     status: 'succeeded' | 'failed' | 'timeout' | 'cancelled';

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

@@ -151,7 +151,24 @@ export declare const AutomationActionSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
             outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
     }, z.core.$strip>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"system">;
+    capability: z.ZodEnum<{
+        "home.advisor.refresh": "home.advisor.refresh";
+        "memory.temporal_sweep": "memory.temporal_sweep";
+        "memory.daily_reconciliation": "memory.daily_reconciliation";
+        "memory.weekly_knowledge": "memory.weekly_knowledge";
+    }>;
 }, z.core.$strict>], "kind">;
+export declare const AutomationManagementSchema: z.ZodObject<{
+    owner: z.ZodString;
+    editable: z.ZodArray<z.ZodEnum<{
+        enabled: "enabled";
+        trigger: "trigger";
+    }>>;
+    runnable: z.ZodBoolean;
+    deletable: z.ZodBoolean;
+}, z.core.$strict>;
 export declare const AutomationReliabilitySchema: z.ZodObject<{
     executionTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
@@ -328,6 +345,14 @@ export declare const AutomationSchema: z.ZodObject<{
                 outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
         }, z.core.$strip>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        capability: z.ZodEnum<{
+            "home.advisor.refresh": "home.advisor.refresh";
+            "memory.temporal_sweep": "memory.temporal_sweep";
+            "memory.daily_reconciliation": "memory.daily_reconciliation";
+            "memory.weekly_knowledge": "memory.weekly_knowledge";
+        }>;
     }, z.core.$strict>], "kind">;
     safety: z.ZodOptional<z.ZodObject<{
         mode: z.ZodEnum<{
@@ -353,6 +378,15 @@ export declare const AutomationSchema: z.ZodObject<{
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    management: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        editable: z.ZodArray<z.ZodEnum<{
+            enabled: "enabled";
+            trigger: "trigger";
+        }>>;
+        runnable: z.ZodBoolean;
+        deletable: z.ZodBoolean;
+    }, z.core.$strict>>;
     state: z.ZodDefault<z.ZodObject<{
         nextRunAtMs: z.ZodOptional<z.ZodNumber>;
         runningRunId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
@@ -490,6 +524,14 @@ export declare const CreateAutomationSchema: z.ZodObject<{
                 outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
         }, z.core.$strip>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        capability: z.ZodEnum<{
+            "home.advisor.refresh": "home.advisor.refresh";
+            "memory.temporal_sweep": "memory.temporal_sweep";
+            "memory.daily_reconciliation": "memory.daily_reconciliation";
+            "memory.weekly_knowledge": "memory.weekly_knowledge";
+        }>;
     }, z.core.$strict>], "kind">;
     trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"manual">;
@@ -541,6 +583,15 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    management: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        editable: z.ZodArray<z.ZodEnum<{
+            enabled: "enabled";
+            trigger: "trigger";
+        }>>;
+        runnable: z.ZodBoolean;
+        deletable: z.ZodBoolean;
+    }, z.core.$strict>>;
     id: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     state: z.ZodOptional<z.ZodObject<{
@@ -679,6 +730,14 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
                 outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
         }, z.core.$strip>], "type">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        capability: z.ZodEnum<{
+            "home.advisor.refresh": "home.advisor.refresh";
+            "memory.temporal_sweep": "memory.temporal_sweep";
+            "memory.daily_reconciliation": "memory.daily_reconciliation";
+            "memory.weekly_knowledge": "memory.weekly_knowledge";
+        }>;
     }, z.core.$strict>], "kind">>;
     trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"manual">;
@@ -721,6 +780,15 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         maxConcurrentRuns: z.ZodOptional<z.ZodNumber>;
         disableAfterConsecutiveFailures: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
+    management: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        editable: z.ZodArray<z.ZodEnum<{
+            enabled: "enabled";
+            trigger: "trigger";
+        }>>;
+        runnable: z.ZodBoolean;
+        deletable: z.ZodBoolean;
+    }, z.core.$strict>>>;
     conversationMode: z.ZodOptional<z.ZodEnum<{
         new_session: "new_session";
         continuous: "continuous";

package/dist/src/automations/domain/validation.js

@@ -89,8 +89,23 @@ const AutomationActionSchema = z.discriminatedUnion("kind", [
 		kind: z.literal("task_command"),
 		taskId: nonEmptyString.max(200),
 		command: TaskCommandSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("system"),
+		capability: z.enum([
+			"home.advisor.refresh",
+			"memory.temporal_sweep",
+			"memory.daily_reconciliation",
+			"memory.weekly_knowledge"
+		])
 	}).strict()
 ]);
+const AutomationManagementSchema = z.object({
+	owner: nonEmptyString.max(100),
+	editable: z.array(z.enum(["enabled", "trigger"])).max(2),
+	runnable: z.boolean(),
+	deletable: z.boolean()
+}).strict();
 const AutomationReliabilitySchema = z.object({
 	executionTimeoutSeconds: z.number().int().min(1).max(86400).optional(),
 	timeoutSeconds: z.number().int().min(1).max(86400).optional(),
@@ -136,6 +151,7 @@ const AutomationSchema = z.object({
 	]).default("attention"),
 	completionWebhookUrl: optionalTrimmedString(2e3),
 	reliability: AutomationReliabilitySchema.optional(),
+	management: AutomationManagementSchema.optional(),
 	state: AutomationStateSchema.default({}),
 	createdAtMs: z.number().int().nonnegative(),
 	updatedAtMs: z.number().int().nonnegative()
@@ -165,4 +181,4 @@ const UpdateAutomationSchema = AutomationSchema.omit({
 	state: AutomationStateSchema
 }).partial().refine((data) => Object.keys(data).length > 0, { message: "At least one field must be provided" });
 //#endregion
-export { AutomationActionSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema };
+export { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema };

package/dist/src/automations/draft/automation-draft-validator.d.ts

@@ -102,6 +102,9 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
                     outputDestinations: Record<string, unknown>[];
                 };
             };
+        } | {
+            kind: "system";
+            capability: "home.advisor.refresh" | "memory.temporal_sweep" | "memory.daily_reconciliation" | "memory.weekly_knowledge";
         };
         trigger?: {
             kind: "manual";
@@ -140,6 +143,12 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             maxConcurrentRuns?: number;
             disableAfterConsecutiveFailures?: number;
         };
+        management?: {
+            owner: string;
+            editable: ("enabled" | "trigger")[];
+            runnable: boolean;
+            deletable: boolean;
+        };
         id?: string;
         enabled?: boolean;
         state?: {

package/dist/src/automations/draft/automation-draft-validator.js

@@ -92,6 +92,7 @@ function summarizeAction(action) {
 	if (action.kind === "workflow") return `Starts workflow ${action.workflowId}.`;
 	if (action.kind === "browser_automation") return `Runs browser automation ${action.automationId}.`;
 	if (action.kind === "task_command") return `Applies ${action.command?.type ?? "a command"} to task ${action.taskId}.`;
+	if (action.kind === "system") return `Runs system capability ${action.capability}.`;
 	return action.agentId ? `Runs agent ${action.agentId}.` : "Runs the default agent.";
 }
 function repairPatchNeedsApproval(patch) {

package/dist/src/automations/index.js

@@ -1,9 +1,9 @@
 import { onAutomationProductEvent, publishAutomationProductEvent } from "./product-events.js";
-import { AutomationActionSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./domain/validation.js";
+import { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./domain/validation.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./domain/schedule.js";
 import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./domain/defaults.js";
 import { AutomationActionExecutor } from "./service/action-executor.js";
 import { AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationService } from "./service/automation-service.js";
 import "./domain/index.js";
 import "./service/index.js";
-export { AutomationActionExecutor, AutomationActionSchema, AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, onAutomationProductEvent, publishAutomationProductEvent, resolveAutomationTimeoutSeconds, timerDelayUntil };
+export { AutomationActionExecutor, AutomationActionSchema, AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, onAutomationProductEvent, publishAutomationProductEvent, resolveAutomationTimeoutSeconds, timerDelayUntil };

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

@@ -128,6 +128,22 @@ var AutomationActionExecutor = class {
 				error: result.reason ?? "Task command failed"
 			};
 		}
+		if (automation.action.kind === "system") {
+			await hooks.onRunPatch?.({ currentPhase: "action" });
+			const execute = this.deps.executeSystemAction;
+			if (!execute) return {
+				status: "failed",
+				error: "System action executor is unavailable"
+			};
+			return {
+				status: "succeeded",
+				summary: (await execute({
+					capability: automation.action.capability,
+					automationId: automation.id,
+					runId: run.id
+				})).summary ?? "System action completed"
+			};
+		}
 		return this.executeAgent(automation, automation.action, run, signal, hooks, deadlineAtMs, context);
 	}
 	async executeBrowserAutomation(automation, action, signal, hooks, context) {

package/dist/src/automations/storage/automation-repository.js

@@ -23,6 +23,7 @@ function rowToAutomation(row) {
 		notificationPolicy: row.notification_policy,
 		completionWebhookUrl: row.completion_webhook_url ?? void 0,
 		reliability: parseJson(row.reliability_json),
+		management: parseJson(row.management_json),
 		state: parseJson(row.state_json) ?? {},
 		createdAtMs: row.created_at_ms,
 		updatedAtMs: row.updated_at_ms
@@ -32,13 +33,13 @@ function upsertAutomation(db, automation) {
 	db.prepare(`INSERT OR REPLACE INTO automations (
       automation_id, name, description, project_id, enabled, trigger_json, action_json,
       safety_json, conversation_mode, notification_policy, completion_webhook_url,
-      reliability_json, state_json, created_at_ms, updated_at_ms
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(automation.id, automation.name, automation.description ?? null, automation.projectId ?? null, automation.enabled ? 1 : 0, JSON.stringify(automation.trigger), JSON.stringify(automation.action), bindJson(automation.safety ?? { mode: "auto_apply" }), automation.conversationMode, automation.notificationPolicy, automation.completionWebhookUrl ?? null, bindJson(automation.reliability), JSON.stringify(automation.state ?? {}), automation.createdAtMs, automation.updatedAtMs);
+      reliability_json, management_json, state_json, created_at_ms, updated_at_ms
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(automation.id, automation.name, automation.description ?? null, automation.projectId ?? null, automation.enabled ? 1 : 0, JSON.stringify(automation.trigger), JSON.stringify(automation.action), bindJson(automation.safety ?? { mode: "auto_apply" }), automation.conversationMode, automation.notificationPolicy, automation.completionWebhookUrl ?? null, bindJson(automation.reliability), bindJson(automation.management), JSON.stringify(automation.state ?? {}), automation.createdAtMs, automation.updatedAtMs);
 }
 const AUTOMATION_SELECT = `
   SELECT automation_id, name, description, project_id, enabled, trigger_json, action_json,
          safety_json, conversation_mode, notification_policy, completion_webhook_url,
-         reliability_json, state_json, created_at_ms, updated_at_ms
+         reliability_json, management_json, state_json, created_at_ms, updated_at_ms
   FROM automations
 `;
 function listAutomations(options) {

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -53,7 +53,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v207).`,
+		message: `SQLite schema v${status.dbVersion} (current release v208).`,
 		hints: []
 	};
 }

package/dist/src/config/schema.d.ts

@@ -1360,6 +1360,10 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        homeIntelligence: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            refreshOnContextChange: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     session: z.ZodDefault<z.ZodObject<{
         scope: z.ZodDefault<z.ZodEnum<{

package/dist/src/config/schema.js

@@ -1052,6 +1052,10 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 				maxKnowledge: 12,
 				maxChars: 6e3,
 				compaction: DEFAULT_CONTEXT_COMPACTION_POLICY
+			},
+			homeIntelligence: {
+				enabled: true,
+				refreshOnContextChange: true
 			}
 		},
 		session: {

package/dist/src/gateway/home-intelligence-automation-reconciler.d.ts

@@ -0,0 +1,3 @@
+import type { AutomationService } from '../automations/index.js';
+export declare const HOME_ADVISOR_REFRESH_AUTOMATION_ID = "system-home-advisor-refresh";
+export declare function reconcileHomeIntelligenceAutomation(automationService: AutomationService): Promise<'created' | 'updated' | 'unchanged'>;

package/dist/src/gateway/home-intelligence-automation-reconciler.js

@@ -0,0 +1,49 @@
+//#region src/gateway/home-intelligence-automation-reconciler.ts
+const HOME_ADVISOR_REFRESH_AUTOMATION_ID = "system-home-advisor-refresh";
+async function reconcileHomeIntelligenceAutomation(automationService) {
+	const current = await automationService.get(HOME_ADVISOR_REFRESH_AUTOMATION_ID);
+	const managed = {
+		name: "Refresh Home AI suggestions",
+		description: "Re-evaluate Home suggestions from current workspace context.",
+		action: {
+			kind: "system",
+			capability: "home.advisor.refresh"
+		},
+		safety: { mode: "auto_apply" },
+		conversationMode: "new_session",
+		notificationPolicy: "none",
+		reliability: { disableAfterConsecutiveFailures: 3 },
+		management: {
+			owner: "home-intelligence",
+			editable: ["enabled", "trigger"],
+			runnable: true,
+			deletable: false
+		}
+	};
+	if (!current) {
+		await automationService.create({
+			id: HOME_ADVISOR_REFRESH_AUTOMATION_ID,
+			enabled: false,
+			trigger: {
+				kind: "schedule",
+				schedule: {
+					kind: "interval",
+					everyMs: 30 * 6e4,
+					anchorMs: Date.now()
+				}
+			},
+			...managed
+		});
+		return "created";
+	}
+	const patch = {
+		...managed,
+		enabled: current.enabled,
+		trigger: current.trigger
+	};
+	if (!Object.entries(patch).some(([key, value]) => JSON.stringify(current[key]) !== JSON.stringify(value))) return "unchanged";
+	await automationService.update(HOME_ADVISOR_REFRESH_AUTOMATION_ID, patch);
+	return "updated";
+}
+//#endregion
+export { HOME_ADVISOR_REFRESH_AUTOMATION_ID, reconcileHomeIntelligenceAutomation };

package/dist/src/gateway/hono/routes/config-patch/misc.js

@@ -1,6 +1,6 @@
 import { ComputerConfigSchema, init_config } from "../../../../computer/config.js";
 import { BindingsSchema, init_binding_schema } from "../../../../routing/binding-schema.js";
-import { ContextPlanningConfigSchema, KnowledgeMemoryConfigSchema, UserContextConfigSchema, UserModelConfigSchema, init_config as init_config$1 } from "../../../../user-context/config.js";
+import { ContextPlanningConfigSchema, HomeIntelligenceConfigSchema, KnowledgeMemoryConfigSchema, UserContextConfigSchema, UserModelConfigSchema, init_config as init_config$1 } from "../../../../user-context/config.js";
 import { BrowserConfigSchema, McpConfigSchema, VoiceConfigSchema, init_schema } from "../../../../config/schema.js";
 import { CredentialResolver, init_credentials } from "../../../../auth/credentials.js";
 import { canonicalizeConfiguredMcpServer } from "../../../../config/mcp-config-normalize.js";
@@ -37,7 +37,8 @@ async function applyMiscPatch(config, body) {
 			"preferences",
 			"userModel",
 			"knowledgeMemory",
-			"contextPlanning"
+			"contextPlanning",
+			"homeIntelligence"
 		].includes(key));
 		if (unknownKeys.length) return patchError(`Unknown userContext settings: ${unknownKeys.join(", ")}`);
 		if (userContextPatch.enabled !== void 0) {
@@ -111,6 +112,19 @@ async function applyMiscPatch(config, body) {
 				contextPlanning: parsed.data
 			};
 		}
+		if (userContextPatch.homeIntelligence !== void 0) {
+			const patch = userContextPatch.homeIntelligence;
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return patchError("userContext.homeIntelligence must be an object");
+			const parsed = HomeIntelligenceConfigSchema.safeParse({
+				...config.userContext.homeIntelligence,
+				...patch
+			});
+			if (!parsed.success) return patchError(parsed.error.issues.map((issue) => issue.message).join("; "));
+			config.userContext = {
+				...config.userContext,
+				homeIntelligence: parsed.data
+			};
+		}
 		const parsedUserContext = UserContextConfigSchema.safeParse(config.userContext);
 		if (!parsedUserContext.success) return patchError(parsedUserContext.error.issues.map((issue) => issue.message).join("; "));
 		config.userContext = parsedUserContext.data;

package/dist/src/gateway/hono/routes/home.js

@@ -16,7 +16,6 @@ function registerHomeRoutes(authenticated, deps) {
 	const home = new HomeQueryService(service, () => service.homeIntelligence.getAdvisor());
 	authenticated.get("/api/home", async (c) => {
 		const locale = c.req.query("locale");
-		service.homeIntelligence.requestRefresh("home_opened", void 0, locale);
 		return c.json(await home.getSnapshot(locale));
 	});
 	authenticated.get("/api/home/advisor/metrics", (c) => {

package/dist/src/gateway/hono/routes/update.js

@@ -32,13 +32,18 @@ function registerUpdateRoutes(authenticated, deps) {
 		});
 	});
 	authenticated.post("/api/update/check", strictRateLimitMiddleware, async (c) => {
-		await runGatewayUpdateCheck({
+		const checkResult = await runGatewayUpdateCheck({
 			config: loadConfig(service.getHealth().configPath),
 			force: true,
 			onUpdateAvailableChange: (update) => {
 				service.emit("update.available", update);
 			}
 		});
+		if (checkResult.ok === false) return c.json({
+			ok: false,
+			error: "update-check-failed",
+			message: `Could not check npm for updates: ${checkResult.error}`
+		}, 502);
 		const result = getUpdateAvailable();
 		return c.json({
 			ok: true,

package/dist/src/gateway/memory-maintenance-automation-reconciler.js

@@ -1,9 +1,6 @@
-import { normalizeAgentId } from "../agent-catalog/id.js";
-import { init_agent_scope, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
-import { maintenanceInstruction, resolveMemoryMaintenanceSchedules } from "../memory-maintenance/schedule.js";
+import { resolveMemoryMaintenanceSchedules } from "../memory-maintenance/schedule.js";
 import "../memory-maintenance/index.js";
 //#region src/gateway/memory-maintenance-automation-reconciler.ts
-init_agent_scope();
 const AUTOMATION_IDS = [
 	"system-memory-temporal-sweep",
 	"system-memory-daily-reconciliation",
@@ -17,8 +14,6 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 	};
 	const schedules = resolveMemoryMaintenanceSchedules(input.config);
 	const enabledIds = new Set(schedules.map((item) => item.automationId));
-	const agentId = normalizeAgentId(resolveDefaultAgentId());
-	const workingDirectory = resolveAgentWorkspaceDir(agentId);
 	for (const id of AUTOMATION_IDS) {
 		if (enabledIds.has(id)) continue;
 		if ((await input.automationService.get(id))?.enabled) {
@@ -36,11 +31,8 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			}
 		};
 		const action = {
-			kind: "agent",
-			agentId,
-			instruction: maintenanceInstruction(schedule.jobType),
-			workingDirectory,
-			timeoutSeconds: 300
+			kind: "system",
+			capability: `memory.${schedule.jobType}`
 		};
 		const next = {
 			name: schedule.name,
@@ -51,7 +43,13 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			safety: { mode: "auto_apply" },
 			conversationMode: "continuous",
 			notificationPolicy: "none",
-			reliability: { disableAfterConsecutiveFailures: 3 }
+			reliability: { disableAfterConsecutiveFailures: 3 },
+			management: {
+				owner: "memory-maintenance",
+				editable: ["enabled", "trigger"],
+				runnable: true,
+				deletable: false
+			}
 		};
 		const current = await input.automationService.get(schedule.automationId);
 		if (!current) {
@@ -62,8 +60,13 @@ async function reconcileMemoryMaintenanceAutomations(input) {
 			result.created += 1;
 			continue;
 		}
-		if (current.name !== next.name || current.description !== next.description || !current.enabled || JSON.stringify(current.trigger) !== JSON.stringify(trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.notificationPolicy !== "none") {
-			await input.automationService.update(schedule.automationId, next);
+		const reconciled = current.management ? {
+			...next,
+			enabled: current.enabled,
+			trigger: current.trigger
+		} : next;
+		if (current.name !== reconciled.name || current.description !== next.description || current.enabled !== reconciled.enabled || JSON.stringify(current.trigger) !== JSON.stringify(reconciled.trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.notificationPolicy !== "none" || JSON.stringify(current.management) !== JSON.stringify(next.management)) {
+			await input.automationService.update(schedule.automationId, reconciled);
 			result.updated += 1;
 		}
 	}

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

@@ -318,6 +318,7 @@ export declare class GatewayService {
     getEffectiveListenPort(): number;
     get automationServiceInstance(): AutomationService;
     private reconcileMemoryMaintenanceAutomations;
+    private executeSystemAutomationAction;
     get notesServiceInstance(): NotesService;
     get sessionIndexInstance(): SessionIndex;
     /** Shared workflow run orchestrator + session bridge (one instance per gateway). */