@moretea-labs/forge 1.5.1 → 1.7.0

package/src/runtime/workflow/findings/store.ts

@@ -1,204 +0,0 @@
-import { createHash, randomUUID } from 'crypto';
-import { readdirSync } from 'fs';
-import { join } from 'path';
-import { repositoryControllerRoot } from '../../../cli/repositories/controller-home';
-import {
-  listControlPlaneRecords,
-  mutateControlPlaneRecord,
-  readOrImportControlPlaneRecord,
-} from '../../control-plane/persistence/sqlite-store';
-import { appendRuntimeEvent } from '../../evidence/event-ledger';
-import { readJsonFile, sanitizeFileComponent } from '../../shared/json-files';
-import type { CandidateFinding, RecordCandidateFindingInput } from './types';
-
-const FINDING_NAMESPACE = 'candidate_finding';
-const FINDING_SCHEMA_VERSION = 1;
-const MAX_EVIDENCE = 100;
-const MAX_FINDINGS = 5_000;
-
-function legacyRoot(controllerHome: string, repoId: string): string {
-  return join(repositoryControllerRoot(controllerHome, repoId), 'candidate-findings');
-}
-function legacyRecordPath(controllerHome: string, repoId: string, findingId: string): string {
-  return join(legacyRoot(controllerHome, repoId), 'records', `${sanitizeFileComponent(findingId)}.json`);
-}
-function legacySemanticPath(controllerHome: string, repoId: string, semanticKey: string): string {
-  return join(legacyRoot(controllerHome, repoId), 'indexes', 'semantic', `${findingKey(semanticKey)}.json`);
-}
-function findingKey(semanticKey: string): string {
-  return createHash('sha256').update(semanticKey).digest('hex');
-}
-function legacyFinding(controllerHome: string, repoId: string, findingId: string): CandidateFinding | undefined {
-  try { return readJsonFile<CandidateFinding>(legacyRecordPath(controllerHome, repoId, findingId)); } catch { return undefined; }
-}
-function legacyFindingForSemanticKey(controllerHome: string, repoId: string, semanticKey: string): CandidateFinding | undefined {
-  try {
-    const reference = readJsonFile<{ findingId?: string }>(legacySemanticPath(controllerHome, repoId, semanticKey));
-    return typeof reference.findingId === 'string' ? legacyFinding(controllerHome, repoId, reference.findingId) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-function records(controllerHome: string, repoId: string): CandidateFinding[] {
-  return listControlPlaneRecords<CandidateFinding>(controllerHome, {
-    namespace: FINDING_NAMESPACE,
-    scope: repoId,
-    limit: MAX_FINDINGS,
-  }).map((record) => record.value);
-}
-function importLegacyFinding(controllerHome: string, repoId: string, finding: CandidateFinding): CandidateFinding {
-  return readOrImportControlPlaneRecord<CandidateFinding>(controllerHome, {
-    namespace: FINDING_NAMESPACE,
-    scope: repoId,
-    key: findingKey(finding.semanticKey),
-    schemaVersion: FINDING_SCHEMA_VERSION,
-    readLegacy: () => finding,
-  })!.value;
-}
-function importLegacyFindings(controllerHome: string, repoId: string): CandidateFinding[] {
-  const directory = join(legacyRoot(controllerHome, repoId), 'records');
-  try {
-    for (const name of readdirSync(directory).filter((entry) => entry.endsWith('.json')).slice(0, MAX_FINDINGS)) {
-      const finding = legacyFinding(controllerHome, repoId, name.slice(0, -'.json'.length));
-      if (finding?.repoId === repoId && finding.semanticKey) importLegacyFinding(controllerHome, repoId, finding);
-    }
-  } catch {
-    // No legacy records is the normal v2 path.
-  }
-  return records(controllerHome, repoId);
-}
-function existingFinding(controllerHome: string, repoId: string, findingId: string): CandidateFinding | undefined {
-  return records(controllerHome, repoId).find((finding) => finding.findingId === findingId)
-    ?? (() => {
-      const legacy = legacyFinding(controllerHome, repoId, findingId);
-      return legacy?.repoId === repoId ? importLegacyFinding(controllerHome, repoId, legacy) : undefined;
-    })();
-}
-
-export function getCandidateFinding(controllerHome: string, repoId: string, findingId: string): CandidateFinding {
-  const finding = existingFinding(controllerHome, repoId, findingId);
-  if (!finding) throw new Error(`CANDIDATE_FINDING_NOT_FOUND: ${findingId}`);
-  return finding;
-}
-
-export function recordCandidateFinding(controllerHome: string, input: RecordCandidateFindingInput): CandidateFinding {
-  const semanticKey = input.semanticKey.trim();
-  const title = input.title.trim();
-  const requestId = input.requestId.trim();
-  if (!semanticKey) throw new Error('CANDIDATE_SEMANTIC_KEY_REQUIRED');
-  if (!title) throw new Error('CANDIDATE_TITLE_REQUIRED');
-  if (!requestId) throw new Error('CANDIDATE_REQUEST_ID_REQUIRED');
-  const timestamp = input.evidence?.observedAt ?? new Date().toISOString();
-  const record = mutateControlPlaneRecord<CandidateFinding>(controllerHome, {
-    namespace: FINDING_NAMESPACE,
-    scope: input.repoId,
-    key: findingKey(semanticKey),
-    schemaVersion: FINDING_SCHEMA_VERSION,
-    action: 'candidate_finding_observed',
-    readLegacy: () => legacyFindingForSemanticKey(controllerHome, input.repoId, semanticKey),
-    mutate: (current) => {
-      const previous = current?.value;
-      const evidence = input.evidence
-        ? [...(previous?.evidence ?? []), { ...input.evidence, observedAt: timestamp }].slice(-MAX_EVIDENCE)
-        : previous?.evidence ?? [];
-      return previous ? {
-        ...previous,
-        revision: previous.revision + 1,
-        title,
-        summary: input.summary ?? previous.summary,
-        severity: input.severity ?? previous.severity,
-        status: previous.status === 'dismissed' ? 'candidate' : previous.status,
-        observationCount: previous.observationCount + 1,
-        evidence,
-        lastSeenAt: timestamp,
-        dismissedReason: previous.status === 'dismissed' ? undefined : previous.dismissedReason,
-        requirementId: input.requirementId ?? previous.requirementId,
-        kind: input.kind ?? previous.kind,
-        sourceRepoId: input.sourceRepoId ?? previous.sourceRepoId,
-        sourceWorkId: input.sourceWorkId ?? previous.sourceWorkId,
-        sourceProcessId: input.sourceProcessId ?? previous.sourceProcessId,
-        sourcePluginId: input.sourcePluginId ?? previous.sourcePluginId,
-        externalRefs: input.externalRefs ?? previous.externalRefs,
-      } : {
-        schemaVersion: 1,
-        revision: 1,
-        findingId: `FIND-${Date.now()}-${randomUUID().slice(0, 8)}`,
-        repoId: input.repoId,
-        semanticKey,
-        title,
-        summary: input.summary,
-        severity: input.severity ?? 'medium',
-        status: 'candidate',
-        observationCount: 1,
-        evidence,
-        firstSeenAt: timestamp,
-        lastSeenAt: timestamp,
-        requirementId: input.requirementId,
-        kind: input.kind,
-        sourceRepoId: input.sourceRepoId,
-        sourceWorkId: input.sourceWorkId,
-        sourceProcessId: input.sourceProcessId,
-        sourcePluginId: input.sourcePluginId,
-        externalRefs: input.externalRefs,
-      };
-    },
-  });
-  const finding = record.value;
-  appendRuntimeEvent(controllerHome, {
-    repoId: finding.repoId,
-    entityType: 'candidate-finding',
-    entityId: finding.findingId,
-    eventType: finding.observationCount === 1 ? 'candidate_finding_created' : 'candidate_finding_observed',
-    requestId,
-    revision: finding.revision,
-    data: { semanticKey, observationCount: finding.observationCount, severity: finding.severity },
-  });
-  return finding;
-}
-
-export function updateCandidateFinding(
-  controllerHome: string,
-  repoId: string,
-  findingId: string,
-  updater: (current: CandidateFinding) => CandidateFinding,
-  requestId: string,
-  eventType: string,
-): CandidateFinding {
-  const existing = getCandidateFinding(controllerHome, repoId, findingId);
-  const record = mutateControlPlaneRecord<CandidateFinding>(controllerHome, {
-    namespace: FINDING_NAMESPACE,
-    scope: repoId,
-    key: findingKey(existing.semanticKey),
-    schemaVersion: FINDING_SCHEMA_VERSION,
-    action: eventType,
-    mutate: (current) => {
-      const previous = current?.value ?? existing;
-      const next = updater(structuredClone(previous));
-      if (next.findingId !== previous.findingId || next.repoId !== previous.repoId || next.semanticKey !== previous.semanticKey) {
-        throw new Error('CANDIDATE_IDENTITY_IMMUTABLE');
-      }
-      return { ...next, revision: previous.revision + 1, lastSeenAt: new Date().toISOString() };
-    },
-  });
-  const finding = record.value;
-  appendRuntimeEvent(controllerHome, {
-    repoId,
-    entityType: 'candidate-finding',
-    entityId: findingId,
-    eventType,
-    requestId,
-    revision: finding.revision,
-    data: { status: finding.status, promotedJobId: finding.promotedJobId },
-  });
-  return finding;
-}
-
-export function listCandidateFindings(controllerHome: string, repoId: string, options: { includeTerminal?: boolean; limit?: number } = {}): CandidateFinding[] {
-  const bounded = Math.max(1, Math.min(options.limit ?? 100, 1000));
-  const stored = records(controllerHome, repoId);
-  const all = stored.length > 0 ? stored : importLegacyFindings(controllerHome, repoId);
-  return all
-    .filter((finding) => options.includeTerminal || finding.status === 'candidate')
-    .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt))
-    .slice(0, bounded);
-}

package/src/runtime/workflow/findings/types.ts

@@ -1,58 +0,0 @@
-export type CandidateFindingStatus = 'candidate' | 'promoted' | 'dismissed';
-
-export interface CandidateFindingEvidence {
-  source: string;
-  reference?: string;
-  observedAt: string;
-  details?: Record<string, unknown>;
-}
-
-export interface CandidateFindingExternalRef {
-  kind: string;
-  url?: string;
-  number?: number;
-  label?: string;
-}
-
-export interface CandidateFinding {
-  schemaVersion: 1;
-  revision: number;
-  findingId: string;
-  repoId: string;
-  semanticKey: string;
-  title: string;
-  summary?: string;
-  severity: 'low' | 'medium' | 'high' | 'critical';
-  status: CandidateFindingStatus;
-  observationCount: number;
-  evidence: CandidateFindingEvidence[];
-  firstSeenAt: string;
-  lastSeenAt: string;
-  promotedJobId?: string;
-  dismissedReason?: string;
-  /** Optional Requirement/operational provenance; repoId remains the owner. */
-  requirementId?: string;
-  kind?: 'defect' | 'performance' | 'reliability' | 'usability';
-  sourceRepoId?: string;
-  sourceWorkId?: string;
-  sourceProcessId?: string;
-  sourcePluginId?: string;
-  externalRefs?: CandidateFindingExternalRef[];
-}
-
-export interface RecordCandidateFindingInput {
-  repoId: string;
-  semanticKey: string;
-  title: string;
-  summary?: string;
-  severity?: CandidateFinding['severity'];
-  evidence?: Omit<CandidateFindingEvidence, 'observedAt'> & { observedAt?: string };
-  requirementId?: string;
-  kind?: CandidateFinding['kind'];
-  sourceRepoId?: string;
-  sourceWorkId?: string;
-  sourceProcessId?: string;
-  sourcePluginId?: string;
-  externalRefs?: CandidateFindingExternalRef[];
-  requestId: string;
-}

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

@@ -1,20 +0,0 @@
-import type { PortfolioWorkflow } from './types';
-import { listActivePortfolioWorkflows, savePortfolioWorkflow } from './store';
-
-const EXTERNAL_CONTROLLER_REQUIRED = 'Portfolio execution requires an explicitly claimed external Controller.';
-
-/**
- * Portfolio definitions remain durable planning records. Kernel-owned DAG execution
- * is retired, so ticking only records the explicit handoff state and creates no Job.
- */
-export function tickPortfolioWorkflow(controllerHome: string, source: PortfolioWorkflow): PortfolioWorkflow {
-  const steps = source.steps.map((step) => step.status === 'pending' || step.status === 'queued'
-    ? { ...step, status: 'blocked' as const, error: EXTERNAL_CONTROLLER_REQUIRED }
-    : step);
-  return savePortfolioWorkflow(controllerHome, { ...source, status: 'paused', steps });
-}
-
-export function tickPortfolioWorkflows(controllerHome: string): PortfolioWorkflow[] {
-  return listActivePortfolioWorkflows(controllerHome)
-    .map((workflow) => tickPortfolioWorkflow(controllerHome, workflow));
-}

package/src/runtime/workflow/portfolio/store.ts

@@ -1,185 +0,0 @@
-import { createHash, randomUUID } from 'crypto';
-import { existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { ensureControllerHome } from '../../../cli/repositories/controller-home';
-import { withControllerLock } from '../../../cli/repositories/locks';
-import { readJsonFile, writeJsonAtomic } from '../../shared/json-files';
-import { appendRuntimeEvent } from '../../evidence/event-ledger';
-import type { PortfolioWorkflow } from './types';
-
-interface PortfolioIndexEntry {
-  workflowId: string;
-  status: PortfolioWorkflow['status'];
-  createdAt: string;
-  updatedAt: string;
-}
-
-
-interface PortfolioRequestRecord {
-  schemaVersion: 1;
-  requestId: string;
-  semanticKey: string;
-  workflowId: string;
-  createdAt: string;
-}
-
-interface PortfolioIndex {
-  schemaVersion: 1;
-  updatedAt: string;
-  active: PortfolioIndexEntry[];
-  recent: PortfolioIndexEntry[];
-}
-
-function portfolioRoot(controllerHome: string): string {
-  return join(ensureControllerHome(controllerHome), 'portfolio');
-}
-function root(controllerHome: string): string { return join(portfolioRoot(controllerHome), 'workflows'); }
-function path(controllerHome: string, workflowId: string): string { return join(root(controllerHome), `${workflowId}.json`); }
-function indexPath(controllerHome: string): string { return join(portfolioRoot(controllerHome), 'indexes', 'workflows.json'); }
-function requestPath(controllerHome: string, requestId: string): string { return join(portfolioRoot(controllerHome), 'indexes', 'requests', `${createHash('sha256').update(requestId).digest('hex')}.json`); }
-function canonical(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, canonical(entry)]));
-  return value;
-}
-function semanticKey(input: Omit<PortfolioWorkflow, 'schemaVersion' | 'revision' | 'workflowId' | 'createdAt' | 'updatedAt' | 'status'>): string {
-  return createHash('sha256').update(JSON.stringify(canonical({ name: input.name, failurePolicy: input.failurePolicy, steps: input.steps }))).digest('hex');
-}
-function emptyIndex(): PortfolioIndex {
-  return { schemaVersion: 1, updatedAt: new Date().toISOString(), active: [], recent: [] };
-}
-function readIndex(controllerHome: string): PortfolioIndex {
-  return readJsonFile<PortfolioIndex>(indexPath(controllerHome), emptyIndex());
-}
-function activeStatus(status: PortfolioWorkflow['status']): boolean {
-  return status === 'active' || status === 'compensating';
-}
-function upsertIndexUnlocked(controllerHome: string, workflow: PortfolioWorkflow): void {
-  const index = readIndex(controllerHome);
-  const entry: PortfolioIndexEntry = {
-    workflowId: workflow.workflowId,
-    status: workflow.status,
-    createdAt: workflow.createdAt,
-    updatedAt: workflow.updatedAt,
-  };
-  index.active = index.active.filter((candidate) => candidate.workflowId !== workflow.workflowId);
-  index.recent = index.recent.filter((candidate) => candidate.workflowId !== workflow.workflowId);
-  if (activeStatus(workflow.status)) index.active.push(entry);
-  index.recent.push(entry);
-  index.active.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
-  index.recent.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
-  index.active = index.active.slice(-5000);
-  index.recent = index.recent.slice(0, 5000);
-  index.updatedAt = new Date().toISOString();
-  writeJsonAtomic(indexPath(controllerHome), index);
-}
-function readIndexedWorkflows(controllerHome: string, entries: PortfolioIndexEntry[], limit: number): PortfolioWorkflow[] {
-  return entries.slice(0, limit).flatMap((entry) => {
-    const candidate = path(controllerHome, entry.workflowId);
-    if (!existsSync(candidate)) return [];
-    try { return [readJsonFile<PortfolioWorkflow>(candidate)]; } catch { return []; }
-  });
-}
-function backfillIndex(controllerHome: string, workflows: PortfolioWorkflow[]): void {
-  if (workflows.length === 0) return;
-  withControllerLock(controllerHome, { scope: 'global' }, 'portfolio-index-backfill', () => {
-    for (const workflow of workflows) upsertIndexUnlocked(controllerHome, workflow);
-  }, 10_000);
-}
-
-export function createPortfolioWorkflow(
-  controllerHome: string,
-  input: Omit<PortfolioWorkflow, 'schemaVersion' | 'revision' | 'workflowId' | 'createdAt' | 'updatedAt' | 'status'>,
-): PortfolioWorkflow {
-  const requestId = input.requestId.trim();
-  if (!requestId) throw new Error('PORTFOLIO_REQUEST_ID_REQUIRED');
-  const inputSemanticKey = semanticKey(input);
-  const ids = new Set(input.steps.map((step) => step.stepId));
-  if (ids.size !== input.steps.length) throw new Error('PORTFOLIO_STEP_DUPLICATE: stepId values must be unique');
-  for (const step of input.steps) {
-    for (const dependency of step.dependsOn) if (!ids.has(dependency)) throw new Error(`PORTFOLIO_DEPENDENCY_UNKNOWN: ${dependency}`);
-  }
-  const dependencies = new Map(input.steps.map((step) => [step.stepId, step.dependsOn]));
-  const visiting = new Set<string>();
-  const visited = new Set<string>();
-  const visit = (stepId: string): void => {
-    if (visiting.has(stepId)) throw new Error(`PORTFOLIO_DEPENDENCY_CYCLE: ${stepId}`);
-    if (visited.has(stepId)) return;
-    visiting.add(stepId);
-    for (const dependency of dependencies.get(stepId) ?? []) visit(dependency);
-    visiting.delete(stepId);
-    visited.add(stepId);
-  };
-  for (const stepId of ids) visit(stepId);
-  return withControllerLock(controllerHome, { scope: 'global' }, `create-portfolio:${requestId}`, () => {
-    const recordPath = requestPath(controllerHome, requestId);
-    if (existsSync(recordPath)) {
-      const record = readJsonFile<PortfolioRequestRecord>(recordPath);
-      if (record.semanticKey !== inputSemanticKey) throw new Error(`PORTFOLIO_REQUEST_ID_CONFLICT: ${requestId}`);
-      return getPortfolioWorkflow(controllerHome, record.workflowId);
-    }
-    const timestamp = new Date().toISOString();
-    const workflow: PortfolioWorkflow = {
-      ...input,
-      requestId,
-      schemaVersion: 1,
-      revision: 1,
-      workflowId: `PFW-${Date.now()}-${randomUUID().slice(0, 8)}`,
-      status: 'active',
-      createdAt: timestamp,
-      updatedAt: timestamp,
-    };
-    writeJsonAtomic(path(controllerHome, workflow.workflowId), workflow);
-    writeJsonAtomic(recordPath, { schemaVersion: 1, requestId, semanticKey: inputSemanticKey, workflowId: workflow.workflowId, createdAt: timestamp } satisfies PortfolioRequestRecord);
-    upsertIndexUnlocked(controllerHome, workflow);
-    for (const repoId of new Set(workflow.steps.map((step) => step.repoId))) {
-      appendRuntimeEvent(controllerHome, { repoId, entityType: 'portfolio', entityId: workflow.workflowId, eventType: 'portfolio_created', requestId, revision: workflow.revision, data: { name: workflow.name, failurePolicy: workflow.failurePolicy } });
-    }
-    return workflow;
-  }, 10_000);
-}
-
-export function savePortfolioWorkflow(controllerHome: string, workflow: PortfolioWorkflow): PortfolioWorkflow {
-  return withControllerLock(controllerHome, { scope: 'global' }, `save-portfolio:${workflow.workflowId}`, () => {
-    const current = getPortfolioWorkflow(controllerHome, workflow.workflowId);
-    const next = { ...workflow, revision: current.revision + 1, updatedAt: new Date().toISOString() };
-    writeJsonAtomic(path(controllerHome, workflow.workflowId), next);
-    upsertIndexUnlocked(controllerHome, next);
-    for (const repoId of new Set(next.steps.map((step) => step.repoId))) {
-      appendRuntimeEvent(controllerHome, { repoId, entityType: 'portfolio', entityId: next.workflowId, eventType: `portfolio_${next.status}`, requestId: next.requestId, revision: next.revision, data: { status: next.status } });
-    }
-    return next;
-  }, 10_000);
-}
-
-export function getPortfolioWorkflow(controllerHome: string, workflowId: string): PortfolioWorkflow {
-  const workflow = readJsonFile<PortfolioWorkflow>(path(controllerHome, workflowId));
-  return { ...workflow, revision: Number.isFinite(workflow.revision) ? workflow.revision : 1 };
-}
-
-export function listActivePortfolioWorkflows(controllerHome: string): PortfolioWorkflow[] {
-  const indexed = readIndexedWorkflows(controllerHome, readIndex(controllerHome).active, 5000)
-    .filter((workflow) => activeStatus(workflow.status));
-  if (indexed.length > 0) return indexed;
-  const legacy = listLegacyPortfolioWorkflows(controllerHome, 5000).filter((workflow) => activeStatus(workflow.status));
-  backfillIndex(controllerHome, legacy);
-  return legacy;
-}
-
-function listLegacyPortfolioWorkflows(controllerHome: string, limit: number): PortfolioWorkflow[] {
-  try {
-    return readdirSync(root(controllerHome)).filter((name) => name.endsWith('.json'))
-      .map((name) => readJsonFile<PortfolioWorkflow>(join(root(controllerHome), name)))
-      .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-      .slice(0, limit);
-  } catch { return []; }
-}
-
-export function listPortfolioWorkflows(controllerHome: string, limit = 100): PortfolioWorkflow[] {
-  const bounded = Math.max(1, Math.min(limit, 1000));
-  const indexed = readIndexedWorkflows(controllerHome, readIndex(controllerHome).recent, bounded);
-  if (indexed.length > 0) return indexed;
-  const legacy = listLegacyPortfolioWorkflows(controllerHome, bounded);
-  backfillIndex(controllerHome, legacy);
-  return legacy;
-}

package/src/runtime/workflow/portfolio/types.ts

@@ -1,29 +0,0 @@
-import type { ExecutionJobPriority, ResourceClaimSpec } from '../../execution/jobs/types';
-
-export interface PortfolioStep {
-  stepId: string;
-  repoId: string;
-  operation: string;
-  arguments?: Record<string, unknown>;
-  dependsOn: string[];
-  priority: ExecutionJobPriority;
-  resourceClaims: ResourceClaimSpec[];
-  compensation?: { operation: string; arguments?: Record<string, unknown> };
-  status: 'pending' | 'queued' | 'running' | 'succeeded' | 'failed' | 'blocked' | 'compensating' | 'compensated';
-  jobId?: string;
-  compensationJobId?: string;
-  error?: string;
-}
-
-export interface PortfolioWorkflow {
-  schemaVersion: 1;
-  revision: number;
-  workflowId: string;
-  name: string;
-  status: 'active' | 'succeeded' | 'failed' | 'compensating' | 'compensated' | 'paused';
-  failurePolicy: 'stop' | 'compensate';
-  steps: PortfolioStep[];
-  createdAt: string;
-  updatedAt: string;
-  requestId: string;
-}