@moretea-labs/forge 1.7.0 → 1.7.2

package/src/runtime/execution/process-runtime/command-facade.ts

@@ -10,7 +10,7 @@
 
 import type { RepositoryRecord } from '../../../cli/repositories/types';
 import { repositoryGitStatus } from '../../../cli/repositories/structured-git';
-import { classifyRepositoryCommand, fixedShellWrapperCommand } from '../../../cli/repositories/command-classifier';
+import { classifyRepositoryCommand, fixedShellWrapperCommand, shellSegments, shellWordsPreservingQuotes } from '../../../cli/repositories/command-classifier';
 import {
   executeRepositoryCommandAsync,
   executeRepositoryReadOnlyCommandDirect,
@@ -237,29 +237,40 @@ function repositoryCommandRecoveryLifecycle(command: string | readonly string[])
   return wrapped ? recoveryLifecycleFromShell(wrapped) : undefined;
 }
 
-function rawGitCommitRequiresExplicitPathScope(command: string | readonly string[]): boolean {
-  const normalized = normalizeRepositoryCommand(command);
-  if (normalized.kind === 'shell') {
-    return /(?:^|[;&|]\s*)\s*git\s+commit\b/i.test(normalized.shellCommand ?? '');
-  }
-  const executable = commandBasename(normalized.executable ?? '');
-  const args = [...(normalized.args ?? [])];
-  if (executable !== 'git') {
-    const wrapped = fixedShellWrapperCommand(normalized.value as string[]);
-    return wrapped ? /(?:^|[;&|]\s*)\s*git\s+commit\b/i.test(wrapped) : false;
-  }
+function gitCommitWordsRequireExplicitPathScope(words: readonly string[]): boolean | undefined {
+  const executable = commandBasename(words[0] ?? '');
+  if (executable !== 'git') return undefined;
+  const args = words.slice(1);
   let index = 0;
   while (index < args.length && args[index]?.startsWith('-')) {
     const option = args[index]!;
     if (['-c', '-C', '--git-dir', '--work-tree', '--namespace'].includes(option)) index += 2;
+    else if (['--git-dir=', '--work-tree=', '--namespace='].some((prefix) => option.startsWith(prefix))) index += 1;
     else index += 1;
   }
-  if (args[index]?.toLowerCase() !== 'commit') return false;
+  if (args[index]?.toLowerCase() !== 'commit') return undefined;
   const commitArgs = args.slice(index + 1);
   const pathSeparator = commitArgs.indexOf('--');
-  const hasExplicitOnly = commitArgs.includes('--only') || commitArgs.includes('-o');
   const paths = pathSeparator >= 0 ? commitArgs.slice(pathSeparator + 1).filter(Boolean) : [];
-  return !(hasExplicitOnly && paths.length > 0);
+  const widensScope = commitArgs.some((arg) => ['-a', '--all', '-i', '--include', '--interactive', '-p', '--patch'].includes(arg));
+  return paths.length === 0 || widensScope;
+}
+
+function rawGitCommitRequiresExplicitPathScope(command: string | readonly string[]): boolean {
+  const normalized = normalizeRepositoryCommand(command);
+  if (normalized.kind === 'argv') {
+    const direct = gitCommitWordsRequireExplicitPathScope([
+      normalized.executable ?? '',
+      ...(normalized.args ?? []),
+    ]);
+    if (direct !== undefined) return direct;
+    const wrapped = fixedShellWrapperCommand(normalized.value as string[]);
+    if (!wrapped) return false;
+    return shellSegments(wrapped)
+      .some((segment) => gitCommitWordsRequireExplicitPathScope(shellWordsPreservingQuotes(segment)) === true);
+  }
+  return shellSegments(normalized.shellCommand ?? '')
+    .some((segment) => gitCommitWordsRequireExplicitPathScope(shellWordsPreservingQuotes(segment)) === true);
 }
 
 function toProcessCommand(command: string | readonly string[], cwd: string): ProcessCommandSpec {
@@ -286,6 +297,7 @@ export function classifyRepositoryCommandRoute(
   command: string | readonly string[],
   options: {
     forceDurable?: boolean;
+    workId?: string;
     defaultBranch?: string;
     timeoutMs?: number;
   } = {},
@@ -300,6 +312,12 @@ export function classifyRepositoryCommandRoute(
     return { route: 'durable', reason: 'force_durable_or_async' };
   }
   const classification = classifyRepositoryCommand(command, options.defaultBranch);
+  // Work-bound effects must survive Controller/Runtime rotation with one durable
+  // Process identity. Read-only observations can remain ephemeral because they
+  // have no ambiguous side effect to reconcile after a restart.
+  if (options.workId?.trim() && classification.risk !== 'readonly') {
+    return { route: 'process_managed', reason: 'work_attributed_effectful_durable' };
+  }
   const text = Array.isArray(command) ? command.join(' ') : String(command);
   // Classification chooses scheduling/receipt granularity only; it does not
   // decide whether a scoped repository command is allowed to run. Known remote
@@ -354,8 +372,7 @@ export async function executeRepositoryCommandViaProcessRuntime(
   assertRepositoryCommandNoPluginExecutionBypass(input.command);
   const decision = classifyRepositoryCommandRoute(input.command, {
     forceDurable: input.forceDurable,
-    // Work identity is continuity/audit metadata only. It must not change the
-    // execution lane of an otherwise ordinary local repository command.
+    workId: input.workId,
     defaultBranch: input.repository.defaultBranch,
     timeoutMs: input.timeoutMs,
   });
@@ -454,6 +471,11 @@ export async function executeRepositoryCommandViaProcessRuntime(
         deferStart: deferLongPreparation,
         reuseActiveEquivalent: deferLongPreparation,
         onCompleted: (result) => {
+          // A terminal child exit is sufficient to close the Process, but not to
+          // advance Work mutation authority when post-execution repository
+          // evidence is unavailable. Finalization must keep failing closed until
+          // a later authoritative repository inspection proves the new HEAD.
+          if (result.evidenceError) return;
           settleWorkHandleExpectedHeadAfterRepositoryCommand({
             controllerHome: input.controllerHome,
             repository: input.repository,

package/src/runtime/execution/process-runtime/lightweight-managed.ts

@@ -52,6 +52,8 @@ interface LightweightExecutionResult {
   cancelled?: boolean;
   stdout?: string;
   stderr?: string;
+  /** Child execution completed, but repository mutation evidence could not be proven. */
+  evidenceError?: { code: string; message: string };
 }
 
 interface LightweightExitObservation {
@@ -714,16 +716,31 @@ export async function startLightweightRepositoryCommand(
           timedOut: result.timedOut,
           cancelled: result.cancelled,
         };
-        persistRunningReceipt(entry, true);
+        // Child exit is the authoritative Process terminal boundary. Repository
+        // post-processing may continue, but it must never keep this Process
+        // logically running or make process_get/process_wait lose the exit fact.
+        entry.result = result;
+        entry.finishedAtMs = Date.now();
+        input.execution.signal?.removeEventListener('abort', onCallerAbort);
+        persistTerminalReceipt(input.controllerHome, entry);
       },
     },
   ).then((result) => {
+    // Enriched execution evidence may replace the compact child-exit result in
+    // memory. The already-persisted terminal Process identity remains stable.
+    // Work lifecycle settlement belongs here, after repository evidence has
+    // either been proven or explicitly marked unavailable.
     entry.result = result;
-    entry.finishedAtMs = Date.now();
-    input.execution.signal?.removeEventListener('abort', onCallerAbort);
     input.onCompleted?.(result);
     persistTerminalReceipt(input.controllerHome, entry);
     return result;
+  }).catch((error) => {
+    // Once child exit has been observed, later bookkeeping failure cannot revoke
+    // the terminal Process fact or trigger command replay. Expected snapshot
+    // degradation is represented by RepositoryCommandExecution.evidenceError;
+    // this catch is the final fail-safe for any later post-processing exception.
+    if (entry.exitObservation && entry.result) return entry.result;
+    throw error;
   });
   entry.promise = input.deferStart
     ? new Promise<LightweightExecutionResult>((resolve, reject) => {

package/src/runtime/execution/process-runtime/persisted-check.ts

@@ -276,7 +276,10 @@ export async function runPersistedCheckViaProcessRuntime(
     checkFingerprint,
     '--result-receipt',
     checkResultReceiptPath,
-    ...(verificationSnapshot ? ['--cleanup-root', verificationSnapshot.root] : []),
+    ...(verificationSnapshot ? [
+      '--isolated-controller-home', verificationSnapshot.isolatedControllerHome,
+      '--cleanup-root', verificationSnapshot.root,
+    ] : []),
   ];
   const invocation = resolvePersistedCheckProcessInvocation(cliTarget, checkArgs);
   let handle;

package/src/runtime/execution/process-runtime/runtime.ts

@@ -694,6 +694,16 @@ export function resolveProcessRunnerEntryPath(
   const configured = env.FORGE_PROCESS_RUNNER_ENTRY?.trim();
   if (configured && existsSync(configured)) return configured;
 
+  // macOS launchd runs the immutable Runtime through a stable mirrored
+  // executable path for TCC identity. In that mode process.execPath is not a
+  // sibling of the active release sidecars, so use the release authority path
+  // exported by the launch contract before any executable/source fallback.
+  const releaseRoot = env.FORGE_RELEASE_PATH?.trim();
+  if (releaseRoot) {
+    const releaseRunner = join(releaseRoot, 'process-runner.js');
+    if (existsSync(releaseRunner)) return releaseRunner;
+  }
+
   // Compiled daemon/Gateway entrypoints and process-runner.js are siblings in
   // every immutable release. Prefer that closed release surface before looking
   // at source paths recorded only for diagnostics and development fallback.

package/src/runtime/execution/process-runtime/types.ts

@@ -140,18 +140,8 @@ export interface ProcessRequestBinding {
   createdAt: string;
 }
 
-/** Content-bound Check identity used only to index/reuse Process Runtime evidence. */
-export interface ProcessCheckExecutionIdentity {
-  schemaVersion: 1;
-  checkId: string;
-  cacheKey: string;
-  revision: string;
-  definitionDigest: string;
-  environmentFingerprint: string;
-  timeoutMs: number;
-  reuseScope: 'repository' | 'checkout';
-  scopeKey: string;
-}
+export type { ProcessCheckExecutionIdentity } from '../../evidence/process-check-execution';
+import type { ProcessCheckExecutionIdentity } from '../../evidence/process-check-execution';
 
 /** Persistent semantic Check binding to one physical Process record. */
 export interface ProcessCheckExecutionBinding {

package/src/runtime/execution/work-activity.ts

@@ -0,0 +1,21 @@
+import { listActiveExecutionJobs } from './jobs/store';
+import type { ExecutionJob } from './jobs/types';
+import { listRecoverableProcessRecords } from './process-runtime/store';
+import { isManagedProcessActive } from './process-runtime/types';
+
+export function executionJobBelongsToWork(job: ExecutionJob, workId: string): boolean {
+  if (job.resourceClaims.some((claim) => claim.workId === workId)) return true;
+  const payload = job.payload as Record<string, unknown>;
+  const args = payload.arguments && typeof payload.arguments === 'object' && !Array.isArray(payload.arguments)
+    ? payload.arguments as Record<string, unknown>
+    : undefined;
+  return [payload.workId, payload.work_id, args?.workId, args?.work_id].some((value) => value === workId);
+}
+
+export function workHasActiveExecution(controllerHome: string, repoId: string, workId: string): boolean {
+  const activeProcess = listRecoverableProcessRecords(controllerHome, repoId)
+    .some((record) => record.workId === workId && isManagedProcessActive(record));
+  if (activeProcess) return true;
+  return listActiveExecutionJobs(controllerHome, repoId)
+    .some((job) => executionJobBelongsToWork(job, workId));
+}

package/src/runtime/execution/workers/executor.ts

@@ -28,6 +28,8 @@ import { writeExecutionArtifact } from '../../evidence/artifact-store';
 import { existsSync } from 'fs';
 import { isAbsolute, relative, resolve, sep } from 'path';
 import { isAssistantPluginError } from '../../plugins/errors';
+import { executeWork, validateWork } from '../../control-plane/execution/work-operation-service';
+import { finalizeWork } from '../../control-plane/execution/work-finalization-service';
 
 
 function childReferenceFromLocalJob(
@@ -524,23 +526,26 @@ export async function executeExecutionJob(controllerHome: string, job: Execution
       toolset: job.payload.toolset === 'core' || job.payload.toolset === 'full' ? job.payload.toolset : 'advanced',
       toolsetLocked: true,
     };
-    // Public Work mutations are admitted by the Gateway, then executed exactly
-    // once here. Calling the implementation directly avoids recursive Job
-    // creation while preserving the existing Work validation/authorization path.
+    // Durable Work mutations execute through control-plane application services.
+    // The Worker must never import MCP transport to obtain Work semantics.
     const durableWorkOperation = job.payload.operation === 'work_execute'
       || job.payload.operation === 'work_validate'
       || job.payload.operation === 'work_finalize';
-    // Load the Work implementation only for Work Jobs. A static import here
-    // creates an initialization cycle through repository command and Local Bridge
-    // modules, changing unrelated execution behavior.
     const toolArguments = { ...(job.payload.arguments ?? {}) };
-    const executionResult = durableWorkOperation
-      ? await import('../../gateway/mcp/execution-tools').then(({ callExecutionTool }) =>
-        callExecutionTool(runtimeContext, job.payload.operation, {
-          ...toolArguments,
-          __from_durable_worker: true,
-          __execution_job_id: job.jobId,
-        }))
+    const workArguments = {
+      ...toolArguments,
+      __from_durable_worker: true,
+      __execution_job_id: job.jobId,
+    };
+    const executionRecord = job.payload.operation === 'work_execute'
+      ? await executeWork(runtimeContext, workArguments)
+      : job.payload.operation === 'work_validate'
+        ? await validateWork(runtimeContext, workArguments)
+        : job.payload.operation === 'work_finalize'
+          ? await finalizeWork(runtimeContext, workArguments)
+          : undefined;
+    const executionResult: CallToolResult | undefined = durableWorkOperation && executionRecord
+      ? { structuredContent: executionRecord, content: [] }
       : undefined;
     const runtimeResult = executionResult ?? (policy.profile === 'controller'
       ? await callRuntimeTool(runtimeContext, job.payload.operation, toolArguments)