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

package/src/runtime/workflow/campaigns/cleanup.ts

@@ -1,263 +0,0 @@
-import { existsSync, realpathSync } from 'fs';
-import { resolve } from 'path';
-import { branchRef, validateBranchName } from '../../../cli/repositories/branch-name-policy';
-import { getRepository, setRepositoryCheckoutLifecycle } from '../../../cli/repositories/registry';
-import { runProcess } from '../../../effects/process-runner';
-import { cancelExecutionJob, findExecutionJob } from '../../execution/jobs/store';
-import type { Campaign, CampaignCleanupReport, CampaignCleanupResource } from './types';
-import { getCampaign, updateCampaign } from './store';
-
-type CleanupOptions = { targetBranch?: string };
-
-function now(): string { return new Date().toISOString(); }
-
-function git(root: string, args: string[]): { ok: boolean; stdout: string; stderr: string } {
-  const result = runProcess('git', ['-C', root, ...args], {
-    timeoutMs: 120_000,
-    maxOutputBytes: 256 * 1024,
-  });
-  return { ok: result.ok, stdout: result.stdout.trim(), stderr: result.stderr || result.error || '' };
-}
-
-function samePath(left: string, right: string): boolean {
-  try { return realpathSync(left) === realpathSync(right); }
-  catch { return resolve(left) === resolve(right); }
-}
-
-function cleanupManagedWorkspace(
-  controllerHome: string,
-  campaign: Campaign,
-  options?: CleanupOptions,
-): { resources: CampaignCleanupResource[]; leaks: string[] } {
-  const resources: CampaignCleanupResource[] = [];
-  const leaks: string[] = [];
-  const workspace = campaign.workspace;
-  if (!workspace.managed || workspace.mode !== 'isolated' || !workspace.root) return { resources, leaks };
-
-  const repository = getRepository(campaign.repoId, controllerHome);
-  const sourceRoot = repository.canonicalRoot;
-  const worktree = workspace.root;
-  const branch = workspace.branch ?? undefined;
-  let safeBranch: string | undefined;
-  if (branch) {
-    try {
-      safeBranch = validateBranchName(branch, { purpose: 'CAMPAIGN_WORKSPACE_BRANCH' });
-    } catch (error) {
-      const message = `Managed Campaign workspace has invalid branch metadata; preserved ${branch}.`;
-      resources.push({ kind: 'branch', id: branch, status: 'preserved', message });
-      leaks.push(message);
-      return { resources, leaks };
-    }
-  }
-  const baseRevision = workspace.baseRevision ?? undefined;
-
-  if (samePath(sourceRoot, worktree)) {
-    const message = 'Managed Campaign workspace resolved to the repository root; refusing cleanup.';
-    resources.push({ kind: 'worktree', id: worktree, status: 'preserved', message });
-    leaks.push(message);
-    return { resources, leaks };
-  }
-
-  if (existsSync(worktree)) {
-    const top = git(worktree, ['rev-parse', '--show-toplevel']);
-    const currentBranch = git(worktree, ['branch', '--show-current']);
-    const status = git(worktree, ['status', '--porcelain=v1', '--untracked-files=all']);
-    if (!top.ok || !samePath(top.stdout, worktree) || (safeBranch && currentBranch.stdout !== safeBranch)) {
-      const message = `Workspace ownership mismatch; preserved ${worktree}.`;
-      resources.push({ kind: 'worktree', id: worktree, status: 'preserved', message });
-      leaks.push(message);
-      return { resources, leaks };
-    }
-    if (!status.ok || status.stdout.trim()) {
-      const message = `Workspace contains unintegrated or unreadable changes; preserved ${worktree}.`;
-      resources.push({ kind: 'worktree', id: worktree, status: 'preserved', message });
-      leaks.push(message);
-      return { resources, leaks };
-    }
-    const removed = git(sourceRoot, ['worktree', 'remove', '--force', worktree]);
-    if (!removed.ok) {
-      const message = `Failed to remove managed worktree: ${removed.stderr}`;
-      resources.push({ kind: 'worktree', id: worktree, status: 'failed', message });
-      leaks.push(message);
-      return { resources, leaks };
-    }
-    resources.push({ kind: 'worktree', id: worktree, status: 'cleaned' });
-  } else {
-    resources.push({ kind: 'worktree', id: worktree, status: 'missing' });
-    git(sourceRoot, ['worktree', 'prune', '--expire', 'now']);
-  }
-
-  const checkoutId = workspace.checkoutId;
-  if (!checkoutId) {
-    const message = `Managed Campaign ${campaign.campaignId} workspace has no checkout identity.`;
-    resources.push({ kind: 'checkout', id: worktree, status: 'failed', message });
-    leaks.push(message);
-  } else {
-    try {
-      setRepositoryCheckoutLifecycle({
-        repoId: campaign.repoId,
-        checkoutId,
-        lifecycle: 'removed',
-        reason: `Campaign ${campaign.campaignId} workspace cleanup completed.`,
-        controllerHome,
-      });
-      resources.push({ kind: 'checkout', id: checkoutId, status: 'cleaned' });
-    } catch (error) {
-      const message = `Failed to update checkout lifecycle: ${error instanceof Error ? error.message : String(error)}`;
-      resources.push({ kind: 'checkout', id: checkoutId, status: 'failed', message });
-      leaks.push(message);
-    }
-  }
-
-  if (safeBranch) {
-    const branchRevision = git(sourceRoot, ['rev-parse', '--verify', branchRef(safeBranch, { purpose: 'CAMPAIGN_WORKSPACE_BRANCH' })]);
-    if (!branchRevision.ok) {
-      resources.push({ kind: 'branch', id: safeBranch, status: 'missing' });
-    } else {
-      const safe = options?.targetBranch
-        ? git(sourceRoot, ['branch', '--merged', options.targetBranch, '--list', safeBranch]).stdout.includes(safeBranch)
-        : !baseRevision || branchRevision.stdout === baseRevision;
-      if (!safe) {
-        const message = options?.targetBranch
-          ? `Campaign branch has unmerged commits into ${options.targetBranch}; preserved ${safeBranch}.`
-          : `Campaign branch has commits beyond its base revision; preserved ${safeBranch}.`;
-        resources.push({ kind: 'branch', id: safeBranch, status: 'preserved', message });
-        leaks.push(message);
-      } else {
-        const deleted = git(sourceRoot, ['branch', '-D', safeBranch]);
-        if (deleted.ok) resources.push({ kind: 'branch', id: safeBranch, status: 'cleaned' });
-        else {
-          const message = `Failed to delete managed branch: ${deleted.stderr}`;
-          resources.push({ kind: 'branch', id: safeBranch, status: 'failed', message });
-          leaks.push(message);
-        }
-      }
-    }
-  }
-  return { resources, leaks };
-}
-
-/**
- * Two-phase, idempotent Campaign cancellation. A Campaign is not terminal
- * until child Jobs and managed workspace resources have been reconciled.
- */
-export async function cancelCampaign(
-  controllerHome: string,
-  repoId: string,
-  campaignId: string,
-  requestId: string,
-  reason = 'Cancelled by user',
-  expectedRevision?: number,
-): Promise<Campaign> {
-  const initial = getCampaign(controllerHome, repoId, campaignId);
-  if (initial.status === 'completed') throw new Error('CAMPAIGN_ALREADY_COMPLETED');
-  if (initial.status === 'cancelled') return initial;
-
-  const startedAt = now();
-  let campaign = updateCampaign(controllerHome, repoId, campaignId, `${requestId}:begin`, (current) => {
-    current.status = 'cancelling';
-    current.pauseReason = reason;
-    current.nextReconcileAt = undefined;
-    current.cleanup = { schemaVersion: 1, startedAt, resources: [], leaks: [] };
-    for (const checkpoint of current.checkpoints) {
-      if (checkpoint.status === 'open') checkpoint.status = 'superseded';
-    }
-    for (const task of current.tasks) {
-      if (!['succeeded', 'succeeded_no_change', 'skipped', 'failed', 'failed_no_effect', 'blocked', 'cancelled'].includes(task.status)) {
-        task.status = 'cancelled';
-        task.completedAt = startedAt;
-      }
-    }
-    return current;
-  }, {
-    expectedRevision,
-    eventType: 'campaign_cancelling',
-    eventData: { reason },
-    requestFingerprint: reason,
-  });
-
-  const report: CampaignCleanupReport = { schemaVersion: 1, startedAt, resources: [], leaks: [] };
-  const childJobIds = new Set([
-    ...campaign.tasks.map((task) => task.jobId),
-    ...campaign.checkpoints.map((checkpoint) => checkpoint.triggerJobId),
-  ].filter((jobId): jobId is string => Boolean(jobId)));
-  for (const jobId of childJobIds) {
-    const job = findExecutionJob(controllerHome, jobId);
-    if (!job) {
-      report.resources.push({ kind: 'job', id: jobId, status: 'missing' });
-      continue;
-    }
-    try {
-      const cancelled = await cancelExecutionJob(controllerHome, repoId, jobId, `Campaign ${campaignId}: ${reason}`);
-      report.resources.push({
-        kind: 'job',
-        id: jobId,
-        status: ['cancelled', 'succeeded', 'failed', 'timed_out', 'orphaned', 'stale', 'human_attention_required'].includes(cancelled.status)
-          ? 'cleaned'
-          : 'failed',
-        message: `Execution Job ended as ${cancelled.status}.`,
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      report.resources.push({ kind: 'job', id: jobId, status: 'failed', message });
-      report.leaks.push(`job ${jobId}: ${message}`);
-    }
-  }
-
-  for (const checkpoint of campaign.checkpoints) {
-    report.resources.push({
-      kind: 'checkpoint', id: checkpoint.checkpointId,
-      status: checkpoint.status === 'superseded' || checkpoint.status === 'submitted' ? 'cleaned' : 'preserved',
-    });
-  }
-
-  const workspace = cleanupManagedWorkspace(controllerHome, campaign);
-  report.resources.push(...workspace.resources);
-  report.leaks.push(...workspace.leaks);
-  report.finishedAt = now();
-
-  campaign = updateCampaign(controllerHome, repoId, campaignId, `${requestId}:finalize`, (current) => {
-    current.cleanup = report;
-    current.status = report.leaks.length > 0 ? 'cancelled_with_leaks' : 'cancelled';
-    current.completedAt = report.finishedAt;
-    current.nextReconcileAt = undefined;
-    return current;
-  }, {
-    eventType: report.leaks.length > 0 ? 'campaign_cancelled_with_leaks' : 'campaign_cancelled',
-    eventData: { reason, cleanup: report },
-    requestFingerprint: JSON.stringify({ reason, leaks: report.leaks }),
-  });
-  return campaign;
-}
-
-/**
- * After a campaign is accepted/completed, clean up its managed workspace using
- * `git branch --merged <targetBranch>` as the safety gate rather than the
- * cancel-path's base-revision check. Merged branches and their worktrees are
- * removed; unmerged ones are preserved and recorded as leaks.
- */
-export function completeCampaignWorkspace(
-  controllerHome: string,
-  repoId: string,
-  campaignId: string,
-  requestId: string,
-): Campaign {
-  const campaign = getCampaign(controllerHome, repoId, campaignId);
-  const repository = getRepository(repoId, controllerHome);
-  const targetBranch = repository.defaultBranch ?? 'main';
-
-  const startedAt = now();
-  const report: CampaignCleanupReport = { schemaVersion: 1, startedAt, resources: [], leaks: [] };
-  const workspace = cleanupManagedWorkspace(controllerHome, campaign, { targetBranch });
-  report.resources.push(...workspace.resources);
-  report.leaks.push(...workspace.leaks);
-  report.finishedAt = now();
-
-  return updateCampaign(controllerHome, repoId, campaignId, `${requestId}:workspace-cleanup`, (current) => {
-    current.cleanup = report;
-    return current;
-  }, {
-    eventType: report.leaks.length > 0 ? 'campaign_workspace_cleanup_leaks' : 'campaign_workspace_cleaned',
-    eventData: { cleanup: report },
-  });
-}

package/src/runtime/workflow/campaigns/engine.ts

@@ -1,112 +0,0 @@
-import type { CampaignReconcileResult, CampaignTask } from './types';
-import { getCampaign, updateCampaign } from './store';
-import { createHandoffItem, createWorkContract, getWorkContract } from '../../control-plane/facade';
-
-const SUCCESS_TASK_STATUSES = new Set<CampaignTask['status']>(['succeeded', 'succeeded_no_change', 'skipped']);
-
-function now(): string { return new Date().toISOString(); }
-
-/**
- * Campaign is a historical planning and migration view. Explicit reconciliation
- * migrates unfinished tasks into WorkContracts and HandoffItems without dispatching
- * ExecutionJobs, Agent Runs, retries, or supervisor triggers.
- */
-function migrateFrozenCampaign(controllerHome: string, repoId: string, campaignId: string): CampaignReconcileResult {
-  const before = getCampaign(controllerHome, repoId, campaignId);
-  if (before.pauseReason?.startsWith('Campaign automation frozen;')) {
-    return { campaignId, changed: false, dispatched: 0, checkpointsOpened: 0, status: before.status };
-  }
-  const migratable = before.tasks.filter((task) => !SUCCESS_TASK_STATUSES.has(task.status));
-  let migrated = 0;
-  for (const task of migratable) {
-    const store = { controllerHome, repoId };
-    const workId = `campaign-${before.campaignId}-${task.taskId}`;
-    const terminalFailure = ['failed', 'failed_no_effect', 'cancelled'].includes(task.status);
-    const work = getWorkContract(store, workId) ?? createWorkContract(store, {
-      workId,
-      repoId,
-      mode: 'direct_control',
-      objective: task.objective || task.title,
-      acceptanceCriteria: before.goals.at(-1)?.acceptanceCriteria ?? [],
-      constraints: {
-        requireHandoffOnAmbiguity: true,
-        workspaceMode: before.workspace.mode === 'isolated' ? 'isolated' : 'current',
-      },
-      allowedPaths: [],
-      forbiddenPaths: [],
-      checks: [],
-      status: terminalFailure ? 'failed' : task.status === 'waiting_review' ? 'ready' : 'blocked',
-      requestedBy: 'system',
-      scopeSummary: `Migrated from frozen Campaign ${before.campaignId} task ${task.taskId}.`,
-    });
-    const handoffId = `campaign-migration-${before.campaignId}-${task.taskId}`;
-    try {
-      createHandoffItem(store, {
-        id: handoffId,
-        repoId,
-        workId: work.workId,
-        title: `Campaign task migrated: ${task.title}`,
-        severity: terminalFailure ? 'failed' : task.status === 'waiting_review' ? 'ready_to_continue' : 'blocked',
-        creationReason: 'ambiguous_outcome',
-        reason: 'Campaign automation is frozen; an external SuperController must inspect and continue this WorkContract.',
-        summary: `Campaign task ${task.taskId} was migrated without dispatching a legacy Job.`,
-        currentState: {
-          repoId,
-          workId: work.workId,
-          statusSummary: task.status,
-          blockedBy: task.dependsOn,
-          checks: task.jobId ? [{ checkId: task.jobId, ok: false, summary: 'Legacy Campaign Job reference retained for inspection.' }] : undefined,
-        },
-        attemptedActions: [
-          ...(task.jobId ? [`legacy ExecutionJob: ${task.jobId}`] : []),
-          ...(task.runId ? [`legacy Agent Run: ${task.runId}`] : []),
-        ],
-        evidenceRefs: task.evidenceIds.map((evidenceId) => ({ evidenceId, title: 'Campaign evidence' })),
-        recommendedDecision: 'Claim the WorkContract and inspect retained evidence before continuation.',
-        recommendedPrompt: `Claim Work ${work.workId}, inspect the Campaign handoff, and continue through the repository MCP facade.`,
-        suggestedNextActions: [],
-      });
-    } catch (error) {
-      if (!(error instanceof Error) || !error.message.includes('already exists')) throw error;
-    }
-    migrated += 1;
-  }
-  const updated = updateCampaign(controllerHome, repoId, campaignId, `migration:${campaignId}:${before.revision}`, (campaign) => {
-    for (const task of campaign.tasks) {
-      if (SUCCESS_TASK_STATUSES.has(task.status)) continue;
-      task.status = 'blocked';
-      task.nextAttemptAt = undefined;
-      task.executionFinishedAt ??= now();
-      task.error = {
-        code: 'CAMPAIGN_MIGRATED_TO_WORK',
-        message: 'Campaign automation is frozen; continue through the linked WorkContract and HandoffItem.',
-        retryable: false,
-      };
-    }
-    campaign.status = 'paused';
-    campaign.pauseReason = `Campaign automation frozen; ${migrated} task(s) migrated to WorkContracts.`;
-    campaign.nextReconcileAt = undefined;
-    return campaign;
-  }, {
-    eventType: 'campaign_migrated_to_work',
-    eventData: { migrated },
-    wakeScheduler: false,
-  });
-  return { campaignId, changed: updated.revision !== before.revision, dispatched: 0, checkpointsOpened: 0, status: updated.status };
-}
-
-export function reconcileCampaign(controllerHome: string, repoId: string, campaignId: string): CampaignReconcileResult {
-  return migrateFrozenCampaign(controllerHome, repoId, campaignId);
-}
-
-export interface TickCampaignsOptions {
-  maxCampaigns?: number;
-}
-
-export function tickCampaigns(controllerHome: string, repoIds: string[], options: TickCampaignsOptions = {}): CampaignReconcileResult[] {
-  // Automatic reconcile, retry, dispatch, and supervisor triggering are retired.
-  void controllerHome;
-  void repoIds;
-  void options;
-  return [];
-}

package/src/runtime/workflow/campaigns/normalize.ts

@@ -1,100 +0,0 @@
-const OPERATION_ALIASES = new Map<string, string>([
-  ['launch_task', 'dispatch_task'],
-  ['launch_ready_tasks', 'dispatch_ready_tasks'],
-  ['retry_run', 'retry_task_run'],
-  ['integrate_run', 'integrate_task_run'],
-  ['verify_edit', 'verify_edit_session'],
-  ['finish_edit', 'finish_edit_session'],
-  ['repository_command', 'repository_command_execute'],
-  ['command_execute', 'repository_command_execute'],
-  ['quick_agent_run', 'quick_agent_session'],
-]);
-
-const OBSOLETE_OPERATION_MESSAGES = new Map<string, string>([
-  ['prepare_issue_launch', 'prepare_issue_launch is obsolete for Campaigns; use launch_issue after readiness review or dispatch_task for one scoped Task.'],
-]);
-
-function extractDependencyReference(value: unknown): string | undefined {
-  if (typeof value === 'string') return value;
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const record = value as Record<string, unknown>;
-  for (const key of ['task_id', 'taskId', 'id', 'reference', 'ref', 'dependency']) {
-    if (typeof record[key] === 'string') return record[key] as string;
-  }
-  return undefined;
-}
-
-function operationToken(value: string): string {
-  return value
-    .trim()
-    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-    .replace(/[^A-Za-z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .toLowerCase();
-}
-
-export function normalizeCampaignOperationName(value: string): string {
-  const normalized = operationToken(value);
-  return OPERATION_ALIASES.get(normalized) ?? normalized;
-}
-
-export function assertCampaignOperationSupported(value: string): string {
-  const operation = normalizeCampaignOperationName(value);
-  if (!operation) throw new Error('CAMPAIGN_TASK_OPERATION_REQUIRED');
-  if (operation.startsWith('work_')) {
-    throw new Error(`CAMPAIGN_OPERATION_INVALID: ${value} is a Work wrapper, not a Campaign task operation.`);
-  }
-  const obsolete = OBSOLETE_OPERATION_MESSAGES.get(operation);
-  if (obsolete) throw new Error(`CAMPAIGN_OPERATION_OBSOLETE: ${obsolete}`);
-  return operation;
-}
-
-export function normalizeCampaignDependencyReference(value: unknown): string | undefined {
-  let text = extractDependencyReference(value)?.trim();
-  if (!text) return undefined;
-  text = text.replace(/^`+|`+$/g, '').trim();
-  while (text.startsWith('#')) text = text.slice(1).trim();
-  const prefixed = /^(?:task|task_id|task-id|dependency|depends_on|depends-on|campaign[_ -]?task|campaign\.task|campaign\/task)[:/#-]+(.+)$/i.exec(text);
-  if (prefixed) text = prefixed[1]?.trim() ?? '';
-  return text || undefined;
-}
-
-function dependencyLookupKeys(value: string): string[] {
-  const normalized = normalizeCampaignDependencyReference(value) ?? value.trim();
-  const keys = new Set<string>();
-  for (const candidate of [value.trim(), normalized]) {
-    if (!candidate) continue;
-    keys.add(candidate);
-    keys.add(candidate.toLowerCase());
-    const token = operationToken(candidate);
-    if (token) keys.add(token);
-  }
-  return [...keys];
-}
-
-export function normalizeCampaignDependencyReferences(
-  values: readonly unknown[],
-  knownTaskIds: readonly string[] = [],
-): string[] {
-  const actualTaskIds = knownTaskIds.map((value) => value.trim()).filter(Boolean);
-  const lookup = new Map<string, string>();
-  for (const taskId of actualTaskIds) {
-    for (const key of dependencyLookupKeys(taskId)) if (!lookup.has(key)) lookup.set(key, taskId);
-  }
-  const normalized: string[] = [];
-  for (const value of values) {
-    const reference = normalizeCampaignDependencyReference(value);
-    if (!reference) continue;
-    const resolved = dependencyLookupKeys(reference).map((key) => lookup.get(key)).find(Boolean) ?? reference;
-    if (!normalized.includes(resolved)) normalized.push(resolved);
-  }
-  return normalized;
-}
-
-export function normalizeCampaignTaskReferences<T extends { taskId: string; dependsOn: string[] }>(tasks: T[]): T[] {
-  const taskIds = tasks.map((task) => task.taskId);
-  for (const task of tasks) {
-    task.dependsOn = normalizeCampaignDependencyReferences(task.dependsOn, taskIds);
-  }
-  return tasks;
-}