@gakim-digital/dexter-bridge 0.11.0 → 0.11.2

package/README.md

@@ -39,7 +39,7 @@ progress, cancellation, and result interface.
 The Framer harness receives only these project-scoped tools:
 
 - `framer_instructions` and `framer_context`
-- `framer_read_project` and `framer_apply_changes`
+- `framer_read_project`, `framer_verify_interactions`, and `framer_apply_changes`
 - restricted `framer_read` and `framer_write`
 - `progress_update`
 
@@ -47,21 +47,34 @@ Native shell, filesystem, web, and unrelated-project access are disabled for
 Framer outcome runs. Publishing is denied unless a future assignment explicitly
 authorizes it.
 
-Project connection is automatic and completes before the model starts:
-
-- The run carries the project ID that Dexter read from the open Framer project.
-- The bridge first reuses an active Framer Agent session or locally authorized
-  project.
-- If needed, the active paired device redeems the matching encrypted
-  per-project credential from the API and installs it through Framer’s official
-  CLI.
-- If no credential exists, or Framer rejects a stale one, Dexter opens Framer’s
-  browser authorization and resumes the same run automatically after approval.
+Bridges advertise `framer-interaction-verification-v1`,
+`framer-behavior-contract-v1`, and `framer-mechanism-verification-v1` only
+when interaction work is declared as observable behavior, checked against the
+selected Framer mechanism before mutation, and verified from live canonical
+Framer nodes afterward. Repeated behavior is verified on one representative
+target before the remaining targets are changed.
+
+Project connection is handled inside Dexter and completes before the model
+starts:
+
+- The plugin reads the exact active project or branch URL directly from Framer.
+- The user adds a Framer project API key once in Dexter. The API verifies it
+  through Framer's documented `connect(projectId, apiKey)` plus
+  `getProjectInfo()` flow, then encrypts and stores it only after that succeeds.
+- The active hosted runtime redeems that verified credential only for the
+  matching run and device, then installs it with Framer’s official
+  `project auth` command against the authoritative 20-character project ID.
+- The runtime opens an official Framer Agent session, reads the active branch
+  back from Framer, and confirms the authoritative project ID again.
+- Rejected credentials are revoked. Replacing a key creates a new credential
+  version, so a cached runtime session cannot reuse the replacement.
+- Hosted worker images bundle the Framer skills and seed them into each
+  runtime's private writable home before processing runs.
 
 The user never runs `@framer/agent setup`, `project auth`, or `session new`.
 The raw project credential is scoped to the matching active run and paired
 device, is excluded from run payloads and logs, and is never sent to the Framer
-plugin.
+plugin after the one-time authenticated submission.
 
 The bridge reports provider token usage on terminal events, including
 interrupted and cancelled runs. Claude-reported
@@ -291,10 +304,10 @@ Recommended release env:
 
 ```bash
 FRAMER_COMPANION_DOWNLOAD_URL=https://instawebai.com/dexter-bridge
-NEXT_PUBLIC_DEXTER_BRIDGE_VERSION=0.11.0
+NEXT_PUBLIC_DEXTER_BRIDGE_VERSION=0.11.1
 NEXT_PUBLIC_DEXTER_BRIDGE_DOWNLOAD_BASE_URL=https://instawebai.com/downloads/dexter-bridge
-NEXT_PUBLIC_DEXTER_BRIDGE_MAC_ARM64_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.0-mac-arm64.dmg
-NEXT_PUBLIC_DEXTER_BRIDGE_MAC_X64_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.0-mac-x64.dmg
-NEXT_PUBLIC_DEXTER_BRIDGE_MAC_ZIP_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.0-mac-universal.zip
-NEXT_PUBLIC_DEXTER_BRIDGE_WIN_X64_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.0-win-x64.exe
+NEXT_PUBLIC_DEXTER_BRIDGE_MAC_ARM64_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.1-mac-arm64.dmg
+NEXT_PUBLIC_DEXTER_BRIDGE_MAC_X64_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.1-mac-x64.dmg
+NEXT_PUBLIC_DEXTER_BRIDGE_MAC_ZIP_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.1-mac-universal.zip
+NEXT_PUBLIC_DEXTER_BRIDGE_WIN_X64_URL=https://instawebai.com/downloads/dexter-bridge/Dexter-Bridge-0.11.1-win-x64.exe
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gakim-digital/dexter-bridge",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Local bridge for InstaWebAI and Dexter — runs Codex, Claude Code, or OpenCode on your machine.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -4,7 +4,11 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import crossSpawn from 'cross-spawn';
-import { getFramerProjectAuthorization, postRunEvent } from './api.js';
+import {
+  getFramerProjectAuthorization,
+  postRunEvent,
+  reportFramerProjectAuthorizationVerification,
+} from './api.js';
 import {
   createCompanionUsageAccumulator,
   createClaudeProgressParser,
@@ -60,15 +64,15 @@ const HARNESS_MCP_SERVER_PATH = fileURLToPath(
 export function harnessMcpProcessEnvironment(
   gateway,
   versions = process.versions,
-  allowedToolNames,
+  toolDefinitions,
 ) {
   return {
     INSTAWEB_HARNESS_GATEWAY_URL: gateway.url,
     INSTAWEB_HARNESS_GATEWAY_TOKEN: gateway.token,
-    ...(Array.isArray(allowedToolNames)
+    ...(Array.isArray(toolDefinitions)
       ? {
-          INSTAWEB_HARNESS_ALLOWED_TOOLS:
-            JSON.stringify(allowedToolNames),
+          INSTAWEB_HARNESS_TOOL_DEFINITIONS:
+            JSON.stringify(toolDefinitions),
         }
       : {}),
     ...(versions?.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
@@ -92,8 +96,8 @@ function deltaModelSessionsEnabled(env = process.env) {
 }
 
 function companionSessionKey(run) {
-  return run?.outcome?.session?.goalSessionId
-    || run?.outcome?.session?.sessionId
+  return run?.outcome?.session?.sessionId
+    || run?.outcome?.session?.goalSessionId
     || run?.modelTurn?.session?.goalSessionId
     || run?.modelTurn?.session?.sessionId
     || run?.turnId
@@ -318,7 +322,8 @@ function claudeOutcomeSystemPrompt(product) {
       'Inspect the project, perform the requested work, verify the result, and return the structured outcome.',
       'Do not access local credentials, unrelated files, other projects, account settings, or billing.',
       'Do not publish unless the assignment explicitly authorizes publishing.',
-      'Call progress_update before the first inspection or edit and at meaningful phase changes.',
+      'Call progress_update before the first inspection or edit and at meaningful phase changes. Use one or two natural first-person sentences that name the specific page area, component, or behavior and the concrete change you are about to make or are making now; optionally say what you will check next. Avoid generic updates such as "working on the next step", "thinking", "loading", or "making changes".',
+      'If framer_write is rejected by the safety boundary, do not retry JavaScript variants. Switch to framer_apply_changes, inspect the relevant state, or report the concrete blocker.',
       `Return only the structured outcome result requested by ${name}.`,
     ].join(' ');
   }
@@ -1317,6 +1322,13 @@ function adapterInvocationModel(run, selectedModel, agent) {
   if (typeof runtimeInvocation === 'string' && runtimeInvocation.trim()) {
     return runtimeInvocation.trim();
   }
+  if (
+    run?.companion?.modelPolicy?.owner === 'harness'
+    && typeof selectedModel?.invocationName === 'string'
+    && selectedModel.invocationName.trim()
+  ) {
+    return selectedModel.invocationName.trim();
+  }
   const explicit = run?.companion?.model?.invocationName;
   if (typeof explicit === 'string' && explicit.trim()) return explicit.trim();
   if (selectedModel?.invocationName) return selectedModel.invocationName;
@@ -1326,12 +1338,63 @@ function adapterInvocationModel(run, selectedModel, agent) {
   return raw.startsWith(prefix) ? raw.slice(prefix.length) : raw || undefined;
 }
 
+function harnessOutcomeModel(run, definition) {
+  const requestedModel =
+    run?.runtimeProfile?.model?.id
+    || run?.companion?.model?.id
+    || run?.model;
+  const requested =
+    run?.runtimeProfile?.model
+    || companionModelDefinition(requestedModel, definition.id);
+  if (run?.companion?.modelPolicy?.owner !== 'harness') return requested;
+  const candidates = (
+    Array.isArray(run?.companion?.models)
+      ? run.companion.models
+      : []
+  ).filter((model) =>
+    model
+    && typeof model === 'object'
+    && String(model.agent || definition.id) === definition.id);
+  if (!candidates.length) return requested;
+  const mode = String(run.companion.modelPolicy.mode || 'auto');
+  if (mode === 'advanced') {
+    return candidates.find((model) => model.id === requested.id) || requested;
+  }
+  if (mode === 'auto') {
+    return (
+      candidates.find((model) => model.isDefault === true)
+      || candidates.find((model) => model.id === requested.id)
+      || requested
+    );
+  }
+  const tier = mode === 'fast' ? 'fast' : 'director';
+  const costRank = { '$': 1, '$$': 2, '$$$': 3 };
+  return (
+    candidates.find((model) => model.routingTier === tier)
+    || [...candidates].sort((left, right) => {
+      const leftRank = costRank[left.costTier] || 2;
+      const rightRank = costRank[right.costTier] || 2;
+      return mode === 'fast'
+        ? leftRank - rightRank
+        : rightRank - leftRank;
+    })[0]
+    || requested
+  );
+}
+
 function controlRequestsCancellation(response) {
   return Boolean(
     response?.control?.cancelRequested || response?.status === 'cancelled' || response?.status === 'expired',
   );
 }
 
+function controlCancellationSource(response) {
+  const source = String(response?.control?.cancelSource || '').trim();
+  if (source) return source;
+  if (response?.status === 'expired') return 'deadline';
+  return 'unknown';
+}
+
 function boundedDurationMs(value, fallback, minimum = 10, maximum = 60 * 60 * 1000) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) return fallback;
@@ -1357,11 +1420,31 @@ function waitForControl(delayMs, signal) {
 }
 
 class CompanionRunCancelledError extends Error {
-  constructor(message = 'The local bridge model turn was cancelled.') {
+  constructor(
+    message = 'The local bridge model turn was cancelled.',
+    cancellationSource = 'unknown',
+  ) {
     super(message);
     this.name = 'CompanionRunCancelledError';
     this.code = 'RUN_CANCELLED';
+    this.cancellationSource = cancellationSource;
+  }
+}
+
+function cancellationMessage(error) {
+  const framer = error?.framer || error?.companionUsage?.framer;
+  const mutationCalls = Number(framer?.mutationCalls) || 0;
+  if (mutationCalls <= 0) {
+    return 'Stopped before Dexter completed a Framer change.';
   }
+  const verificationCompleted = framer?.verification?.completed === true;
+  return [
+    `Stopped after ${mutationCalls} successful Framer change ${mutationCalls === 1 ? 'batch' : 'batches'}.`,
+    'Those changes remain in Framer.',
+    verificationCompleted
+      ? 'The harness verified the latest project state before the run stopped.'
+      : 'The harness did not verify the final project state before the run stopped.',
+  ].join(' ');
 }
 
 async function callProviderAdapter(
@@ -2093,13 +2176,14 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
     || run?.companion?.model?.id
     || run?.model
     || options.selectedModel;
-  const selectedModel =
-    run?.runtimeProfile?.model
-    || companionModelDefinition(requestedModel, definition.id);
+  const selectedModel = harnessOutcomeModel(run, definition);
   const selectedModelId =
-    typeof requestedModel === 'string' && requestedModel.trim()
-      ? requestedModel.trim()
-      : selectedModel?.id || definition.model;
+    selectedModel?.id
+    || (
+      typeof requestedModel === 'string' && requestedModel.trim()
+        ? requestedModel.trim()
+        : definition.model
+    );
   const outcomeMaxDurationMs = boundedDurationMs(
     run?.outcome?.maxDurationMs
       ?? options.maxDurationMs
@@ -2120,6 +2204,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
   const controlMonitorAbort = new AbortController();
   let finished = false;
   let cancelRequested = false;
+  let cancellationSource = 'unknown';
   let cancelAction = null;
   let rejectCancellation;
   let latestTokenUsage = normalizeCompanionTokenUsage();
@@ -2128,7 +2213,10 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
     rejectCancellation = reject;
   });
   const cancellationError = () => {
-    const error = new CompanionRunCancelledError();
+    const error = new CompanionRunCancelledError(
+      'The local bridge model turn was cancelled.',
+      cancellationSource,
+    );
     error.companionUsage = {
       tokenUsage: latestTokenUsage,
       usageAvailable: latestTokenUsage.totalTokens > 0,
@@ -2137,7 +2225,10 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
     };
     return error;
   };
-  const requestCancel = () => {
+  const requestCancel = (source = 'unknown') => {
+    if (cancellationSource === 'unknown' && source) {
+      cancellationSource = source;
+    }
     if (cancelRequested) return cancelAction;
     cancelRequested = true;
     infrastructureAbortController.abort();
@@ -2153,7 +2244,9 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
       .then(async () => {
         if (finished) return;
         const response = await send('activity', payload);
-        if (controlRequestsCancellation(response)) await requestCancel();
+        if (controlRequestsCancellation(response)) {
+          await requestCancel(controlCancellationSource(response));
+        }
       })
       .catch((error) => {
         if (!finished) {
@@ -2185,7 +2278,9 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
       Boolean(event.message || event.name) ||
       event.kind === 'turn_started';
     if (!meaningful) return;
-    const userFacingUpdate = event.kind === 'status_update';
+    const userFacingUpdate =
+      event.kind === 'status_update'
+      && event.source === 'harness';
     void postActivity({
       stage: 'outcome',
       outcomeId: run?.outcome?.outcomeId,
@@ -2226,7 +2321,9 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           occurredAt: new Date().toISOString(),
           message: `${definition.label} is still working.`,
         });
-        if (controlRequestsCancellation(response)) await requestCancel();
+        if (controlRequestsCancellation(response)) {
+          await requestCancel(controlCancellationSource(response));
+        }
       } catch (error) {
         if (!controlMonitorAbort.signal.aborted && !cancelRequested) {
           options.trace?.warn?.('outcome_control_poll_failed', {
@@ -2291,7 +2388,29 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
                   allowInsecureHttp: options.allowInsecureHttp,
                 })
             : undefined,
-        openAuthorizationUrl: options.openAuthorizationUrl,
+        verifyProjectAuthorization:
+          options.apiBaseUrl && options.deviceToken
+            ? ({
+                status,
+                framerProjectId,
+                framerProjectUrl,
+                credentialVersion,
+                errorCode,
+                signal,
+              }) =>
+                reportFramerProjectAuthorizationVerification(options.apiBaseUrl, {
+                  deviceToken: options.deviceToken,
+                  runId: run.runId,
+                  status,
+                  framerProjectId,
+                  framerProjectUrl,
+                  credentialVersion,
+                  errorCode,
+                  fetchImpl: options.fetchImpl,
+                  signal,
+                  allowInsecureHttp: options.allowInsecureHttp,
+                })
+            : undefined,
       })
     : createHarnessToolRuntime({
         assignment: run?.outcome,
@@ -2300,10 +2419,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
         trace: options.trace,
         onActivity: progress,
       });
-  let prompt = buildOutcomePrompt(run.outcome, product);
-  if (materializedNativeSkills) {
-    prompt = claudeNativeSkillPrompt(prompt, materializedNativeSkills);
-  }
+  let prompt = '';
   const schema = outcomeOutputSchema();
   assertOutcomeResponseContract(
     STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
@@ -2317,6 +2433,24 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
     if (framerAgentOutcome) {
       await Promise.race([harnessTools.preflight(), cancellation]);
     }
+    const framerGuidance = framerAgentOutcome
+      ? await Promise.race([
+          harnessTools.loadProjectGuidance(),
+          cancellation,
+        ])
+      : null;
+    harnessTools.configurePromptContext?.({
+      doctrineLoaded: Boolean(run?.doctrine),
+      doctrineVersion: run?.doctrineVersion,
+    });
+    prompt = buildOutcomePrompt(run.outcome, product, {
+      doctrine: run?.doctrine,
+      doctrineVersion: run?.doctrineVersion,
+      framerGuidance: framerGuidance?.content,
+    });
+    if (materializedNativeSkills) {
+      prompt = claudeNativeSkillPrompt(prompt, materializedNativeSkills);
+    }
     const gateway =
       definition.id === 'codex' ? null : await harnessTools.startGateway();
     const mcpServer = gateway
@@ -2327,7 +2461,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           environment: harnessMcpProcessEnvironment(
             gateway,
             process.versions,
-            harnessTools.toolNames,
+            harnessTools.definitions,
           ),
         }
       : null;
@@ -2349,15 +2483,22 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
     });
     if (controlRequestsCancellation(statusResponse)) {
       await options.providerAdapter?.cancel?.(sessionKey);
-      throw new CompanionRunCancelledError();
+      throw new CompanionRunCancelledError(
+        undefined,
+        controlCancellationSource(statusResponse),
+      );
     }
-    const providerExecution = (async () => {
+    const executeProviderOutcome = async (
+      turnPrompt,
+      resumeSessionIdOverride,
+      step = 0,
+    ) => {
       if (options.providerAdapter?.runOutcome) {
         const providerResult = await options.providerAdapter.runOutcome({
           runId: run.runId,
           sessionId: sessionKey,
-          resumeSessionId: rememberedSession?.providerSessionId,
-          prompt,
+          resumeSessionId: resumeSessionIdOverride,
+          prompt: turnPrompt,
           model: adapterInvocationModel(run, selectedModel, definition.id),
           outputSchema: schema,
           responseContract: STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
@@ -2387,12 +2528,12 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
       }
       const resumeSessionId =
         agentSessionResumeEnabled(definition, options.env)
-          ? rememberedSession?.providerSessionId
+          ? resumeSessionIdOverride
           : undefined;
       let processResult;
       try {
         providerAttempts += 1;
-        processResult = await callLocalJsonAgent(definition.id, prompt, {
+        processResult = await callLocalJsonAgent(definition.id, turnPrompt, {
           ...options,
           model: selectedModelId,
           timeoutMs: outcomeInactivityTimeoutMs,
@@ -2401,7 +2542,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           outputSchema: schema,
           responseContract: STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
           product,
-          step: 0,
+          step,
           maxDurationMs: outcomeMaxDurationMs,
           cwd: materialized.directory,
           harnessMode: true,
@@ -2415,7 +2556,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
       } catch (error) {
         if (!resumeSessionId || !resumeFailure(error)) throw error;
         providerAttempts += 1;
-        processResult = await callLocalJsonAgent(definition.id, prompt, {
+        processResult = await callLocalJsonAgent(definition.id, turnPrompt, {
           ...options,
           model: selectedModelId,
           timeoutMs: outcomeInactivityTimeoutMs,
@@ -2423,7 +2564,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           outputSchema: schema,
           responseContract: STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
           product,
-          step: 0,
+          step,
           maxDurationMs: outcomeMaxDurationMs,
           cwd: materialized.directory,
           harnessMode: true,
@@ -2441,7 +2582,11 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
         text: parsedOutput.resultText,
         sessionId: parsedOutput.sessionId,
       };
-    })();
+    };
+    const providerExecution = executeProviderOutcome(
+      prompt,
+      rememberedSession?.providerSessionId,
+    );
     const infrastructureFailure = harnessTools
       .waitForFatalInfrastructure()
       .then(async (error) => {
@@ -2466,7 +2611,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
       if (cancelRequested) throw cancellationError();
       throw error;
     }
-    const providerSessionId = result?.threadId || result?.sessionId;
+    let providerSessionId = result?.threadId || result?.sessionId;
     if (providerSessionId || options.providerAdapter) {
       rememberCompanionSession(sessionKey, {
         providerSessionId:
@@ -2478,7 +2623,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
       });
     }
     usageAccumulator.add(result);
-    const completion = normalizeOutcomeCompletion(
+    let rawCompletion = normalizeOutcomeCompletion(
       extractJsonObject(result?.text || result?.resultText || ''),
       run?.outcome?.outcomeId,
     );
@@ -2486,11 +2631,68 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
     if (harnessTools.directWorkspace) {
       synchronization = await harnessTools.inspect();
     } else if (
-      completion.status === 'ready_for_verification'
+      rawCompletion.status === 'completed'
       || harnessTools.hasPendingChanges()
     ) {
       synchronization = await harnessTools.synchronize();
     }
+    const repairPrompt =
+      rawCompletion.status === 'completed'
+      && typeof harnessTools.verificationRepairPrompt === 'function'
+        ? harnessTools.verificationRepairPrompt()
+        : null;
+    if (
+      repairPrompt
+      && Date.now() - callStartedAt < outcomeMaxDurationMs - 5_000
+    ) {
+      progress({
+        kind: 'status_update',
+        source: 'harness',
+        message:
+          'I’m completing the final Framer verification before I finish.',
+      });
+      const repairResult = await Promise.race([
+        executeProviderOutcome(
+          repairPrompt,
+          providerSessionId
+            || rememberedSession?.providerSessionId
+            || sessionKey,
+          1,
+        ),
+        infrastructureFailure,
+        cancellation,
+      ]);
+      usageAccumulator.add(repairResult);
+      result = repairResult;
+      providerSessionId =
+        repairResult?.threadId
+        || repairResult?.sessionId
+        || providerSessionId;
+      rawCompletion = normalizeOutcomeCompletion(
+        extractJsonObject(
+          repairResult?.text || repairResult?.resultText || '',
+        ),
+        run?.outcome?.outcomeId,
+      );
+      synchronization = harnessTools.directWorkspace
+        ? await harnessTools.inspect()
+        : await harnessTools.synchronize();
+      await Promise.race([activityChain, cancellation]);
+    }
+    if (providerSessionId || options.providerAdapter) {
+      rememberCompanionSession(sessionKey, {
+        providerSessionId:
+          providerSessionId
+          || rememberedSession?.providerSessionId
+          || sessionKey,
+        agent: definition.id,
+        updatedAt: Date.now(),
+      });
+    }
+    const completion =
+      typeof harnessTools.finalizeCompletion === 'function'
+        ? harnessTools.finalizeCompletion(rawCompletion)
+        : rawCompletion;
     const files = harnessTools.directWorkspace
       ? []
       : collectOutcomeWorkspaceChanges(run.outcome, materialized);
@@ -2524,7 +2726,7 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
           outcomeId: run?.outcome?.outcomeId,
           model: selectedModelId,
           status:
-            normalized.status === 'ready_for_verification'
+            normalized.status === 'completed'
               ? 'succeeded'
               : normalized.status,
           durationMs: Date.now() - callStartedAt,
@@ -2534,6 +2736,22 @@ async function executeOutcomeRun(run, send, agent, options = {}) {
         },
       ],
     });
+  } catch (error) {
+    const failure =
+      error instanceof Error
+        ? error
+        : new Error(String(error || 'The Framer outcome failed.'));
+    usageAccumulator.add(failure.companionUsage || {});
+    const framer =
+      typeof harnessTools.summary === 'function'
+        ? harnessTools.summary()
+        : undefined;
+    failure.framer = framer;
+    failure.companionUsage = {
+      ...usageAccumulator.snapshot(),
+      ...(framer ? { framer } : {}),
+    };
+    throw failure;
   } finally {
     finished = true;
     controlMonitorAbort.abort();
@@ -2563,7 +2781,6 @@ export async function executeRun(
     inspectAgentAuthentication,
     runtimeProfile: suppliedRuntimeProfile,
     framerAgentRunCli,
-    openAuthorizationUrl,
     allowInsecureHttp = false,
   } = {},
 ) {
@@ -2685,7 +2902,6 @@ export async function executeRun(
       apiBaseUrl,
       deviceToken,
       fetchImpl,
-      openAuthorizationUrl,
       allowInsecureHttp,
     };
     if (outcomeRun) {
@@ -2699,12 +2915,17 @@ export async function executeRun(
     return { cancelled: false };
   } catch (error) {
     if (error?.code === 'RUN_CANCELLED') {
-      trace.info('run_cancelled', { message: error.message });
+      const message = cancellationMessage(error);
+      trace.info('run_cancelled', {
+        message,
+        cancellationSource: error?.cancellationSource,
+      });
       await send('error', {
         operationType: 'cancelled',
         outcome: 'cancelled',
-        message: error.message,
+        message,
         code: 'RUN_CANCELLED',
+        cancellationSource: error?.cancellationSource || 'unknown',
         ...(error?.companionUsage || usageAccumulator.snapshot()),
       }).catch(() => undefined);
       return { cancelled: true };

package/src/api.js

@@ -200,6 +200,40 @@ export function getFramerProjectAuthorization(apiBaseUrl, {
   );
 }
 
+export function reportFramerProjectAuthorizationVerification(apiBaseUrl, {
+  deviceToken,
+  runId,
+  status,
+  framerProjectId,
+  framerProjectUrl,
+  credentialVersion,
+  errorCode,
+  fetchImpl,
+  signal,
+  allowInsecureHttp,
+}) {
+  return requestJson(
+    apiBaseUrl,
+    `/ai/framer/companion/runs/${encodeURIComponent(runId)}/framer-authorization/verification`,
+    {
+      method: 'POST',
+      deviceToken,
+      fetchImpl,
+      signal,
+      allowInsecureHttp,
+      body: {
+        status,
+        framerProjectId,
+        ...(framerProjectUrl ? { framerProjectUrl } : {}),
+        credentialVersion,
+        ...(errorCode ? { errorCode } : {}),
+        platform: process.platform,
+        companionVersion: BRIDGE_VERSION,
+      },
+    },
+  );
+}
+
 export function postRunEvent(apiBaseUrl, {
   deviceToken,
   runId,