openpond 0.0.55 → 0.0.57

package/dist/chunks/{chunk-OVE6IFEM.js → chunk-XX6KALN2.js}

@@ -1,4 +1,17 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  assertSafeBranchName,
+  isGeneratedWorkspacePath,
+  listPlainWorkspaceFiles,
+  loadWorkspaceDiffAtPath,
+  loadWorkspaceStateAtPath,
+  normalizeWorkspaceFilePath,
+  readLocalImageFile,
+  runCommand,
+  truncatePatch,
+  uniqueSortedPaths,
+  workspaceImageContentType
+} from "./chunk-5Y7Q6ZSH.js";
 import {
   AGENT_PROTOCOL_VERSION,
   AGENT_RPC_METHODS,
@@ -16,32 +29,19 @@ import {
   runProviderRound,
   runProviderRoundLoop
 } from "./chunk-NFNEENNR.js";
-import {
-  getBundledRuntimeVersion,
-  loadOpenPondAccountContext,
-  loadOpenPondHostedModels,
-  streamOpenPondHostedChatTurn
-} from "./chunk-EIRW6Z6S.js";
-import {
-  assertSafeBranchName,
-  isGeneratedWorkspacePath,
-  listPlainWorkspaceFiles,
-  loadWorkspaceDiffAtPath,
-  loadWorkspaceStateAtPath,
-  normalizeWorkspaceFilePath,
-  readLocalImageFile,
-  runCommand,
-  truncatePatch,
-  uniqueSortedPaths,
-  workspaceImageContentType
-} from "./chunk-CW4QSUDH.js";
 import {
   HOSTED_CHAT_SYSTEM_PROMPT,
   VERSION,
   event,
   now,
   textFromUnknown
-} from "./chunk-LACG7NNI.js";
+} from "./chunk-XHTO6KF2.js";
+import {
+  getBundledRuntimeVersion,
+  loadOpenPondAccountContext,
+  loadOpenPondHostedModels,
+  streamOpenPondHostedChatTurn
+} from "./chunk-UBHCG2NE.js";
 import {
   AppPreferencesSchema,
   ApplyCreateImproveRunActionRequestSchema,
@@ -158,7 +158,7 @@ import {
   runAgentSdkProjectCommand,
   runProfileSkillCommand,
   sidebarFileBookmarkId
-} from "./chunk-55KT7K5P.js";
+} from "./chunk-5ZLFZZLS.js";
 import {
   AgentSnapshotSchema,
   AttemptReceiptSchema,
@@ -236,7 +236,7 @@ import {
   stableId,
   uniqueEventRefs,
   validateConnectedAppProviderOperationRequest
-} from "./chunk-US7DOPAH.js";
+} from "./chunk-VG4H4TQG.js";
 import {
   external_exports
 } from "./chunk-WYDVQOBL.js";
@@ -7864,11 +7864,16 @@ function executableSearchPath(environment = process.env, platform = process.plat
 }
 
 // ../server/src/harness/local-harness-refiner-context.ts
-var MAX_REFINER_SOURCE_BYTES = 6e4;
+var MAX_REFINER_SOURCE_BYTES = 36e3;
 var MAX_PDF_ARTIFACTS = 10;
 var MAX_PDF_BYTES = 20 * 1024 * 1024;
+var MAX_REVIEW_TIMELINE_EVENTS = 40;
+var MAX_REVIEW_TIMELINE_CHARS = 24e3;
+var MAX_PRIOR_CONVERSATION_TURNS = 3;
+var MAX_PRIOR_INCIDENTS = 3;
+var MAX_PRIOR_INCIDENT_TIMELINE_EVENTS = 6;
 var execFileAsync = promisify(execFile);
-async function loadBoundedRefinerContext(store, trigger, observations) {
+async function loadBoundedRefinerContext(store, trigger, observations, workspaceId) {
   const [session, turn, events, turns, usageRecords] = await Promise.all([
     store.getSession(trigger.runRef),
     store.getTurn(trigger.turnId),
@@ -7918,6 +7923,30 @@ async function loadBoundedRefinerContext(store, trigger, observations) {
       0
     ) || receiptProfile.totalTokens
   };
+  const executionProfile = {
+    modelRequestCount: durableUsage.modelRequestCount,
+    failedModelRequestCount: usageRecords.filter(
+      (record9) => record9.status === "failed" || record9.status === "interrupted"
+    ).length,
+    promptTokens: durableUsage.promptTokens,
+    completionTokens: durableUsage.completionTokens,
+    totalTokens: durableUsage.totalTokens,
+    toolFailureCount: observationKinds.filter((kind) => kind === "tool_failure").length,
+    retryCount: observationKinds.filter((kind) => kind === "retry").length,
+    recoveryCount: observationKinds.filter((kind) => kind === "recovery").length
+  };
+  const artifactDiagnostics = await inspectBoundedPdfArtifactDiagnostics(session?.cwd);
+  const timelineCandidates = events.filter(
+    (runtimeEvent) => runtimeEvent.turnId === trigger.turnId && isRefinerReviewTimelineEvent(runtimeEvent) && (runtimeEvent.sequence === void 0 || runtimeEvent.sequence <= trigger.boundary.eventSequence)
+  ).sort(compareRuntimeEvents);
+  const timeline = boundedReviewTimeline(timelineCandidates);
+  const priorConversation = orderedTurns.slice(Math.max(0, turnIndex - MAX_PRIOR_CONVERSATION_TURNS), Math.max(0, turnIndex)).map((candidate) => conversationTurn(candidate, events));
+  const priorIncidents = workspaceId ? await loadRelevantPriorIncidentPackets({
+    store,
+    workspaceId,
+    trigger,
+    observations
+  }) : [];
   return {
     task: {
       prompt: turn?.prompt ? redactAndBoundRefinerText(turn.prompt, 8e3) : null,
@@ -7925,19 +7954,8 @@ async function loadBoundedRefinerContext(store, trigger, observations) {
       assistantOutputLinkCount: countAbsoluteLinks(assistantOutput),
       previousAssistantOutput: previousTurn ? assistantOutputForTurn(events, previousTurn.id) : null
     },
-    artifactDiagnostics: await inspectBoundedPdfArtifactDiagnostics(session?.cwd),
-    executionProfile: {
-      modelRequestCount: durableUsage.modelRequestCount,
-      failedModelRequestCount: usageRecords.filter(
-        (record9) => record9.status === "failed" || record9.status === "interrupted"
-      ).length,
-      promptTokens: durableUsage.promptTokens,
-      completionTokens: durableUsage.completionTokens,
-      totalTokens: durableUsage.totalTokens,
-      toolFailureCount: observationKinds.filter((kind) => kind === "tool_failure").length,
-      retryCount: observationKinds.filter((kind) => kind === "retry").length,
-      recoveryCount: observationKinds.filter((kind) => kind === "recovery").length
-    },
+    artifactDiagnostics,
+    executionProfile,
     eventExcerpts: evidenceEvents.map((runtimeEvent) => {
       const data = asRecord(runtimeEvent.data);
       const result = asRecord(data.result);
@@ -7954,9 +7972,242 @@ async function loadBoundedRefinerContext(store, trigger, observations) {
         stderr: textField(result.stderr, 3e3),
         stdout: textField(result.stdout, 3e3)
       };
-    })
+    }),
+    reviewPacket: {
+      currentTurn: {
+        id: trigger.turnId,
+        status: turn?.status ?? null,
+        error: turn?.error ? redactAndBoundRefinerText(turn.error, 2e3) : null,
+        prompt: turn?.prompt ? redactAndBoundRefinerText(turn.prompt, 8e3) : null,
+        assistantOutput,
+        assistantOutputLinkCount: countAbsoluteLinks(assistantOutput)
+      },
+      priorConversation,
+      timeline,
+      artifacts: fileOutputInventory(events, trigger.turnId),
+      artifactDiagnostics,
+      executionProfile,
+      priorIncidents,
+      truncation: {
+        timelineEventCount: timelineCandidates.length,
+        includedTimelineEventCount: timeline.length,
+        timelineTruncated: timeline.length < timelineCandidates.length
+      }
+    }
+  };
+}
+function conversationTurn(turn, events) {
+  return {
+    turnId: turn.id,
+    status: turn.status,
+    prompt: turn.prompt ? redactAndBoundRefinerText(turn.prompt, 3e3) : null,
+    assistantOutput: assistantOutputForTurn(events, turn.id, 3e3)
   };
 }
+function boundedReviewTimeline(events) {
+  const mapped = events.map(reviewTimelineEntry);
+  if (mapped.length <= MAX_REVIEW_TIMELINE_EVENTS) {
+    return fitTimelineToCharacterBudget(mapped);
+  }
+  const important = mapped.filter(
+    (entry) => entry.status === "failed" || entry.name === "turn.completed" || entry.name === "turn.failed" || entry.name === "turn.interrupted" || entry.name === "skill.loaded" || entry.name === "validation.completed" || entry.name === "diagnostic"
+  );
+  const retainedKeys = new Set(important.map(timelineEntryKey));
+  const remaining = mapped.filter((entry) => !retainedKeys.has(timelineEntryKey(entry))).slice(-(MAX_REVIEW_TIMELINE_EVENTS - Math.min(important.length, MAX_REVIEW_TIMELINE_EVENTS)));
+  return fitTimelineToCharacterBudget(
+    [...important.slice(-MAX_REVIEW_TIMELINE_EVENTS), ...remaining].sort((left, right) => Number(left.sequence ?? 0) - Number(right.sequence ?? 0))
+  );
+}
+function fitTimelineToCharacterBudget(entries) {
+  const retained = [];
+  let used = 0;
+  for (const entry of entries) {
+    const size = JSON.stringify(entry).length;
+    if (used + size > MAX_REVIEW_TIMELINE_CHARS) continue;
+    retained.push(entry);
+    used += size;
+  }
+  return retained;
+}
+function reviewTimelineEntry(runtimeEvent) {
+  const data = asRecord(runtimeEvent.data);
+  const result = asRecord(data.result);
+  return {
+    sequence: runtimeEvent.sequence ?? null,
+    timestamp: runtimeEvent.timestamp,
+    name: runtimeEvent.name,
+    action: runtimeEvent.action ?? (typeof data.tool === "string" ? data.tool : null),
+    status: runtimeEvent.status ?? null,
+    args: boundedUnknown(runtimeEvent.args, 1500),
+    command: textField(result.command, 2e3),
+    error: textField(runtimeEvent.error, 2e3),
+    output: textField(result.output, 2e3) ?? textField(runtimeEvent.output, 2e3),
+    exitCode: typeof result.exitCode === "number" ? result.exitCode : null,
+    timedOut: result.timedOut === true,
+    stderr: textField(result.stderr, 2e3),
+    stdout: textField(result.stdout, 2e3)
+  };
+}
+function timelineEntryKey(entry) {
+  return `${entry.sequence ?? "none"}:${entry.name ?? "unknown"}:${entry.action ?? "none"}`;
+}
+function fileOutputInventory(events, turnId) {
+  const byRevision = /* @__PURE__ */ new Map();
+  for (const runtimeEvent of events) {
+    if (runtimeEvent.turnId !== turnId) continue;
+    for (const output of findFileOutputRefs(runtimeEvent.data)) {
+      byRevision.set(`${output.id}:${output.revision}`, output);
+    }
+  }
+  return [...byRevision.values()].sort((left, right) => left.title.localeCompare(right.title) || left.revision - right.revision).slice(0, 30).map((output) => ({
+    id: output.id,
+    title: output.title,
+    revision: output.revision,
+    contentType: output.contentType,
+    sizeBytes: output.sizeBytes,
+    sha256: output.sha256,
+    locationKind: output.location.kind,
+    validation: output.validation.map((validation) => ({
+      kind: validation.kind,
+      status: validation.status,
+      label: validation.label,
+      detail: validation.detail ?? null
+    }))
+  }));
+}
+function findFileOutputRefs(value, depth = 0) {
+  if (depth > 8) return [];
+  const parsed = FileOutputRefSchema.safeParse(value);
+  if (parsed.success) return [parsed.data];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => findFileOutputRefs(item, depth + 1));
+  }
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).flatMap(
+    (item) => findFileOutputRefs(item, depth + 1)
+  );
+}
+async function loadRelevantPriorIncidentPackets(input) {
+  const currentClasses = new Set(
+    input.observations.flatMap(
+      (observation) => observation.deterministicClass ? [observation.deterministicClass] : []
+    )
+  );
+  const currentTools = new Set(
+    input.observations.flatMap((observation) => observation.tool ? [observation.tool.name] : [])
+  );
+  if (currentClasses.size === 0 && currentTools.size === 0) return [];
+  const available = (await input.store.listHarnessImprovementArtifacts(
+    input.workspaceId,
+    "observation",
+    200
+  )).filter(
+    (observation) => observation.runRef !== input.trigger.runRef && observation.turnId !== input.trigger.turnId && (observation.deterministicClass !== null && currentClasses.has(observation.deterministicClass) || observation.tool !== null && currentTools.has(observation.tool.name))
+  ).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+  const byTurn = /* @__PURE__ */ new Map();
+  for (const observation of available) {
+    const key = `${observation.runRef}:${observation.turnId}`;
+    const list = byTurn.get(key) ?? [];
+    list.push(observation);
+    byTurn.set(key, list);
+  }
+  const packets = [];
+  for (const group of byTurn.values()) {
+    if (packets.length >= MAX_PRIOR_INCIDENTS) break;
+    const first = group[0];
+    const [turn, events] = await Promise.all([
+      input.store.getTurn(first.turnId),
+      input.store.runtimeEventsForSession(first.runRef, { limit: 1e3 })
+    ]);
+    if (!turn) continue;
+    const matchingClasses = [...new Set(group.flatMap(
+      (observation) => observation.deterministicClass && currentClasses.has(observation.deterministicClass) ? [observation.deterministicClass] : []
+    ))];
+    const matchingTools = [...new Set(group.flatMap(
+      (observation) => observation.tool && currentTools.has(observation.tool.name) ? [observation.tool.name] : []
+    ))];
+    const timeline = priorIncidentTimeline(
+      events.filter((runtimeEvent) => runtimeEvent.turnId === turn.id)
+    );
+    packets.push({
+      runRef: first.runRef,
+      turnId: first.turnId,
+      createdAt: first.createdAt,
+      matchedBy: {
+        deterministicClasses: matchingClasses,
+        tools: matchingTools
+      },
+      observations: group.slice(0, 4).map((observation) => ({
+        kind: observation.kind,
+        state: observation.state,
+        deterministicClass: observation.deterministicClass,
+        summary: observation.summary
+      })),
+      prompt: turn.prompt ? redactAndBoundRefinerText(turn.prompt, 1200) : null,
+      assistantOutput: assistantOutputForTurn(events, turn.id, 1200),
+      timeline,
+      artifacts: fileOutputInventory(events, turn.id).slice(0, 5)
+    });
+  }
+  return packets;
+}
+function priorIncidentTimeline(events) {
+  const terminalNames = /* @__PURE__ */ new Set(["turn.completed", "turn.failed", "turn.interrupted"]);
+  const candidates = events.filter((runtimeEvent) => {
+    if (terminalNames.has(runtimeEvent.name)) return true;
+    const serialized = JSON.stringify({
+      error: runtimeEvent.error,
+      output: runtimeEvent.output,
+      data: runtimeEvent.data
+    });
+    return runtimeEvent.status === "failed" || /"ok"\s*:\s*false|failed|denied|unavailable|timed?\s*out|exception|traceback/i.test(serialized);
+  }).sort(compareRuntimeEvents).map((runtimeEvent) => {
+    const entry = reviewTimelineEntry(runtimeEvent);
+    return {
+      sequence: entry.sequence,
+      name: entry.name,
+      action: entry.action,
+      status: entry.status,
+      error: textField(entry.error, 800),
+      output: textField(entry.output, 800),
+      exitCode: entry.exitCode,
+      timedOut: entry.timedOut
+    };
+  });
+  const unique2 = /* @__PURE__ */ new Map();
+  for (const entry of candidates) {
+    const signature = JSON.stringify({
+      name: entry.name,
+      action: entry.action,
+      status: entry.status,
+      error: entry.error,
+      output: entry.output,
+      exitCode: entry.exitCode,
+      timedOut: entry.timedOut
+    });
+    const existing = unique2.get(signature);
+    if (existing) {
+      existing.occurrenceCount += 1;
+      continue;
+    }
+    unique2.set(signature, { ...entry, occurrenceCount: 1 });
+  }
+  const compact = [...unique2.values()];
+  if (compact.length <= MAX_PRIOR_INCIDENT_TIMELINE_EVENTS) return compact;
+  return [
+    ...compact.slice(0, MAX_PRIOR_INCIDENT_TIMELINE_EVENTS - 2),
+    ...compact.slice(-2)
+  ];
+}
+function boundedUnknown(value, maxLength) {
+  if (value === void 0) return null;
+  try {
+    const text = redactAndBoundRefinerText(JSON.stringify(value), maxLength);
+    return JSON.parse(text.endsWith("\n[truncated]") ? JSON.stringify(text) : text);
+  } catch {
+    return redactAndBoundRefinerText(String(value), maxLength);
+  }
+}
 function tasksetGradeExecutionProfile(events, turnId) {
   const fallback = {
     modelRequestCount: 0,
@@ -8074,11 +8325,11 @@ function countAbsoluteLinks(value) {
   if (!value) return 0;
   return value.match(/https?:\/\/[^\s<>)\]}"']+/gi)?.length ?? 0;
 }
-function assistantOutputForTurn(events, turnId) {
+function assistantOutputForTurn(events, turnId, maxLength = 8e3) {
   const output = events.filter(
     (runtimeEvent) => runtimeEvent.turnId === turnId && runtimeEvent.name === "assistant.delta" && typeof runtimeEvent.output === "string"
   ).sort(compareRuntimeEvents).map((runtimeEvent) => runtimeEvent.output).join("");
-  return output ? redactAndBoundRefinerText(output, 8e3) : null;
+  return output ? redactAndBoundRefinerText(output, maxLength) : null;
 }
 async function loadExactObservations(store, workspaceId, trigger) {
   const available = await store.listHarnessImprovementArtifacts(
@@ -8115,7 +8366,14 @@ async function readBoundedRefinerSource(bundlePath, trigger) {
     kind: file.kind,
     loaded: file.kind === "skill" && loadedSkillNames.has(skillNameFromPath(file.path))
   }));
-  for (const file of manifest.files) {
+  const rankedFiles = manifest.files.slice().sort((left, right) => {
+    const leftLoaded = left.kind === "skill" && loadedSkillNames.has(skillNameFromPath(left.path));
+    const rightLoaded = right.kind === "skill" && loadedSkillNames.has(skillNameFromPath(right.path));
+    if (leftLoaded !== rightLoaded) return leftLoaded ? -1 : 1;
+    const rank = (kind) => kind === "instruction" ? 0 : kind === "skill" ? 1 : 2;
+    return rank(left.kind) - rank(right.kind) || left.path.localeCompare(right.path);
+  });
+  for (const file of rankedFiles) {
     if (!["instruction", "skill", "agent"].includes(file.kind) || file.visibility !== "policy" || !["text/markdown", "text/plain", "text/javascript"].includes(file.mediaType)) {
       continue;
     }
@@ -8156,6 +8414,18 @@ function isRefinerEvidenceEvent(runtimeEvent) {
     "diagnostic"
   ].includes(runtimeEvent.name);
 }
+function isRefinerReviewTimelineEvent(runtimeEvent) {
+  return [
+    "turn.completed",
+    "turn.failed",
+    "turn.interrupted",
+    "tool.completed",
+    "workspace_action_result",
+    "skill.loaded",
+    "validation.completed",
+    "diagnostic"
+  ].includes(runtimeEvent.name);
+}
 function compareRuntimeEvents(left, right) {
   return (left.sequence ?? Number.MAX_SAFE_INTEGER) - (right.sequence ?? Number.MAX_SAFE_INTEGER);
 }
@@ -9693,6 +9963,11 @@ async function refreshOpenAiSubscriptionToken(refreshToken) {
       client_id: OPENAI_OAUTH_CLIENT_ID
     }).toString()
   });
+  if (response.status === 401) {
+    throw new Error(
+      "Your OpenAI ChatGPT sign-in has expired or was invalidated. Reconnect it in Settings > Providers > OpenAI > Subscription by selecting Connect ChatGPT. This is an authentication issue, not a billing or model-access error."
+    );
+  }
   if (!response.ok) throw new Error(`OpenAI token refresh failed: ${response.status}`);
   return await response.json();
 }
@@ -11078,41 +11353,13 @@ async function runLocalHarnessRefinerWorker(input) {
   const boundedContext = await loadBoundedRefinerContext(
     input.store,
     trigger,
-    observations
-  );
-  const currentObservationHashes = new Set(
-    observations.map((observation) => observation.contentHash)
+    observations,
+    workspace.id
   );
-  const recentObservations = (await input.store.listHarnessImprovementArtifacts(
-    workspace.id,
-    "observation",
-    100
-  )).filter((observation) => !currentObservationHashes.has(observation.contentHash)).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 20).map((observation) => ({
-    ...boundedObservationEvidence(observation),
-    runRef: observation.runRef,
-    turnId: observation.turnId,
-    createdAt: observation.createdAt
-  }));
-  const recentOutcomes = (await input.store.listHarnessImprovementArtifacts(
-    workspace.id,
-    "refiner_outcome",
-    100
-  )).filter((outcome) => outcome.trigger.contentHash !== trigger.contentHash).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 8).map((outcome) => ({
-    id: outcome.id,
-    decision: outcome.decision,
-    reason: outcome.reason,
-    createdAt: outcome.createdAt,
-    triggerId: outcome.trigger.id
-  }));
   const refinerEvidence = {
     trigger: boundedTriggerEvidence(trigger),
     observations: observations.map(boundedObservationEvidence),
-    task: boundedContext.task,
-    eventExcerpts: boundedContext.eventExcerpts,
-    artifactDiagnostics: boundedContext.artifactDiagnostics,
-    executionProfile: boundedContext.executionProfile,
-    recentObservations,
-    recentOutcomes,
+    reviewPacket: boundedContext.reviewPacket,
     sourceFiles: source.files,
     sourceCatalog: source.catalog,
     additionalEvidence: input.additionalEvidence ?? null
@@ -27573,6 +27820,72 @@ async function executeScopedOpenPondAction(input) {
       data: { result: result2 }
     };
   }
+  if (implementation?.type === "openpond-project-action") {
+    const executionTarget = resolveWorkspaceExecutionTarget({ session: context.session });
+    if (isSandboxExecutionTarget(executionTarget)) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is a local Project Action and cannot run while Working in Hybrid or sandbox. Switch Working in to Local.`
+      );
+    }
+    if (!deps.executeProjectAction) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is a local Project Action, but local action execution is not configured.`
+      );
+    }
+    const projectRoot = stringValue7(implementation.projectRoot) ?? action.sourcePath;
+    const projectId = stringValue7(implementation.projectId);
+    const projectActionId = stringValue7(implementation.actionId) ?? action.id;
+    if (!projectRoot) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is missing its local Project root.`
+      );
+    }
+    if (!projectId || projectId !== context.session.localProjectId) {
+      return failedActionToolResult(
+        context.callId,
+        resultToolName,
+        `Action ${action.id} is not authorized for the selected local Project.`
+      );
+    }
+    const result2 = await deps.executeProjectAction({
+      action: projectActionId,
+      input: input.input,
+      metadata: {
+        source: "openpond_project_action",
+        projectRoot,
+        projectId,
+        selectedActionId: projectActionId,
+        selectedActionLabel: action.label ?? action.name ?? projectActionId,
+        selectedBy: "native_model_tool",
+        displayPrompt: context.userPrompt,
+        sessionId: context.session.id,
+        turnId: context.turnId,
+        toolCallId: context.callId
+      }
+    });
+    return {
+      toolCallId: context.callId,
+      name: resultToolName,
+      ok: true,
+      contentText: JSON.stringify(
+        {
+          ok: true,
+          action: resultToolName,
+          output: `Ran Project Action ${projectActionId}.`,
+          data: { result: result2 }
+        },
+        null,
+        2
+      ),
+      data: { result: result2 }
+    };
+  }
   const payloadArgs = {
     actionName: action.sourceActionId ?? action.name ?? action.id,
     input: input.input
@@ -37887,6 +38200,7 @@ function createCapabilityCatalogRuntime(deps) {
         actionCatalog: openPondActionCatalog,
         executeWorkspaceTool: deps.executeWorkspaceTool,
         executeProfileAction: deps.executeProfileAction,
+        executeProjectAction: deps.executeProjectAction,
         trainingHarness: options.trainingHarness
       });
     }
@@ -37976,7 +38290,8 @@ function createCapabilityCatalogRuntime(deps) {
         ...createOpenPondActionModelToolDefinitions({
           actionCatalog: openPondActionCatalog,
           executeWorkspaceTool: deps.executeWorkspaceTool,
-          executeProfileAction: deps.executeProfileAction
+          executeProfileAction: deps.executeProfileAction,
+          executeProjectAction: deps.executeProjectAction
         })
       );
     }
@@ -41932,7 +42247,7 @@ function uniqueEvidence(run, evidence) {
 }
 async function verifyAppliedProfileCommit(input) {
   const command = input.command ?? (async (name, args, cwd, env) => {
-    const { runWorkspaceCommand } = await import("./workspaces-VFM7AUWY.js");
+    const { runWorkspaceCommand } = await import("./workspaces-R3EVRSWA.js");
     return runWorkspaceCommand(name, args, cwd, env);
   });
   const result = await command("git", ["rev-parse", "HEAD"], input.repoPath);
@@ -46242,6 +46557,7 @@ function createTurnRunner(deps) {
     workInputsForSession,
     executeOpenPondCommand,
     executeProfileAction,
+    executeProjectAction,
     executeDatasetBuilderAction,
     loadOpenPondProfileState: loadOpenPondProfileState2,
     loadOpenPondProfileStateForRef: loadOpenPondProfileStateForRef2,
@@ -46682,6 +46998,7 @@ function createTurnRunner(deps) {
     executeWebSearch,
     createScheduledWork,
     executeProfileAction,
+    executeProjectAction,
     loadOpenPondProfileStateForRef: loadOpenPondProfileStateForRef2
   });
   function createNativeModelToolDefinitions(openPondActionCatalog, runtimeEvents, profileSkillRuntime, connectedApps, options = {}) {

package/dist/chunks/{cli-7SSGEHXC.js → cli-EUZHWEJR.js}

@@ -3,12 +3,12 @@ import {
   resolveWebLaunchMessages,
   runOpenPondAppServerCli,
   runOpenPondServerCli
-} from "./chunk-IPAZ4FVZ.js";
+} from "./chunk-7JUIWABV.js";
 import "./chunk-NFNEENNR.js";
-import "./chunk-EIRW6Z6S.js";
-import "./chunk-LACG7NNI.js";
-import "./chunk-55KT7K5P.js";
-import "./chunk-US7DOPAH.js";
+import "./chunk-XHTO6KF2.js";
+import "./chunk-UBHCG2NE.js";
+import "./chunk-5ZLFZZLS.js";
+import "./chunk-VG4H4TQG.js";
 import "./chunk-WYDVQOBL.js";
 import "./chunk-KHNHUA2H.js";
 import "./chunk-UACZUFIA.js";

package/dist/chunks/{core-commands-SND555SC.js → core-commands-RI4B7TYM.js}

@@ -16,12 +16,12 @@ import {
   runTemplateUpdate,
   runToolList,
   runToolRun
-} from "./chunk-M2OSF2YN.js";
+} from "./chunk-OJ34YA7E.js";
 import "./chunk-FCVVOMIP.js";
 import "./chunk-KHNHUA2H.js";
-import "./chunk-6QWTEC2D.js";
+import "./chunk-42GGG3W4.js";
 import "./chunk-SMNFI2FU.js";
-import "./chunk-JSRCXDIL.js";
+import "./chunk-5QJGC2QI.js";
 import "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
 import "./chunk-MUMPWI4O.js";

package/dist/chunks/{desktop-test-WSWXNSFS.js → desktop-test-DRTCQWDV.js}

@@ -5,9 +5,9 @@ import {
 import "./chunk-KHNHUA2H.js";
 import {
   CliUsageError
-} from "./chunk-6QWTEC2D.js";
+} from "./chunk-42GGG3W4.js";
 import "./chunk-SMNFI2FU.js";
-import "./chunk-JSRCXDIL.js";
+import "./chunk-5QJGC2QI.js";
 import "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
 import {

package/dist/chunks/{extension-3IKF6YQE.js → extension-XMWCG6YG.js}

@@ -1,12 +1,4 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import "./chunk-3KLQ52B2.js";
-import "./chunk-W5GKHH77.js";
-import {
-  loadOpenPondProfileState,
-  parseProfileSkillMarkdown
-} from "./chunk-EJURKADM.js";
-import "./chunk-JIEUB6OS.js";
-import "./chunk-BYAPLT37.js";
 import {
   CONNECTED_APP_PROVIDER_TOOL_NAMES,
   CapabilityRequirementSchema,
@@ -17,7 +9,15 @@ import {
   SandboxTemplateValidationDiagnosticSchema,
   ToolDeclarationSchema,
   validateConnectedAppToolCallRequest
-} from "./chunk-US7DOPAH.js";
+} from "./chunk-VG4H4TQG.js";
+import "./chunk-3KLQ52B2.js";
+import "./chunk-W5GKHH77.js";
+import {
+  loadOpenPondProfileState,
+  parseProfileSkillMarkdown
+} from "./chunk-EJURKADM.js";
+import "./chunk-JIEUB6OS.js";
+import "./chunk-BYAPLT37.js";
 import {
   external_exports
 } from "./chunk-WYDVQOBL.js";