@runfusion/fusion 0.76.0-beta.3 → 0.77.0-beta.0

package/dist/migrations/0059_fn_9037_tasks_source_agent_index.sql

@@ -0,0 +1,3 @@
+CREATE INDEX IF NOT EXISTS "idxTasksProjectSourceAgentId"
+  ON project.tasks USING btree ("project_id", "source_agent_id")
+  WHERE "source_agent_id" IS NOT NULL;

package/dist/migrations/0060_fn_9059_workspace_coordination_leases.sql

@@ -0,0 +1,10 @@
+-- FNXC:Workspace 2026-08-15-08:23: durable project-scoped leases fence multi-node workspace writers; intents survive a post-push process death.
+CREATE TABLE IF NOT EXISTS project.workspace_coordination_leases (
+ project_id text NOT NULL DEFAULT current_setting('fusion.project_id', true), lease_key text NOT NULL, kind text NOT NULL, owner_task_id text NOT NULL, owner_node_id text NOT NULL, owner_incarnation_id text NOT NULL, owner_run_id text, fence_token bigint NOT NULL DEFAULT 0, fence_ref_name text, fence_ref_sha text, status text NOT NULL, acquired_at text NOT NULL, renewed_at text NOT NULL, expires_at text NOT NULL, created_at text NOT NULL, updated_at text NOT NULL, PRIMARY KEY(project_id, lease_key), CONSTRAINT workspace_coordination_leases_kind_check CHECK(kind IN ('acquire','land','merge-dispatch')), CONSTRAINT workspace_coordination_leases_status_check CHECK(status IN ('held','released','expired')));
+CREATE INDEX IF NOT EXISTS "idxWorkspaceCoordinationLeasesOwnerTask" ON project.workspace_coordination_leases(project_id, owner_task_id);
+CREATE INDEX IF NOT EXISTS "idxWorkspaceCoordinationLeasesOwnerNode" ON project.workspace_coordination_leases(project_id, owner_node_id);
+CREATE INDEX IF NOT EXISTS "idxWorkspaceCoordinationLeasesExpiry" ON project.workspace_coordination_leases(status, expires_at);
+CREATE TABLE IF NOT EXISTS project.workspace_land_intents (
+ project_id text NOT NULL DEFAULT current_setting('fusion.project_id', true), task_id text NOT NULL, repo_rel_path text NOT NULL, remote_url text NOT NULL, integration_ref text NOT NULL, intended_sha text NOT NULL, expected_tip text NOT NULL, fence_ref_name text NOT NULL, fence_ref_sha text NOT NULL, owner_task_id text NOT NULL, owner_node_id text NOT NULL, owner_incarnation_id text NOT NULL, fence_token bigint NOT NULL, status text NOT NULL, resolved_sha text, resolution text, created_at text NOT NULL, updated_at text NOT NULL, resolved_at text, PRIMARY KEY(project_id, task_id, repo_rel_path), CONSTRAINT workspace_land_intents_status_check CHECK(status IN ('pending','recorded','abandoned')), CONSTRAINT workspace_land_intents_resolution_check CHECK(resolution IS NULL OR resolution IN ('landed','not-landed')));
+CREATE INDEX IF NOT EXISTS "idxWorkspaceLandIntentsStatus" ON project.workspace_land_intents(project_id, status);
+DO $$ DECLARE tbl text; BEGIN FOREACH tbl IN ARRAY ARRAY['workspace_coordination_leases','workspace_land_intents'] LOOP EXECUTE format('ALTER TABLE project.%I ENABLE ROW LEVEL SECURITY', tbl); EXECUTE format('ALTER TABLE project.%I FORCE ROW LEVEL SECURITY', tbl); EXECUTE format('DROP POLICY IF EXISTS fusion_project_isolation ON project.%I', tbl); EXECUTE format('CREATE POLICY fusion_project_isolation ON project.%I USING (current_setting(''fusion.project_bypass'', true) = ''on'' OR project_id = current_setting(''fusion.project_id'', true)) WITH CHECK (current_setting(''fusion.project_bypass'', true) = ''on'' OR project_id = current_setting(''fusion.project_id'', true))', tbl); EXECUTE format('DROP TRIGGER IF EXISTS fusion_assign_project_id ON project.%I', tbl); EXECUTE format('CREATE TRIGGER fusion_assign_project_id BEFORE INSERT OR UPDATE OF project_id ON project.%I FOR EACH ROW EXECUTE FUNCTION project.fusion_assign_project_id()', tbl); END LOOP; END $$;

package/dist/pi-claude-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.76.0-beta.3",
+  "version": "0.77.0-beta.0",
   "type": "module",
   "private": true,
   "main": "index.ts",

package/dist/plugin-sdk/index.d.ts

@@ -861,6 +861,65 @@ interface HandoffToReviewOptions {
     now?: string;
 }
 
+type WorkspaceLeaseKind = "acquire" | "land" | "merge-dispatch";
+type WorkspaceLeaseStatus = "held" | "released" | "expired";
+type WorkspaceLeaseOwner = {
+    taskId: string;
+    nodeId: string;
+    incarnationId: string;
+    runId?: string;
+};
+type WorkspaceLeaseHandle = {
+    leaseKey: string;
+    owner: WorkspaceLeaseOwner;
+    fenceToken: bigint;
+    expiresAt: string;
+    fenceRefName?: string;
+    fenceRefSha?: string;
+};
+type WorkspaceLeaseClaimOutcome = "acquired" | "reentrant" | "reclaimed-expired" | "conflict";
+type WorkspaceLandIntentResolution = "landed" | "not-landed";
+type WorkspaceLeaseReclaimOutcome = "reclaimed" | "stale-precondition" | "still-live" | "owner-unresolvable" | "missing";
+interface WorkspaceLease extends WorkspaceLeaseHandle {
+    kind: WorkspaceLeaseKind;
+    status: WorkspaceLeaseStatus;
+    acquiredAt: string;
+    renewedAt: string;
+}
+interface WorkspaceLeaseConflict {
+    leaseKey: string;
+    taskId: string;
+    nodeId: string;
+    incarnationId: string;
+    fenceToken: bigint;
+    expiresAt: string;
+}
+type AcquireWorkspaceLeaseResult = {
+    outcome: Exclude<WorkspaceLeaseClaimOutcome, "conflict">;
+    handle: WorkspaceLeaseHandle;
+} | {
+    outcome: "conflict";
+    conflict: WorkspaceLeaseConflict;
+};
+interface WorkspaceLandIntent {
+    taskId: string;
+    repoRelPath: string;
+    remoteUrl: string;
+    integrationRef: string;
+    intendedSha: string;
+    expectedTip: string;
+    fenceRefName: string;
+    fenceRefSha: string;
+    owner: WorkspaceLeaseOwner;
+    fenceToken: bigint;
+    status: "pending" | "recorded" | "abandoned";
+    resolvedSha?: string;
+    resolution?: WorkspaceLandIntentResolution;
+    createdAt: string;
+    updatedAt: string;
+    resolvedAt?: string;
+}
+
 interface TaskMoveLanes {
     readonly hold?: string;
     readonly intake?: string;
@@ -4164,6 +4223,62 @@ interface ReconcileStaleSymbolLocksResult {
     skipped: string[];
 }
 
+declare function recordWorkspaceLandIntentAsync(store: TaskStore, input: {
+    handle: WorkspaceLeaseHandle;
+    taskId: string;
+    repoRelPath: string;
+    remoteUrl: string;
+    integrationRef: string;
+    intendedSha: string;
+    expectedTip: string;
+}): Promise<void>;
+declare function listPendingWorkspaceLandIntentsAsync(store: TaskStore, filter?: {
+    taskId?: string;
+    repoRelPath?: string;
+    limit?: number;
+}): Promise<WorkspaceLandIntent[]>;
+declare function resolveWorkspaceLandIntentAsync(store: TaskStore, input: {
+    handle: WorkspaceLeaseHandle;
+    taskId: string;
+    repoRelPath: string;
+    expectedIntentFenceToken: bigint;
+    resolution: WorkspaceLandIntentResolution;
+    resolvedSha?: string;
+    persistLandedSha?: () => Promise<void>;
+}): Promise<{
+    outcome: "missing";
+} | {
+    outcome: "resolved";
+} | {
+    outcome: "stale-intent";
+}>;
+declare function resolveOrphanedWorkspaceLandIntentAsync(store: TaskStore, input: {
+    leaseKey: string;
+    taskId: string;
+    repoRelPath: string;
+    expectedIntentFenceToken: bigint;
+    resolution: WorkspaceLandIntentResolution;
+    resolvedSha?: string;
+    persistLandedSha?: () => Promise<void>;
+}): Promise<{
+    outcome: "missing";
+} | {
+    outcome: "resolved";
+} | {
+    outcome: "stale-intent";
+} | {
+    outcome: "lease-live";
+}>;
+declare function reclaimWorkspaceLeaseAsync(store: TaskStore, input: {
+    leaseKey: string;
+    expectedOwner: WorkspaceLeaseOwner;
+    expectedFenceToken: bigint;
+    requireTerminalOwner?: boolean;
+    reason?: string;
+}): Promise<{
+    outcome: WorkspaceLeaseReclaimOutcome;
+}>;
+
 declare const TASK_DELETE_CALLER_KINDS: readonly ["operator-ui", "operator-cli", "agent-tool", "engine", "api-unattributed"];
 type TaskDeleteCallerKind = (typeof TASK_DELETE_CALLER_KINDS)[number];
 interface TaskDeleteAuditContext {
@@ -4977,6 +5092,54 @@ declare class TaskStore extends EventEmitter<TaskStoreEvents> {
     releaseSymbolLocks(symbols: readonly string[], ownerTaskId: string): Promise<ReleaseSymbolLocksResult>;
     inspectSymbolLockConflicts(symbols: readonly string[]): Promise<SymbolLockConflict[]>;
     reconcileStaleSymbolLocks(): Promise<ReconcileStaleSymbolLocksResult>;
+    acquireWorkspaceLease(input: {
+        leaseKey: string;
+        kind: WorkspaceLeaseKind;
+        owner: WorkspaceLeaseOwner;
+        leaseMs: number;
+    }): Promise<AcquireWorkspaceLeaseResult>;
+    renewWorkspaceLease(handle: WorkspaceLeaseHandle, leaseMs: number): Promise<WorkspaceLeaseHandle | undefined>;
+    releaseWorkspaceLease(handle: WorkspaceLeaseHandle): Promise<boolean>;
+    withValidWorkspaceLease<T>(handle: WorkspaceLeaseHandle, fn: (tx: DbTransaction) => Promise<T>): Promise<T>;
+    validateWorkspaceLeaseFence(input: {
+        leaseKey: string;
+        owner: WorkspaceLeaseOwner;
+        fenceToken: bigint;
+    }): Promise<"unknown" | "superseded" | "missing" | "valid">;
+    recordWorkspaceLeaseFenceRef(input: {
+        handle: WorkspaceLeaseHandle;
+        fenceRefName: string;
+        fenceRefSha: string;
+    }): Promise<WorkspaceLeaseHandle>;
+    inspectWorkspaceLeases(filter?: {
+        taskId?: string;
+        leaseKeys?: string[];
+    }): Promise<WorkspaceLease[]>;
+    reclaimWorkspaceLease(input: Parameters<typeof reclaimWorkspaceLeaseAsync>[1]): Promise<{
+        outcome: WorkspaceLeaseReclaimOutcome;
+    }>;
+    reconcileExpiredWorkspaceLeases(): Promise<string[]>;
+    releaseStaleWorkspaceLeasesForNode(nodeId: string, options: {
+        currentIncarnationId: string;
+    }): Promise<string[]>;
+    recordWorkspaceLandIntent(input: Parameters<typeof recordWorkspaceLandIntentAsync>[1]): Promise<void>;
+    listPendingWorkspaceLandIntents(filter?: Parameters<typeof listPendingWorkspaceLandIntentsAsync>[1]): Promise<WorkspaceLandIntent[]>;
+    resolveWorkspaceLandIntent(input: Parameters<typeof resolveWorkspaceLandIntentAsync>[1]): Promise<{
+        outcome: "missing";
+    } | {
+        outcome: "resolved";
+    } | {
+        outcome: "stale-intent";
+    }>;
+    resolveOrphanedWorkspaceLandIntent(input: Parameters<typeof resolveOrphanedWorkspaceLandIntentAsync>[1]): Promise<{
+        outcome: "missing";
+    } | {
+        outcome: "resolved";
+    } | {
+        outcome: "stale-intent";
+    } | {
+        outcome: "lease-live";
+    }>;
     resolveTaskSymbols(taskId: string): Promise<TaskSymbolResolution>;
     resolveTaskSymbolsForWorkItem(workItem: Pick<WorkflowWorkItem, "taskId">): Promise<TaskSymbolResolution>;
     setTaskDeclaredSymbols(taskId: string, symbols: readonly string[]): Promise<Task>;
@@ -5164,6 +5327,13 @@ declare class TaskStore extends EventEmitter<TaskStoreEvents> {
         status?: BranchGroup["status"];
     }): Promise<BranchGroup>;
     getTaskColumns(ids: string[]): Promise<Map<string, Column>>;
+    findTaskByProposalClaimId(proposalClaimId: string, options?: {
+        includeDeleted?: boolean;
+    }): Promise<Task | null>;
+    listTasksBySourceLineage(input: {
+        sourceAgentId?: string | null;
+        sourceParentTaskId?: string | null;
+    }): Promise<Task[]>;
     listTasks(options?: {
         limit?: number;
         offset?: number;
@@ -5487,6 +5657,10 @@ declare class TaskStore extends EventEmitter<TaskStoreEvents> {
     markToolFailureRetryExhaustedAudit(taskId: string): Promise<boolean>;
     updateTaskAtomic(id: string, updater: (current: Task) => Parameters<TaskStore["updateTask"]>[1] | null | undefined | Promise<Parameters<TaskStore["updateTask"]>[1] | null | undefined>, runContext?: RunMutationContext): Promise<Task>;
     linkTaskRecommendation(id: string, recommendationId: string, createdTaskId: string, completeColumns?: ReadonlySet<string>): Promise<Task>;
+    mergeWorkspaceWorktreeEntry(id: string, repoRelPath: string, patch: Partial<WorkspaceWorktreeEntry>, options?: {
+        requireExistingEntry?: boolean;
+        clearSingularWorktree?: boolean;
+    }): Promise<Task>;
     resolveTaskWedgeNotificationEpisode(id: string, episodeId: string): Promise<{
         task: Task;
         resolved: boolean;
@@ -5706,10 +5880,12 @@ declare class TaskStore extends EventEmitter<TaskStoreEvents> {
     archiveTask(id: string, optionsOrCleanup?: boolean | {
         cleanup?: boolean;
         removeLineageReferences?: boolean;
+        liveExecutionGuard?: "refuse" | "off";
     }): Promise<Task>;
     archiveTaskBackend(id: string, optionsOrCleanup: boolean | {
         cleanup?: boolean;
         removeLineageReferences?: boolean;
+        liveExecutionGuard?: "refuse" | "off";
     }): Promise<Task>;
     archiveTaskAndCleanup(id: string): Promise<Task>;
     resolveUnarchiveTargetColumn(preArchiveColumn: unknown, taskId?: string): Promise<Column>;
@@ -7365,6 +7541,18 @@ interface TaskReleaseGateVerdict {
     evaluatedAt: string;
     evaluatedForUpdatedAt?: string;
 }
+interface WorkspaceWorktreeEntry {
+    worktreePath: string;
+    branch: string;
+    baseCommitSha?: string;
+    landedSha?: string;
+    revertBoundarySha?: string;
+    landFailure?: {
+        message: string;
+        at: string;
+        branch?: string;
+    };
+}
 interface Task {
     id: string;
     lineageId?: string;
@@ -7378,12 +7566,7 @@ interface Task {
     breakIntoSubtasks?: boolean;
     noCommitsExpected?: boolean;
     worktree?: string;
-    workspaceWorktrees?: Record<string, {
-        worktreePath: string;
-        branch: string;
-        baseCommitSha?: string;
-        landedSha?: string;
-    }>;
+    workspaceWorktrees?: Record<string, WorkspaceWorktreeEntry>;
     steps: TaskStep[];
     currentStep: number;
     customFields?: Record<string, unknown>;
@@ -7836,6 +8019,7 @@ interface GlobalSettings {
     dashboardKeyboardShortcuts?: DashboardKeyboardShortcuts;
     dismissModalsOnOutsideClick?: boolean;
     skipConfirmationDialogs?: boolean;
+    quickAddSubmitOnEnter?: boolean;
     language?: Locale;
     defaultProvider?: string;
     defaultCredentialInstanceId?: string;
@@ -8182,9 +8366,6 @@ interface ProjectSettings {
     mergeConflictStrategy?: MergeConflictStrategy;
     maxAutoMergeRetries?: number;
     merger?: MergerSettings;
-    mergeDiffVolumeMinLines?: number;
-    mergeDiffVolumeThreshold?: number;
-    mergeDiffVolumeAllowlist?: string[];
     requiredChecks?: string[];
     mergeStrategyOverlapBehavior?: MergeStrategyOverlapBehavior;
     postMergeAuditMode?: PostMergeAuditMode;

package/dist/plugin-sdk/index.js

@@ -5777,7 +5777,9 @@ __export(project_exports, {
   workflowSettings: () => workflowSettings,
   workflowSteps: () => workflowSteps,
   workflowWorkItems: () => workflowWorkItems,
-  workflows: () => workflows
+  workflows: () => workflows,
+  workspaceCoordinationLeases: () => workspaceCoordinationLeases,
+  workspaceLandIntents: () => workspaceLandIntents
 });
 var projectSchema = pgSchema(PROJECT_SCHEMA);
 var tasks = projectSchema.table("tasks", {
@@ -6044,6 +6046,9 @@ var tasks = projectSchema.table("tasks", {
   the gate is a full tasks-table scan. Sparse: most rows have NULL parent.
   */
   index("idxTasksSourceParentTaskId").on(t.sourceParentTaskId),
+  /* FNXC:TaskRecommendations 2026-08-13-22:23: duplicate intake filters source
+   * lineage on recommendation/agent creates; this sparse index avoids a task-table scan. */
+  index("idxTasksProjectSourceAgentId").on(t.projectId, t.sourceAgentId).where(sql`${t.sourceAgentId} IS NOT NULL`),
   // FNXC:EphemeralAgentTaskCreation 2026-07-30-12:00: proposal retries share one stable key, so the database—not a read-before-create race—enforces at-most-once materialization.
   uniqueIndex("uqTasksProjectProposalClaimId").on(t.projectId, t.proposalClaimId).where(sql`${t.proposalClaimId} IS NOT NULL`),
   /*
@@ -6278,6 +6283,52 @@ var distributedTaskIdReservations = projectSchema.table("distributed_task_id_res
   index("idxDistributedTaskIdReservationsPrefixStatus").on(t.prefix, t.status),
   index("idxDistributedTaskIdReservationsExpiry").on(t.status, t.expiresAt)
 ]);
+var workspaceCoordinationLeases = projectSchema.table("workspace_coordination_leases", {
+  projectId: text("project_id").notNull().default(sql`current_setting('fusion.project_id', true)`),
+  leaseKey: text("lease_key").notNull(),
+  kind: text("kind").notNull(),
+  ownerTaskId: text("owner_task_id").notNull(),
+  ownerNodeId: text("owner_node_id").notNull(),
+  ownerIncarnationId: text("owner_incarnation_id").notNull(),
+  ownerRunId: text("owner_run_id"),
+  fenceToken: bigint("fence_token", { mode: "bigint" }).notNull().default(sql`0`),
+  fenceRefName: text("fence_ref_name"),
+  fenceRefSha: text("fence_ref_sha"),
+  status: text("status").notNull(),
+  acquiredAt: text("acquired_at").notNull(),
+  renewedAt: text("renewed_at").notNull(),
+  expiresAt: text("expires_at").notNull(),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (t) => [
+  primaryKey({ columns: [t.projectId, t.leaseKey] }),
+  check("workspace_coordination_leases_kind_check", sql`${t.kind} IN ('acquire', 'land', 'merge-dispatch')`),
+  check("workspace_coordination_leases_status_check", sql`${t.status} IN ('held', 'released', 'expired')`),
+  index("idxWorkspaceCoordinationLeasesOwnerTask").on(t.projectId, t.ownerTaskId),
+  index("idxWorkspaceCoordinationLeasesOwnerNode").on(t.projectId, t.ownerNodeId),
+  index("idxWorkspaceCoordinationLeasesExpiry").on(t.status, t.expiresAt)
+]);
+var workspaceLandIntents = projectSchema.table("workspace_land_intents", {
+  projectId: text("project_id").notNull().default(sql`current_setting('fusion.project_id', true)`),
+  taskId: text("task_id").notNull(),
+  repoRelPath: text("repo_rel_path").notNull(),
+  remoteUrl: text("remote_url").notNull(),
+  integrationRef: text("integration_ref").notNull(),
+  intendedSha: text("intended_sha").notNull(),
+  expectedTip: text("expected_tip").notNull(),
+  fenceRefName: text("fence_ref_name").notNull(),
+  fenceRefSha: text("fence_ref_sha").notNull(),
+  ownerTaskId: text("owner_task_id").notNull(),
+  ownerNodeId: text("owner_node_id").notNull(),
+  ownerIncarnationId: text("owner_incarnation_id").notNull(),
+  fenceToken: bigint("fence_token", { mode: "bigint" }).notNull(),
+  status: text("status").notNull(),
+  resolvedSha: text("resolved_sha"),
+  resolution: text("resolution"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  resolvedAt: text("resolved_at")
+}, (t) => [primaryKey({ columns: [t.projectId, t.taskId, t.repoRelPath] }), check("workspace_land_intents_status_check", sql`${t.status} IN ('pending', 'recorded', 'abandoned')`), check("workspace_land_intents_resolution_check", sql`${t.resolution} IS NULL OR ${t.resolution} IN ('landed', 'not-landed')`), index("idxWorkspaceLandIntentsStatus").on(t.projectId, t.status)]);
 var symbolLocks = projectSchema.table("symbol_locks", {
   projectId: text("project_id").notNull().default(sql`current_setting('fusion.project_id', true)`),
   symbolKey: text("symbol_key").notNull(),
@@ -8852,6 +8903,11 @@ var DEFAULT_GLOBAL_SETTINGS = {
   Critical-action confirmation dialogs stay enabled by default. This global-only preference may opt an operator into primary/default auto-approval, but project settings cannot enable it for collaborators.
   */
   skipConfirmationDialogs: false,
+  /*
+  FNXC:QuickEntry 2026-08-16-03:15:
+  Quick Add keeps its historical Enter-to-submit behavior by default; only an operator's global preference may opt into newline-first entry.
+  */
+  quickAddSubmitOnEnter: true,
   language: void 0,
   defaultProvider: void 0,
   defaultCredentialInstanceId: void 0,
@@ -9314,9 +9370,6 @@ var DEFAULT_PROJECT_SETTINGS = {
    * New and unconfigured projects default AI merge to sync a dirty checked-out integration branch, restoring the legacy stash → fast-forward → restore landing behavior. Explicit persisted merger.allowDirtyLocalCheckoutSync values still win, and no existing-project migration stamps this default into storage.
    */
   merger: { mode: "ai", maxReviewPasses: 3, allowDirtyLocalCheckoutSync: true },
-  mergeDiffVolumeMinLines: void 0,
-  mergeDiffVolumeThreshold: void 0,
-  mergeDiffVolumeAllowlist: void 0,
   requiredChecks: void 0,
   mergeStrategyOverlapBehavior: "flip-to-prefer-branch",
   postMergeAuditMode: "warn",
@@ -17967,10 +18020,6 @@ var AgentStore = class _AgentStore extends EventEmitter {
       };
       await this.writeAgent(updated);
       this.emit("agent:stateChanged", agentId, currentState, newState);
-      if (this.asyncLayer) try {
-        await appendAgentActivityEvent(this.asyncLayer, { type: "agent:state-changed", attributionClaim: resolveAgentActivityAttribution([{ id: agentId, provenance: "roster" }], "executor"), taskId: updated.taskId, occurredAt: updated.updatedAt, discriminator: updated.updatedAt, metadata: { fromState: currentState, toState: newState, source: "update" } });
-      } catch {
-      }
       this.emit("agent:updated", updated, currentState);
       return updated;
     });
@@ -18462,10 +18511,10 @@ var AgentStore = class _AgentStore extends EventEmitter {
     return agents2;
   }
   /*
-  FNXC:MemoryAgent 2026-08-11-09:41:
-  Memory Keeper is custom because it is not a workflow-stage principal. Unlike the four routed
-  owners its heartbeat is enabled, while auto-claim remains off because it only maintains memory.
-  This runs during init, where createAgent name collisions would abort startup; preflight probes,
+  FNXC:MemoryAgent 2026-08-16-02:31:
+  Memory Keeper is custom because it is not a workflow-stage principal. Its heartbeat defaults off
+  until an operator opts in, while auto-claim remains off because it only maintains memory. This
+  runs during init, where createAgent name collisions would abort startup; preflight probes,
   a fallback name, a null degraded result, and the init-side catch keep an operator's same-named
   agent untouched and the project runnable.
   */
@@ -18491,7 +18540,13 @@ var AgentStore = class _AgentStore extends EventEmitter {
             roles: [...BUILTIN_MEMORY_AGENT_DEFAULT.roles],
             title: BUILTIN_MEMORY_AGENT_DEFAULT.title,
             metadata: { [BUILTIN_MEMORY_AGENT_PROVENANCE_KEY]: true },
-            runtimeConfig: { enabled: true, autoClaimRelevantTasks: false, heartbeatIntervalMs: 36e5 },
+            /*
+            FNXC:MemoryAgent 2026-08-16-02:31:
+            Memory consolidation is opt-in: newly provisioned Memory Keepers must not begin
+            hourly autonomous heartbeats until an operator enables the existing heartbeat toggle.
+            Keep auto-claim off and the one-hour interval ready for that later opt-in.
+            */
+            runtimeConfig: { enabled: false, autoClaimRelevantTasks: false, heartbeatIntervalMs: 36e5 },
             instructionsText: BUILTIN_MEMORY_AGENT_DEFAULT.instructionsText,
             soul: BUILTIN_MEMORY_AGENT_DEFAULT.soul,
             bundleConfig: { ...BUILTIN_MEMORY_AGENT_DEFAULT.bundleConfig, files: [...BUILTIN_MEMORY_AGENT_DEFAULT.bundleConfig.files] }
@@ -18506,7 +18561,9 @@ var AgentStore = class _AgentStore extends EventEmitter {
         return owner;
       }
       const metadata = { ...owner.metadata ?? {}, [BUILTIN_MEMORY_AGENT_PROVENANCE_KEY]: true };
-      const runtimeConfig = { ...owner.runtimeConfig ?? {}, enabled: true, autoClaimRelevantTasks: false, heartbeatIntervalMs: 36e5 };
+      const currentRuntimeConfig = owner.runtimeConfig ?? {};
+      const enabled = typeof currentRuntimeConfig.enabled === "boolean" ? currentRuntimeConfig.enabled : false;
+      const runtimeConfig = currentRuntimeConfig.enabled === enabled && currentRuntimeConfig.autoClaimRelevantTasks === false && currentRuntimeConfig.heartbeatIntervalMs === DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS ? currentRuntimeConfig : { ...currentRuntimeConfig, enabled, autoClaimRelevantTasks: false, heartbeatIntervalMs: DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS };
       const updates = {
         roles: [...BUILTIN_MEMORY_AGENT_DEFAULT.roles],
         role: "custom",
@@ -18516,7 +18573,9 @@ var AgentStore = class _AgentStore extends EventEmitter {
         instructionsText: owner.instructionsText?.trim() ? owner.instructionsText : BUILTIN_MEMORY_AGENT_DEFAULT.instructionsText,
         soul: owner.soul?.trim() ? owner.soul : BUILTIN_MEMORY_AGENT_DEFAULT.soul
       };
-      owner = { ...owner, ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      const nextOwner = { ...owner, ...updates };
+      if (JSON.stringify(nextOwner) === JSON.stringify(owner)) return owner;
+      owner = { ...nextOwner, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
       await this.writeAgent(owner, executor);
       return owner;
     };
@@ -19388,19 +19447,6 @@ var AgentStore = class _AgentStore extends EventEmitter {
         this.agentSnapshotCache.set(agent.id, this.watchSnapshotOf(agent));
         if (stateChanged) {
           this.emit("agent:stateChanged", agent.id, previousState, agent.state);
-          if (this.asyncLayer) {
-            try {
-              await appendAgentActivityEvent(this.asyncLayer, {
-                type: "agent:state-changed",
-                attributionClaim: resolveAgentActivityAttribution([{ id: agent.id, provenance: "roster" }], "executor"),
-                taskId: agent.taskId,
-                occurredAt: agent.updatedAt,
-                discriminator: agent.updatedAt,
-                metadata: { fromState: previousState, toState: agent.state, source: "reconciliation" }
-              });
-            } catch {
-            }
-          }
           this.emit("agent:updated", agent, previousState);
         } else {
           this.emit("agent:updated", agent);