@moretea-labs/forge 1.7.2 → 1.8.0

package/scripts/smoke-schedule-engine.ts

@@ -6,7 +6,7 @@ import { registerRepository } from '../src/cli/repositories/registry';
 import { listHandoffItems } from '../src/runtime/control-plane/facade/handoff-inbox-store';
 import { listExecutionJobs } from '../src/runtime/execution/jobs/store';
 import { evaluateSchedule } from '../src/runtime/workflow/schedules/engine';
-import { createSchedule, getSchedule, getScheduleDecision } from '../src/runtime/workflow/schedules/store';
+import { createSchedule, getSchedule, getScheduleDecision } from '../packages/kernel/scheduler/api/index';
 
 const root = mkdtempSync(join(tmpdir(), 'forge-schedule-smoke-'));
 const repoRoot = join(root, 'repo');

package/scripts/stage-runtime-release.ts

@@ -18,14 +18,18 @@ const args = process.argv.slice(2);
 const controllerHome = resolve(requiredOption(args, '--controller-home'));
 const sourceRoot = resolve(requiredOption(args, '--source-root'));
 const expectedHead = requiredOption(args, '--expected-head');
+const sourceRepositoryId = requiredOption(args, '--source-repository-id');
 if (!/^[a-f0-9]{40}$/i.test(expectedHead)) throw new Error('RUNTIME_RELEASE_CANDIDATE_EXPECTED_HEAD_INVALID');
 if (realpathSync(sourceRoot) !== realpathSync(process.cwd())) throw new Error('RUNTIME_RELEASE_CANDIDATE_CWD_MISMATCH');
 
-const staged = stageRuntimeRelease({ controllerHome, sourceRoot });
+const staged = stageRuntimeRelease({ controllerHome, sourceRoot, sourceRepositoryId });
 assertRuntimeReleaseFiles(staged);
 if (staged.sourceCommit !== expectedHead) {
   throw new Error(`RUNTIME_RELEASE_CANDIDATE_SOURCE_MISMATCH: expected ${expectedHead}, got ${staged.sourceCommit}`);
 }
+if (staged.sourceRepositoryId !== sourceRepositoryId) {
+  throw new Error(`RUNTIME_RELEASE_CANDIDATE_SOURCE_REPOSITORY_MISMATCH: expected ${sourceRepositoryId}, got ${staged.sourceRepositoryId ?? 'missing'}`);
+}
 
 const receipt: CandidateRuntimeStageReceiptV1 = {
   schemaVersion: 1,
@@ -35,5 +39,6 @@ const receipt: CandidateRuntimeStageReceiptV1 = {
   artifactIdentity: staged.artifactIdentity,
   manifestSha256: staged.manifestSha256,
   sourceCommit: staged.sourceCommit,
+  sourceRepositoryId,
 };
 process.stdout.write(`${JSON.stringify(receipt)}\n`);

package/scripts/test-governance.ts

@@ -1,5 +1,8 @@
 #!/usr/bin/env bun
-import { resolve } from 'path';
+import { mkdirSync, renameSync, writeFileSync } from 'fs';
+import { dirname, isAbsolute, resolve } from 'path';
+import { ensureControllerHome } from '../src/cli/repositories/controller-home';
+import { findRegisteredRepositoryByCheckoutRoot, registerRepository } from '../src/cli/repositories/registry';
 import {
   collectChangedPaths,
   loadTestManifest,
@@ -8,6 +11,11 @@ import {
   validateTestManifest,
   type TestGate,
 } from '../src/testing/test-governance';
+import { TEST_FAILURE_CODES } from './run-bun-test-file';
+import {
+  STRUCTURED_CHECK_RESULT_PATH_ENV,
+  type StructuredCheckFailureEvidence,
+} from '../src/runtime/execution/process-runtime/check-result';
 
 const ROOT = resolve(import.meta.dir, '..');
 const gates = new Set<TestGate>(['affected', 'core', 'integration', 'infrastructure', 'fault', 'full']);
@@ -44,12 +52,46 @@ export function parseTestGovernanceArgs(args: string[]): CliOptions {
   return { gate, changedPaths: changedPaths.filter(Boolean), explicitTests, baseRef, listOnly, validateOnly, useCache };
 }
 
+export function consumeStructuredCheckResultPath(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const value = env[STRUCTURED_CHECK_RESULT_PATH_ENV]?.trim();
+  delete env[STRUCTURED_CHECK_RESULT_PATH_ENV];
+  if (!value) return undefined;
+  if (!isAbsolute(value)) throw new Error('TEST_STRUCTURED_RESULT_PATH_MUST_BE_ABSOLUTE');
+  return value;
+}
+
+function writeStructuredCheckEvidence(path: string | undefined, evidence: StructuredCheckFailureEvidence): void {
+  if (!path) return;
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(evidence, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temporary, path);
+}
+
 export async function main(args: string[]): Promise<number> {
   const options = parseTestGovernanceArgs(args);
+  const structuredResultPath = consumeStructuredCheckResultPath();
   const manifest = loadTestManifest(ROOT);
   const errors = validateTestManifest(ROOT, manifest);
   if (errors.length > 0) {
     for (const error of errors) console.error(`[tests] manifest: ${error}`);
+    writeStructuredCheckEvidence(structuredResultPath, {
+      schemaVersion: 1,
+      producer: 'test-governance',
+      gate: options.gate,
+      status: 'failed',
+      failures: 1,
+      failureClasses: ['source'],
+      failureDetails: [{
+        file: 'tests/test-manifest.v1.json',
+        failureClass: 'source',
+        failureCode: TEST_FAILURE_CODES.SOURCE_MANIFEST_INVALID,
+        attempts: 1,
+        durationMs: 0,
+      }],
+      failureDetailsTruncated: false,
+      contaminated: false,
+    });
     return 1;
   }
   if (options.validateOnly) {
@@ -69,7 +111,14 @@ export async function main(args: string[]): Promise<number> {
     for (const file of selection.files) console.log(file);
     return 0;
   }
-  return runTestSelection(ROOT, manifest, selection, { useCache: options.useCache });
+  const controllerHome = ensureControllerHome();
+  const repository = findRegisteredRepositoryByCheckoutRoot(ROOT, controllerHome)
+    ?? registerRepository({ path: ROOT, controllerHome });
+  return runTestSelection(ROOT, manifest, selection, {
+    useCache: options.useCache,
+    storageAuthority: { controllerHome, repoId: repository.repoId },
+    onReceipt: (receipt) => writeStructuredCheckEvidence(structuredResultPath, receipt.failureEvidence),
+  });
 }
 
 if (import.meta.main) process.exitCode = await main(process.argv.slice(2));

package/src/cli/agent-jobs/job-manager.ts

@@ -36,7 +36,7 @@ import {
 } from "../controller/runtime-config";
 import { normalizeRemoteUrl, stableCheckoutId, stableRemoteRepoId } from "../repositories/identity";
 import { resolveRepoPreferredControllerHome } from "../repositories/controller-home";
-import { listRepositories } from "../repositories/registry";
+import { listRepositories, repositoryCheckoutRootMatches } from "../repositories/registry";
 import { managedWorktreePath } from "../repositories/worktree-storage";
 import {
   ensureControllerEpoch,
@@ -172,6 +172,15 @@ function atomicCreateJson(path: string, value: unknown): boolean {
 }
 
 function tryReadRepositoryIdentity(repoRoot: string): { repoId: string; checkoutId: string } {
+  const controllerHome = resolveRepoPreferredControllerHome(repoRoot);
+  const registered = listRepositories(controllerHome, { includeRemoved: true })
+    .find((record) => repositoryCheckoutRootMatches(record, repoRoot));
+  if (registered) {
+    return { repoId: registered.repoId, checkoutId: stableCheckoutId(registered.repoId, repoRoot) };
+  }
+
+  // Import-only compatibility for repositories that have not yet been registered
+  // into the Controller Home registry. New writes never recreate this file.
   const path = join(repoRoot, ".ai/harness/repository.json");
   let repoId = "";
   try {

package/src/cli/chatgpt-browser/bind-server.ts

@@ -13,6 +13,7 @@ import {
   openNativeBrowserPage,
 } from './native-provider';
 import type { NativeBrowserChannel } from './types';
+import { serveFetchHttp } from '../../runtime/platform/fetch-http-server';
 
 export interface BrowserBindServerOptions {
   profileDir?: string;
@@ -349,7 +350,7 @@ export async function startBrowserBindServer(repoRoot: string, opts: BrowserBind
     };
   }
 
-  const server = Bun.serve({
+  const server = await serveFetchHttp({
     hostname: host,
     port,
     async fetch(request) {

package/src/cli/chatgpt-browser/binding.ts

@@ -9,7 +9,7 @@ export const DEFAULT_CHATGPT_URL = 'https://chatgpt.com/';
 export interface ChatgptBrowserBinding {
   version: 1;
   product: 'chatgpt';
-  profileDir: string;
+  profileDir?: string;
   profileDirectory?: string;
   selectedProfilePath?: string;
   browserChannel: NativeBrowserChannel;
@@ -81,7 +81,7 @@ export function readBrowserBinding(repoRoot: string): { path: string; binding?:
   if (!existsSync(path)) return { path };
   try {
     const binding = JSON.parse(readFileSync(path, 'utf-8')) as ChatgptBrowserBinding;
-    if (binding.version !== 1 || binding.product !== 'chatgpt' || !binding.profileDir) {
+    if (binding.version !== 1 || binding.product !== 'chatgpt' || (!binding.profileDir && !binding.bridgeToken)) {
       return { path, error: 'binding file is malformed' };
     }
     return { path, binding };
@@ -110,17 +110,27 @@ export function writeBrowserBinding(repoRoot: string, opts: BrowserSetupOptions
 }
 
 /**
- * Return the binding's bridge capability token, lazily generating and persisting
- * one for pre-existing bindings that predate the token. Returns undefined when no
- * binding file exists (callers fall back to an ephemeral per-run token).
+ * Return the stable bridge capability token, lazily generating and persisting
+ * one for pre-existing bindings and creating a bridge-only binding when native
+ * profile configuration does not exist.
  */
-export function ensureBridgeToken(repoRoot: string): string | undefined {
+export function ensureBridgeToken(repoRoot: string): string {
   const current = readBrowserBinding(repoRoot).binding;
-  if (!current) return undefined;
-  if (current.bridgeToken) return current.bridgeToken;
+  if (current?.bridgeToken) return current.bridgeToken;
   const bridgeToken = generateBridgeToken();
-  const next: ChatgptBrowserBinding = { ...current, bridgeToken, updatedAt: new Date().toISOString() };
-  writeFileSync(resolveBrowserBindingPath(repoRoot), `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+  const next: ChatgptBrowserBinding = current
+    ? { ...current, bridgeToken, updatedAt: new Date().toISOString() }
+    : {
+        version: 1,
+        product: 'chatgpt',
+        browserChannel: 'chrome',
+        chatgptUrl: DEFAULT_CHATGPT_URL,
+        bridgeToken,
+        updatedAt: new Date().toISOString(),
+      };
+  const bindingPath = resolveBrowserBindingPath(repoRoot);
+  mkdirSync(dirname(bindingPath), { recursive: true });
+  writeFileSync(bindingPath, `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
   return bridgeToken;
 }
 

package/src/cli/chatgpt-browser/bridge-extension.ts

@@ -26,6 +26,7 @@ function forgeAuthHeaders(base) {
 const FORGE_CHATGPT_COMPOSERS = [
   '[data-testid="composer-text-input"]',
   '#prompt-textarea',
+  'textarea[name="prompt"]',
   'textarea[placeholder*="Message"]',
   'div[role="textbox"][contenteditable="true"]',
 ];
@@ -35,6 +36,7 @@ const FORGE_CHATGPT_SEND_BUTTONS = [
   'button[data-testid*="send"]',
 ];
 const FORGE_CHATGPT_ASSISTANT = '[data-message-author-role="assistant"]';
+const FORGE_CHATGPT_USER = '[data-message-author-role="user"]';
 
 function forgeVisible(element) {
   return Boolean(element && element.getClientRects && element.getClientRects().length);
@@ -72,11 +74,14 @@ async function forgeSleep(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+let forgeLastDispatch = null;
+
 async function forgeHeartbeat() {
   await forgePost('/api/extension/heartbeat', {
     url: location.href,
     title: document.title,
     composerVisible: Boolean(forgeComposer()),
+    lastDispatch: forgeLastDispatch,
     ts: new Date().toISOString(),
   });
 }
@@ -124,6 +129,69 @@ function forgeAssistantText() {
   return (nodes.at(-1)?.innerText || '').replace(/^ChatGPT said:\\s*/i, '').trim();
 }
 
+function forgeComposerText() {
+  const composer = forgeComposer();
+  if (!composer) return '';
+  return ('value' in composer ? composer.value : composer.textContent || '').trim();
+}
+
+function forgeNormalizeOutboundText(value) {
+  return String(value || '')
+    .split(String.fromCharCode(10)).join(' ')
+    .split(String.fromCharCode(13)).join(' ')
+    .split(String.fromCharCode(9)).join(' ')
+    .split(' ').filter(Boolean).join(' ')
+    .trim();
+}
+
+function forgeOutboundFingerprint(prompt) {
+  const normalized = forgeNormalizeOutboundText(prompt);
+  const prefix = normalized.slice(0, 160);
+  const suffix = normalized.length > 240 ? normalized.slice(-80) : '';
+  return suffix ? prefix + '|' + suffix : prefix;
+}
+
+function forgeOutboundMessageMatchesPrompt(messageText, prompt) {
+  const message = forgeNormalizeOutboundText(messageText);
+  const normalizedPrompt = forgeNormalizeOutboundText(prompt);
+  return Boolean(message && normalizedPrompt && message === normalizedPrompt);
+}
+
+function forgeHasConversationIdentity(urlValue) {
+  try {
+    const pathParts = new URL(urlValue, location.href).pathname.split('/').filter(Boolean);
+    return pathParts.length >= 2 && pathParts[0] === 'c' && Boolean(pathParts[1]);
+  } catch (_error) {
+    return false;
+  }
+}
+
+async function forgeWaitForSubmission(timeoutMs, initialUrl, prompt, initialUserMessageCount) {
+  const deadline = Date.now() + timeoutMs;
+  const initialHasConversation = forgeHasConversationIdentity(initialUrl);
+  let transportSignalObserved = false;
+  while (Date.now() < deadline) {
+    if (!forgeComposerText() || document.querySelector('[data-testid="stop-button"], button[aria-label*="Stop"]')) {
+      transportSignalObserved = true;
+    }
+    const userMessages = [...document.querySelectorAll(FORGE_CHATGPT_USER)];
+    const newUserMessage = userMessages.length > initialUserMessageCount ? userMessages.at(-1) : undefined;
+    const outboundConfirmed = Boolean(newUserMessage && forgeOutboundMessageMatchesPrompt(newUserMessage.innerText || newUserMessage.textContent || '', prompt));
+    const conversationEstablished = initialHasConversation || forgeHasConversationIdentity(location.href);
+    if (outboundConfirmed && conversationEstablished) {
+      return {
+        conversationUrl: location.href,
+        outboundFingerprint: forgeOutboundFingerprint(prompt),
+        confirmedAt: new Date().toISOString(),
+      };
+    }
+    await forgeSleep(100);
+  }
+  throw new Error(transportSignalObserved
+    ? 'ChatGPT transport changed, but the corresponding outbound user message fingerprint was not observed'
+    : 'ChatGPT prompt submission was not observed');
+}
+
 async function forgeWaitForAssistant(timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   let latest = '';
@@ -146,7 +214,14 @@ async function forgeWaitForAssistant(timeoutMs) {
 async function forgeRunTask(task) {
   await forgePost('/api/extension/task-started', {taskId: task.id, url: location.href});
   try {
+    const initialUserMessageCount = document.querySelectorAll(FORGE_CHATGPT_USER).length;
     await forgeSubmitPrompt(task.prompt);
+    if (task.dispatchOnly === true) {
+      const confirmation = await forgeWaitForSubmission(Math.min(task.timeoutMs || 10000, 10000), location.href, task.prompt, initialUserMessageCount);
+      forgeLastDispatch = {taskId: task.id, ...confirmation};
+      await forgePost('/api/extension/dispatched', forgeLastDispatch).catch(() => undefined);
+      return;
+    }
     const capture = await forgeWaitForAssistant(task.timeoutMs || 180000);
     await forgePost('/api/extension/result', {
       taskId: task.id,