@moretea-labs/forge 1.8.0 → 1.8.2

package/src/runtime/control-plane/execution/edit-validation-coordinator.ts

@@ -4,13 +4,13 @@ import {
   recordEditSessionProcessCheckReceipts,
   type EditSession,
 } from '../../../cli/editing/edit-session';
-import { listControllerChecks } from '../../../cli/controller/check-runner';
+import { listControllerChecks, readLatestControllerCheckEvidence } from '../../../cli/controller/check-runner';
 import type { RepositoryRecord } from '../../../cli/repositories/types';
 import { repositoryGitStatus } from '../../../cli/repositories/structured-git';
 import { selectRepositoryCheckout } from '../../../cli/repositories/registry';
 import { executionIdentityForRepository } from './execution-identity';
 import { getWorkContract } from '../../../../packages/kernel/work/api/index';
-import { verifyGoalWorkloop } from '../facade/goal-workloop';
+import { recordWorkCheckEvidence } from './work-check-evidence';
 import { commandFingerprint, verificationInputFingerprint, workspaceValidationFingerprint } from './verification-evidence';
 import {
   claimsForCheck,
@@ -20,6 +20,7 @@ import {
   runPersistedCheckViaProcessRuntime,
   type ProcessCheckCompletionReceipt,
 } from '../../execution/process-runtime';
+import { projectTerminalCheckVerification } from '../../execution/process-runtime/check-result';
 import { resourceClaimsConflict } from '../../resources/claims/conflicts';
 import {
   mutateControlPlaneRecord,
@@ -451,10 +452,10 @@ export async function reconcileEditValidationRun(
           issueId: session.issueId,
           taskId: session.taskId,
         },
-        verificationSnapshot: work ? {
-          workId: work.workId,
-          allowedPaths: work.allowedPaths,
-          forbiddenPaths: work.forbiddenPaths,
+        verificationSnapshot: session.workId ? {
+          workId: session.workId,
+          allowedPaths: session.allowedPaths,
+          forbiddenPaths: [],
         } : undefined,
         leaseWaitMs: run.leaseWaitMs,
       });
@@ -492,36 +493,44 @@ export async function reconcileEditValidationRun(
 
   try {
     const receipts = run.checkIds.map((checkId) => receiptFor(controllerHome, validationRepository, run, checkId));
+    const projections = receipts.map((receipt, index) => {
+      const record = records[index]!;
+      const legacyEvidence = record.origin?.checkResultReceiptPath
+        ? undefined
+        : readLatestControllerCheckEvidence(validationRepository.canonicalRoot, receipt.checkId);
+      return projectTerminalCheckVerification(record, receipt.checkId, receipt, { legacyEvidence });
+    });
+    const infrastructureProjectionIndex = projections.findIndex((projection) => projection.outcome === 'infrastructure_failure');
+    if (infrastructureProjectionIndex >= 0) {
+      const receipt = receipts[infrastructureProjectionIndex]!;
+      const projection = projections[infrastructureProjectionIndex]!;
+      throw new Error(`EDIT_VALIDATION_CHECK_INFRASTRUCTURE_FAILURE: ${receipt.checkId}: ${projection.infrastructureReason ?? projection.evidence.warning ?? receipt.summary}`);
+    }
     if (session.workId && work) {
       if (!run.sourceRevision || !run.workspaceFingerprint) throw new Error('EDIT_VALIDATION_WORK_IDENTITY_REQUIRED');
       const availableChecks = listControllerChecks(validationRepository.canonicalRoot);
-      const workloopCtx = {
-        workStore: { controllerHome, repoId: validationRepository.repoId },
-        handoffStore: { controllerHome, repoId: validationRepository.repoId },
-        repoId: validationRepository.repoId,
-        availableChecks,
-        sourceRevision: run.sourceRevision,
-        workspaceFingerprint: run.workspaceFingerprint,
-      };
-      for (const receipt of receipts) {
+      const workStore = { controllerHome, repoId: validationRepository.repoId };
+      for (const [index, receipt] of receipts.entries()) {
         const checkId = receipt.checkId;
+        const projection = projections[index]!;
         const inputFingerprint = verificationInputFingerprint({
           sourceRevision: run.sourceRevision,
           workspaceFingerprint: run.workspaceFingerprint,
           checkId,
           requestedChecks: work.checks.length ? work.checks : run.checkIds,
         });
-        const infrastructureFailed = receipt.timedOut || receipt.cancelled || (!receipt.ok && receipt.status !== 'failed');
-        verifyGoalWorkloop(workloopCtx, {
+        recordWorkCheckEvidence({
+          store: workStore,
           workId: session.workId,
           checkId,
+          availableChecks,
           sourceRevision: run.sourceRevision,
           workspaceFingerprint: run.workspaceFingerprint,
           verificationInputFingerprint: inputFingerprint,
           commandFingerprint: commandFingerprint(checkId, receipt.commandId),
           receipt,
-          infrastructureFailed,
-          checkFailed: !receipt.ok && !infrastructureFailed,
+          infrastructureFailed: projection.isInfrastructureIssue,
+          checkFailed: projection.isAcceptanceFailure,
         });
       }
     }
@@ -535,7 +544,7 @@ export async function reconcileEditValidationRun(
     run = saveRun(controllerHome, {
       ...run,
       status: 'completed',
-      ok: receipts.every((receipt) => receipt.ok),
+      ok: projections.every((projection) => projection.outcome === 'valid_pass'),
       receipts,
       error: undefined,
     });

package/src/runtime/control-plane/execution/execution-identity.ts

@@ -25,12 +25,15 @@ export type ExecutionIdentityErrorCode =
   | 'REPOSITORY_NOT_EXECUTABLE'
   | 'LEGACY_WORK_IDENTITY_AMBIGUOUS'
   | 'LEGACY_WORK_IDENTITY_REJECTED'
-  | 'WORKSPACE_SCOPE_MISMATCH';
+  | 'WORKSPACE_SCOPE_MISMATCH'
+  | 'FORGE_INSTANCE_SCOPE_MISMATCH';
 
 export interface ResolvedExecutionIdentity {
   readonly schemaVersion: 1;
-  readonly authority?: 'repository' | 'ephemeral_workspace';
+  readonly authority?: 'repository' | 'ephemeral_workspace' | 'forge_instance';
+  /** Legacy storage coordinate. For forge_instance authority this is the reserved Process scope key `instance`, not a Repository id. */
   readonly repositoryId: string;
+  /** Legacy storage coordinate. For forge_instance authority this is `instance`, not a checkout. */
   readonly checkoutId: string;
   readonly canonicalRoot: string;
   readonly workId?: string;
@@ -253,7 +256,7 @@ export function executionIdentityFromCoordinates(input: {
   branch?: string;
   expectedHead?: string;
   allowArchived?: boolean;
-  authority?: 'repository' | 'ephemeral_workspace';
+  authority?: 'repository' | 'ephemeral_workspace' | 'forge_instance';
 }): ResolvedExecutionIdentity {
   if (!input.repositoryId.trim() || !input.checkoutId.trim() || !input.canonicalRoot.trim()) {
     fail('EXECUTION_IDENTITY_REQUIRED', 'repositoryId, checkoutId, and canonicalRoot are required');
@@ -331,6 +334,23 @@ export function assertExecutionIdentity(input: {
     });
   }
 
+  if (identity.authority === 'forge_instance') {
+    const instanceRoot = realpathOrFail(identity.canonicalRoot, 'WORKTREE_MISSING', 'ForgeInstance execution root');
+    const requestedCwd = isAbsolute(input.cwd) ? input.cwd : resolve(instanceRoot, input.cwd);
+    const resolvedCwd = realpathOrFail(requestedCwd, 'WORKTREE_MISSING', 'process cwd');
+    if (!statSync(resolvedCwd).isDirectory()) {
+      fail('FORGE_INSTANCE_SCOPE_MISMATCH', 'process cwd is not a directory', { actual: resolvedCwd });
+    }
+    const cwdRelative = relative(instanceRoot, resolvedCwd);
+    if (cwdRelative === '..' || cwdRelative.startsWith('../') || cwdRelative.startsWith('..\\')) {
+      fail('FORGE_INSTANCE_SCOPE_MISMATCH', 'process cwd escapes ForgeInstance execution root', {
+        expected: instanceRoot,
+        actual: resolvedCwd,
+      });
+    }
+    return Object.freeze({ ...identity, canonicalRoot: instanceRoot, resolvedCwd });
+  }
+
   if (identity.authority === 'ephemeral_workspace') {
     const workspaceRoot = realpathOrFail(identity.canonicalRoot, 'WORKTREE_MISSING', 'ephemeral workspace root');
     const requestedCwd = isAbsolute(input.cwd) ? input.cwd : resolve(workspaceRoot, input.cwd);

package/src/runtime/control-plane/execution/repository-work-attribution.ts

@@ -1,7 +1,5 @@
 import { readExecutionSession } from './session-store';
-import { controllerSessionPrincipalId, getControllerSession, listControllerSessions } from '../../../../packages/kernel/controller/api/index';
-import { getWorkContract } from '../../../../packages/kernel/work/api/index';
-import { isTerminalWorkContractStatus } from '../facade/types';
+import { getWorkContract, semanticWorkState } from '../../../../packages/kernel/work/api/index';
 
 export interface RepositoryWorkAttributionCaller {
   sessionId?: string;
@@ -22,12 +20,7 @@ export function resolveExplicitClaimedRepositoryWork(
 ) {
   if (!caller?.principalId?.trim()) return undefined;
   const work = getWorkContract({ controllerHome, repoId: target.repoId }, workId);
-  if (!work || isTerminalWorkContractStatus(work.status)) throw new Error(`WORK_ATTRIBUTION_INVALID: ${workId}`);
-  const owner = getControllerSession({ controllerHome, repoId: target.repoId }, workId);
-  if (!owner) throw new Error(`WORK_CONTROLLER_CLAIM_REQUIRED: ${workId}`);
-  if (controllerSessionPrincipalId(owner) !== caller.principalId.trim()) {
-    throw new Error(`WORK_CONTROLLER_OWNERSHIP_MISMATCH: ${workId}`);
-  }
+  if (!work || semanticWorkState(work) !== 'open') throw new Error(`WORK_ATTRIBUTION_INVALID: ${workId}`);
   if (work.checkoutId && work.checkoutId !== target.activeCheckoutId) {
     throw new Error(
       `WORK_CHECKOUT_MISMATCH: work=${workId}; resolved_checkout=${target.activeCheckoutId}; expected_work_checkout=${work.checkoutId}; retry with checkout_id=${work.checkoutId} and the same work_id`,
@@ -51,8 +44,8 @@ export function assertNoBoundExecutionSessionMutation(
   if (!workId || executionSession?.activeRepositoryId !== target.repoId) return;
   const work = getWorkContract({ controllerHome, repoId: target.repoId }, workId);
   if (!work) throw new Error(`WORK_ATTRIBUTION_INVALID: ${workId}`);
-  if (isTerminalWorkContractStatus(work.status)) {
-    throw new Error(`WORK_ATTRIBUTION_TERMINAL: ${work.workId}:${work.status}`);
+  if (semanticWorkState(work) !== 'open') {
+    throw new Error(`WORK_ATTRIBUTION_TERMINAL: ${work.workId}:${work.semanticState}`);
   }
   throw new Error(`WORK_ATTRIBUTION_REQUIRED: ${work.workId}; active execution session mutations must pass work_id explicitly`);
 }
@@ -80,27 +73,11 @@ export function resolveClaimedRepositoryWorkId(
       && executionSession?.activeRepositoryId === target.repoId
       && (!executionSession.activeCheckoutId || executionSession.activeCheckoutId === target.activeCheckoutId)) {
       const work = getWorkContract({ controllerHome, repoId: target.repoId }, workId);
-      if (work && isTerminalWorkContractStatus(work.status)) {
-        throw new Error(`WORK_ATTRIBUTION_TERMINAL: ${work.workId}:${work.status}`);
-      }
-      const owner = getControllerSession({ controllerHome, repoId: target.repoId }, workId);
-      if (work && owner?.sessionId === caller.sessionId && controllerSessionPrincipalId(owner) === caller.principalId.trim()) {
-        return workId;
+      if (work && semanticWorkState(work) !== 'open') {
+        throw new Error(`WORK_ATTRIBUTION_TERMINAL: ${work.workId}:${work.semanticState}`);
       }
+      if (work) return workId;
     }
   }
-  const principal = caller.principalId.trim();
-  const candidates = listControllerSessions({ controllerHome, repoId: target.repoId })
-    .filter((owner) => controllerSessionPrincipalId(owner) === principal)
-    .map((owner) => ({ owner, work: getWorkContract({ controllerHome, repoId: target.repoId }, owner.workId) }))
-    .filter((entry): entry is { owner: ReturnType<typeof listControllerSessions>[number]; work: NonNullable<ReturnType<typeof getWorkContract>> } => Boolean(
-      entry.work
-      && !isTerminalWorkContractStatus(entry.work.status)
-      && (!entry.work.checkoutId || entry.work.checkoutId === target.activeCheckoutId),
-    ));
-  if (candidates.length === 1) return candidates[0].work.workId;
-  if (candidates.length > 1) {
-    throw new Error(`WORK_ATTRIBUTION_AMBIGUOUS: principal ${principal} owns ${candidates.length} active Works on checkout ${target.activeCheckoutId}`);
-  }
   return undefined;
 }