@moretea-labs/forge 1.5.0 → 1.6.0

package/src/runtime/plugins/gmail-adapter.ts

@@ -364,7 +364,33 @@ function gmailActions(): AssistantPluginActionDescriptor[] {
   ];
 }
 
-function buildMimeMessage(args: Record<string, unknown>, config: GmailPluginConfig): string {
+export function encodeMimeHeaderValue(value: string): string {
+  if (/[\r\n]/.test(value)) {
+    throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'MIME header values must not contain CR or LF.');
+  }
+  if (/^[\x00-\x7F]*$/.test(value)) return value;
+
+  // RFC 2047 encoded-words are limited to 75 characters including wrappers.
+  // 45 UTF-8 bytes encode to at most 60 Base64 characters, leaving room for
+  // the =?UTF-8?B?...?= wrapper. Split only at Unicode code-point boundaries.
+  const chunks: string[] = [];
+  let current = '';
+  for (const character of value) {
+    const candidate = `${current}${character}`;
+    if (current && Buffer.byteLength(candidate, 'utf8') > 45) {
+      chunks.push(current);
+      current = character;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks
+    .map((chunk) => `=?UTF-8?B?${Buffer.from(chunk, 'utf8').toString('base64')}?=`)
+    .join('\r\n ');
+}
+
+export function buildMimeMessage(args: Record<string, unknown>, config: GmailPluginConfig): string {
   const to = stringArray(args.to);
   const cc = stringArray(args.cc);
   const bcc = stringArray(args.bcc);
@@ -378,7 +404,7 @@ function buildMimeMessage(args: Record<string, unknown>, config: GmailPluginConf
     ...(cc ? [`Cc: ${cc.join(', ')}`] : []),
     ...(bcc ? [`Bcc: ${bcc.join(', ')}`] : []),
     ...(config.accountEmail ? [`From: ${config.accountEmail}`] : []),
-    `Subject: ${subject}`,
+    `Subject: ${encodeMimeHeaderValue(subject)}`,
     'Content-Type: text/plain; charset="UTF-8"',
     'MIME-Version: 1.0',
     '',

package/src/runtime/plugins/local-system-adapter.ts

@@ -522,7 +522,7 @@ function actions(): AssistantPluginActionDescriptor[] {
     { actionId: 'restart_user_launch_agent', title: 'Restart verified user LaunchAgent', description: 'Restart one loaded user LaunchAgent by exact label only after launchctl evidence contains the expected program identity.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false, scopes: ['local-system.process'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { label: { type: 'string' }, expected_program_contains: { type: 'string' } }, required: ['label', 'expected_program_contains'], additionalProperties: false } },
     { actionId: 'stop_user_launch_agent', title: 'Stop verified user LaunchAgent', description: 'Boot out one exact loaded user LaunchAgent only after its launchd identity matches the expected program.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: true, scopes: ['local-system.process'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { label: { type: 'string' }, expected_program_contains: { type: 'string' } }, required: ['label', 'expected_program_contains'], additionalProperties: false } },
     { actionId: 'start_user_launch_agent', title: 'Start verified user LaunchAgent', description: 'Bootstrap or start one exact current-user LaunchAgent from ~/Library/LaunchAgents only after the installed plist matches the expected program identity.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: true, scopes: ['local-system.process'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { label: { type: 'string' }, expected_program_contains: { type: 'string' } }, required: ['label', 'expected_program_contains'], additionalProperties: false } },
-    { actionId: 'open_application', title: 'Open application', description: 'Open one macOS application by name or bundle id.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false, scopes: ['local-system.open'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { app_name: { type: 'string' }, bundle_id: { type: 'string' } }, additionalProperties: false } },
+    { actionId: 'open_application', title: 'Open application', description: 'Open one macOS application by name or bundle id in the background without stealing foreground focus.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false, scopes: ['local-system.open'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { app_name: { type: 'string' }, bundle_id: { type: 'string' } }, additionalProperties: false } },
     { actionId: 'list_targets', title: 'List filesystem targets', description: 'List active expiring local filesystem grants.', readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true, scopes: ['local-system.files.read'], resourceClaims: controllerRead, argumentsSchema: { type: 'object', properties: {}, additionalProperties: false } },
     { actionId: 'authorize_target', title: 'Authorize filesystem target', description: 'Authorize an expiring filesystem target. By default, a path inside a Git project authorizes the whole project/repository root; use scope=directory only when intentionally granting a narrower directory.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: true, scopes: ['local-system.files.write'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { target_key: { type: 'string' }, root_path: { type: 'string' }, scope: { type: 'string', enum: ['auto', 'project', 'directory'] }, expires_in_minutes: { type: 'number' }, reason: { type: 'string' }, access: { type: 'string', enum: ['read_only', 'read_write'] } }, required: ['target_key', 'root_path', 'reason'], additionalProperties: false } },
     { actionId: 'revoke_target', title: 'Revoke filesystem target', description: 'Immediately revoke one active filesystem target owned by the authenticated caller.', readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 15_000, cancellable: true, idempotent: false, scopes: ['local-system.files.write'], resourceClaims: controllerWrite, argumentsSchema: { type: 'object', properties: { target_key: { type: 'string' } }, required: ['target_key'], additionalProperties: false } },
@@ -636,7 +636,7 @@ export async function executeLocalSystemPluginAction(input: AssistantPluginActio
       if ((!appName && !bundleId) || (appName && bundleId)) {
         throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'Provide exactly one of app_name or bundle_id.', { retryable: false });
       }
-      const command = bundleId ? ['open', '-b', bundleId] : ['open', '-a', appName as string];
+      const command = bundleId ? ['open', '-g', '-b', bundleId] : ['open', '-g', '-a', appName as string];
       const opened = run(command[0], command.slice(1));
       if (!opened.ok) throw new AssistantPluginError('LOCAL_SYSTEM_OPEN_FAILED', opened.stderr || opened.stdout, { retryable: true, details: { command } });
       return { opened: true, command };

package/src/runtime/plugins/plugin-management-adapter.ts

@@ -0,0 +1,140 @@
+import type {
+  AssistantPluginActionDescriptor,
+  AssistantPluginActionExecutionInput,
+  AssistantPluginCapability,
+  AssistantPluginManifest,
+  AssistantPluginPermissionScope,
+} from './types';
+import { AssistantPluginError } from './errors';
+import {
+  disableExternalPluginRegistration,
+  getExternalPluginRegistration,
+  installExternalPluginRegistration,
+  listExternalPluginRegistrations,
+  previewExternalPluginRegistration,
+  removeExternalPluginRegistration,
+  type ExternalPluginRegistrationInput,
+} from './external-registration';
+
+const PLUGIN_ID = 'plugin_management';
+
+function now(): string { return new Date().toISOString(); }
+function requiredString(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `${field} is required.`);
+  return value.trim();
+}
+function expectedRevision(value: unknown): number | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+    throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'expected_revision must be a non-negative integer.');
+  }
+  return value;
+}
+function registrationInput(value: unknown): ExternalPluginRegistrationInput {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'registration must be an object.');
+  }
+  return value as ExternalPluginRegistrationInput;
+}
+
+function permissions(): AssistantPluginPermissionScope[] {
+  return [
+    { scope: 'external-plugins.read', mode: 'read', description: 'Read and validate external plugin registrations.', granted: true, required: true },
+    { scope: 'external-plugins.write', mode: 'write', description: 'Install, update, and disable validated external plugin registrations.', granted: true, required: true },
+    { scope: 'external-plugins.remove', mode: 'write', description: 'Remove one external plugin registration after strong confirmation.', granted: true, required: true },
+  ];
+}
+
+function capabilities(): AssistantPluginCapability[] {
+  return [{
+    capabilityId: 'external-plugin-registration-management',
+    title: 'External Plugin Registration Management',
+    description: 'Preview, install/update, inspect, disable, and remove external provider registrations through the canonical validation authority.',
+    scopes: ['external-plugins.read', 'external-plugins.write', 'external-plugins.remove'],
+    actions: ['list_registrations', 'get_registration', 'preview_registration', 'install_registration', 'disable_registration', 'remove_registration'],
+  }];
+}
+
+const registrationProperty = { type: 'object', description: 'ExternalPluginRegistrationInput. Canonical Forge validation rejects invalid identity, transport, lifecycle, permissions, capabilities, and actions.' };
+function actions(): AssistantPluginActionDescriptor[] {
+  return [
+    {
+      actionId: 'list_registrations', title: 'List external plugin registrations', description: 'List canonical installed external plugin registrations.',
+      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
+      scopes: ['external-plugins.read'], resourceClaims: [{ resource: 'provider-state', mode: 'read' }],
+      argumentsSchema: { type: 'object', properties: {}, additionalProperties: false },
+    },
+    {
+      actionId: 'get_registration', title: 'Get external plugin registration', description: 'Read one canonical external plugin registration.',
+      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
+      scopes: ['external-plugins.read'], resourceClaims: [{ resource: 'provider-state', mode: 'read' }],
+      argumentsSchema: { type: 'object', properties: { plugin_id: { type: 'string' } }, required: ['plugin_id'], additionalProperties: false },
+    },
+    {
+      actionId: 'preview_registration', title: 'Preview external plugin registration', description: 'Validate registration input and return its canonical fingerprint/revision plan without mutation.',
+      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
+      scopes: ['external-plugins.read'], resourceClaims: [{ resource: 'provider-state', mode: 'read' }],
+      argumentsSchema: { type: 'object', properties: { registration: registrationProperty }, required: ['registration'], additionalProperties: false },
+    },
+    {
+      actionId: 'install_registration', title: 'Install or update external plugin registration', description: 'Install/update through installExternalPluginRegistration with revision guarding.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
+      scopes: ['external-plugins.write'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
+      argumentsSchema: { type: 'object', properties: { registration: registrationProperty, expected_revision: { type: 'number' } }, required: ['registration'], additionalProperties: false },
+    },
+    {
+      actionId: 'disable_registration', title: 'Disable external plugin registration', description: 'Disable one installed registration while preserving its audited identity and revision history.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
+      scopes: ['external-plugins.write'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
+      argumentsSchema: { type: 'object', properties: { plugin_id: { type: 'string' }, expected_revision: { type: 'number' } }, required: ['plugin_id'], additionalProperties: false },
+    },
+    {
+      actionId: 'remove_registration', title: 'Remove external plugin registration', description: 'Explicitly remove one canonical external provider registration.',
+      readOnly: false, risk: 'destructive', confirmation: 'strong_confirmation', requiredConfirmationText: 'remove-external-plugin-registration', defaultTimeoutMs: 10_000, cancellable: true, idempotent: true,
+      scopes: ['external-plugins.remove'], resourceClaims: [{ resource: 'provider-state', mode: 'write' }],
+      argumentsSchema: { type: 'object', properties: { plugin_id: { type: 'string' }, expected_revision: { type: 'number' } }, required: ['plugin_id'], additionalProperties: false },
+    },
+  ];
+}
+
+export function buildPluginManagementManifest(previousRevision = 0, previousUpdatedAt?: string): AssistantPluginManifest {
+  return {
+    schemaVersion: 1, manifestVersion: 1, revision: Math.max(1, previousRevision || 1), pluginId: PLUGIN_ID,
+    provider: 'forge-controller', displayName: 'Forge Plugin Management', pluginVersion: '1.0.0',
+    authority: { strategy: 'derived', duplicateStateAllowed: false, sourceOfTruth: ['controller-home:plugins/external/registrations'] },
+    enabled: true, lifecycle: { state: 'enabled', reason: 'Canonical external plugin registration authority is available.' },
+    health: { state: 'ready', checkedAt: now(), ready: true, probed: true, errors: [], warnings: [] },
+    permissions: permissions(), capabilities: capabilities(), actions: actions(), updatedAt: previousUpdatedAt ?? now(),
+  };
+}
+
+export async function executePluginManagementAction(input: AssistantPluginActionExecutionInput): Promise<Record<string, unknown>> {
+  switch (input.actionId) {
+    case 'list_registrations': return { registrations: listExternalPluginRegistrations(input.controllerHome) };
+    case 'get_registration': {
+      const pluginId = requiredString(input.args.plugin_id, 'plugin_id');
+      const registration = getExternalPluginRegistration(input.controllerHome, pluginId);
+      if (!registration) throw new AssistantPluginError('PLUGIN_EXTERNAL_REGISTRATION_NOT_FOUND', `External plugin registration ${pluginId} was not found.`, { retryable: false });
+      return { registration };
+    }
+    case 'preview_registration': return { preview: previewExternalPluginRegistration(input.controllerHome, registrationInput(input.args.registration)) };
+    case 'install_registration': return { registration: installExternalPluginRegistration(input.controllerHome, registrationInput(input.args.registration), { expectedRevision: expectedRevision(input.args.expected_revision) }) };
+    case 'disable_registration': return { registration: disableExternalPluginRegistration(input.controllerHome, requiredString(input.args.plugin_id, 'plugin_id'), { expectedRevision: expectedRevision(input.args.expected_revision) }) };
+    case 'remove_registration': return { removed: removeExternalPluginRegistration(input.controllerHome, requiredString(input.args.plugin_id, 'plugin_id'), { expectedRevision: expectedRevision(input.args.expected_revision) }) };
+    default: throw new AssistantPluginError('PLUGIN_ACTION_NOT_SUPPORTED', `${PLUGIN_ID}/${input.actionId} is not supported.`, { retryable: false });
+  }
+}
+
+function affectedPluginIdsAfterAction(actionId: string, result: Record<string, unknown>): string[] {
+  if (!['install_registration', 'disable_registration', 'remove_registration'].includes(actionId)) return [];
+  const value = (result.registration ?? result.removed) as { pluginId?: unknown } | undefined;
+  return typeof value?.pluginId === 'string' && value.pluginId.trim() ? [value.pluginId.trim()] : [];
+}
+
+export const pluginManagementAdapter = {
+  pluginId: PLUGIN_ID,
+  scope: 'controller' as const,
+  buildManifest: buildPluginManagementManifest,
+  executeAction: executePluginManagementAction,
+  affectedPluginIdsAfterAction,
+};

package/src/runtime/plugins/store.ts

@@ -2,7 +2,7 @@ import { createHash } from 'crypto';
 import { join } from 'path';
 import type { RepositoryRecord } from '../../cli/repositories/types';
 import { CONTROLLER_SCOPE_REPO_ID, controllerSystemRoot, ensureControllerHome, repositoryControllerRoot } from '../../cli/repositories/controller-home';
-import { existsSync, mkdirSync, readdirSync} from 'fs';
+import { existsSync, mkdirSync, readdirSync, rmSync } from 'fs';
 import type { ExecutionJob, ResourceClaimSpec } from '../execution/jobs/types';
 import { appendRuntimeEvent } from '../evidence/event-ledger';
 import { readJsonFile, sanitizeFileComponent, writeJsonAtomic } from '../shared/json-files';
@@ -18,7 +18,7 @@ import {
   recordWorkCompletionReceipt,
   updateWorkContract,
 } from '../control-plane/facade/work-contract-store';
-import type { LocalEffectCompletionReceipt, WorkRisk } from '../control-plane/facade/types';
+import { isTerminalWorkContractStatus, type LocalEffectCompletionReceipt, type RemoteEffectCompletionReceipt, type WorkContract, type WorkRisk } from '../control-plane/facade/types';
 import type {
   AssistantPluginAdapter,
   AssistantPluginActionDescriptor,
@@ -671,6 +671,74 @@ function localEffectTarget(
   };
 }
 
+function remoteEffectWorkForPluginAction(
+  controllerHome: string,
+  repository: RepositoryRecord,
+  action: AssistantPluginActionDescriptor,
+  request: AssistantPluginActionRequest,
+  receiptId?: string,
+): WorkContract | undefined {
+  const workId = request.workId?.trim();
+  if (!workId) return undefined;
+  if (action.risk !== 'remote_write') {
+    throw new Error(`WORK_PLUGIN_RECEIPT_BINDING_REQUIRES_REMOTE_WRITE: ${action.actionId}`);
+  }
+  const work = getWorkContract({ controllerHome, repoId: repository.repoId }, workId);
+  if (!work) throw new Error(`WORK_PLUGIN_RECEIPT_BINDING_NOT_FOUND: ${workId}`);
+  if (work.workKind !== 'remote_effect') {
+    throw new Error(`WORK_PLUGIN_RECEIPT_BINDING_KIND_MISMATCH: ${workId} is ${work.workKind}, expected remote_effect`);
+  }
+  if (work.checks.length > 0) {
+    throw new Error(`WORK_PLUGIN_RECEIPT_BINDING_CHECKS_PRESENT: ${workId} declares repository checks and cannot be completed by a plugin receipt alone`);
+  }
+  if (isTerminalWorkContractStatus(work.status)) {
+    if (work.status === 'completed' && receiptId && work.completionReceipt?.receiptId === receiptId) return work;
+    throw new Error(`WORK_PLUGIN_RECEIPT_BINDING_TERMINAL: ${workId} is ${work.status}`);
+  }
+  return work;
+}
+
+function bindRemoteEffectReceiptToWork(
+  controllerHome: string,
+  repository: RepositoryRecord,
+  action: AssistantPluginActionDescriptor,
+  request: AssistantPluginActionRequest,
+  receipt: PluginActionReceipt,
+): WorkContract | undefined {
+  if (!request.workId) return undefined;
+  if (receipt.status !== 'succeeded') return remoteEffectWorkForPluginAction(controllerHome, repository, action, request);
+  const work = remoteEffectWorkForPluginAction(controllerHome, repository, action, request, receipt.receiptId);
+  if (!work) return undefined;
+  if (work.status === 'completed' && work.completionReceipt?.receiptId === receipt.receiptId) return work;
+  if (!work.evidenceRefs.some((evidence) => evidence.evidenceId === receipt.receiptId)) {
+    appendWorkEvidence({ controllerHome, repoId: repository.repoId }, work.workId, {
+      evidenceId: receipt.receiptId,
+      title: 'typed remote plugin effect completed',
+      summary: `${receipt.pluginId}/${receipt.actionId} completed with durable receipt ${receipt.receiptId}.`,
+      detailLevel: 'summary',
+    });
+  }
+  const remoteReceipt: RemoteEffectCompletionReceipt = {
+    schemaVersion: 1,
+    receiptId: receipt.receiptId,
+    source: 'remote_effect',
+    workId: work.workId,
+    pluginId: receipt.pluginId,
+    actionId: receipt.actionId,
+    requestId: receipt.requestId,
+    semanticKey: receipt.semanticKey,
+    resultDigest: createHash('sha256').update(JSON.stringify(receipt.result ?? null)).digest('hex'),
+    recordedAt: new Date().toISOString(),
+  };
+  return recordWorkCompletionReceipt(
+    { controllerHome, repoId: repository.repoId },
+    work.workId,
+    remoteReceipt,
+    'completed_remote',
+    'remote_effect',
+  );
+}
+
 function compatibilityJobFromReceipt(receipt: PluginActionReceipt, checkoutId: string): ExecutionJob {
   return {
     schemaVersion: 1,
@@ -741,6 +809,10 @@ export async function submitAssistantPluginAction(
     if (!existing) {
       throw new Error(`PLUGIN_RECEIPT_LOST: ${request.requestId}`);
     }
+    if (request.workId && existing.workId !== request.workId) {
+      throw new Error(`WORK_PLUGIN_RECEIPT_BINDING_CONFLICT: ${request.requestId} already belongs to Work ${existing.workId ?? 'none'}`);
+    }
+    if (request.workId) bindRemoteEffectReceiptToWork(controllerHome, repository, action, request, existing);
     return {
       manifest,
       action,
@@ -754,6 +826,7 @@ export async function submitAssistantPluginAction(
 
   const createdAt = new Date().toISOString();
   const receiptId = `PLG-${Date.now()}-${createHash('sha256').update(request.requestId).digest('hex').slice(0, 8)}`;
+  const boundRemoteWork = remoteEffectWorkForPluginAction(controllerHome, repository, action, request);
   const requiresLocalEffectWork = localSystemActionRequiresWork(
     repository,
     request.pluginId,
@@ -833,6 +906,17 @@ export async function submitAssistantPluginAction(
         : undefined,
     });
     let resultWithLineage = result;
+    if (boundRemoteWork) {
+      resultWithLineage = {
+        ...result,
+        work: {
+          workId: boundRemoteWork.workId,
+          workKind: 'remote_effect',
+          completionOutcome: 'completed_remote',
+          status: 'completed',
+        },
+      };
+    }
     if (acceptedWork) {
       const recordedAt = new Date().toISOString();
       const target = localEffectTarget(normalizedArgs, result);
@@ -877,7 +961,7 @@ export async function submitAssistantPluginAction(
       semanticKey: key,
       status: 'succeeded',
       createdAt,
-      ...(acceptedWork ? { workId: acceptedWork.workId } : {}),
+      ...(acceptedWork ? { workId: acceptedWork.workId } : boundRemoteWork ? { workId: boundRemoteWork.workId } : {}),
       origin: request.origin,
       result: resultWithLineage,
     };
@@ -889,6 +973,7 @@ export async function submitAssistantPluginAction(
       semanticKey: key,
       createdAt,
     } satisfies PluginActionRequestIndex);
+    if (boundRemoteWork) bindRemoteEffectReceiptToWork(controllerHome, repository, action, request, receipt);
     const nextManifest = getAssistantPluginManifest(controllerHome, repository, request.pluginId);
     return {
       manifest: nextManifest,
@@ -897,11 +982,18 @@ export async function submitAssistantPluginAction(
       deduplicated: false,
       result: resultWithLineage,
       receipt,
-      workId: acceptedWork?.workId,
+      workId: acceptedWork?.workId ?? boundRemoteWork?.workId,
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'PLUGIN_ACTION_FAILED';
+    if (boundRemoteWork) {
+      appendWorkEvidence({ controllerHome, repoId: repository.repoId }, boundRemoteWork.workId, {
+        title: 'typed remote plugin effect failed',
+        summary: `${request.pluginId}/${request.actionId}: ${message}`.slice(0, 1_000),
+        detailLevel: 'summary',
+      });
+    }
     if (acceptedWork) {
       const current = getWorkContract({ controllerHome, repoId: repository.repoId }, acceptedWork.workId);
       updateWorkContract({ controllerHome, repoId: repository.repoId }, acceptedWork.workId, {
@@ -926,7 +1018,7 @@ export async function submitAssistantPluginAction(
       semanticKey: key,
       status: 'failed',
       createdAt,
-      ...(acceptedWork ? { workId: acceptedWork.workId } : {}),
+      ...(acceptedWork ? { workId: acceptedWork.workId } : boundRemoteWork ? { workId: boundRemoteWork.workId } : {}),
       origin: request.origin,
       error: { code, message },
     };
@@ -963,6 +1055,16 @@ export async function executeAssistantPluginAction(
       args: normalizedArgs,
       providerIdentityPrevalidated: manifestLookup.providerIdentityPrevalidated,
     });
+    for (const affectedPluginId of adapter.affectedPluginIdsAfterAction?.(input.actionId, result) ?? []) {
+      if (!affectedPluginId || affectedPluginId === input.pluginId) continue;
+      invalidateAssistantPluginManifestCache(input.controllerHome, repository.repoId, affectedPluginId);
+      const affectedAdapter = resolvePluginAdapter(input.controllerHome, affectedPluginId);
+      if (affectedAdapter && adapterMatchesRepository(affectedAdapter, repository)) {
+        syncAssistantPluginManifest(input.controllerHome, repository, affectedPluginId);
+      } else {
+        rmSync(manifestPath(input.controllerHome, repository.repoId, affectedPluginId), { force: true });
+      }
+    }
     const refreshManifest = adapter.shouldRefreshManifestAfterAction?.(input.actionId) ?? true;
     const nextManifest = refreshManifest
       ? syncAssistantPluginManifest(input.controllerHome, repository, input.pluginId).manifest

package/src/runtime/plugins/types.ts

@@ -100,6 +100,8 @@ export interface AssistantPluginActionRequest {
   pluginId: string;
   actionId: string;
   requestId: string;
+  /** Optional existing external-effect Work that owns this typed action receipt. */
+  workId?: string;
   args: Record<string, unknown>;
   timeoutMs?: number;
   signal?: AbortSignal;
@@ -135,4 +137,6 @@ export interface AssistantPluginAdapter {
   executeAction(input: AssistantPluginActionExecutionInput): Promise<Record<string, unknown>>;
   /** Defaults to true. External providers can defer routine health refresh until the normal manifest cache expires. */
   shouldRefreshManifestAfterAction?(actionId: string): boolean;
+  /** Other plugin manifests whose canonical authority changed as a side effect of this action. */
+  affectedPluginIdsAfterAction?(actionId: string, result: Record<string, unknown>): string[];
 }

package/src/runtime/recovery/actions.ts

@@ -131,16 +131,6 @@ export const RECOVERY_ACTIONS = {
     localOnly: true,
     boundedTo: ['google_workspace_auth_handoff'],
   },
-  browserDomainAccessPreview: {
-    id: 'recovery.browser_domain_access_preview',
-    title: 'Preview browser domain grant',
-    description: 'Preview a domain-key browser grant instead of retrying arbitrary URLs.',
-    class: 'browser_domain_grant_required',
-    risk: 'readonly',
-    confirmation: 'none',
-    localOnly: true,
-    boundedTo: ['browser_allowed_domains'],
-  },
   externalFilesystemGrantPreview: {
     id: 'recovery.external_filesystem_grant_preview',
     title: 'Preview external filesystem grant',

package/src/runtime/recovery/classifier.ts

@@ -52,13 +52,6 @@ const LOCAL_JOBS_LEGACY_ACTIVE_PATTERNS = [
   /local jobs?.*finish before runtime storage/i,
 ];
 
-const BROWSER_GRANT_PATTERNS = [
-  /web_target_not_allowed/i,
-  /browser.*domain.*not allowed/i,
-  /allowed_domains/i,
-  /domain access.*required/i,
-  /browser domain grant/i,
-];
 
 const EXTERNAL_FILESYSTEM_GRANT_PATTERNS = [
   /external filesystem/i,
@@ -125,7 +118,6 @@ export function classifyFailure(message: string | undefined): RecoveryClass {
   if (LOCAL_JOBS_UNREADABLE_PATTERNS.some((pattern) => pattern.test(text))) return 'local_jobs_unreadable';
   if (RUNTIME_STORAGE_PATTERNS.some((pattern) => pattern.test(text))) return 'runtime_storage_not_ready';
   if (AUTH_PATTERNS.some((pattern) => pattern.test(text))) return 'auth_required';
-  if (BROWSER_GRANT_PATTERNS.some((pattern) => pattern.test(text))) return 'browser_domain_grant_required';
   if (EXTERNAL_FILESYSTEM_GRANT_PATTERNS.some((pattern) => pattern.test(text))) return 'external_filesystem_grant_required';
   if (DIRTY_WORKTREE_CONFLICT_PATTERNS.some((pattern) => pattern.test(text))) return 'dirty_worktree_conflict';
   if (USER_ACTION_PATTERNS.some((pattern) => pattern.test(text))) return 'user_action_required';
@@ -144,7 +136,6 @@ export function dominantRecoveryClass(classes: readonly RecoveryClass[]): Recove
     'local_jobs_legacy_active',
     'local_jobs_unreadable',
     'runtime_storage_not_ready',
-    'browser_domain_grant_required',
     'external_filesystem_grant_required',
     'local_jobs_reconciliation_required',
     'maintenance_executor_required',

package/src/runtime/recovery/maintenance-executor.ts

@@ -6,7 +6,11 @@ import { ensureRepositoryRuntimeStorage, type RepositoryRuntimeStorageReport } f
 import type { RepositoryRecord } from '../../cli/repositories/types';
 import { rebuildRepositoryProjection } from '../projections/materialized-view';
 import { getWorkContract, readWorkContractStore, transitionWorkContractPhase } from '../control-plane/facade/work-contract-store';
-import { isTerminalWorkContractStatus } from '../control-plane/facade/types';
+import { getControllerSession } from '../control-plane/facade/controller-session-store';
+import { listPlanContracts } from '../control-plane/facade/plan-contract-store';
+import { readRequirement } from '../control-plane/persistence/requirement-store';
+import { isTerminalWorkContractStatus, type WorkContract } from '../control-plane/facade/types';
+import { listSchedules } from '../workflow/schedules/store';
 import {
   collectRuntimeProcesses,
   removeRuntimeTempEntry,
@@ -397,6 +401,29 @@ function normalizedOptions(options: RuntimeMaintenanceOptions = {}): Required<Ru
   };
 }
 
+function activeWorkAuthorityRefs(
+  repository: RuntimeMaintenanceRepository,
+  controllerHome: string,
+  contract: WorkContract,
+): string[] {
+  const refs: string[] = [];
+  if (getControllerSession({ controllerHome, repoId: repository.repoId }, contract.workId)) refs.push('controller_session');
+  const activePlans = listPlanContracts({ controllerHome, repoId: repository.repoId, status: 'active', limit: 100 });
+  const plan = activePlans.find((candidate) => candidate.planId === contract.planId || candidate.steps.some((step) => step.workId === contract.workId));
+  if (plan) refs.push(`plan:${plan.planId}`);
+  if (contract.requirementId) {
+    const requirement = readRequirement({ controllerHome }, contract.requirementId)?.value;
+    if (requirement && !['done', 'cancelled'].includes(requirement.state)) refs.push(`requirement:${requirement.requirementId}:${requirement.state}`);
+  }
+  const boundSchedule = listSchedules(controllerHome, repository.repoId).find((schedule) => {
+    if (!schedule.enabled) return false;
+    const args = schedule.action.arguments as Record<string, unknown> | undefined;
+    return args?.work_id === contract.workId;
+  });
+  if (boundSchedule) refs.push(`schedule:${boundSchedule.scheduleId}`);
+  return refs;
+}
+
 function scanStaleWorkContractCandidates(
   repository: RuntimeMaintenanceRepository,
   controllerHome: string,
@@ -413,16 +440,21 @@ function scanStaleWorkContractCandidates(
     .filter(({ ageMinutes }) => ageMinutes >= options.minAgeMinutes)
     .sort((left, right) => right.ageMinutes - left.ageMinutes)
     .slice(0, options.maxCandidates)
-    .map(({ contract, ageMinutes }) => ({
-      kind: 'stale_work_contract' as const,
-      id: contract.workId,
-      status: contract.status,
-      safe: true,
-      reason: 'Nonterminal WorkContract exceeded the explicit maintenance age threshold; cancellation preserves durable evidence and does not delete source or remote state.',
-      ageMinutes,
-      suggestedAction: 'full_maintenance_pass' as const,
-      ownershipStatus: 'explicit' as const,
-    }));
+    .map(({ contract, ageMinutes }) => {
+      const authorityRefs = activeWorkAuthorityRefs(repository, controllerHome, contract);
+      return {
+        kind: 'stale_work_contract' as const,
+        id: contract.workId,
+        status: contract.status,
+        safe: authorityRefs.length === 0,
+        reason: authorityRefs.length > 0
+          ? `Nonterminal WorkContract is old but still has active lifecycle authority (${authorityRefs.join(', ')}); maintenance must not cancel it from age alone.`
+          : 'Nonterminal WorkContract exceeded the explicit maintenance age threshold and has no active Plan, Requirement, Schedule, or Controller authority; explicit full maintenance may cancel it while retaining evidence.',
+        ageMinutes,
+        suggestedAction: 'full_maintenance_pass' as const,
+        ownershipStatus: 'explicit' as const,
+      };
+    });
 }
 
 function scanStaleEditSessionCandidates(

package/src/runtime/recovery/probe.ts

@@ -61,7 +61,6 @@ function failingJobClass(input: CapabilityRecoveryInput): RecoveryClass {
 function suggestedActionsForClass(recoveryClass: RecoveryClass): RecoveryActionDescriptor[] {
   if (recoveryClass === 'platform_blocked' || recoveryClass === 'dirty_worktree_conflict') return [RECOVERY_ACTIONS.createPatchHandoff];
   if (recoveryClass === 'auth_required') return [RECOVERY_ACTIONS.workspaceAuthLoginPrepare];
-  if (recoveryClass === 'browser_domain_grant_required') return [RECOVERY_ACTIONS.browserDomainAccessPreview];
   if (recoveryClass === 'external_filesystem_grant_required') return [RECOVERY_ACTIONS.externalFilesystemGrantPreview];
   if (recoveryClass === 'agent_runtime_failure') return [RECOVERY_ACTIONS.reconcileJobs];
   if (recoveryClass === 'source_defect_suspected' || recoveryClass === 'external_lifecycle_required') return [];

package/src/runtime/recovery/types.ts

@@ -9,7 +9,6 @@ export type RecoveryClass =
   | 'stale_runtime_state'
   | 'external_lifecycle_required'
   | 'runtime_storage_not_ready'
-  | 'browser_domain_grant_required'
   | 'external_filesystem_grant_required'
   | 'local_jobs_legacy_active'
   | 'local_jobs_unreadable'