@moretea-labs/forge 1.5.0-rc.1 → 1.5.1

package/src/runtime/control-plane/execution/work-validation-reconciler.ts

@@ -0,0 +1,277 @@
+import {
+  getWorkContract,
+  transitionWorkContractPhase,
+  updateWorkContract,
+} from '../facade/work-contract-store';
+import {
+  listValidatingWorkHandles,
+  transitionWorkHandle,
+  type WorkHandleState,
+} from './work-handle-store';
+import { processCheckCompletionReceipt } from '../../execution/process-runtime/check-receipt';
+import { processCheckSemanticScopeKey } from '../../execution/process-runtime/check-facade';
+import { getProcessRecord } from '../../execution/process-runtime/store';
+import { controllerCheckExecutionIdentity } from '../../../cli/controller/check-runner';
+
+export type WorkValidationOutcome =
+  | 'not_validating'
+  | 'running'
+  | 'passed'
+  | 'failed'
+  | 'infrastructure_failure';
+
+export interface WorkValidationReconciliation {
+  handle: WorkHandleState;
+  changed: boolean;
+  outcome: WorkValidationOutcome;
+  summary?: string;
+}
+
+export function hasCurrentWorkValidationAuthority(input: {
+  finalizationValidation: WorkHandleState['finalization']['validation'];
+  validatedInputFingerprint?: string;
+  evidenceState: string;
+  expectedFingerprint: string;
+}): boolean {
+  return input.finalizationValidation === 'done'
+    && input.evidenceState === 'valid'
+    && input.validatedInputFingerprint === input.expectedFingerprint;
+}
+
+/**
+ * A new validation run invalidates delivery authority without deleting or
+ * rewriting the prior receipts. `stale` is the only valid transition from an
+ * already-valid evidence set; all other retryable states converge through
+ * `partial`.
+ */
+export function markWorkValidationPending(controllerHome: string, handle: WorkHandleState): void {
+  const contractId = handle.workContractId;
+  if (!contractId) return;
+  const options = { controllerHome, repoId: handle.repositoryId };
+  const contract = getWorkContract(options, contractId);
+  if (!contract || contract.completionReceipt) return;
+  const evidenceState = contract.evidenceState === 'valid' || contract.evidenceState === 'stale'
+    ? 'stale'
+    : 'partial';
+  if (contract.evidenceState !== evidenceState) updateWorkContract(options, contractId, { evidenceState });
+}
+
+/**
+ * Project durable validation evidence into the Work-owned contract lifecycle.
+ * Process and Check records contribute evidence only; they never become a
+ * second completion or lifecycle authority.
+ */
+export function projectWorkValidationOutcome(
+  controllerHome: string,
+  handle: WorkHandleState,
+  outcome: Exclude<WorkValidationOutcome, 'not_validating' | 'running'>,
+  summary?: string,
+): void {
+  const contractId = handle.workContractId;
+  if (!contractId) return;
+  const options = { controllerHome, repoId: handle.repositoryId };
+  const contract = getWorkContract(options, contractId);
+  if (!contract || contract.completionReceipt) return;
+
+  if (outcome === 'passed') {
+    transitionWorkContractPhase(options, contractId, {
+      phase: 'delivery',
+      status: 'running',
+      state: 'active',
+      summary: summary ?? 'All requested validation receipts passed; delivery is next.',
+      evidenceRefs: contract.evidenceRefs,
+    });
+    updateWorkContract(options, contractId, { evidenceState: 'valid' });
+    return;
+  }
+
+  if (outcome === 'failed') {
+    transitionWorkContractPhase(options, contractId, {
+      phase: 'cleanup',
+      status: 'failed',
+      state: 'failed',
+      summary: summary ?? 'A requested validation check failed; terminal cleanup is next.',
+      evidenceRefs: contract.evidenceRefs,
+    });
+    updateWorkContract(options, contractId, { evidenceState: 'failed' });
+    return;
+  }
+
+  transitionWorkContractPhase(options, contractId, {
+    phase: 'cleanup',
+    status: 'failed',
+    state: 'failed',
+    summary: summary ?? 'Validation infrastructure failed; terminal cleanup is required without treating this as an acceptance failure.',
+    evidenceRefs: contract.evidenceRefs,
+  });
+  updateWorkContract(options, contractId, {
+    evidenceState: contract.evidenceState === 'valid' || contract.evidenceState === 'stale' ? 'stale' : 'partial',
+  });
+}
+
+function settleInfrastructureFailure(
+  controllerHome: string,
+  handle: WorkHandleState,
+  summary: string,
+): WorkValidationReconciliation {
+  const next = transitionWorkHandle(controllerHome, handle, 'failed', {
+    finalization: { ...handle.finalization, validation: 'failed', lastError: summary },
+    validationRun: undefined,
+    failureReason: summary,
+  });
+  projectWorkValidationOutcome(controllerHome, next, 'infrastructure_failure', summary);
+  return { handle: next, changed: true, outcome: 'infrastructure_failure', summary };
+}
+
+/**
+ * Converge a persisted Work validation run from durable Process receipts.
+ *
+ * No command is launched here. Missing/running bindings stay pending; timeout,
+ * cancellation, missing process state, or malformed receipt makes the Work
+ * terminally failed for cleanup without classifying it as an acceptance failure.
+ */
+export function reconcileWorkValidation(
+  controllerHome: string,
+  handle: WorkHandleState,
+): WorkValidationReconciliation {
+  const run = handle.validationRun;
+  if (handle.state !== 'validating' || !run) {
+    return { handle, changed: false, outcome: 'not_validating' };
+  }
+
+  if (run.requestedChecks.length === 0) {
+    const next = transitionWorkHandle(controllerHome, handle, run.resumeState, {
+      finalization: { ...handle.finalization, validation: 'done', lastError: undefined },
+      validationRun: undefined,
+      validatedInputFingerprint: run.fingerprint,
+      failureReason: undefined,
+    });
+    projectWorkValidationOutcome(controllerHome, next, 'passed', 'No validation checks were required.');
+    return { handle: next, changed: true, outcome: 'passed' };
+  }
+
+  for (const checkId of run.requestedChecks) {
+    const binding = run.processes[checkId];
+    if (!binding) return { handle, changed: false, outcome: 'running' };
+    const record = getProcessRecord(controllerHome, handle.repositoryId, binding.processId);
+    if (!record) {
+      return settleInfrastructureFailure(
+        controllerHome,
+        handle,
+        `Validation process record is unavailable: ${binding.processId}`,
+      );
+    }
+    if (record.status === 'running' || record.status === 'starting' || record.status === 'running_recovered') {
+      return { handle, changed: false, outcome: 'running' };
+    }
+
+    try {
+      const currentIdentity = record.checkExecution
+        ? controllerCheckExecutionIdentity(handle.worktreePath, checkId, record.checkExecution.timeoutMs)
+        : undefined;
+      const receipt = processCheckCompletionReceipt(record, {
+        repoId: handle.repositoryId,
+        checkoutId: handle.checkoutId,
+        workId: handle.workId,
+        executionSessionId: handle.sessionId,
+        checkId,
+        processId: binding.processId,
+        ...(currentIdentity ? {
+          checkExecution: {
+            cacheKey: currentIdentity.cacheKey,
+            revision: currentIdentity.revision,
+            definitionDigest: currentIdentity.definitionDigest,
+            environmentFingerprint: currentIdentity.environmentFingerprint,
+            timeoutMs: currentIdentity.timeoutMs,
+            scopeKey: processCheckSemanticScopeKey({
+              checkoutId: handle.checkoutId,
+              workId: handle.workId,
+              verificationBinding: { executionSessionId: handle.sessionId },
+            }, currentIdentity.reuseScope),
+          },
+        } : {}),
+      });
+      if (!receipt.ok) {
+        if (receipt.status === 'timed_out' || receipt.status === 'cancelled') {
+          return settleInfrastructureFailure(controllerHome, handle, receipt.summary);
+        }
+        const next = transitionWorkHandle(controllerHome, handle, 'failed', {
+          finalization: { ...handle.finalization, validation: 'failed', lastError: receipt.summary },
+          validationRun: undefined,
+          failureReason: receipt.summary,
+        });
+        projectWorkValidationOutcome(controllerHome, next, 'failed', receipt.summary);
+        return { handle: next, changed: true, outcome: 'failed', summary: receipt.summary };
+      }
+    } catch (error) {
+      const summary = error instanceof Error ? error.message : String(error);
+      return settleInfrastructureFailure(controllerHome, handle, summary);
+    }
+  }
+
+  const next = transitionWorkHandle(controllerHome, handle, run.resumeState, {
+    finalization: { ...handle.finalization, validation: 'done', lastError: undefined },
+    validationRun: undefined,
+    validatedInputFingerprint: run.fingerprint,
+    failureReason: undefined,
+  });
+  projectWorkValidationOutcome(controllerHome, next, 'passed', 'All requested validation receipts passed.');
+  return { handle: next, changed: true, outcome: 'passed' };
+}
+
+export interface PendingWorkValidationReconciliationSummary {
+  repositoryId: string;
+  examined: number;
+  validating: number;
+  changed: number;
+  running: number;
+  passed: number;
+  failed: number;
+  infrastructureFailure: number;
+  errors: Array<{ workId: string; error: string }>;
+  truncated: boolean;
+}
+
+/**
+ * Scheduler-safe convergence for validation Processes that were already
+ * launched by a Work. This function never launches commands and never waits
+ * for a Process. It only projects terminal receipts into Work state, allowing
+ * long checks to finish without ChatGPT polling.
+ */
+export function reconcilePendingWorkValidations(
+  controllerHome: string,
+  repositoryId: string,
+  limit = 500,
+): PendingWorkValidationReconciliationSummary {
+  const boundedLimit = Math.max(1, Math.min(Math.trunc(limit), 5_000));
+  const validating = listValidatingWorkHandles(controllerHome, repositoryId, boundedLimit);
+  const handles = validating;
+  const summary: PendingWorkValidationReconciliationSummary = {
+    repositoryId,
+    examined: handles.length,
+    validating: validating.length,
+    changed: 0,
+    running: 0,
+    passed: 0,
+    failed: 0,
+    infrastructureFailure: 0,
+    errors: [],
+    truncated: handles.length >= boundedLimit,
+  };
+  for (const handle of validating) {
+    try {
+      const reconciled = reconcileWorkValidation(controllerHome, handle);
+      if (reconciled.changed) summary.changed += 1;
+      if (reconciled.outcome === 'running') summary.running += 1;
+      else if (reconciled.outcome === 'passed') summary.passed += 1;
+      else if (reconciled.outcome === 'failed') summary.failed += 1;
+      else if (reconciled.outcome === 'infrastructure_failure') summary.infrastructureFailure += 1;
+    } catch (error) {
+      summary.errors.push({
+        workId: handle.workId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return summary;
+}

package/src/runtime/control-plane/execution/work-verification-snapshot.ts

@@ -0,0 +1,169 @@
+import { createHash } from 'crypto';
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+} from 'fs';
+import { dirname, join, resolve } from 'path';
+import { spawnSync } from 'child_process';
+import { repositoryControllerRoot } from '../../../cli/repositories/controller-home';
+import { globMatches, normalizeMcpRelativePath } from '../../../cli/mcp/paths';
+import { sanitizeFileComponent } from '../../shared/json-files';
+
+const STALE_SNAPSHOT_MS = 6 * 60 * 60_000;
+const SNAPSHOT_MARKER = '.forge-work-verification-snapshot.json';
+
+export interface WorkVerificationSnapshotScope {
+  workId: string;
+  allowedPaths: readonly string[];
+  forbiddenPaths: readonly string[];
+}
+
+export interface WorkVerificationSnapshot {
+  root: string;
+  sourceHead: string;
+  includedPaths: string[];
+  excludedPaths: string[];
+  ownershipDigest: string;
+}
+
+function git(root: string, args: string[], maxBytes = 2 * 1024 * 1024): Buffer {
+  const result = spawnSync('git', ['-C', root, ...args], {
+    encoding: 'buffer',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 120_000,
+    maxBuffer: maxBytes,
+  });
+  if (result.status !== 0 || result.error) {
+    const stderr = Buffer.isBuffer(result.stderr) ? result.stderr.toString('utf8') : String(result.stderr ?? '');
+    throw new Error(`WORK_VERIFICATION_SNAPSHOT_GIT_FAILED: git ${args.join(' ')}: ${stderr || result.error?.message || `exit ${result.status}`}`);
+  }
+  return Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout ?? '');
+}
+
+function nulPaths(value: Buffer): string[] {
+  return value.toString('utf8').split('\0').filter(Boolean).map((raw) => {
+    const normalized = normalizeMcpRelativePath(raw);
+    if (!normalized.ok || !normalized.relativePath) {
+      throw new Error(`WORK_VERIFICATION_SNAPSHOT_PATH_INVALID: ${raw}`);
+    }
+    return normalized.relativePath;
+  });
+}
+
+function matchesAny(patterns: readonly string[], path: string): boolean {
+  return patterns.some((pattern) => globMatches(pattern, path));
+}
+
+function snapshotRoot(controllerHome: string, repoId: string, workId: string): string {
+  const root = join(repositoryControllerRoot(controllerHome, repoId), 'verification-snapshots');
+  mkdirSync(root, { recursive: true });
+  const now = Date.now();
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith('snapshot-')) continue;
+    const path = join(root, entry.name);
+    try {
+      if (now - statSync(path).mtimeMs > STALE_SNAPSHOT_MS) rmSync(path, { recursive: true, force: true });
+    } catch {
+      // Best-effort stale cleanup; a fresh snapshot must not fail because an old
+      // directory disappeared concurrently.
+    }
+  }
+  return mkdtempSync(join(root, `snapshot-${sanitizeFileComponent(workId).slice(0, 48)}-`));
+}
+
+function cloneHead(sourceRoot: string, targetRoot: string, head: string): void {
+  const clone = spawnSync('git', ['clone', '--shared', '--no-checkout', '--quiet', '--', sourceRoot, targetRoot], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 120_000,
+  });
+  if (clone.status !== 0 || clone.error) {
+    throw new Error(`WORK_VERIFICATION_SNAPSHOT_CLONE_FAILED: ${clone.stderr || clone.error?.message || `exit ${clone.status}`}`);
+  }
+  git(targetRoot, ['checkout', '--detach', '--quiet', head]);
+}
+
+function overlayPath(sourceRoot: string, targetRoot: string, relativePath: string): void {
+  const source = resolve(sourceRoot, relativePath);
+  const target = resolve(targetRoot, relativePath);
+  rmSync(target, { recursive: true, force: true });
+  if (!existsSync(source)) return;
+  mkdirSync(dirname(target), { recursive: true });
+  const stat = lstatSync(source);
+  if (stat.isSymbolicLink()) {
+    cpSync(source, target, { recursive: false, dereference: false, force: true });
+    return;
+  }
+  cpSync(source, target, { recursive: stat.isDirectory(), dereference: false, force: true, preserveTimestamps: true });
+}
+
+function linkIgnoredNodeModules(sourceRoot: string, targetRoot: string): void {
+  const source = join(sourceRoot, 'node_modules');
+  const target = join(targetRoot, 'node_modules');
+  if (!existsSync(source) || existsSync(target)) return;
+  const ignored = spawnSync('git', ['-C', sourceRoot, 'check-ignore', '--quiet', '--', 'node_modules'], { stdio: 'ignore', timeout: 10_000 });
+  if (ignored.status !== 0) return;
+  try {
+    symlinkSync(source, target, process.platform === 'win32' ? 'junction' : 'dir');
+  } catch {
+    // Dependency linking is an optimization. If it is unavailable the check may
+    // still succeed using its own toolchain resolution; never copy a huge cache.
+  }
+}
+
+export function materializeWorkVerificationSnapshot(input: {
+  controllerHome: string;
+  repoId: string;
+  sourceRoot: string;
+  scope: WorkVerificationSnapshotScope;
+}): WorkVerificationSnapshot {
+  const sourceHead = git(input.sourceRoot, ['rev-parse', '--verify', 'HEAD']).toString('utf8').trim();
+  const tracked = nulPaths(git(input.sourceRoot, ['diff', '--name-only', '-z', 'HEAD', '--']));
+  const untracked = nulPaths(git(input.sourceRoot, ['ls-files', '--others', '--exclude-standard', '-z']));
+  const dirtyPaths = [...new Set([...tracked, ...untracked])].sort();
+  const includedPaths: string[] = [];
+  const excludedPaths: string[] = [];
+  for (const path of dirtyPaths) {
+    if (matchesAny(input.scope.forbiddenPaths, path)) {
+      excludedPaths.push(path);
+      continue;
+    }
+    if (input.scope.allowedPaths.length > 0 && matchesAny(input.scope.allowedPaths, path)) {
+      includedPaths.push(path);
+      continue;
+    }
+    throw new Error(`WORK_VERIFICATION_PATH_OWNERSHIP_AMBIGUOUS: ${path} is dirty but is neither allowed nor forbidden for ${input.scope.workId}`);
+  }
+
+  const root = snapshotRoot(input.controllerHome, input.repoId, input.scope.workId);
+  try {
+    cloneHead(input.sourceRoot, root, sourceHead);
+    for (const path of includedPaths) overlayPath(input.sourceRoot, root, path);
+    linkIgnoredNodeModules(input.sourceRoot, root);
+    const ownershipDigest = createHash('sha256').update(JSON.stringify({
+      sourceHead,
+      workId: input.scope.workId,
+      includedPaths,
+      excludedPaths,
+      allowedPaths: [...input.scope.allowedPaths].sort(),
+      forbiddenPaths: [...input.scope.forbiddenPaths].sort(),
+    })).digest('hex');
+    writeFileSync(join(root, SNAPSHOT_MARKER), `${JSON.stringify({ schemaVersion: 1, ...input.scope, sourceHead, includedPaths, excludedPaths, ownershipDigest }, null, 2)}\n`);
+    return { root, sourceHead, includedPaths, excludedPaths, ownershipDigest };
+  } catch (error) {
+    rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export function cleanupWorkVerificationSnapshot(snapshotRoot: string): void {
+  rmSync(snapshotRoot, { recursive: true, force: true });
+}

package/src/runtime/control-plane/facade/capability-registry.ts

@@ -142,16 +142,6 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     schemaExposure: 'stable_static',
     summary: 'Plan, dispatch, review, verify, retry, and accept durable Issue and Task work through existing typed handlers.',
   },
-  {
-    capabilityId: 'workflow.campaign',
-    domain: 'controller',
-    group: 'campaign',
-    operationClass: 'execute',
-    risk: 'workspace_write',
-    exposedVia: 'rh_work',
-    schemaExposure: 'stable_static',
-    summary: 'Coordinate multi-step campaign DAGs and review checkpoints while keeping integration and final acceptance explicit.',
-  },
   {
     capabilityId: 'plugin.browser',
     domain: 'plugin',

package/src/runtime/control-plane/facade/handoff-inbox-store.ts

@@ -1,6 +1,7 @@
 import { mkdirSync } from 'fs';
 import { join } from 'path';
 import { repositoryControllerRoot } from '../../../cli/repositories/controller-home';
+import { withControllerLock } from '../../../cli/repositories/locks';
 import { readJsonFile, sanitizeFileComponent, writeJsonAtomic } from '../../shared/json-files';
 import {
   type HandoffCreationReason,
@@ -65,6 +66,20 @@ function nowIso(options: HandoffInboxStoreOptions): string {
   return options.now?.() ?? new Date().toISOString();
 }
 
+function withHandoffInboxWriteLock<T>(
+  options: HandoffInboxStoreOptions,
+  owner: string,
+  operation: () => T,
+): T {
+  if (!options.controllerHome || !options.repoId || options.root) return operation();
+  return withControllerLock(
+    options.controllerHome,
+    { scope: 'task', repoId: options.repoId, taskId: 'handoff-inbox' },
+    owner,
+    operation,
+  );
+}
+
 export function handoffInboxRoot(location: HandoffInboxStoreLocation): string {
   if (location.root) {
     mkdirSync(location.root, { recursive: true });
@@ -117,17 +132,19 @@ export function createHandoffItem(options: HandoffInboxStoreOptions, input: Crea
     createdAt: at,
     updatedAt: input.updatedAt ?? at,
   };
-  const store = readHandoffInboxStore(options);
-  if (store.items.some((existing) => existing.id === item.id)) {
-    throw new Error(`handoff already exists: ${item.id}`);
-  }
-  const nextStore: HandoffInboxStore = {
-    schemaVersion: 1,
-    updatedAt: item.updatedAt,
-    items: [item, ...store.items],
-  };
-  writeHandoffInboxStore(options, nextStore);
-  return item;
+  return withHandoffInboxWriteLock(options, `create-handoff:${item.id}`, () => {
+    const store = readHandoffInboxStore(options);
+    if (store.items.some((existing) => existing.id === item.id)) {
+      throw new Error(`handoff already exists: ${item.id}`);
+    }
+    const nextStore: HandoffInboxStore = {
+      schemaVersion: 1,
+      updatedAt: item.updatedAt,
+      items: [item, ...store.items],
+    };
+    writeHandoffInboxStore(options, nextStore);
+    return item;
+  });
 }
 
 export function listHandoffItems(options: ListHandoffOptions): HandoffItem[] {
@@ -171,20 +188,22 @@ function setHandoffStatus(
   patch: Partial<Pick<HandoffItem, 'decision' | 'resolver'>> = {},
 ): HandoffItem {
   const sanitizedId = sanitizeFileComponent(id);
-  const store = readHandoffInboxStore(options);
-  const index = store.items.findIndex((item) => item.id === sanitizedId);
-  if (index < 0) throw new Error(`handoff not found: ${sanitizedId}`);
-  const at = nowIso(options);
-  const item: HandoffItem = {
-    ...store.items[index],
-    ...patch,
-    status,
-    updatedAt: at,
-  };
-  const items = [...store.items];
-  items[index] = item;
-  writeHandoffInboxStore(options, { schemaVersion: 1, updatedAt: at, items });
-  return item;
+  return withHandoffInboxWriteLock(options, `update-handoff:${sanitizedId}`, () => {
+    const store = readHandoffInboxStore(options);
+    const index = store.items.findIndex((item) => item.id === sanitizedId);
+    if (index < 0) throw new Error(`handoff not found: ${sanitizedId}`);
+    const at = nowIso(options);
+    const item: HandoffItem = {
+      ...store.items[index],
+      ...patch,
+      status,
+      updatedAt: at,
+    };
+    const items = [...store.items];
+    items[index] = item;
+    writeHandoffInboxStore(options, { schemaVersion: 1, updatedAt: at, items });
+    return item;
+  });
 }
 
 export function acknowledgeHandoffItem(options: HandoffInboxStoreOptions, id: string): HandoffItem {

package/src/runtime/control-plane/facade/suggested-actions.ts

@@ -12,8 +12,14 @@ function expectedActionRisk(action: SuggestedNextAction): SuggestedNextAction['r
     case 'controller_claim':
     case 'controller_release':
     case 'launcher_start':
+    case 'schedule_create':
+    case 'schedule_pause':
+    case 'schedule_resume':
+    case 'schedule_trigger':
       return 'workspace_write';
     case 'controller_get_owner':
+    case 'schedule_list':
+    case 'schedule_get':
       return 'readonly';
     case 'plan_create':
     case 'plan_get':
@@ -34,7 +40,7 @@ const ALLOWED_FACADE_OPERATIONS: Record<FacadeTool, readonly string[]> = {
   rh_status: ['list', 'get', 'repair'],
   rh_inbox: ['list', 'get', 'ack', 'accept', 'resolve', 'dismiss', 'create'],
   rh_context: ['list', 'get', 'search'],
-  rh_work: ['start', 'continue', 'verify', 'repair', 'finalize', 'stop', 'delegate', 'controller_claim', 'controller_release', 'controller_get_owner', 'launcher_start', 'plan_create', 'plan_get', 'plan_list', 'plan_approve', 'plan_supersede'],
+  rh_work: ['start', 'continue', 'verify', 'repair', 'finalize', 'stop', 'delegate', 'controller_claim', 'controller_release', 'controller_get_owner', 'launcher_start', 'plan_create', 'plan_get', 'plan_list', 'plan_approve', 'plan_supersede', 'schedule_create', 'schedule_list', 'schedule_get', 'schedule_pause', 'schedule_resume', 'schedule_trigger'],
 };
 
 export interface SuggestedActionValidationOptions {

package/src/runtime/control-plane/facade/types.ts

@@ -22,7 +22,6 @@ export const CAPABILITY_GROUPS = [
   'repository-core',
   'git',
   'issue-task',
-  'campaign',
   'browser',
   'ios',
   'plugin',