@moretea-labs/forge 1.8.0 → 1.8.1

package/scripts/canary-controller-semantic-wait.ts

@@ -15,11 +15,9 @@ import {
   getControllerRoundRelay,
   readControllerRoundSemanticStateFingerprint,
   submitControllerRoundDisposition,
-} from '../src/runtime/control-plane/facade/controller-round-relay';
-import { bindControllerSessionBinding } from '../packages/kernel/controller/api/index';
-import { resumeScheduledControllerContinuation } from '../packages/kernel/scheduler/api/index';
+} from '../packages/kernel/controller/api/index';
+import { bindControllerSessionBinding, resumeControllerRoundOccurrence } from '../packages/kernel/controller/api/index';
 import { upsertChatgptControllerBinding } from '../adapters/chatgpt/controller-binding-store';
-import { createWorkContinuationSchedule } from '../src/runtime/workflow/schedules/work-continuation';
 
 const root = mkdtempSync(join(tmpdir(), 'forge-stage3c-semantic-wait-canary-'));
 const controllerHome = join(root, 'controller');
@@ -59,15 +57,14 @@ try {
     repoId: repository.repoId,
     requirementId,
     checkoutId: repository.activeCheckoutId,
-    mode: 'goal_workloop',
     objective: 'Prove semantic wait admission before provider dispatch.',
     acceptanceCriteria: ['Unchanged semantic state stays quiescent.', 'One meaningful state change wakes one successor.'],
     allowedPaths: [],
     forbiddenPaths: [],
     checks: [],
-    constraints: { requireHandoffOnAmbiguity: true },
+    constraints: {},
     requestedBy: 'chatgpt',
-    status: 'ready',
+    phase: 'verification',
   });
 
   const owner = claimControllerSession(store, {
@@ -88,13 +85,6 @@ try {
     tabPolicy: 'auto',
   });
   bindControllerSessionBinding(store, { workId, sessionId: owner.sessionId, binding: adapter.binding });
-  const { schedule } = createWorkContinuationSchedule(controllerHome, repository.repoId, {
-    workId,
-    scheduleMode: 'continuation',
-    controllerType: 'chatgpt',
-    triggerType: 'manual',
-    shadowMode: false,
-  });
   const relayScopeId = `requirement:${requirementId}`;
   beginInitialControllerRoundDispatch(store, {
     workId,
@@ -146,29 +136,27 @@ try {
       return { accepted: true, dispatchId: `stage3c-canary-provider-${providerCalls}` };
     },
   };
-  const unchanged = await resumeScheduledControllerContinuation(store, {
-    scheduleId: schedule.scheduleId,
+  const unchanged = await resumeControllerRoundOccurrence(store, {
     occurrenceId: 'stage3c-canary-unchanged',
     workId,
     controllerBindingId: adapter.binding.bindingId,
     relayScopeId,
   }, host);
-  if (unchanged.dispatch.status !== 'semantic_wait' || providerCallCount() !== 0) {
-    throw new Error(`CANARY_UNCHANGED_WAIT_DISPATCHED:${unchanged.dispatch.status}:calls=${providerCallCount()}`);
+  if (unchanged.outcome !== 'semantic_wait' || providerCallCount() !== 0) {
+    throw new Error(`CANARY_UNCHANGED_WAIT_DISPATCHED:${unchanged.outcome}:calls=${providerCallCount()}`);
   }
 
   recordWorkEvidenceState(store, workId, 'partial');
   const changedFingerprint = readControllerRoundSemanticStateFingerprint(store, workId);
   if (!changedFingerprint || changedFingerprint === baselineFingerprint) throw new Error('CANARY_MEANINGFUL_CHANGE_NOT_DETECTED');
-  const changed = await resumeScheduledControllerContinuation(store, {
-    scheduleId: schedule.scheduleId,
+  const changed = await resumeControllerRoundOccurrence(store, {
     occurrenceId: 'stage3c-canary-changed',
     workId,
     controllerBindingId: adapter.binding.bindingId,
     relayScopeId,
   }, host);
-  if (changed.dispatch.status !== 'dispatched' || providerCallCount() !== 1) {
-    throw new Error(`CANARY_CHANGED_STATE_DISPATCH_COUNT:${changed.dispatch.status}:calls=${providerCallCount()}`);
+  if (changed.outcome !== 'dispatched' || providerCallCount() !== 1) {
+    throw new Error(`CANARY_CHANGED_STATE_DISPATCH_COUNT:${changed.outcome}:calls=${providerCallCount()}`);
   }
   const finalRelay = getControllerRoundRelay(store, workId);
   if (finalRelay?.providerDispatchReceiptId !== 'stage3c-canary-provider-1') {
@@ -185,8 +173,8 @@ try {
     baselineFingerprint,
     timestampChurnFingerprint,
     changedFingerprint,
-    unchangedDispatchStatus: unchanged.dispatch.status,
-    changedDispatchStatus: changed.dispatch.status,
+    unchangedDispatchStatus: unchanged.outcome,
+    changedDispatchStatus: changed.outcome,
     providerCalls: providerCallCount(),
     providerDispatchReceiptId: finalRelay.providerDispatchReceiptId,
   }, null, 2));

package/scripts/check-mcp-compatibility.ts

@@ -1,5 +1,8 @@
 import { readFileSync } from 'fs';
 import { FORGE_TOOL_SURFACE, FORGE_VERSION, forgeToolSurfaceFingerprint } from '../src/cli/controller/runtime-config';
+import { injectAutomationEnvelopeFields } from '../adapters/mcp/runtime-gateway/automation-receipt-adapter';
+import { injectCognitionSettlementFields } from '../adapters/mcp/runtime-gateway/cognition-settlement';
+import { injectDurableCommandFields } from '../src/runtime/gateway/mcp/router';
 import { runtimePolicy } from '../src/cli/mcp/multi-repository';
 import { buildMcpToolDefinitions } from '../src/cli/mcp/tools';
 import { accessToolDefinitions } from '../src/cli/mcp/access-tools';
@@ -7,15 +10,6 @@ import { repositoryToolDefinitions } from '../src/cli/mcp/repository-tools';
 import { runtimeToolDefinitions } from '../src/runtime/gateway/mcp/runtime-tools';
 import { executionToolDefinitions } from '../src/runtime/gateway/mcp/execution-tools';
 import { processToolDefinitions } from '../src/runtime/gateway/mcp/process-tools';
-import {
-  buildPlanObligationCompatibilityCapability,
-  parseControllerRoundCompatibilityCapability,
-  parsePlanObligationCompatibilityCapability,
-} from '../adapters/mcp/controller-round-compatibility';
-import {
-  buildFrozenSemanticCompatibilityCapability,
-  parseFrozenSemanticCompatibilityCapability,
-} from '../adapters/mcp/frozen-client-semantic-compatibility';
 import {
   ADVANCED_CONTROLLER_TOOL_NAMES,
   CORE_CONTROLLER_TOOL_NAMES,
@@ -34,13 +28,20 @@ const MAX_DEFAULT_TOOL_COUNT = 24;
 // tool. Adapter extraction may move implementation ownership without silently
 // changing names, descriptions, input schemas, or annotations.
 const EXPECTED_STABLE_CONTROLLER_TOOL_NAMES = [
-  'rh_access', 'rh_status', 'rh_inbox', 'rh_context', 'rh_work',
+  'rh_access', 'rh_status', 'rh_inbox', 'rh_context', 'rh_work', 'capability_execute',
   'repository_list', 'repository_get', 'repository_register', 'repository_command_execute',
   'read_repository_file', 'repository_safe_patch_apply', 'run_check', 'plugin_action_execute',
-  'process_get', 'process_wait', 'process_logs', 'process_cancel', 'result_read', 'result_search',
+  'process_exec', 'process_get', 'process_wait', 'process_logs', 'process_cancel', 'result_read', 'result_search',
 ] as const;
-const EXPECTED_STABLE_TOOL_NAME_FINGERPRINT = '8e6613493e480a26';
-const EXPECTED_STABLE_TOOL_SCHEMA_FINGERPRINT = 'a6c8a8cb0af7f7d8';
+// The stable bounded surface now includes the generic typed capability executor
+// already shipped on main. V3 Work objective relations intentionally extend only
+// the existing rh_work input schema; both changes must invalidate stale Connector
+// schema snapshots without adding a parallel execution or graph authority.
+const EXPECTED_STABLE_TOOL_NAME_FINGERPRINT = 'b25da75c1f774e66';
+// Every public object-schema tool carries shared transport metadata only through
+// the final tools/list materialization path. Automation and Cognition settlement
+// revisions intentionally invalidate stale Connector schema snapshots.
+const EXPECTED_STABLE_TOOL_SCHEMA_FINGERPRINT = '643521037647c28a';
 
 const policy = runtimePolicy(process.cwd(), {
   profile: 'controller',
@@ -68,7 +69,9 @@ const advancedNames: string[] = [...ADVANCED_CONTROLLER_TOOL_NAMES];
 const catalogNames: string[] = [...STABLE_CONTROLLER_TOOL_NAMES];
 const preferredNames: string[] = [...PREFERRED_FACADE_TOOL_NAMES];
 const defaultFingerprint = forgeToolSurfaceFingerprint(defaultNames);
-const stableDefinitions = defaultNames.map((name) => definitionByName.get(name)).filter((tool) => tool !== undefined);
+const stableDefinitions = defaultNames
+  .map((name) => definitionByName.get(name)).filter((tool) => tool !== undefined)
+  .map((tool) => injectCognitionSettlementFields(injectAutomationEnvelopeFields(injectDurableCommandFields(tool))));
 const stableSchemaFingerprint = forgeToolSurfaceFingerprint(stableDefinitions);
 const catalogFingerprint = forgeToolSurfaceFingerprint(catalogNames);
 const fullFingerprint = forgeToolSurfaceFingerprint(fullNames);
@@ -88,8 +91,31 @@ const currentToolNames = new Set([
 const legacyHandlerSource = readFileSync(new URL('../src/cli/mcp/legacy-tool-service.ts', import.meta.url), 'utf8');
 const legacyHandlerNames = [...legacyHandlerSource.matchAll(/case\s+["']([^"']+)["']\s*:/g)].map((match) => match[1]);
 const legacyHandlerCollisions = [...new Set(legacyHandlerNames.filter((name) => currentToolNames.has(name)))].sort();
+const recoveryMcpSource = readFileSync(new URL('../src/runtime/standalone-recovery/mcp-server.ts', import.meta.url), 'utf8');
+const recoveryStatelessMarkers = [
+  'createMcpHandler',
+  'toNodeHandler',
+  "legacy: 'stateless'",
+  "responseMode: 'auto'",
+];
+const recoverySessionAuthorityMarkers = [
+  'McpSessionRegistry',
+  'NodeStreamableHTTPServerTransport',
+  'Mcp-Session-Reset',
+  'sessionIdGenerator',
+];
 
 const failures: string[] = [];
+for (const marker of recoveryStatelessMarkers) {
+  if (!recoveryMcpSource.includes(marker)) {
+    failures.push(`Standalone Recovery MCP must remain stateless across protocol eras: missing ${marker}`);
+  }
+}
+for (const marker of recoverySessionAuthorityMarkers) {
+  if (recoveryMcpSource.includes(marker)) {
+    failures.push(`Standalone Recovery MCP must not own transport-session state: found ${marker}`);
+  }
+}
 if (defaultNames.join('\n') !== EXPECTED_STABLE_CONTROLLER_TOOL_NAMES.join('\n')) {
   failures.push(`stable ChatGPT Tool Contract names changed: ${defaultNames.join(', ')}`);
 }
@@ -125,129 +151,15 @@ if (fullNames.length < defaultNames.length) {
 
 const rhWorkDefinition = runtimeToolDefinitions.find((tool) => tool.name === 'rh_work');
 const rhWorkProperties = (rhWorkDefinition?.inputSchema?.properties ?? {}) as Record<string, unknown>;
-if (!('capability_id' in rhWorkProperties)) failures.push('rh_work compatibility carrier capability_id is missing');
-if (!('obligation_dispositions' in rhWorkProperties)) failures.push('rh_work native obligation_dispositions schema is missing');
-
-const planCompatibilityFixture = [
-  {
-    predecessor_plan_id: 'PLAN-predecessor',
-    obligation_id: 'step:p0:acceptance:0',
-    disposition: 'change' as const,
-    successor_refs: ['step:p0:acceptance:0'],
-    rationale: 'successor expands the same obligation',
-  },
-  {
-    predecessor_plan_id: 'PLAN-predecessor',
-    obligation_id: 'step:p1',
-    disposition: 'keep' as const,
-    successor_refs: ['step:p1'],
-  },
-];
-try {
-  const capability = buildPlanObligationCompatibilityCapability(planCompatibilityFixture);
-  const parsed = parsePlanObligationCompatibilityCapability('plan_create', capability);
-  if (JSON.stringify(parsed) !== JSON.stringify(planCompatibilityFixture)) {
-    failures.push('frozen Plan obligation compatibility round-trip changed the typed payload');
-  }
-  if (parsePlanObligationCompatibilityCapability('repair', capability) !== undefined) {
-    failures.push('frozen Plan obligation compatibility must be scoped to plan_create');
-  }
-  try {
-    parsePlanObligationCompatibilityCapability('plan_create', 'plan.obligations.v1:not+base64');
-    failures.push('frozen Plan obligation compatibility accepted malformed payload');
-  } catch {
-    // Expected: malformed frozen-client transport input remains fail-closed.
-  }
-} catch (error) {
-  failures.push(`frozen Plan obligation compatibility failed: ${error instanceof Error ? error.message : String(error)}`);
+for (const field of [
+  'checkout_id',
+  'workflow_id',
+  'workflow_run_id',
+  'outcome_observation',
+  'experience_draft',
+] as const) {
+  if (!(field in rhWorkProperties)) failures.push(`stable rh_work Tool Contract missing ${field}`);
 }
-
-try {
-  const authorityId = `cra_${'a'.repeat(32)}`;
-  const relayScopeId = 'goal:work-frozen-review-compatibility';
-  const parsedReview = parseControllerRoundCompatibilityCapability(
-    'repair',
-    `controller.round:review:approved:${authorityId}:${relayScopeId}`,
-  );
-  if (JSON.stringify(parsedReview) !== JSON.stringify({ operation: 'review', authorityId, relayScopeId, reviewDecision: 'approved' })) {
-    failures.push('frozen ControllerRound review compatibility changed authority, scope, or review decision');
-  }
-  const parsedVerify = parseControllerRoundCompatibilityCapability(
-    'repair',
-    `controller.round:verify:${authorityId}:${relayScopeId}`,
-  );
-  if (JSON.stringify(parsedVerify) !== JSON.stringify({ operation: 'verify', authorityId, relayScopeId })) {
-    failures.push('legacy ControllerRound compatibility changed non-review operation semantics');
-  }
-  for (const invalid of [
-    `controller.round:review:${authorityId}:${relayScopeId}`,
-    `controller.round:review:maybe:${authorityId}:${relayScopeId}`,
-  ]) {
-    try {
-      parseControllerRoundCompatibilityCapability('repair', invalid);
-      failures.push('frozen ControllerRound review compatibility accepted a missing or invalid explicit decision');
-    } catch {
-      // Expected: frozen review must carry one explicit canonical review decision.
-    }
-  }
-} catch (error) {
-  failures.push(`frozen ControllerRound review compatibility failed: ${error instanceof Error ? error.message : String(error)}`);
-}
-
-try {
-  const semanticFixture = {
-    operation: 'requirement_create' as const,
-    args: {
-      requirement_title: 'Frozen semantic compatibility',
-      requirement_outcome: 'Use the canonical Requirement authority through an old rh_work schema.',
-      requirement_acceptance_criteria: ['Compatibility remains transport-only.'],
-    },
-  };
-  const capability = buildFrozenSemanticCompatibilityCapability(semanticFixture);
-  const parsed = parseFrozenSemanticCompatibilityCapability('repair', capability);
-  if (JSON.stringify(parsed) !== JSON.stringify(semanticFixture)) {
-    failures.push('frozen semantic compatibility round-trip changed the typed payload');
-  }
-  const planFixture = {
-    operation: 'plan_create' as const,
-    args: {
-      obligation_dispositions: [{
-        predecessor_plan_id: 'PLAN-R1',
-        obligation_id: 'obl-example',
-        disposition: 'keep' as const,
-        successor_refs: ['step:implementation'],
-      }],
-    },
-  };
-  const planCapability = buildFrozenSemanticCompatibilityCapability(planFixture);
-  const parsedPlan = parseFrozenSemanticCompatibilityCapability('repair', planCapability);
-  if (JSON.stringify(parsedPlan) !== JSON.stringify(planFixture)) {
-    failures.push('frozen Plan successor semantic compatibility changed obligation dispositions');
-  }
-  try {
-    parseFrozenSemanticCompatibilityCapability('plan_create', capability);
-    failures.push('frozen semantic compatibility accepted a non-repair transport operation');
-  } catch {
-    // Expected: the generic semantic envelope is reachable only through the stable repair transport.
-  }
-  const unknownOperation = `semantic.v1:${Buffer.from(JSON.stringify({ v: 1, op: 'finalize', a: {} }), 'utf8').toString('base64url')}`;
-  try {
-    parseFrozenSemanticCompatibilityCapability('repair', unknownOperation);
-    failures.push('frozen semantic compatibility accepted an operation outside the explicit allowlist');
-  } catch {
-    // Expected: compatibility cannot grow into an arbitrary-operation tunnel.
-  }
-  const unknownField = `semantic.v1:${Buffer.from(JSON.stringify({ v: 1, op: 'requirement_create', a: { requirement_title: 'x', requirement_outcome: 'y', remote_write: true } }), 'utf8').toString('base64url')}`;
-  try {
-    parseFrozenSemanticCompatibilityCapability('repair', unknownField);
-    failures.push('frozen semantic compatibility accepted an unknown operation argument');
-  } catch {
-    // Expected: each allowlisted operation has an exact transport schema.
-  }
-} catch (error) {
-  failures.push(`frozen semantic compatibility failed: ${error instanceof Error ? error.message : String(error)}`);
-}
-
 if (failures.length) {
   console.error('[mcp-compatibility] FAILED');
   for (const failure of failures) console.error(`- ${failure}`);