openpond 0.0.30-bootstrap.0

package/dist/chunks/chunk-4HYJG2JE.js

@@ -0,0 +1,3875 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  resolveOpChatApiBaseUrl,
+  sendHostedChatTurn
+} from "./chunk-NLBKZZEK.js";
+import {
+  CreatePipelinePlanSchema,
+  CreatePipelineSnapshotSchema,
+  WorkflowCaptureArtifactSchema,
+  createPipelineActionShapeFromMetadata,
+  inferCreatePipelineActionShape
+} from "./chunk-VQX33YAG.js";
+import {
+  external_exports
+} from "./chunk-WYDVQOBL.js";
+import {
+  apiFetch,
+  loadGlobalConfig,
+  readApiJson,
+  runShellCommand
+} from "./chunk-XSAXENQD.js";
+
+// src/goal/cli.ts
+import { randomUUID as randomUUID9 } from "node:crypto";
+import { readFile as readFile3 } from "node:fs/promises";
+
+// src/goal/config.ts
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { join, resolve } from "node:path";
+var DEFAULT_GOAL_EXECUTION_POLICY = {
+  sourceUpdates: "auto_commit_push_default_branch",
+  externalEffects: "approval_required",
+  budgetEscalation: "approval_required"
+};
+var DEFAULT_GOAL_VERIFICATION = {
+  commands: [],
+  requiredChecks: [],
+  successCriteria: [],
+  regressionPolicy: "existing_checks_must_pass",
+  artifactRefs: []
+};
+var DEFAULT_GOAL_BUDGET = {
+  maxIterations: 8,
+  maxRuntimeMinutes: 60,
+  maxModelCostUsd: null
+};
+function goalKindDefaultProfile(kind) {
+  return kind === "create_agent" || kind === "update_agent" ? "openpond_agent" : "generic_coding";
+}
+function defaultPromptPackForGoal(kind) {
+  if (kind === "create_agent") return "openpond_agent_create_v1";
+  if (kind === "update_agent") return "openpond_agent_update_v1";
+  return "generic_coding_v1";
+}
+function createGoalState(input) {
+  const kind = input.kind ?? "general_code_goal";
+  const profile = input.profile ?? goalKindDefaultProfile(kind);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: `goal_${randomUUID()}`,
+    teamId: input.teamId ?? null,
+    projectId: input.projectId ?? null,
+    agentId: input.agentId ?? null,
+    workItemId: input.workItemId ?? null,
+    conversationId: input.conversationId ?? null,
+    sandboxId: null,
+    runtimeId: null,
+    kind,
+    profile,
+    promptPack: input.promptPack ?? defaultPromptPackForGoal(kind),
+    objective: input.objective,
+    status: "queued",
+    executionPolicy: DEFAULT_GOAL_EXECUTION_POLICY,
+    verification: {
+      ...DEFAULT_GOAL_VERIFICATION,
+      ...input.verification ?? {},
+      commands: input.verification?.commands ?? DEFAULT_GOAL_VERIFICATION.commands,
+      requiredChecks: input.verification?.requiredChecks ?? DEFAULT_GOAL_VERIFICATION.requiredChecks,
+      successCriteria: input.verification?.successCriteria ?? DEFAULT_GOAL_VERIFICATION.successCriteria,
+      artifactRefs: input.verification?.artifactRefs ?? DEFAULT_GOAL_VERIFICATION.artifactRefs
+    },
+    constraints: [],
+    evidenceRefs: [],
+    budget: DEFAULT_GOAL_BUDGET,
+    questions: [],
+    answers: [],
+    approvals: [],
+    events: [
+      {
+        id: `event_${randomUUID()}`,
+        goalId: "",
+        iterationId: null,
+        kind: "goal.created",
+        summary: "Goal created",
+        payload: { kind, profile },
+        createdAt: now
+      }
+    ],
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function normalizeGoalState(state) {
+  return {
+    ...state,
+    events: state.events.map(
+      (event) => event.goalId ? event : { ...event, goalId: state.id }
+    )
+  };
+}
+function resolveGoalWorkspace(cwd) {
+  return resolve(cwd || process.cwd());
+}
+var DEFAULT_GOAL_STORAGE_LOCATION = "global";
+function parseGoalStorageLocation(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === "global" || normalized === "home" || normalized === "user-home") return "global";
+  if (normalized === "workspace" || normalized === "cwd" || normalized === "working-directory") return "workspace";
+  throw new Error("goal storage must be global or workspace");
+}
+async function resolveGoalStorageLocation(explicit) {
+  const explicitLocation = parseGoalStorageLocation(explicit);
+  if (explicitLocation) return explicitLocation;
+  const envLocation = parseGoalStorageLocation(
+    process.env.OPENPOND_GOAL_STORAGE_LOCATION || process.env.OPENPOND_GOAL_STORAGE
+  );
+  if (envLocation) return envLocation;
+  const config = await loadGlobalConfig().catch(() => null);
+  return config?.goalStorageLocation ?? DEFAULT_GOAL_STORAGE_LOCATION;
+}
+function resolveGoalStorageRoot(input) {
+  return input.location === "workspace" ? resolveGoalWorkspace(input.cwd) : os.homedir();
+}
+function goalStateDisplayPath(input) {
+  const home = os.homedir();
+  const relative3 = join(".openpond", "goals", input.goalId, input.fileName);
+  return input.storageRoot === home ? `~/${relative3}` : relative3;
+}
+
+// src/goal/create-pipeline.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function shouldCreatePipelineForGoal(kind) {
+  return kind === "create_agent" || kind === "update_agent";
+}
+function createInitialCreatePipeline(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const requestId = `create_request_${randomUUID2()}`;
+  const planId = `create_plan_${randomUUID2()}`;
+  const approvalId = `approval_${randomUUID2()}`;
+  const operation = input.goal.kind === "update_agent" ? "edit" : "create";
+  const createAgentId = input.goal.agentId ?? slugFromObjective(input.goal.objective);
+  const sourceRoot = sourceRootPathForAgent(
+    operation === "edit" && input.goal.agentId ? input.goal.agentId : createAgentId
+  );
+  const request = {
+    schemaVersion: "openpond.createPipeline.request.v1",
+    id: requestId,
+    operation,
+    surface: input.surface,
+    command: input.command,
+    objective: input.goal.objective,
+    adapter: {
+      kind: "local",
+      sourceAuthority: "local_profile",
+      activeProfile: input.profile?.activeProfile ?? null,
+      repoPath: input.profile?.repoPath ?? null,
+      sourcePath: input.profile?.sourcePath ?? null,
+      localHead: input.profile?.localHead ?? null,
+      confirmationPolicy: "always_require_plan_approval"
+    },
+    actor: {
+      id: input.actorId ?? null,
+      kind: "user",
+      label: null
+    },
+    scope: {
+      conversationId: input.goal.conversationId,
+      workItemId: input.goal.workItemId,
+      projectId: input.goal.projectId,
+      targetProject: input.goal.projectId ? {
+        id: input.goal.projectId,
+        name: null,
+        workspacePath: null,
+        sourceRef: null,
+        baseSha: null
+      } : null
+    },
+    context: {
+      messageIds: [],
+      conversationExcerpts: [],
+      attachments: [],
+      apps: [],
+      tools: [],
+      targetRepoAssumptions: []
+    },
+    targetAgent: {
+      agentId: input.goal.agentId,
+      displayName: null,
+      defaultActionKey: input.goal.agentId ? `${input.goal.agentId}.chat` : "chat"
+    },
+    metadata: {
+      goalKind: input.goal.kind,
+      promptPack: input.goal.promptPack,
+      sourceOwnership: "Profile source is durable agent code/config; local Goal state is operational run history and is not committed by default.",
+      stateOwnership: "Local questions, answers, approvals, events, create plans, and workflow capture are stored under the configured local Goal storage root."
+    },
+    createdAt: now
+  };
+  const parsedRequest = request;
+  const actionShape = inferCreatePipelineActionShape(parsedRequest);
+  const actionShapeDecisionSource = createPipelineActionShapeFromMetadata(
+    parsedRequest.metadata
+  ) ? "request_metadata" : "default_chat_fallback";
+  const plan = CreatePipelinePlanSchema.parse({
+    schemaVersion: "openpond.createPipeline.plan.v1",
+    id: planId,
+    goalId: input.goal.id,
+    requestId,
+    status: "pending_approval",
+    objective: input.goal.objective,
+    summary: operation === "edit" ? "Edit the selected source-backed OpenPond profile agent after this plan is approved." : "Create a source-backed OpenPond profile agent after this plan is approved.",
+    capturedContextSummary: input.surface === "local_extend" ? "Local extend request from the active profile source. No prior chat context was attached." : "Direct prompt request. No prior chat context was attached.",
+    defaultChatAction: {
+      key: input.goal.agentId ? `${input.goal.agentId}.chat` : "chat",
+      label: "Default chat",
+      required: true
+    },
+    sourcePlan: [
+      {
+        path: sourceRoot,
+        operation: operation === "edit" ? "update" : "create",
+        reason: operation === "edit" ? "Revise the selected profile agent source while preserving the default chat route." : "Implement the new profile agent source without overwriting existing profile agents."
+      },
+      {
+        path: "settings/profile.yaml",
+        operation: "update",
+        reason: "Register the agent and expose the default chat action in the local profile catalog."
+      },
+      {
+        path: sdkOutputPath(sourceRoot, "agent-manifest.json"),
+        operation: "inspect",
+        reason: "Regenerate and reload the action catalog from SDK outputs after checks pass."
+      },
+      {
+        path: sdkOutputPath(sourceRoot, "action-registry.json"),
+        operation: "inspect",
+        reason: "Verify the default chat action and explicit actions are catalog-addressable."
+      }
+    ],
+    requirements: [
+      {
+        kind: "target_project",
+        name: "active OpenPond profile source",
+        status: "required",
+        detail: input.profile?.sourcePath ?? "Resolved from the local goal workspace.",
+        metadata: {}
+      }
+    ],
+    checks: [
+      { name: "inspect", command: "pnpm agent:inspect --json", required: true },
+      { name: "build", command: "pnpm agent:build", required: true },
+      { name: "validate", command: "pnpm agent:validate --json", required: true },
+      { name: "eval", command: "pnpm agent:eval --json", required: true }
+    ],
+    approvalId,
+    approvedAt: null,
+    editedFromPlanId: null,
+    metadata: {
+      actionShape,
+      actionShapeDecisionSource,
+      reviewSections: [
+        "What happened",
+        "Agent/workflow plan",
+        "Files/source to create",
+        "Dependencies and runtime setup",
+        "Secrets and connections needed",
+        "Validation checks"
+      ]
+    },
+    createdAt: now,
+    updatedAt: now
+  });
+  const workflowCapture = WorkflowCaptureArtifactSchema.parse({
+    schemaVersion: "openpond.createPipeline.workflowCapture.v1",
+    id: `workflow_capture_${randomUUID2()}`,
+    goalId: input.goal.id,
+    requestId,
+    command: input.command,
+    objective: input.goal.objective,
+    conversationExcerpts: [],
+    attachments: [],
+    apps: [],
+    tools: [],
+    profileActions: [],
+    externalProviders: [],
+    environmentVariables: [],
+    files: [],
+    schedules: [],
+    webhooks: [],
+    channelTargets: [],
+    outputArtifacts: [],
+    targetRepoAssumptions: [],
+    traceRefs: [],
+    metadata: {
+      capturePolicy: "Moderate capture only: names, high-level inputs/outputs, setup requirements, artifacts, and side effects. Raw secrets and large logs are excluded."
+    },
+    createdAt: now
+  });
+  const snapshot = CreatePipelineSnapshotSchema.parse({
+    schemaVersion: "openpond.createPipeline.snapshot.v1",
+    id: `create_pipeline_${randomUUID2()}`,
+    goalId: input.goal.id,
+    state: "awaiting_plan_approval",
+    request: parsedRequest,
+    plan,
+    workflowCapture,
+    approvalIds: [approvalId],
+    checkRefs: [],
+    sourceRefs: [],
+    localGoalId: input.goal.id,
+    localProfileCommit: input.profile?.localHead ?? null,
+    hostedGoalId: null,
+    hostedSourceCommit: null,
+    hostedSourceRef: null,
+    blockedReason: null,
+    metadata: {},
+    createdAt: now,
+    updatedAt: now
+  });
+  const approval = {
+    id: approvalId,
+    goalId: input.goal.id,
+    kind: "create_plan",
+    title: operation === "edit" ? "Approve agent edit plan" : "Approve agent create plan",
+    reason: "OpenPond requires plan approval before mutating durable profile agent source.",
+    payload: {
+      requestId,
+      planId,
+      pipelineId: snapshot.id,
+      objective: input.goal.objective,
+      defaultActionKey: plan.defaultChatAction.key,
+      sourcePlan: plan.sourcePlan,
+      checks: plan.checks
+    },
+    createdAt: now,
+    status: "pending",
+    decidedAt: null,
+    decisionNote: null
+  };
+  return { snapshot, approval };
+}
+function slugFromObjective(objective) {
+  return normalizeAgentId(
+    objective.toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "created-agent"
+  );
+}
+function sourceRootPathForAgent(agentId) {
+  return agentId === "default" ? "agent" : `agents/${agentId}`;
+}
+function sdkOutputPath(sourceRoot, fileName) {
+  return sourceRoot === "agent" ? `.openpond/${fileName}` : `${sourceRoot}/.openpond/${fileName}`;
+}
+function normalizeAgentId(value) {
+  const normalized = value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return normalized || "created-agent";
+}
+function approveCreatePipelinePlan(goal, approvalId) {
+  return decideCreatePipelinePlan(goal, approvalId, "approved");
+}
+function rejectCreatePipelinePlan(goal, approvalId, decisionNote) {
+  return decideCreatePipelinePlan(goal, approvalId, "rejected", decisionNote);
+}
+function cancelCreatePipelinePlan(goal, approvalId, decisionNote) {
+  return decideCreatePipelinePlan(goal, approvalId, "cancelled", decisionNote);
+}
+function reviseCreatePipelinePlan(goal, input) {
+  const pipeline = goal.createPipeline;
+  if (!pipeline?.plan) {
+    throw new Error("goal has no create plan to edit");
+  }
+  if (pipeline.plan.status !== "pending_approval") {
+    throw new Error("only a pending create plan can be edited before source mutation");
+  }
+  const revision = input.revision.trim();
+  if (!revision) {
+    throw new Error("plan edit instructions are required");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const previousPlan = pipeline.plan;
+  const nextPlan = CreatePipelinePlanSchema.parse({
+    ...previousPlan,
+    id: `create_plan_${randomUUID2()}`,
+    status: "pending_approval",
+    summary: `${previousPlan.summary}
+
+Revision requested: ${revision}`,
+    sourcePlan: previousPlan.sourcePlan.map((item) => ({
+      ...item,
+      reason: `${item.reason} Revision requested: ${revision}`
+    })),
+    approvedAt: null,
+    editedFromPlanId: previousPlan.id,
+    metadata: {
+      ...previousPlan.metadata,
+      revision,
+      supersedesPlanId: previousPlan.id
+    },
+    createdAt: now,
+    updatedAt: now
+  });
+  const approvals = goal.approvals.map(
+    (approval) => approval.id === previousPlan.approvalId ? {
+      ...approval,
+      title: "Approve revised agent plan",
+      reason: "OpenPond requires approval of the revised plan before mutating durable profile agent source.",
+      payload: {
+        ...approval.payload,
+        planId: nextPlan.id,
+        previousPlanId: previousPlan.id,
+        objective: nextPlan.objective,
+        defaultActionKey: nextPlan.defaultChatAction.key,
+        sourcePlan: nextPlan.sourcePlan,
+        checks: nextPlan.checks,
+        revision
+      },
+      status: "pending",
+      decidedAt: null,
+      decisionNote: null
+    } : approval
+  );
+  return {
+    ...goal,
+    status: "awaiting_approval",
+    approvals,
+    createPipeline: CreatePipelineSnapshotSchema.parse({
+      ...pipeline,
+      state: "awaiting_plan_approval",
+      plan: nextPlan,
+      blockedReason: null,
+      metadata: {
+        ...pipeline.metadata,
+        previousPlanId: previousPlan.id
+      },
+      updatedAt: now
+    }),
+    updatedAt: now
+  };
+}
+function decideCreatePipelinePlan(goal, approvalId, decision, decisionNote) {
+  const pipeline = goal.createPipeline;
+  if (!pipeline?.plan || pipeline.plan.approvalId !== approvalId) return goal;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const nextState = decision === "approved" ? "applying_source" : decision === "cancelled" ? "cancelled" : "blocked";
+  return {
+    ...goal,
+    createPipeline: CreatePipelineSnapshotSchema.parse({
+      ...pipeline,
+      state: nextState,
+      plan: {
+        ...pipeline.plan,
+        status: decision,
+        approvedAt: decision === "approved" ? now : pipeline.plan.approvedAt,
+        metadata: {
+          ...pipeline.plan.metadata,
+          decision,
+          ...decisionNote ? { decisionNote } : {}
+        },
+        updatedAt: now
+      },
+      blockedReason: decision === "rejected" ? "Create plan rejected before source mutation." : decision === "cancelled" ? "Create plan cancelled before source mutation." : null,
+      updatedAt: now
+    })
+  };
+}
+
+// src/goal/events.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function createGoalEvent(input) {
+  return {
+    id: `event_${randomUUID3()}`,
+    goalId: input.goalId,
+    iterationId: input.iterationId ?? null,
+    kind: input.kind,
+    summary: input.summary,
+    payload: input.payload ?? {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function serializeGoalEventRecord(event) {
+  return JSON.stringify(event);
+}
+async function recordGoalEvent(event, targets) {
+  await targets.localState?.appendEvent(event.goalId, event);
+  await targets.hostedClient?.appendEvent(event.goalId, event);
+}
+
+// src/goal/runner.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
+
+// src/goal/budgets.ts
+function goalIterationBudgetRemaining(goal) {
+  const startedIterations = goal.events.filter(
+    (event) => event.kind === "iteration.started"
+  ).length;
+  return Math.max(0, goal.budget.maxIterations - startedIterations);
+}
+
+// src/goal/prompts.ts
+var GENERIC_CODING_PROMPT = `# Generic Coding Goal
+
+You are working on a source-backed coding goal. Make scoped source edits, run the configured checks, ask structured questions when blocked, and return a reviewable result.`;
+var CREATE_AGENT_PROMPT = `# Create OpenPond Agent Goal
+
+Create a source-backed OpenPond agent from the user's prompt. Ask structured questions for missing setup decisions, run the project-local OpenPond agent SDK commands through the openpond_agent_* tools, and leave a reviewable source update.
+
+Do not invoke openpond-agent through shell, npx, pnpm dlx, or yarn dlx.
+
+Create-agent and edit-agent Goals use a create pipeline. The pipeline request, plan, and workflow capture are durable Goal state under the configured local Goal storage root, normally ~/.openpond/goals/<goalId>; they are operational run history, not profile source to commit. Source mutation is allowed only after the create_plan approval is approved. When the Goal metadata contains an approved create pipeline plan, follow that plan, preserve or create a default chat action, keep openpond_chat routed to that default action, and run the required SDK checks before claiming the agent is ready.
+
+## Create Plan Action Shape
+
+When you author or revise a create plan, decide the public action shape from the user request, captured conversation context, attachments, prior tool/action evidence, existing profile catalog, and answered questions. Do not use hardcoded business examples or hidden keyword lists.
+
+Record the decision as metadata.actionShape on the create plan:
+
+{
+  "mode": "chat | direct_action | chat_and_direct_actions",
+  "label": "Short user-visible shape label",
+  "detail": "Why this shape fits the request",
+  "defaultActionKey": "chat or the generated default chat action id",
+  "directActionHint": "The repeatable direct action to expose, or null",
+  "artifactPolicy": "What run summaries, traces, and output artifacts should be persisted"
+}
+
+Use chat when the request is mainly conversational: answer questions, help with analysis, route follow-ups, or operate through normal OpenPond chat. Use direct_action when the request is a repeatable runnable operation with clear inputs and outputs, such as producing a report, transforming an artifact, running a workflow, exporting/importing data, or triggering a deterministic task without needing a conversation. Use chat_and_direct_actions when both a normal chat surface and one or more repeatable catalog actions are useful. If the source data, setup, output artifact, or invocation shape is ambiguous enough to change source design, ask a focused questions_ask question before requesting approval instead of guessing.
+
+If an existing plan says metadata.actionShapeDecisionSource is default_chat_fallback, treat that shape as a conservative app fallback rather than a model decision; refine the generated actions from the approved objective and captured context when the requested behavior clearly needs a direct action.
+
+Hosted create-agent goals may start from a generated OpenPond SDK project with package.json, openpond.yaml, and agent/** already present. Treat that as the scaffold to edit. Do not exhaust tool rounds reading every source file. Once you understand the scaffold and answered questions, update the minimal source files needed, run openpond_agent_default_checks, and then return a final no-tool response. If checks fail, use the check output and trace refs as repair input, edit the source or eval that is wrong, and rerun checks before returning a final response. Generated evals must test the behavior the agent actually implements; if you add a new intent/action, wire the default chat path or the eval input so the intent and result contract match.
+
+Do not inspect the openpond-agent-sdk package internals, vendored SDK source, or generated .openpond outputs unless an OpenPond agent check explicitly reports an error in those files. Use the existing agent/** files and the openpond_agent_* tools as the contract.
+
+For SharePoint or other unavailable external systems, do not spend multiple rounds searching for CLIs, SDK packages, credentials, or network access. If the user gives enough target details but real external access is unavailable, create a local draft agent behavior that detects the request, explains the missing external access honestly, and includes eval coverage for that intent. Then run openpond_agent_default_checks and return a final answer with the external access blocker. Do not claim that an external read/write succeeded.`;
+var UPDATE_AGENT_PROMPT = `# Update OpenPond Agent Goal
+
+Update an existing source-backed OpenPond agent from the user's request and evidence refs. Run before/after checks through the openpond_agent_* tools and leave a reviewable source update. Do not invoke openpond-agent through shell, npx, pnpm dlx, or yarn dlx.`;
+function resolveGoalPromptPack(goal) {
+  if (goal.promptPack === "openpond_agent_create_v1") {
+    return {
+      id: goal.promptPack,
+      title: "Create OpenPond Agent Goal",
+      instructions: CREATE_AGENT_PROMPT
+    };
+  }
+  if (goal.promptPack === "openpond_agent_update_v1") {
+    return {
+      id: goal.promptPack,
+      title: "Update OpenPond Agent Goal",
+      instructions: UPDATE_AGENT_PROMPT
+    };
+  }
+  return {
+    id: goal.promptPack || "generic_coding_v1",
+    title: "Generic Coding Goal",
+    instructions: GENERIC_CODING_PROMPT
+  };
+}
+
+// src/goal/redaction.ts
+var SECRET_PATTERNS = [
+  /\bopk_[A-Za-z0-9_-]{12,}\b/g,
+  /\bsk-[A-Za-z0-9_-]{12,}\b/g,
+  /\bghp_[A-Za-z0-9_]{12,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{12,}\b/g,
+  /\bOPENPOND_[A-Z0-9_]*(?:API_KEY|TOKEN|SECRET)\s*=\s*[^\s]+/g,
+  /\b(?:API_KEY|TOKEN|SECRET|PASSWORD)\s*=\s*[^\s]+/gi
+];
+var REDACTED = "[redacted]";
+function redactString(value) {
+  return SECRET_PATTERNS.reduce(
+    (current, pattern) => current.replace(pattern, REDACTED),
+    value
+  );
+}
+function truncateForEvent(value, maxLength = 4e3) {
+  const redacted = redactString(value);
+  if (redacted.length <= maxLength) return redacted;
+  return `${redacted.slice(0, maxLength)}
+[truncated ${redacted.length - maxLength} chars]`;
+}
+function redactJson(value) {
+  if (typeof value === "string") return redactString(value);
+  if (Array.isArray(value)) return value.map((entry) => redactJson(entry));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      redactJson(entry)
+    ])
+  );
+}
+
+// src/goal/llm.ts
+function buildGoalLlmMessages(goal) {
+  const promptPack = resolveGoalPromptPack(goal);
+  return [
+    {
+      role: "system",
+      content: [
+        "You are the OpenPond Goal runner. Produce executable tool calls, ask structured questions when blocked, and stay within the provided execution policy.",
+        "",
+        promptPack.instructions,
+        "",
+        "Runner rules:",
+        "- Use files_write for source edits instead of describing edits.",
+        "- Use questions_ask for required user input.",
+        "- Use checks_run or configured verification commands before claiming completion.",
+        "- Hosted coding sandboxes include node, npm, pnpm, and common POSIX utilities; follow the target repository's lockfile when choosing install/test commands, use command -v for PATH checks, and do not block on standalone toolchain probes once a needed package manager command works.",
+        "- For OpenPond agent goals, run SDK actions through openpond_agent_* tools. Do not invoke openpond-agent through shell, npx, pnpm dlx, or yarn dlx.",
+        "- For OpenPond agent goals, after source edits use openpond_agent_default_checks unless a narrower SDK command is clearly enough; do not spend the remaining rounds on broad inspection.",
+        "- After required edits and checks are complete, return a concise final response with no tool calls.",
+        "- Do not keep inspecting once you have enough context to make the requested change.",
+        "- Do not claim external integration reads or writes succeeded without tool evidence."
+      ].join("\n")
+    },
+    {
+      role: "user",
+      content: buildGoalUserContext(goal)
+    }
+  ];
+}
+function buildGoalUserContext(goal) {
+  const answeredQuestions = goal.questions.filter((question) => question.answeredAt).map((question) => {
+    const answer = goal.answers.find((item) => item.questionId === question.id);
+    return {
+      question: question.title,
+      optionId: answer?.optionId ?? null,
+      answer: answer?.freeformText ?? null,
+      value: answer?.value ?? {}
+    };
+  });
+  const openQuestions = goal.questions.filter((question) => !question.answeredAt).map((question) => ({
+    title: question.title,
+    reason: question.reason,
+    required: question.required,
+    options: question.options,
+    freeformAllowed: question.freeformAllowed
+  }));
+  const approvals = goal.approvals.map((approval) => ({
+    kind: approval.kind,
+    status: approval.status,
+    title: approval.title,
+    reason: approval.reason,
+    decisionNote: approval.decisionNote,
+    decidedAt: approval.decidedAt
+  }));
+  const createPipeline = goal.createPipeline ? {
+    id: goal.createPipeline.id,
+    state: goal.createPipeline.state,
+    request: {
+      id: goal.createPipeline.request.id,
+      operation: goal.createPipeline.request.operation,
+      surface: goal.createPipeline.request.surface,
+      command: goal.createPipeline.request.command,
+      sourceAuthority: goal.createPipeline.request.adapter.sourceAuthority,
+      confirmationPolicy: goal.createPipeline.request.adapter.confirmationPolicy
+    },
+    plan: goal.createPipeline.plan ? {
+      id: goal.createPipeline.plan.id,
+      status: goal.createPipeline.plan.status,
+      summary: goal.createPipeline.plan.summary,
+      defaultChatAction: goal.createPipeline.plan.defaultChatAction,
+      sourcePlan: goal.createPipeline.plan.sourcePlan,
+      requirements: goal.createPipeline.plan.requirements,
+      checks: goal.createPipeline.plan.checks,
+      metadata: {
+        actionShape: goal.createPipeline.plan.metadata?.actionShape ?? null,
+        actionShapeDecisionSource: goal.createPipeline.plan.metadata?.actionShapeDecisionSource ?? null
+      },
+      approvedAt: goal.createPipeline.plan.approvedAt
+    } : null,
+    workflowCapture: goal.createPipeline.workflowCapture ? {
+      id: goal.createPipeline.workflowCapture.id,
+      tools: goal.createPipeline.workflowCapture.tools,
+      apps: goal.createPipeline.workflowCapture.apps,
+      targetRepoAssumptions: goal.createPipeline.workflowCapture.targetRepoAssumptions
+    } : null
+  } : null;
+  return [
+    `Objective: ${goal.objective}`,
+    "",
+    "Goal metadata:",
+    JSON.stringify(
+      {
+        goalId: goal.id,
+        kind: goal.kind,
+        profile: goal.profile,
+        promptPack: goal.promptPack,
+        status: goal.status,
+        constraints: goal.constraints,
+        evidenceRefs: goal.evidenceRefs,
+        executionPolicy: goal.executionPolicy,
+        verification: goal.verification,
+        createPipeline,
+        answeredQuestions,
+        openQuestions,
+        approvals
+      },
+      null,
+      2
+    )
+  ].join("\n");
+}
+async function callHostedGoalLlm(params) {
+  const request = {
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    promptPack: params.goal.promptPack,
+    messages: params.messages ?? buildGoalLlmMessages(params.goal),
+    tools: params.tools,
+    metadata: params.metadata
+  };
+  const response = await params.hostedClient.callLlm(request);
+  if (response.usage) {
+    await recordGoalEvent(
+      createGoalEvent({
+        goalId: params.goal.id,
+        iterationId: params.iterationId,
+        kind: "model.usage",
+        summary: "Goal LLM call completed",
+        payload: redactJson({ usage: response.usage })
+      }),
+      { localState: params.localState, hostedClient: params.hostedClient }
+    );
+  }
+  return response;
+}
+function resolveLocalGoalLlmConfig(env = typeof process === "undefined" ? {} : process.env) {
+  const token = env.OPENPOND_GOAL_OPCHAT_API_KEY?.trim() || env.OPENPOND_OPCHAT_API_KEY?.trim() || env.OPENPOND_API_KEY?.trim();
+  if (!token) return null;
+  return {
+    apiBaseUrl: resolveOpChatApiBaseUrl({ env }),
+    token,
+    model: env.OPENPOND_GOAL_MODEL?.trim() || env.OPENPOND_OPCHAT_MODEL?.trim() || "openpond-chat"
+  };
+}
+async function callLocalGoalLlm(params) {
+  const config = resolveLocalGoalLlmConfig(params.env);
+  if (!config) return null;
+  const completion = await sendHostedChatTurn({
+    apiBaseUrl: config.apiBaseUrl,
+    token: config.token,
+    model: config.model,
+    messages: params.messages ?? buildGoalLlmMessages(params.goal),
+    tools: params.tools,
+    toolChoice: params.tools?.length ? "auto" : void 0,
+    temperature: 0.2,
+    metadata: {
+      source: "openpond-code-goal",
+      goalId: params.goal.id,
+      promptPack: params.goal.promptPack,
+      ...params.metadata ?? {}
+    }
+  });
+  const response = goalLlmResponseFromHostedChatCompletion(completion, {
+    afterToolResults: (params.messages ?? []).some(
+      (message) => message.role === "tool"
+    )
+  });
+  if (response.usage) {
+    await recordGoalEvent(
+      createGoalEvent({
+        goalId: params.goal.id,
+        iterationId: params.iterationId,
+        kind: "model.usage",
+        summary: "Local Goal LLM call completed",
+        payload: redactJson({ usage: response.usage })
+      }),
+      { localState: params.localState }
+    );
+  }
+  return response;
+}
+function goalLlmResponseFromHostedChatCompletion(completion, options = {}) {
+  const choice = completion.choices?.[0];
+  const message = choice?.message;
+  const content = typeof message?.content === "string" ? message.content.trim() : "";
+  const toolCalls = (message?.tool_calls ?? []).flatMap((toolCall) => {
+    const id = typeof toolCall.id === "string" ? toolCall.id : "";
+    const name = typeof toolCall.function?.name === "string" ? toolCall.function.name : "";
+    if (!id || !name) return [];
+    return [
+      {
+        id,
+        name,
+        arguments: parseToolArguments(toolCall.function?.arguments)
+      }
+    ];
+  });
+  return {
+    status: toolCalls.length > 0 || options.afterToolResults ? "ok" : "blocked",
+    summary: toolCalls.length > 0 ? `Goal planner returned ${toolCalls.length} tool call${toolCalls.length === 1 ? "" : "s"}.` : content || "Goal planner returned no executable tool calls.",
+    message: {
+      role: "assistant",
+      content
+    },
+    ...toolCalls.length > 0 ? { toolCalls } : {},
+    ...completion.usage ? {
+      usage: {
+        inputTokens: completion.usage.prompt_tokens ?? completion.usage.input_tokens,
+        outputTokens: completion.usage.completion_tokens ?? completion.usage.output_tokens,
+        totalTokens: completion.usage.total_tokens
+      }
+    } : {}
+  };
+}
+function parseToolArguments(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || !value.trim()) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+// src/goal/result.ts
+function createGoalRunResult(input) {
+  return {
+    goalId: input.goal.id,
+    status: input.status,
+    summary: input.summary,
+    events: input.events
+  };
+}
+
+// src/goal/local-create-pipeline.ts
+var MODEL_BACKED_LOCAL_CREATE_REQUIRED_REASON = "Approved local Create plans require model-backed SDK source application; no source mutation was performed.";
+function shouldRunLocalCreatePipeline(goal, mode) {
+  const pipeline = goal.createPipeline;
+  return Boolean(
+    mode === "local" && pipeline && pipeline.state === "applying_source" && pipeline.request.adapter.kind === "local"
+  );
+}
+async function runLocalCreatePipeline(input) {
+  const localState = input.localState;
+  if (!localState) {
+    const blocked2 = createGoalEvent({
+      goalId: input.goal.id,
+      iterationId: input.iterationId,
+      kind: "goal.blocked",
+      summary: "Local create pipeline requires local Goal state",
+      payload: { reason: "missing_local_state" }
+    });
+    return createGoalRunResult({
+      goal: input.goal,
+      status: "blocked",
+      summary: blocked2.summary,
+      events: [...input.startedEvents, blocked2]
+    });
+  }
+  const current = await localState.get(input.goal.id) ?? input.goal;
+  const pipeline = current.createPipeline;
+  if (!pipeline || pipeline.request.adapter.kind !== "local") {
+    const blocked2 = createGoalEvent({
+      goalId: current.id,
+      iterationId: input.iterationId,
+      kind: "goal.blocked",
+      summary: "Goal does not have a local create pipeline to run",
+      payload: { reason: "missing_local_create_pipeline" }
+    });
+    await recordGoalEvent(blocked2, { localState });
+    await localState.update({ ...current, status: "blocked" });
+    return createGoalRunResult({
+      goal: current,
+      status: "blocked",
+      summary: blocked2.summary,
+      events: [...input.startedEvents, blocked2]
+    });
+  }
+  const events = [...input.startedEvents];
+  const blockedTransition = await transitionLocalCreatePipeline({
+    localState,
+    goalId: current.id,
+    iterationId: input.iterationId,
+    state: "blocked",
+    summary: MODEL_BACKED_LOCAL_CREATE_REQUIRED_REASON,
+    blockedReason: MODEL_BACKED_LOCAL_CREATE_REQUIRED_REASON
+  });
+  events.push(blockedTransition.event);
+  await localState.update({
+    ...blockedTransition.goal,
+    status: "blocked"
+  });
+  const blocked = createGoalEvent({
+    goalId: current.id,
+    iterationId: input.iterationId,
+    kind: "goal.blocked",
+    summary: MODEL_BACKED_LOCAL_CREATE_REQUIRED_REASON,
+    payload: {
+      pipelineId: pipeline.id,
+      operation: pipeline.request.operation,
+      reason: "model_backed_source_application_required",
+      sourcePath: pipeline.request.adapter.sourcePath ?? null,
+      repoPath: pipeline.request.adapter.repoPath ?? null
+    }
+  });
+  await recordGoalEvent(blocked, { localState });
+  events.push(blocked);
+  return createGoalRunResult({
+    goal: blockedTransition.goal,
+    status: "blocked",
+    summary: blocked.summary,
+    events
+  });
+}
+async function transitionLocalCreatePipeline(input) {
+  const current = await input.localState.get(input.goalId);
+  if (!current?.createPipeline) {
+    throw new Error(`goal has no create pipeline: ${input.goalId}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const previousState = current.createPipeline.state;
+  const nextPipeline = CreatePipelineSnapshotSchema.parse({
+    ...current.createPipeline,
+    state: input.state,
+    checkRefs: mergeRefs(current.createPipeline.checkRefs, input.checkRefs ?? []),
+    blockedReason: input.blockedReason === void 0 ? current.createPipeline.blockedReason : input.blockedReason,
+    updatedAt: now
+  });
+  const goal = await input.localState.update({
+    ...current,
+    createPipeline: nextPipeline,
+    updatedAt: now
+  });
+  const event = createGoalEvent({
+    goalId: input.goalId,
+    iterationId: input.iterationId,
+    kind: "create_pipeline.status_changed",
+    summary: input.summary,
+    payload: {
+      fromState: previousState,
+      toState: input.state,
+      pipelineId: nextPipeline.id,
+      blockedReason: nextPipeline.blockedReason,
+      checkRefs: nextPipeline.checkRefs
+    }
+  });
+  await recordGoalEvent(event, { localState: input.localState });
+  return {
+    goal: await input.localState.get(input.goalId) ?? goal,
+    event
+  };
+}
+function mergeRefs(existing, next) {
+  return Array.from(new Set([...existing, ...next].filter(Boolean)));
+}
+
+// src/goal/policy.ts
+function assertGoalCanStartIteration(goal) {
+  if (goal.status === "cancelled" || goal.status === "completed" || goal.status === "failed") {
+    throw new Error(`goal is terminal: ${goal.status}`);
+  }
+  if (goal.status === "paused") throw new Error("goal is paused");
+  if (goal.status === "awaiting_user_input") {
+    throw new Error("goal is awaiting required user input");
+  }
+  if (goal.status === "awaiting_approval") {
+    throw new Error("goal is awaiting approval");
+  }
+}
+
+// src/goal/profiles/generic-coding.ts
+var GENERIC_CODING_PROFILE = {
+  id: "generic_coding",
+  promptPack: "generic_coding_v1",
+  defaultVerificationCommands: [],
+  toolNames: [
+    "shell",
+    "files",
+    "checks",
+    "artifacts",
+    "questions",
+    "approvals",
+    "source"
+  ]
+};
+
+// src/goal/profiles/openpond-agent.ts
+var OPENPOND_AGENT_PROFILE = {
+  id: "openpond_agent",
+  promptPack: "openpond_agent_create_v1",
+  defaultVerificationCommands: [],
+  toolNames: [
+    "shell",
+    "files",
+    "checks",
+    "artifacts",
+    "questions",
+    "approvals",
+    "source",
+    "openpond_agent_sdk"
+  ]
+};
+
+// src/goal/profiles/index.ts
+function getGoalProfileDescriptor(goal) {
+  if (goal.profile === "openpond_agent") {
+    return {
+      ...OPENPOND_AGENT_PROFILE,
+      promptPack: goal.promptPack
+    };
+  }
+  return {
+    ...GENERIC_CODING_PROFILE,
+    promptPack: goal.promptPack
+  };
+}
+
+// src/goal/tools/checks.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+
+// src/goal/limits.ts
+import { Buffer } from "node:buffer";
+var MAX_GOAL_FILE_READ_BYTES = 1024 * 1024;
+var MAX_GOAL_COMMAND_LOG_ARTIFACT_BYTES = 256 * 1024;
+function assertGoalFileReadSize(path, size) {
+  if (size <= MAX_GOAL_FILE_READ_BYTES) return;
+  throw new Error(
+    `file is too large to read through goal tools: ${path} (${size} bytes, max ${MAX_GOAL_FILE_READ_BYTES} bytes)`
+  );
+}
+function truncateGoalTextArtifact(content, maxBytes = MAX_GOAL_COMMAND_LOG_ARTIFACT_BYTES) {
+  if (Buffer.byteLength(content, "utf-8") <= maxBytes) {
+    return { content, truncated: false };
+  }
+  const marker = `
+[truncated after ${maxBytes} bytes]
+`;
+  const bodyBytes = Math.max(0, maxBytes - Buffer.byteLength(marker, "utf-8"));
+  return {
+    content: `${Buffer.from(content).subarray(0, bodyBytes).toString("utf8")}${marker}`,
+    truncated: true
+  };
+}
+
+// src/goal/tools/artifacts.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import os2 from "node:os";
+import { join as join2 } from "node:path";
+function safeFileName(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "artifact";
+}
+function createGoalArtifact(input) {
+  const content = redactString(input.content);
+  return {
+    id: `artifact_${randomUUID4()}`,
+    goalId: input.goalId,
+    iterationId: input.iterationId ?? null,
+    kind: input.kind,
+    name: input.name,
+    mimeType: input.mimeType ?? "text/plain",
+    content,
+    bytes: Buffer2.byteLength(content, "utf-8"),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function recordGoalArtifact(params) {
+  const artifact = params.artifact;
+  const ref = params.hostedClient ? await params.hostedClient.uploadArtifact(artifact) : await writeLocalArtifact(artifact, params.storageRoot ?? params.workspace);
+  await recordGoalEvent(
+    createGoalEvent({
+      goalId: artifact.goalId,
+      iterationId: artifact.iterationId,
+      kind: "artifact.created",
+      summary: `Artifact created: ${artifact.name}`,
+      payload: {
+        artifactRef: ref.ref,
+        artifactId: ref.id,
+        kind: ref.kind,
+        name: ref.name,
+        bytes: ref.bytes
+      }
+    }),
+    { localState: params.localState, hostedClient: params.hostedClient }
+  );
+  return ref;
+}
+async function writeLocalArtifact(artifact, storageRoot) {
+  const root = storageRoot || process.cwd();
+  const dir = join2(root, ".openpond", "goals", artifact.goalId, "artifacts");
+  await mkdir(dir, { recursive: true });
+  const fileName = `${artifact.id}-${safeFileName(artifact.name)}`;
+  const path = join2(dir, fileName);
+  await writeFile(path, artifact.content, "utf-8");
+  const relativeRef = `.openpond/goals/${artifact.goalId}/artifacts/${fileName}`;
+  return {
+    id: artifact.id,
+    ref: root === os2.homedir() ? `~/${relativeRef}` : relativeRef,
+    kind: artifact.kind,
+    name: artifact.name,
+    mimeType: artifact.mimeType,
+    bytes: artifact.bytes
+  };
+}
+
+// src/goal/tools/shell.ts
+var DEFAULT_GOAL_SHELL_TIMEOUT_SECONDS = 120;
+async function runGoalShellCommand(params) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const redactedCommand = redactString(params.command);
+  await recordGoalEvent(
+    createGoalEvent({
+      goalId: params.goalId,
+      iterationId: params.iterationId,
+      kind: "command.started",
+      summary: `Command started: ${redactedCommand}`,
+      payload: { command: redactedCommand, cwd: params.cwd }
+    }),
+    { localState: params.localState, hostedClient: params.hostedClient }
+  );
+  const start = Date.now();
+  const result = await runShellCommand(params.command, {
+    cwd: params.cwd,
+    env: params.env,
+    timeoutSeconds: params.timeoutSeconds ?? DEFAULT_GOAL_SHELL_TIMEOUT_SECONDS
+  });
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const artifactRefs = [];
+  const commandResult = {
+    command: params.command,
+    cwd: params.cwd,
+    code: result.code,
+    timedOut: result.timedOut,
+    durationMs: Date.now() - start,
+    stdoutTail: truncateForEvent(result.stdout),
+    stderrTail: truncateForEvent(result.stderr),
+    artifactRefs,
+    startedAt,
+    completedAt
+  };
+  const combinedOutput = [
+    result.stdout ? `stdout:
+${result.stdout}` : "",
+    result.stderr ? `stderr:
+${result.stderr}` : ""
+  ].filter(Boolean).join("\n\n");
+  if (combinedOutput.trim()) {
+    const artifactContent = truncateGoalTextArtifact(redactString(combinedOutput));
+    const artifact = createGoalArtifact({
+      goalId: params.goalId,
+      iterationId: params.iterationId,
+      kind: "command_log",
+      name: `${redactedCommand.replace(/\s+/g, "_").slice(0, 80)}.log`,
+      content: artifactContent.content
+    });
+    const ref = await recordGoalArtifact({
+      artifact,
+      workspace: params.workspace,
+      storageRoot: params.storageRoot,
+      localState: params.localState,
+      hostedClient: params.hostedClient
+    });
+    artifactRefs.push(ref.ref);
+  }
+  await recordGoalEvent(
+    createGoalEvent({
+      goalId: params.goalId,
+      iterationId: params.iterationId,
+      kind: "command.completed",
+      summary: result.code === 0 ? `Command completed: ${redactedCommand}` : `Command failed: ${redactedCommand}`,
+      payload: {
+        ...commandResult,
+        command: redactedCommand,
+        artifactRefs
+      }
+    }),
+    { localState: params.localState, hostedClient: params.hostedClient }
+  );
+  return commandResult;
+}
+
+// src/goal/tools/checks.ts
+async function runGoalVerificationChecks(params) {
+  const checks = [];
+  for (const command of params.goal.verification.commands) {
+    const redactedCommand = redactString(command);
+    const result = await runGoalShellCommand({
+      goalId: params.goal.id,
+      iterationId: params.iterationId,
+      command,
+      cwd: params.cwd,
+      workspace: params.workspace,
+      storageRoot: params.storageRoot,
+      localState: params.localState,
+      hostedClient: params.hostedClient
+    });
+    const status = result.code === 0 && !result.timedOut ? "passed" : "failed";
+    const check = {
+      id: `check_${randomUUID5()}`,
+      goalId: params.goal.id,
+      iterationId: params.iterationId,
+      name: redactedCommand,
+      command: redactedCommand,
+      status,
+      code: result.code,
+      timedOut: result.timedOut,
+      durationMs: result.durationMs,
+      summary: status === "passed" ? `Check passed: ${redactedCommand}` : `Check failed: ${redactedCommand}`,
+      artifactRefs: result.artifactRefs,
+      startedAt: result.startedAt,
+      completedAt: result.completedAt
+    };
+    checks.push(check);
+    await recordGoalEvent(
+      createGoalEvent({
+        goalId: params.goal.id,
+        iterationId: params.iterationId,
+        kind: "check.completed",
+        summary: check.summary,
+        payload: check
+      }),
+      { localState: params.localState, hostedClient: params.hostedClient }
+    );
+    if (status !== "passed") break;
+  }
+  return checks;
+}
+
+// src/goal/tools/registry.ts
+var OPENPOND_AGENT_SDK_COMMANDS = [
+  "inspect",
+  "build",
+  "validate",
+  "eval",
+  "traces"
+];
+var GOAL_TOOL_REGISTRY = [
+  {
+    family: "files",
+    canonicalName: "files.read",
+    aliases: ["files_read", "files.read"],
+    schema: tool(
+      "files_read",
+      "Read a UTF-8 file from the goal workspace.",
+      {
+        path: stringSchema("Workspace-relative path to read.")
+      },
+      ["path"]
+    )
+  },
+  {
+    family: "files",
+    canonicalName: "files.write",
+    aliases: ["files_write", "files.write"],
+    schema: tool(
+      "files_write",
+      "Write a UTF-8 file inside the goal workspace.",
+      {
+        path: stringSchema("Workspace-relative path to write."),
+        content: stringSchema("Complete file content to write.")
+      },
+      ["path", "content"]
+    )
+  },
+  {
+    family: "files",
+    canonicalName: "files.list",
+    aliases: ["files_list", "files.list"],
+    schema: tool(
+      "files_list",
+      "List direct children of a workspace directory.",
+      {
+        path: {
+          ...stringSchema("Workspace-relative directory path. Defaults to root."),
+          default: "."
+        }
+      }
+    )
+  },
+  {
+    family: "shell",
+    canonicalName: "shell.run",
+    aliases: ["shell", "shell_run", "shell.run"],
+    schema: tool(
+      "shell_run",
+      "Run a shell command inside the goal workspace.",
+      {
+        command: stringSchema("Command to execute."),
+        cwd: {
+          ...stringSchema("Workspace-relative directory. Defaults to root."),
+          default: "."
+        },
+        timeoutSeconds: {
+          type: "number",
+          minimum: 1,
+          maximum: 600,
+          description: "Optional command timeout in seconds."
+        }
+      },
+      ["command"]
+    )
+  },
+  {
+    family: "questions",
+    canonicalName: "questions.ask",
+    aliases: ["questions", "questions_ask", "questions.ask"],
+    schema: tool(
+      "questions_ask",
+      "Ask a structured user question and pause if required.",
+      {
+        title: stringSchema("Short question title."),
+        reason: stringSchema("Why the answer is needed."),
+        required: {
+          type: "boolean",
+          description: "Whether work must pause until answered.",
+          default: true
+        },
+        freeformAllowed: {
+          type: "boolean",
+          description: "Whether the user may type a custom answer.",
+          default: true
+        },
+        options: {
+          type: "array",
+          description: "Optional answer choices.",
+          items: {
+            type: "object",
+            properties: {
+              id: stringSchema("Stable option id."),
+              label: stringSchema("User-visible option label."),
+              description: stringSchema("Optional option detail.")
+            },
+            required: ["id", "label"],
+            additionalProperties: false
+          }
+        }
+      },
+      ["title", "reason"]
+    )
+  },
+  {
+    family: "approvals",
+    canonicalName: "approvals.request",
+    aliases: [
+      "approvals",
+      "approval_request",
+      "approvals_request",
+      "approvals.request"
+    ],
+    schema: tool(
+      "approvals_request",
+      "Request user approval for publish, integration writes, secret/env changes, budget escalation, or other external side effects.",
+      {
+        kind: {
+          type: "string",
+          enum: [
+            "create_plan",
+            "deploy_publish",
+            "integration_write",
+            "secret_or_env_change",
+            "budget_escalation",
+            "external_effect"
+          ],
+          description: "The type of approval gate needed."
+        },
+        title: stringSchema("Short approval title shown to the user."),
+        reason: stringSchema("Why approval is required before continuing."),
+        payload: {
+          type: "object",
+          description: "Optional compact approval metadata.",
+          additionalProperties: true
+        }
+      },
+      ["kind", "title", "reason"]
+    )
+  },
+  {
+    family: "checks",
+    canonicalName: "checks.run",
+    aliases: ["checks", "checks_run", "checks.run"],
+    schema: tool(
+      "checks_run",
+      "Run the goal verification commands.",
+      {
+        stopOnFailure: {
+          type: "boolean",
+          description: "Reserved; checks currently stop on first failure.",
+          default: true
+        }
+      }
+    )
+  },
+  {
+    family: "artifacts",
+    canonicalName: "artifacts.create",
+    aliases: ["artifacts", "artifacts_create", "artifacts.create"],
+    schema: tool(
+      "artifacts_create",
+      "Create a goal artifact from text content.",
+      {
+        kind: {
+          type: "string",
+          enum: ["command_log", "check_log", "patch", "trace", "manifest", "result"]
+        },
+        name: stringSchema("Artifact file name."),
+        content: stringSchema("Artifact text content."),
+        mimeType: {
+          ...stringSchema("Artifact MIME type."),
+          default: "text/plain"
+        }
+      },
+      ["kind", "name", "content"]
+    )
+  },
+  {
+    family: "source",
+    canonicalName: "source.finalize",
+    aliases: ["source", "source_finalize", "source.finalize"],
+    schema: tool(
+      "source_finalize",
+      "Commit and push checked source changes when policy allows.",
+      {
+        checksPassed: {
+          type: "boolean",
+          description: "Whether required checks passed."
+        },
+        defaultBranch: {
+          ...stringSchema("Default branch to push to, when known."),
+          default: ""
+        }
+      },
+      ["checksPassed"]
+    )
+  },
+  ...OPENPOND_AGENT_SDK_COMMANDS.map((sdkCommand) => ({
+    family: "openpond_agent_sdk",
+    canonicalName: `openpond_agent.${sdkCommand}`,
+    aliases: [`openpond_agent_${sdkCommand}`],
+    schema: tool(
+      `openpond_agent_${sdkCommand}`,
+      `Run project-local openpond-agent ${sdkCommand}.`,
+      {
+        args: stringArraySchema("Additional CLI args."),
+        json: {
+          type: "boolean",
+          description: "Request JSON output when supported.",
+          default: sdkCommand === "inspect" || sdkCommand === "eval" || sdkCommand === "traces"
+        }
+      },
+      []
+    )
+  })),
+  {
+    family: "openpond_agent_sdk",
+    canonicalName: "openpond_agent.run",
+    aliases: ["openpond_agent_run"],
+    schema: tool(
+      "openpond_agent_run",
+      "Run a project-local openpond-agent action.",
+      {
+        args: stringArraySchema("CLI args, such as --action and --input."),
+        json: {
+          type: "boolean",
+          description: "Request JSON output when supported.",
+          default: true
+        }
+      },
+      []
+    )
+  },
+  {
+    family: "openpond_agent_sdk",
+    canonicalName: "openpond_agent.default_checks",
+    aliases: [
+      "openpond_agent_default_checks",
+      "openpond_agent.default_checks"
+    ],
+    schema: tool(
+      "openpond_agent_default_checks",
+      "Run inspect, build, validate, and eval through the project-local SDK.",
+      {}
+    )
+  }
+];
+var ALIAS_TO_CANONICAL = new Map(
+  GOAL_TOOL_REGISTRY.flatMap((registration) => [
+    [registration.canonicalName, registration.canonicalName],
+    ...registration.aliases.map(
+      (alias) => [alias, registration.canonicalName]
+    )
+  ])
+);
+function buildGoalLlmToolSchemas(toolNames) {
+  const enabled = new Set(toolNames);
+  return GOAL_TOOL_REGISTRY.flatMap(
+    (registration) => enabled.has(registration.family) && registration.schema ? [registration.schema] : []
+  );
+}
+function normalizeGoalToolName(name, args) {
+  const raw = name.trim();
+  const canonical = ALIAS_TO_CANONICAL.get(raw);
+  if (canonical) return canonical;
+  const sdkPrefix = "openpond_agent_";
+  if (raw.startsWith(sdkPrefix)) {
+    return `openpond_agent.${raw.slice(sdkPrefix.length)}`;
+  }
+  if (raw === "files") {
+    const action = optionalString(args, "action");
+    return action ? `files.${action}` : raw;
+  }
+  if (raw === "openpond_agent_sdk") {
+    const command = optionalString(args, "command");
+    return command ? `openpond_agent.${command}` : raw;
+  }
+  return raw;
+}
+function tool(name, description, properties, required = []) {
+  return {
+    type: "function",
+    function: {
+      name,
+      description,
+      parameters: {
+        type: "object",
+        properties,
+        required,
+        additionalProperties: false
+      }
+    }
+  };
+}
+function stringSchema(description) {
+  return { type: "string", description };
+}
+function stringArraySchema(description) {
+  return {
+    type: "array",
+    description,
+    items: { type: "string" },
+    default: []
+  };
+}
+function optionalString(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+// src/goal/tools/dispatch.ts
+import { Buffer as Buffer3 } from "node:buffer";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "node:path";
+
+// src/goal/approvals.ts
+function createGoalApprovalRequest(input) {
+  return {
+    goalId: input.goal.id,
+    kind: input.kind,
+    title: input.title,
+    reason: input.reason,
+    payload: input.payload ?? {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/goal/tools/files.ts
+import { constants as fsConstants } from "node:fs";
+import { access, mkdir as mkdir2, readFile, readdir, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve as resolve2 } from "node:path";
+function resolveWorkspacePath(workspace, filePath) {
+  const resolved = resolve2(workspace, filePath);
+  const rel = relative(workspace, resolved);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`path is outside workspace: ${filePath}`);
+  }
+  return resolved;
+}
+async function readGoalPath(params) {
+  const absolute = resolveWorkspacePath(params.workspace, params.path);
+  const info = await stat(absolute);
+  if (info.isDirectory()) {
+    const entries = await readdir(absolute, { withFileTypes: true });
+    return {
+      path: params.path,
+      type: "directory",
+      entries: entries.map((entry) => entry.name).sort()
+    };
+  }
+  assertGoalFileReadSize(params.path, info.size);
+  return {
+    path: params.path,
+    type: "file",
+    content: await readFile(absolute, "utf-8")
+  };
+}
+async function writeGoalFile(params) {
+  const absolute = resolveWorkspacePath(params.workspace, params.path);
+  const created = !await fileExists(absolute);
+  await mkdir2(dirname(absolute), { recursive: true });
+  await writeFile2(absolute, params.content, "utf-8");
+  return { path: params.path, created };
+}
+async function listGoalFiles(params) {
+  const root = resolveWorkspacePath(params.workspace, params.path || ".");
+  const entries = await readdir(root, { withFileTypes: true });
+  return entries.map((entry) => entry.name).sort();
+}
+async function fileExists(path) {
+  return access(path, fsConstants.F_OK).then(() => true).catch(() => false);
+}
+
+// src/goal/tools/questions.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+async function askGoalQuestion(params) {
+  const question = {
+    id: `question_${randomUUID6()}`,
+    goalId: params.goalId,
+    title: params.title,
+    reason: params.reason,
+    required: params.required ?? true,
+    options: params.options ?? [],
+    freeformAllowed: params.freeformAllowed ?? true,
+    answeredAt: null
+  };
+  await params.localState?.addQuestion(params.goalId, question);
+  await params.hostedClient?.createQuestion(params.goalId, question);
+  await recordGoalEvent(
+    createGoalEvent({
+      goalId: params.goalId,
+      iterationId: params.iterationId,
+      kind: "question.created",
+      summary: `Question created: ${question.title}`,
+      payload: {
+        questionId: question.id,
+        required: question.required,
+        options: question.options,
+        freeformAllowed: question.freeformAllowed
+      }
+    }),
+    { localState: params.localState, hostedClient: params.hostedClient }
+  );
+  return question;
+}
+
+// src/goal/tools/sdk-agent.ts
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join as join3 } from "node:path";
+function resolveProjectLocalAgentCommand(cwd) {
+  const packageDistCli = join3(
+    cwd,
+    "node_modules",
+    "openpond-agent-sdk",
+    "dist",
+    "cli.js"
+  );
+  if (existsSync(packageDistCli)) return { command: process.execPath, args: [packageDistCli] };
+  const localBin = join3(cwd, "node_modules", ".bin", "openpond-agent");
+  if (existsSync(localBin)) return { command: localBin, args: [] };
+  const packageCli = join3(
+    cwd,
+    "node_modules",
+    "openpond-agent-sdk",
+    "src",
+    "cli.ts"
+  );
+  if (existsSync(packageCli)) {
+    const packageJson = join3(cwd, "node_modules", "openpond-agent-sdk", "package.json");
+    const tsxCli = createRequire(packageJson).resolve("tsx/cli");
+    return { command: process.execPath, args: [tsxCli, packageCli] };
+  }
+  return null;
+}
+async function runAgentSdkCommand(params) {
+  if (params.sdkCommand === "inspect" && !resolveProjectLocalAgentCommand(params.cwd) && !existsSync(join3(params.cwd, "package.json"))) {
+    return uninitializedAgentInspectResult(params.cwd);
+  }
+  const command = await ensureProjectLocalAgentCommand(params);
+  const args = [
+    ...command.args,
+    params.sdkCommand,
+    ...params.args ?? [],
+    "--cwd",
+    params.cwd
+  ];
+  if (params.json) args.push("--json");
+  return runGoalShellCommand({
+    goalId: params.goalId,
+    iterationId: params.iterationId,
+    command: [command.command, ...args].map(shellEscape).join(" "),
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+}
+function uninitializedAgentInspectResult(cwd) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    command: "openpond-agent inspect --json",
+    cwd,
+    code: 0,
+    timedOut: false,
+    durationMs: 0,
+    stdoutTail: JSON.stringify({
+      status: "not_initialized",
+      summary: "No OpenPond agent project was found yet. Create package.json and source files before running SDK validation.",
+      packageJsonFound: false,
+      projectLocalOpenpondAgentFound: false
+    }),
+    stderrTail: "",
+    artifactRefs: [],
+    startedAt: now,
+    completedAt: now
+  };
+}
+async function runDefaultAgentSdkChecks(params) {
+  const commands = [
+    "inspect",
+    "build",
+    "validate",
+    "eval",
+    "traces"
+  ];
+  const results = [];
+  for (const sdkCommand of commands) {
+    const result = await runAgentSdkCommand({
+      ...params,
+      sdkCommand,
+      json: sdkCommand === "inspect" || sdkCommand === "eval" || sdkCommand === "traces"
+    });
+    results.push(result);
+    if (result.code !== 0 || result.timedOut) break;
+  }
+  return results;
+}
+async function ensureProjectLocalAgentCommand(params) {
+  const existing = resolveProjectLocalAgentCommand(params.cwd);
+  if (existing) return existing;
+  const installCommand = dependencyInstallCommand(params.cwd);
+  if (!installCommand) {
+    throw new Error(
+      "project-local openpond-agent is missing and no package.json was found"
+    );
+  }
+  const setup = await runGoalShellCommand({
+    goalId: params.goalId,
+    iterationId: params.iterationId,
+    command: installCommand,
+    cwd: params.cwd,
+    timeoutSeconds: 600,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  if (setup.code !== 0 || setup.timedOut) {
+    throw new Error(`dependency setup failed before openpond-agent: ${installCommand}`);
+  }
+  const installed = resolveProjectLocalAgentCommand(params.cwd);
+  if (!installed) {
+    throw new Error("project-local openpond-agent was not created by dependency setup");
+  }
+  return installed;
+}
+function dependencyInstallCommand(cwd) {
+  if (!existsSync(join3(cwd, "package.json"))) return null;
+  if (existsSync(join3(cwd, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync(join3(cwd, "yarn.lock"))) return "yarn install";
+  if (existsSync(join3(cwd, "package-lock.json"))) return "npm install";
+  return "npm install";
+}
+function shellEscape(value) {
+  if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/goal/tools/source.ts
+async function finalizeCheckedSourceUpdate(params) {
+  if (params.goal.executionPolicy.sourceUpdates !== "auto_commit_push_default_branch") {
+    return blocked("source update policy is propose-only");
+  }
+  if (!params.checksPassed) return blocked("required checks have not passed");
+  if (params.hostedClient) {
+    return {
+      status: "skipped",
+      branch: null,
+      commitMessage: null,
+      summary: "Source finalization delegated to OpenPond control plane"
+    };
+  }
+  const status = await runGoalShellCommand({
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    command: "git status --porcelain -uall",
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  if (!status.stdoutTail.trim()) {
+    return {
+      status: "skipped",
+      branch: null,
+      commitMessage: null,
+      summary: "No source changes to commit"
+    };
+  }
+  const unsafePath = unsafeSourceFinalizationPathFromStatus(status.stdoutTail);
+  if (unsafePath) {
+    return blocked(`source update includes disallowed path: ${unsafePath}`);
+  }
+  const branch = params.defaultBranch?.trim() || await resolveDefaultBranch({
+    ...params
+  });
+  if (!branch) return blocked("could not resolve project default branch");
+  const message = [
+    `OpenPond Goal: ${params.goal.objective.slice(0, 72)}`,
+    "",
+    `Goal: ${params.goal.id}`,
+    `Iteration: ${params.iterationId}`
+  ].join("\n");
+  const add = await runGoalShellCommand({
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    command: "git add -A",
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  if (add.code !== 0) return blocked("git add failed");
+  const commit = await runGoalShellCommand({
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    command: `git -c user.name='OpenPond Goal' -c user.email=goals@openpond.ai commit -m ${shellEscape2(message)}`,
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  if (commit.code !== 0) return blocked("git commit failed");
+  const push = await runGoalShellCommand({
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    command: `git push origin HEAD:${shellEscape2(branch)}`,
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  if (push.code !== 0) return blocked("git push failed");
+  const result = {
+    status: "committed",
+    branch,
+    commitMessage: message,
+    summary: `Committed and pushed checked source update to ${branch}`
+  };
+  await recordGoalEvent(
+    createGoalEvent({
+      goalId: params.goal.id,
+      iterationId: params.iterationId,
+      kind: "source.updated",
+      summary: result.summary,
+      payload: {
+        branch,
+        policy: params.goal.executionPolicy.sourceUpdates
+      }
+    }),
+    { localState: params.localState, hostedClient: params.hostedClient }
+  );
+  return result;
+  function blocked(summary) {
+    return {
+      status: "blocked",
+      branch: null,
+      commitMessage: null,
+      summary
+    };
+  }
+}
+function unsafeSourceFinalizationPathFromStatus(statusOutput) {
+  if (statusOutput.includes("[truncated ")) return "git status output was truncated";
+  for (const line of statusOutput.split(/\r?\n/)) {
+    const paths = porcelainStatusPaths(line);
+    const unsafe = paths.find(isUnsafeSourceFinalizationPath);
+    if (unsafe) return unsafe;
+  }
+  return null;
+}
+function porcelainStatusPaths(line) {
+  if (line.length < 4) return [];
+  const raw = line.slice(3).trim();
+  if (!raw) return [];
+  return raw.split(" -> ").map((path) => path.replace(/^"|"$/g, "").trim()).filter(Boolean);
+}
+function isUnsafeSourceFinalizationPath(path) {
+  return path === ".env" || path.startsWith(".env.") || path.includes("/.env") || path === "node_modules" || path.startsWith("node_modules/") || path.includes("/node_modules/") || path === ".git" || path.startsWith(".git/") || path.includes("/.git/");
+}
+async function resolveDefaultBranch(params) {
+  const remoteHead = await runGoalShellCommand({
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    command: "git symbolic-ref --short refs/remotes/origin/HEAD",
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  const branch = remoteHead.stdoutTail.trim().replace(/^origin\//, "");
+  if (remoteHead.code === 0 && branch) return branch;
+  const current = await runGoalShellCommand({
+    goalId: params.goal.id,
+    iterationId: params.iterationId,
+    command: "git branch --show-current",
+    cwd: params.cwd,
+    workspace: params.workspace,
+    storageRoot: params.storageRoot,
+    localState: params.localState,
+    hostedClient: params.hostedClient
+  });
+  const currentBranch = current.stdoutTail.trim();
+  return current.code === 0 && currentBranch ? currentBranch : null;
+}
+function shellEscape2(value) {
+  if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/goal/tools/dispatch.ts
+async function runGoalLlmToolCall(context, toolCall) {
+  const normalizedName = normalizeGoalToolName(toolCall.name, toolCall.arguments);
+  try {
+    return await runKnownTool(context, toolCall, normalizedName);
+  } catch (error) {
+    const summary = error instanceof Error ? error.message : `Tool failed: ${normalizedName}`;
+    await recordGoalEvent(
+      createGoalEvent({
+        goalId: context.goal.id,
+        iterationId: context.iterationId,
+        kind: "goal.blocked",
+        summary,
+        payload: {
+          toolCallId: toolCall.id,
+          toolName: normalizedName
+        }
+      }),
+      context
+    );
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: "blocked",
+      summary
+    };
+  }
+}
+async function runKnownTool(context, toolCall, normalizedName) {
+  const args = toolCall.arguments;
+  if (normalizedName === "files.read") {
+    const path = requireString(args, "path");
+    const result = await readGoalPath({ workspace: context.workspace, path });
+    if (result.type === "directory") {
+      return ok(toolCall, normalizedName, `Path is a directory; listed entries: ${path}`, {
+        path,
+        type: "directory",
+        entries: result.entries,
+        next: "Use files.read with one of the listed file paths, or files.list for another directory."
+      });
+    }
+    const content = result.content;
+    return ok(toolCall, normalizedName, `Read file: ${path}`, {
+      path,
+      type: "file",
+      contentTail: truncateForEvent(content)
+    });
+  }
+  if (normalizedName === "files.write") {
+    const path = requireString(args, "path");
+    const content = requireRawString(args, "content");
+    const policyBlock = hostedFileWritePolicyBlock(context, path);
+    if (policyBlock) {
+      await recordGoalEvent(
+        createGoalEvent({
+          goalId: context.goal.id,
+          iterationId: context.iterationId,
+          kind: "command.completed",
+          summary: policyBlock.summary,
+          payload: {
+            path: policyBlock.path,
+            reason: policyBlock.reason,
+            skipped: true,
+            next: policyBlock.next
+          }
+        }),
+        context
+      );
+      return ok(toolCall, normalizedName, policyBlock.summary, {
+        path: policyBlock.path,
+        reason: policyBlock.reason,
+        skipped: true,
+        next: policyBlock.next
+      });
+    }
+    const result = await writeGoalFile({ workspace: context.workspace, path, content });
+    await recordGoalEvent(
+      createGoalEvent({
+        goalId: context.goal.id,
+        iterationId: context.iterationId,
+        kind: "source.updated",
+        summary: `${result.created ? "Created" : "Updated"} file: ${path}`,
+        payload: {
+          path,
+          created: result.created,
+          bytes: Buffer3.byteLength(content, "utf-8")
+        }
+      }),
+      context
+    );
+    return ok(toolCall, normalizedName, `${result.created ? "Created" : "Updated"} file: ${path}`, result);
+  }
+  if (normalizedName === "files.list") {
+    const path = optionalString2(args, "path") || ".";
+    const entries = await listGoalFiles({ workspace: context.workspace, path });
+    return ok(toolCall, normalizedName, `Listed files: ${path}`, {
+      path,
+      entries
+    });
+  }
+  if (normalizedName === "shell.run") {
+    const command = requireString(args, "command");
+    const policyBlock = hostedShellCommandPolicyBlock(context, command);
+    if (policyBlock) {
+      await recordGoalEvent(
+        createGoalEvent({
+          goalId: context.goal.id,
+          iterationId: context.iterationId,
+          kind: "command.completed",
+          summary: policyBlock.summary,
+          payload: {
+            command: policyBlock.command,
+            reason: policyBlock.reason,
+            skipped: true,
+            next: policyBlock.next
+          }
+        }),
+        context
+      );
+      return {
+        toolCallId: toolCall.id,
+        name: normalizedName,
+        status: "ok",
+        summary: policyBlock.summary,
+        output: {
+          reason: policyBlock.reason,
+          skipped: true,
+          next: policyBlock.next
+        }
+      };
+    }
+    const cwd = resolveToolCwd(context.workspace, optionalString2(args, "cwd"));
+    const result = await runGoalShellCommand({
+      goalId: context.goal.id,
+      iterationId: context.iterationId,
+      command,
+      cwd,
+      timeoutSeconds: optionalNumber(args, "timeoutSeconds") ?? void 0,
+      workspace: context.workspace,
+      storageRoot: context.storageRoot,
+      localState: context.localState,
+      hostedClient: context.hostedClient
+    });
+    const passed = result.code === 0 && !result.timedOut;
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: passed ? "ok" : "blocked",
+      summary: passed ? `Command completed: ${command}` : `Command failed: ${command}`,
+      output: {
+        code: result.code,
+        timedOut: result.timedOut,
+        stdoutTail: result.stdoutTail,
+        stderrTail: result.stderrTail
+      }
+    };
+  }
+  if (normalizedName === "questions.ask") {
+    const question = await askGoalQuestion({
+      goalId: context.goal.id,
+      iterationId: context.iterationId,
+      title: requireString(args, "title"),
+      reason: requireString(args, "reason"),
+      required: optionalBoolean(args, "required") ?? true,
+      freeformAllowed: optionalBoolean(args, "freeformAllowed") ?? true,
+      options: normalizeQuestionOptions(args.options),
+      localState: context.localState,
+      hostedClient: context.hostedClient
+    });
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: question.required ? "needs_user_input" : "ok",
+      summary: `Question created: ${question.title}`,
+      output: { questionId: question.id, required: question.required }
+    };
+  }
+  if (normalizedName === "approvals.request") {
+    const kind = normalizeApprovalKind(requireString(args, "kind"));
+    const request = createGoalApprovalRequest({
+      goal: context.goal,
+      kind,
+      title: requireString(args, "title"),
+      reason: requireString(args, "reason"),
+      payload: optionalRecord(args, "payload")
+    });
+    if (context.hostedClient) {
+      await context.hostedClient.requestApproval(request);
+    } else {
+      await recordGoalEvent(
+        createGoalEvent({
+          goalId: context.goal.id,
+          iterationId: context.iterationId,
+          kind: "approval.requested",
+          summary: request.title,
+          payload: {
+            ...request.payload,
+            kind: request.kind,
+            reason: request.reason
+          }
+        }),
+        context
+      );
+      if (context.localState) {
+        const current = await context.localState.get(context.goal.id);
+        await context.localState.update({
+          ...current ?? context.goal,
+          status: "awaiting_approval",
+          approvals: [
+            ...(current ?? context.goal).approvals ?? [],
+            {
+              ...request,
+              id: `approval_${randomUUID7()}`,
+              status: "pending",
+              decidedAt: null,
+              decisionNote: null
+            }
+          ],
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: "needs_approval",
+      summary: `Approval requested: ${request.title}`,
+      output: {
+        kind: request.kind
+      }
+    };
+  }
+  if (normalizedName === "checks.run") {
+    const checks = await runGoalVerificationChecks({
+      goal: context.goal,
+      iterationId: context.iterationId,
+      cwd: context.workspace,
+      workspace: context.workspace,
+      storageRoot: context.storageRoot,
+      localState: context.localState,
+      hostedClient: context.hostedClient
+    });
+    const failed = checks.find((check) => check.status !== "passed");
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: failed ? "blocked" : "ok",
+      summary: failed ? "Goal checks failed" : "Goal checks passed",
+      output: { checks: compactChecks(checks) },
+      checksPassed: !failed
+    };
+  }
+  if (normalizedName === "artifacts.create") {
+    const artifact = createGoalArtifact({
+      goalId: context.goal.id,
+      iterationId: context.iterationId,
+      kind: normalizeArtifactKind(optionalString2(args, "kind")),
+      name: requireString(args, "name"),
+      mimeType: optionalString2(args, "mimeType") || "text/plain",
+      content: requireRawString(args, "content")
+    });
+    const ref = await recordGoalArtifact({
+      artifact,
+      workspace: context.workspace,
+      storageRoot: context.storageRoot,
+      localState: context.localState,
+      hostedClient: context.hostedClient
+    });
+    return ok(toolCall, normalizedName, `Artifact created: ${artifact.name}`, {
+      artifactRef: ref.ref,
+      artifactId: ref.id,
+      bytes: ref.bytes
+    });
+  }
+  if (normalizedName === "source.finalize") {
+    const result = await finalizeCheckedSourceUpdate({
+      goal: context.goal,
+      iterationId: context.iterationId,
+      cwd: context.workspace,
+      checksPassed: optionalBoolean(args, "checksPassed") ?? false,
+      defaultBranch: optionalString2(args, "defaultBranch") || null,
+      workspace: context.workspace,
+      storageRoot: context.storageRoot,
+      localState: context.localState,
+      hostedClient: context.hostedClient
+    });
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: result.status === "blocked" ? "blocked" : "ok",
+      summary: result.summary,
+      output: result
+    };
+  }
+  if (normalizedName.startsWith("openpond_agent.")) {
+    return runAgentTool(context, toolCall, normalizedName);
+  }
+  throw new Error(`Unsupported goal tool: ${toolCall.name}`);
+}
+function hostedFileWritePolicyBlock(context, filePath) {
+  if (!context.hostedClient) return null;
+  const path = normalizedWorkspaceRelativePath(context.workspace, filePath);
+  if (!path) return null;
+  if (isHostedProtectedWritePath(path)) {
+    return {
+      path,
+      reason: "hosted_protected_source_path",
+      summary: `Skipped write to protected hosted path: ${path}`,
+      next: "Use normal source files for edits. Do not write generated metadata, dependency directories, git internals, or secret/env files."
+    };
+  }
+  if (context.goal.profile === "openpond_agent" && path === "openpond.yaml") {
+    return {
+      path,
+      reason: "hosted_openpond_agent_manifest_write_disallowed",
+      summary: "Skipped write to generated OpenPond agent manifest: openpond.yaml",
+      next: "For hosted OpenPond-agent goals, edit agent/** source files and run openpond_agent_* tools. Do not change openpond.yaml directly."
+    };
+  }
+  return null;
+}
+function normalizedWorkspaceRelativePath(workspace, filePath) {
+  const resolved = resolve3(workspace, filePath);
+  const rel = relative2(workspace, resolved);
+  if (!rel || rel.startsWith("..") || isAbsolute2(rel)) return null;
+  return rel.replace(/\\/g, "/");
+}
+function isHostedProtectedWritePath(path) {
+  return path === ".env" || path.startsWith(".env.") || path.includes("/.env") || path === ".git" || path.startsWith(".git/") || path === ".openpond" || path.startsWith(".openpond/") || path === "node_modules" || path.startsWith("node_modules/");
+}
+function hostedShellCommandPolicyBlock(context, command) {
+  if (!context.hostedClient || context.goal.profile !== "openpond_agent") {
+    return null;
+  }
+  if (!/\bopenpond-agent\b/.test(command)) return null;
+  return {
+    command,
+    reason: "hosted_openpond_agent_shell_disallowed",
+    summary: "Skipped direct OpenPond agent shell command; use openpond_agent_* tools",
+    next: "Call openpond_agent_inspect, openpond_agent_build, openpond_agent_validate, openpond_agent_eval, openpond_agent_traces, openpond_agent_run, or openpond_agent_default_checks."
+  };
+}
+async function runAgentTool(context, toolCall, normalizedName) {
+  if (normalizedName === "openpond_agent.default_checks") {
+    const results = await runDefaultAgentSdkChecks({
+      goalId: context.goal.id,
+      iterationId: context.iterationId,
+      cwd: context.workspace,
+      workspace: context.workspace,
+      storageRoot: context.storageRoot,
+      localState: context.localState,
+      hostedClient: context.hostedClient
+    });
+    const failed = results.find((result2) => result2.code !== 0 || result2.timedOut);
+    return {
+      toolCallId: toolCall.id,
+      name: normalizedName,
+      status: failed ? "blocked" : "ok",
+      summary: failed ? "OpenPond agent SDK checks failed" : "OpenPond agent SDK checks passed",
+      output: {
+        commands: results.map((result2) => ({
+          command: result2.command,
+          code: result2.code,
+          timedOut: result2.timedOut
+        }))
+      },
+      checksPassed: !failed
+    };
+  }
+  const sdkCommand = normalizedName.replace("openpond_agent.", "");
+  if (!isAgentSdkCommand(sdkCommand)) {
+    throw new Error(`Unsupported OpenPond agent SDK command: ${sdkCommand}`);
+  }
+  const result = await runAgentSdkCommand({
+    goalId: context.goal.id,
+    iterationId: context.iterationId,
+    cwd: context.workspace,
+    sdkCommand,
+    args: optionalStringArray(toolCall.arguments, "args"),
+    json: optionalBoolean(toolCall.arguments, "json") ?? shouldDefaultJson(sdkCommand),
+    workspace: context.workspace,
+    storageRoot: context.storageRoot,
+    localState: context.localState,
+    hostedClient: context.hostedClient
+  });
+  const passed = result.code === 0 && !result.timedOut;
+  return {
+    toolCallId: toolCall.id,
+    name: normalizedName,
+    status: passed ? "ok" : "blocked",
+    summary: passed ? `openpond-agent ${sdkCommand} completed` : `openpond-agent ${sdkCommand} failed`,
+    output: {
+      code: result.code,
+      timedOut: result.timedOut,
+      stdoutTail: result.stdoutTail,
+      stderrTail: result.stderrTail
+    }
+  };
+}
+function ok(toolCall, name, summary, output) {
+  return {
+    toolCallId: toolCall.id,
+    name,
+    status: "ok",
+    summary,
+    output
+  };
+}
+function requireString(args, key) {
+  const value = optionalString2(args, key);
+  if (!value) throw new Error(`Tool argument ${key} must be a non-empty string`);
+  return value;
+}
+function requireRawString(args, key) {
+  const value = args[key];
+  if (typeof value !== "string") {
+    throw new Error(`Tool argument ${key} must be a string`);
+  }
+  return value;
+}
+function optionalString2(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function optionalNumber(args, key) {
+  const value = args[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function optionalBoolean(args, key) {
+  const value = args[key];
+  return typeof value === "boolean" ? value : null;
+}
+function optionalStringArray(args, key) {
+  const value = args[key];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function optionalRecord(args, key) {
+  const value = args[key];
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function normalizeQuestionOptions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const record = item;
+    const id = optionalString2(record, "id");
+    const label = optionalString2(record, "label");
+    if (!id || !label) return [];
+    const description = optionalString2(record, "description");
+    return [{ id, label, ...description ? { description } : {} }];
+  });
+}
+function normalizeApprovalKind(value) {
+  const allowed = /* @__PURE__ */ new Set([
+    "create_plan",
+    "deploy_publish",
+    "integration_write",
+    "secret_or_env_change",
+    "budget_escalation",
+    "external_effect"
+  ]);
+  if (!allowed.has(value)) {
+    throw new Error(`Unsupported approval kind: ${value}`);
+  }
+  return value;
+}
+function normalizeArtifactKind(value) {
+  const allowed = /* @__PURE__ */ new Set([
+    "command_log",
+    "check_log",
+    "patch",
+    "trace",
+    "manifest",
+    "result"
+  ]);
+  return value && allowed.has(value) ? value : "result";
+}
+function compactChecks(checks) {
+  return checks.map((check) => ({
+    id: check.id,
+    name: check.name,
+    status: check.status,
+    code: check.code,
+    timedOut: check.timedOut
+  }));
+}
+function resolveToolCwd(workspace, cwd) {
+  if (!cwd || cwd === ".") return workspace;
+  const resolved = resolve3(workspace, cwd);
+  const rel = relative2(workspace, resolved);
+  if (rel.startsWith("..") || isAbsolute2(rel)) {
+    throw new Error(`Tool cwd is outside workspace: ${cwd}`);
+  }
+  return resolved;
+}
+function isAgentSdkCommand(value) {
+  return ["inspect", "build", "validate", "eval", "traces", "run"].includes(value);
+}
+function shouldDefaultJson(command) {
+  return command === "inspect" || command === "eval" || command === "traces" || command === "run";
+}
+
+// src/goal/runner.ts
+var MAX_GOAL_TOOL_ROUNDS = 24;
+async function runGoalIteration(params) {
+  assertGoalCanStartIteration(params.config.goal);
+  if (goalIterationBudgetRemaining(params.config.goal) <= 0) {
+    const limited = createGoalEvent({
+      goalId: params.config.goal.id,
+      kind: "goal.blocked",
+      summary: "Goal iteration budget exhausted",
+      payload: {
+        reason: "iteration_budget_exhausted",
+        maxIterations: params.config.goal.budget.maxIterations
+      }
+    });
+    await recordGoalEvent(limited, params);
+    await updateGoalStatus(params, "budget_limited");
+    return finishGoalRunResult(
+      params,
+      createGoalRunResult({
+        goal: params.config.goal,
+        status: "budget_limited",
+        summary: limited.summary,
+        events: [limited]
+      })
+    );
+  }
+  const iterationId = params.config.iterationId || `iteration_${randomUUID8()}`;
+  const started = createGoalEvent({
+    goalId: params.config.goal.id,
+    iterationId,
+    kind: "iteration.started",
+    summary: "Goal iteration started",
+    payload: {
+      mode: params.config.mode,
+      profile: params.config.goal.profile,
+      promptPack: params.config.goal.promptPack
+    }
+  });
+  await updateGoalStatus(params, "running");
+  await recordGoalEvent(started, params);
+  const events = [started];
+  const profile = getGoalProfileDescriptor(params.config.goal);
+  const workspace = params.config.workspace ?? process.cwd();
+  const storageRoot = params.config.storageRoot ?? workspace;
+  if (shouldRunLocalCreatePipeline(params.config.goal, params.config.mode)) {
+    const result = await runLocalCreatePipeline({
+      goal: params.config.goal,
+      iterationId,
+      workspace,
+      localState: params.localState,
+      startedEvents: events
+    });
+    return finishGoalRunResult(params, result);
+  }
+  let llmResponse = null;
+  let toolResults = [];
+  const toolSchemas = buildGoalLlmToolSchemas(profile.toolNames);
+  try {
+    const planner = await runGoalPlannerLoop({
+      ...params,
+      iterationId,
+      workspace,
+      storageRoot,
+      toolSchemas,
+      profileMetadata: { profile: profile.id, tools: profile.toolNames }
+    });
+    llmResponse = planner.response;
+    toolResults = planner.toolResults;
+  } catch (error) {
+    const blocked2 = createGoalEvent({
+      goalId: params.config.goal.id,
+      iterationId,
+      kind: "goal.blocked",
+      summary: params.config.mode === "hosted" ? "Hosted Goal LLM route is not available" : "Local Goal LLM route is not available",
+      payload: {
+        error: error instanceof Error ? error.message : "LLM route failed"
+      }
+    });
+    await recordGoalEvent(blocked2, params);
+    await updateGoalStatus(params, "blocked");
+    return finishGoalRunResult(
+      params,
+      createGoalRunResult({
+        goal: params.config.goal,
+        status: "blocked",
+        summary: blocked2.summary,
+        events: [...events, blocked2]
+      })
+    );
+  }
+  if (llmResponse) {
+    const pausedForQuestion = toolResults.find(
+      (result) => result.status === "needs_user_input"
+    );
+    if (pausedForQuestion) {
+      const paused = createGoalEvent({
+        goalId: params.config.goal.id,
+        iterationId,
+        kind: "iteration.completed",
+        summary: pausedForQuestion.summary,
+        payload: {
+          status: "awaiting_user_input",
+          toolResults: compactToolResults(toolResults)
+        }
+      });
+      await recordGoalEvent(paused, params);
+      await updateGoalStatus(params, "awaiting_user_input");
+      return finishGoalRunResult(
+        params,
+        createGoalRunResult({
+          goal: params.config.goal,
+          status: "awaiting_user_input",
+          summary: paused.summary,
+          events: [...events, paused]
+        })
+      );
+    }
+    const pausedForApproval = toolResults.find(
+      (result) => result.status === "needs_approval"
+    );
+    if (pausedForApproval) {
+      const paused = createGoalEvent({
+        goalId: params.config.goal.id,
+        iterationId,
+        kind: "iteration.completed",
+        summary: pausedForApproval.summary,
+        payload: {
+          status: "awaiting_approval",
+          toolResults: compactToolResults(toolResults)
+        }
+      });
+      await recordGoalEvent(paused, params);
+      await updateGoalStatus(params, "awaiting_approval");
+      return finishGoalRunResult(
+        params,
+        createGoalRunResult({
+          goal: params.config.goal,
+          status: "awaiting_approval",
+          summary: paused.summary,
+          events: [...events, paused]
+        })
+      );
+    }
+    const blockedTool = latestUnresolvedBlockedToolResult(toolResults);
+    if (blockedTool) {
+      const blocked2 = createGoalEvent({
+        goalId: params.config.goal.id,
+        iterationId,
+        kind: "goal.blocked",
+        summary: blockedTool.summary,
+        payload: {
+          toolResults: compactToolResults(toolResults)
+        }
+      });
+      await recordGoalEvent(blocked2, params);
+      await updateGoalStatus(params, "blocked");
+      return finishGoalRunResult(
+        params,
+        createGoalRunResult({
+          goal: params.config.goal,
+          status: "blocked",
+          summary: blocked2.summary,
+          events: [...events, blocked2]
+        })
+      );
+    }
+    if (llmResponse.status === "needs_user_input" && (llmResponse.toolCalls?.length ?? 0) === 0) {
+      const blocked2 = createGoalEvent({
+        goalId: params.config.goal.id,
+        iterationId,
+        kind: "goal.blocked",
+        summary: "Goal needs user input but no structured question was provided",
+        payload: {
+          responseSummary: llmResponse.summary ?? null
+        }
+      });
+      await recordGoalEvent(blocked2, params);
+      await updateGoalStatus(params, "blocked");
+      return finishGoalRunResult(
+        params,
+        createGoalRunResult({
+          goal: params.config.goal,
+          status: "blocked",
+          summary: blocked2.summary,
+          events: [...events, blocked2]
+        })
+      );
+    }
+    if (llmResponse.status === "blocked" && (llmResponse.toolCalls?.length ?? 0) === 0) {
+      const blocked2 = createGoalEvent({
+        goalId: params.config.goal.id,
+        iterationId,
+        kind: "goal.blocked",
+        summary: llmResponse.summary || "Goal LLM reported a blocker",
+        payload: {
+          message: llmResponse.message?.content ?? null
+        }
+      });
+      await recordGoalEvent(blocked2, params);
+      await updateGoalStatus(params, "blocked");
+      return finishGoalRunResult(
+        params,
+        createGoalRunResult({
+          goal: params.config.goal,
+          status: "blocked",
+          summary: blocked2.summary,
+          events: [...events, blocked2]
+        })
+      );
+    }
+  }
+  if (params.config.goal.verification.commands.length > 0) {
+    const checks = await runGoalVerificationChecks({
+      goal: params.config.goal,
+      iterationId,
+      cwd: workspace,
+      workspace,
+      storageRoot,
+      localState: params.localState,
+      hostedClient: params.hostedClient
+    });
+    const failed = checks.find((check) => check.status !== "passed");
+    const completed = createGoalEvent({
+      goalId: params.config.goal.id,
+      iterationId,
+      kind: "iteration.completed",
+      summary: failed ? "Goal iteration completed with failed checks" : "Goal verification checks passed",
+      payload: {
+        checks: checks.map((check) => ({
+          id: check.id,
+          name: check.name,
+          status: check.status,
+          code: check.code
+        }))
+      }
+    });
+    await recordGoalEvent(completed, params);
+    await updateGoalStatus(params, failed ? "blocked" : "completed");
+    return finishGoalRunResult(
+      params,
+      createGoalRunResult({
+        goal: params.config.goal,
+        status: failed ? "blocked" : "completed",
+        summary: completed.summary,
+        events: [...events, completed]
+      })
+    );
+  }
+  if (toolResults.length > 0) {
+    const completed = createGoalEvent({
+      goalId: params.config.goal.id,
+      iterationId,
+      kind: "iteration.completed",
+      summary: llmResponse?.summary || "Goal tool calls completed",
+      payload: {
+        toolResults: compactToolResults(toolResults),
+        verificationConfigured: false
+      }
+    });
+    await recordGoalEvent(completed, params);
+    await updateGoalStatus(params, "completed");
+    return finishGoalRunResult(
+      params,
+      createGoalRunResult({
+        goal: params.config.goal,
+        status: "completed",
+        summary: completed.summary,
+        events: [...events, completed]
+      })
+    );
+  }
+  const blocked = createGoalEvent({
+    goalId: params.config.goal.id,
+    iterationId,
+    kind: "goal.blocked",
+    summary: "Goal produced no tool calls or verification commands",
+    payload: {
+      reason: "no_executable_goal_plan",
+      profile: profile.id,
+      next: "configure a hosted Goal LLM route, local provider, tool calls, or verification commands"
+    }
+  });
+  await recordGoalEvent(blocked, params);
+  await updateGoalStatus(params, "blocked");
+  return finishGoalRunResult(
+    params,
+    createGoalRunResult({
+      goal: params.config.goal,
+      status: "blocked",
+      summary: blocked.summary,
+      events: [started, blocked]
+    })
+  );
+}
+async function runGoalPlannerLoop(params) {
+  if (params.config.mode === "hosted" && !params.hostedClient) {
+    return { response: null, toolResults: [] };
+  }
+  const messages = buildGoalLlmMessages(params.config.goal);
+  const toolResults = [];
+  let response = null;
+  for (let round = 0; round < MAX_GOAL_TOOL_ROUNDS; round += 1) {
+    response = params.config.mode === "hosted" ? await callHostedGoalLlm({
+      goal: params.config.goal,
+      iterationId: params.iterationId,
+      hostedClient: params.hostedClient,
+      localState: params.localState,
+      messages,
+      tools: params.toolSchemas,
+      metadata: { ...params.profileMetadata, round }
+    }) : await callLocalGoalLlm({
+      goal: params.config.goal,
+      iterationId: params.iterationId,
+      localState: params.localState,
+      messages,
+      tools: params.toolSchemas,
+      metadata: { ...params.profileMetadata, round }
+    });
+    if (!response) return { response: null, toolResults };
+    const toolCalls = response.toolCalls ?? [];
+    if (toolCalls.length === 0) return { response, toolResults };
+    const roundResults = await runLlmToolCalls({
+      config: params.config,
+      localState: params.localState,
+      hostedClient: params.hostedClient,
+      iterationId: params.iterationId,
+      workspace: params.workspace,
+      storageRoot: params.storageRoot,
+      response
+    });
+    toolResults.push(...roundResults);
+    messages.push(assistantToolCallMessage(response));
+    messages.push(...roundResults.map(toolResultMessage));
+    if (roundResults.some(
+      (result) => result.status === "needs_user_input" || result.status === "needs_approval"
+    )) {
+      return { response, toolResults };
+    }
+  }
+  return {
+    response: {
+      status: "blocked",
+      summary: "Goal planner exceeded tool round budget",
+      message: {
+        role: "assistant",
+        content: "Goal planner exceeded tool round budget."
+      }
+    },
+    toolResults
+  };
+}
+function latestUnresolvedBlockedToolResult(results) {
+  const latest = results.at(-1);
+  return latest?.status === "blocked" ? latest : null;
+}
+async function runLlmToolCalls(params) {
+  const toolCalls = params.response.toolCalls ?? [];
+  const results = [];
+  for (const toolCall of toolCalls) {
+    const result = await runGoalLlmToolCall(
+      {
+        goal: params.config.goal,
+        iterationId: params.iterationId,
+        workspace: params.workspace,
+        storageRoot: params.storageRoot,
+        localState: params.localState,
+        hostedClient: params.hostedClient
+      },
+      toolCall
+    );
+    results.push(result);
+    if (result.status !== "ok") break;
+  }
+  return results;
+}
+function assistantToolCallMessage(response) {
+  return {
+    role: "assistant",
+    content: response.message?.content ?? response.summary ?? "",
+    tool_calls: (response.toolCalls ?? []).map((toolCall) => ({
+      id: toolCall.id,
+      type: "function",
+      function: {
+        name: toolCall.name,
+        arguments: JSON.stringify(toolCall.arguments)
+      }
+    }))
+  };
+}
+function toolResultMessage(result) {
+  return {
+    role: "tool",
+    tool_call_id: result.toolCallId,
+    name: result.name,
+    content: JSON.stringify({
+      status: result.status,
+      summary: result.summary,
+      output: result.output ?? {},
+      checksPassed: result.checksPassed ?? null
+    })
+  };
+}
+function compactToolResults(results) {
+  return results.map((result) => ({
+    toolCallId: result.toolCallId,
+    name: result.name,
+    status: result.status,
+    summary: result.summary,
+    checksPassed: result.checksPassed
+  }));
+}
+async function finishGoalRunResult(params, result) {
+  if (!params.localState?.writeResult) return result;
+  const current = await params.localState.get(params.config.goal.id);
+  const persisted = current ? { ...result, events: current.events } : result;
+  await params.localState.writeResult(params.config.goal.id, persisted);
+  return persisted;
+}
+async function updateGoalStatus(params, status) {
+  await params.hostedClient?.updateStatus(params.config.goal.id, status);
+  if (params.localState) {
+    const current = await params.localState.get(params.config.goal.id);
+    await params.localState.update({
+      ...current ?? params.config.goal,
+      status,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+}
+
+// src/goal/state/local.ts
+import { mkdir as mkdir3, readFile as readFile2, readdir as readdir2, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// src/goal/schemas/event.ts
+var goalEventRecordSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  goalId: external_exports.string().min(1),
+  iterationId: external_exports.string().min(1).nullable(),
+  kind: external_exports.enum([
+    "goal.created",
+    "goal.status_changed",
+    "iteration.started",
+    "iteration.completed",
+    "question.created",
+    "question.answered",
+    "approval.requested",
+    "approval.decided",
+    "create_pipeline.created",
+    "create_pipeline.status_changed",
+    "create_plan.created",
+    "workflow_capture.created",
+    "command.started",
+    "command.completed",
+    "check.completed",
+    "source.updated",
+    "artifact.created",
+    "model.usage",
+    "goal.blocked",
+    "goal.failed"
+  ]),
+  summary: external_exports.string().min(1),
+  payload: external_exports.record(external_exports.string(), external_exports.unknown()),
+  createdAt: external_exports.string().min(1)
+});
+function assertGoalEventRecord(event) {
+  return goalEventRecordSchema.parse(event);
+}
+
+// src/goal/schemas/question.ts
+var goalQuestionOptionRecordSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  label: external_exports.string().min(1),
+  description: external_exports.string().min(1).optional()
+});
+var goalQuestionRecordSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  goalId: external_exports.string().min(1),
+  title: external_exports.string().min(1),
+  reason: external_exports.string().min(1),
+  required: external_exports.boolean(),
+  options: external_exports.array(goalQuestionOptionRecordSchema),
+  freeformAllowed: external_exports.boolean(),
+  answeredAt: external_exports.string().min(1).nullable()
+});
+var goalAnswerRecordSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  goalId: external_exports.string().min(1),
+  questionId: external_exports.string().min(1),
+  optionId: external_exports.string().min(1).nullable(),
+  freeformText: external_exports.string().min(1).nullable(),
+  value: external_exports.record(external_exports.string(), external_exports.unknown()),
+  createdAt: external_exports.string().min(1)
+});
+var goalQuestionSnapshotSchema = external_exports.object({
+  questions: external_exports.array(goalQuestionRecordSchema),
+  answers: external_exports.array(goalAnswerRecordSchema)
+});
+function assertGoalQuestionSnapshot(snapshot) {
+  return goalQuestionSnapshotSchema.parse(snapshot);
+}
+
+// src/goal/schemas/result.ts
+var goalRunResultRecordSchema = external_exports.object({
+  goalId: external_exports.string().min(1),
+  status: external_exports.enum([
+    "queued",
+    "running",
+    "awaiting_user_input",
+    "awaiting_approval",
+    "paused",
+    "blocked",
+    "completed",
+    "failed",
+    "cancelled",
+    "budget_limited"
+  ]),
+  summary: external_exports.string().min(1),
+  events: external_exports.array(goalEventRecordSchema)
+});
+function assertGoalRunResultRecord(result) {
+  return goalRunResultRecordSchema.parse(result);
+}
+
+// src/goal/state/local.ts
+var GOAL_STATE_FILE = "state.json";
+var GOAL_EVENTS_FILE = "events.jsonl";
+var GOAL_QUESTIONS_FILE = "questions.json";
+var GOAL_RESULT_FILE = "result.json";
+var CREATE_PIPELINE_FILE = "create-pipeline.json";
+var CREATE_PLAN_FILE = "create-plan.json";
+var WORKFLOW_CAPTURE_FILE = "workflow-capture.json";
+var LocalGoalStateAdapter = class {
+  constructor(storageRoot) {
+    this.storageRoot = storageRoot;
+  }
+  storageRoot;
+  async create(goal) {
+    await this.write(goal);
+    return goal;
+  }
+  async get(goalId) {
+    try {
+      const raw = await readFile2(this.goalStatePath(goalId), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async findGoalByQuestionId(questionId) {
+    const root = this.goalRoot();
+    let entries = [];
+    try {
+      entries = await readdir2(root);
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      const goal = await this.get(entry);
+      if (goal?.questions.some((question) => question.id === questionId)) {
+        return goal;
+      }
+    }
+    return null;
+  }
+  async update(goal) {
+    const next = { ...goal, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.write(next);
+    return next;
+  }
+  async appendEvent(goalId, event) {
+    const goal = await this.requireGoal(goalId);
+    const next = {
+      ...goal,
+      events: [...goal.events, event],
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.write(next);
+    return next;
+  }
+  async addQuestion(goalId, question) {
+    const goal = await this.requireGoal(goalId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const createPipeline = goal.createPipeline ? CreatePipelineSnapshotSchema.parse({
+      ...goal.createPipeline,
+      state: question.required ? "awaiting_questions" : goal.createPipeline.state,
+      questionIds: Array.from(
+        /* @__PURE__ */ new Set([...goal.createPipeline.questionIds ?? [], question.id])
+      ),
+      updatedAt: now
+    }) : void 0;
+    const next = {
+      ...goal,
+      status: question.required ? "awaiting_user_input" : goal.status,
+      questions: [...goal.questions, question],
+      ...createPipeline ? { createPipeline } : {},
+      updatedAt: now
+    };
+    await this.write(next);
+    return next;
+  }
+  async answerQuestion(params) {
+    const goal = await this.requireGoal(params.goalId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const questions = goal.questions.map(
+      (question) => question.id === params.questionId ? { ...question, answeredAt: now } : question
+    );
+    const hasOpenRequiredQuestion = questions.some(
+      (question) => question.required && !question.answeredAt
+    );
+    const createPipeline = goal.createPipeline && goal.createPipeline.state === "awaiting_questions" && !hasOpenRequiredQuestion ? CreatePipelineSnapshotSchema.parse({
+      ...goal.createPipeline,
+      state: goal.createPipeline.plan?.status === "pending_approval" ? "awaiting_plan_approval" : "planning",
+      updatedAt: now
+    }) : goal.createPipeline;
+    const next = {
+      ...goal,
+      status: goal.status === "awaiting_user_input" && !hasOpenRequiredQuestion ? "queued" : goal.status,
+      questions,
+      answers: [...goal.answers, params.answer],
+      ...createPipeline ? { createPipeline } : {},
+      updatedAt: now
+    };
+    await this.write(next);
+    return next;
+  }
+  async writeResult(goalId, result) {
+    await mkdir3(this.goalDir(goalId), { recursive: true });
+    const validated = assertGoalRunResultRecord(result);
+    await writeFile3(
+      this.goalResultPath(goalId),
+      `${JSON.stringify(validated, null, 2)}
+`,
+      "utf-8"
+    );
+  }
+  async requireGoal(goalId) {
+    const goal = await this.get(goalId);
+    if (!goal) throw new Error(`goal not found: ${goalId}`);
+    return goal;
+  }
+  goalRoot() {
+    return join4(this.storageRoot, ".openpond", "goals");
+  }
+  goalDir(goalId) {
+    return join4(this.goalRoot(), goalId);
+  }
+  goalStatePath(goalId) {
+    return join4(this.goalDir(goalId), GOAL_STATE_FILE);
+  }
+  goalEventsPath(goalId) {
+    return join4(this.goalDir(goalId), GOAL_EVENTS_FILE);
+  }
+  goalQuestionsPath(goalId) {
+    return join4(this.goalDir(goalId), GOAL_QUESTIONS_FILE);
+  }
+  goalResultPath(goalId) {
+    return join4(this.goalDir(goalId), GOAL_RESULT_FILE);
+  }
+  createPipelinePath(goalId) {
+    return join4(this.goalDir(goalId), CREATE_PIPELINE_FILE);
+  }
+  createPlanPath(goalId) {
+    return join4(this.goalDir(goalId), CREATE_PLAN_FILE);
+  }
+  workflowCapturePath(goalId) {
+    return join4(this.goalDir(goalId), WORKFLOW_CAPTURE_FILE);
+  }
+  async write(goal) {
+    await mkdir3(this.goalDir(goal.id), { recursive: true });
+    const events = goal.events.map(assertGoalEventRecord);
+    const questionSnapshot = assertGoalQuestionSnapshot({
+      questions: goal.questions,
+      answers: goal.answers
+    });
+    await writeFile3(
+      this.goalStatePath(goal.id),
+      `${JSON.stringify(goal, null, 2)}
+`,
+      "utf-8"
+    );
+    await writeFile3(
+      this.goalEventsPath(goal.id),
+      events.length > 0 ? `${events.map(serializeGoalEventRecord).join("\n")}
+` : "",
+      "utf-8"
+    );
+    await writeFile3(
+      this.goalQuestionsPath(goal.id),
+      `${JSON.stringify(questionSnapshot, null, 2)}
+`,
+      "utf-8"
+    );
+    if (goal.createPipeline) {
+      await writeFile3(
+        this.createPipelinePath(goal.id),
+        `${JSON.stringify(goal.createPipeline, null, 2)}
+`,
+        "utf-8"
+      );
+      if (goal.createPipeline.plan) {
+        await writeFile3(
+          this.createPlanPath(goal.id),
+          `${JSON.stringify(goal.createPipeline.plan, null, 2)}
+`,
+          "utf-8"
+        );
+      }
+      if (goal.createPipeline.workflowCapture) {
+        await writeFile3(
+          this.workflowCapturePath(goal.id),
+          `${JSON.stringify(goal.createPipeline.workflowCapture, null, 2)}
+`,
+          "utf-8"
+        );
+      }
+    }
+  }
+};
+
+// src/goal/state/hosted.ts
+function resolveHostedGoalCredential() {
+  return process.env.OPENPOND_GOAL_API_KEY?.trim() || process.env.OPENPOND_API_KEY?.trim() || null;
+}
+function resolveHostedGoalApiUrl() {
+  return process.env.OPENPOND_GOAL_API_URL?.trim().replace(/\/$/, "") || process.env.OPENPOND_API_URL?.trim().replace(/\/$/, "") || null;
+}
+var HostedGoalClient = class {
+  constructor(apiUrl, apiKey) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+  }
+  apiUrl;
+  apiKey;
+  request(path, init) {
+    const headers = new Headers(init?.headers || {});
+    headers.set("openpond-api-key", this.apiKey);
+    return apiFetch(this.apiUrl, this.apiKey, path, {
+      ...init,
+      headers
+    });
+  }
+  async getRunConfig(goalId) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(goalId)}/run-config`
+    );
+    return readApiJson(response, "goal run-config");
+  }
+  async appendEvent(goalId, event) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(goalId)}/events`,
+      {
+        method: "POST",
+        body: JSON.stringify({ event })
+      }
+    );
+    await readApiJson(response, "goal event");
+  }
+  async answerQuestion(params) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(params.goalId)}/questions/${encodeURIComponent(
+        params.questionId
+      )}/answers`,
+      {
+        method: "POST",
+        body: JSON.stringify({ answer: params.answer })
+      }
+    );
+    await readApiJson(response, "goal answer");
+  }
+  async createQuestion(goalId, question) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(goalId)}/questions`,
+      {
+        method: "POST",
+        body: JSON.stringify({ question })
+      }
+    );
+    await readApiJson(response, "goal question");
+  }
+  async requestApproval(request) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(request.goalId)}/approvals`,
+      {
+        method: "POST",
+        body: JSON.stringify({ approval: request })
+      }
+    );
+    await readApiJson(response, "goal approval request");
+  }
+  async updateStatus(goalId, status) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(goalId)}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ status })
+      }
+    );
+    await readApiJson(response, "goal status update");
+  }
+  async pause(goalId) {
+    await this.postLifecycle(goalId, "pause");
+  }
+  async resume(goalId) {
+    await this.postLifecycle(goalId, "resume");
+  }
+  async cancel(goalId) {
+    await this.postLifecycle(goalId, "cancel");
+  }
+  async approve(goalId, decisionNote) {
+    await this.postLifecycle(goalId, "approve", { decisionNote });
+  }
+  async reject(goalId, decisionNote) {
+    await this.postLifecycle(goalId, "reject", { decisionNote });
+  }
+  async postLifecycle(goalId, action, body) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(goalId)}/${action}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body ?? {})
+      }
+    );
+    await readApiJson(response, `goal ${action}`);
+  }
+  async callLlm(request) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(request.goalId)}/llm`,
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    );
+    return readApiJson(response, "goal llm call");
+  }
+  async uploadArtifact(artifact) {
+    const response = await this.request(
+      `/v1/goals/${encodeURIComponent(artifact.goalId)}/artifacts`,
+      {
+        method: "POST",
+        body: JSON.stringify({ artifact })
+      }
+    );
+    return readApiJson(response, "goal artifact upload");
+  }
+};
+
+// src/goal/cli.ts
+var DEFAULT_HOSTED_GOAL_LAUNCH_PATH = "/run/openpond/goal-run.json";
+function printGoalHelp() {
+  console.log("OpenPond Goal commands");
+  console.log("");
+  console.log("Usage:");
+  console.log('  openpond goal "<objective>" [--cwd <path>] [--goal-storage global|workspace]');
+  console.log("  openpond goal run --goal-id <id> [--cwd <path>] [--goal-storage global|workspace]");
+  console.log('  openpond goal create-agent "<agent idea>" [--cwd <path>] [--goal-storage global|workspace]');
+  console.log('  openpond goal update-agent "<agent change>" [--agent-id <id>] [--cwd <path>] [--goal-storage global|workspace]');
+  console.log("  openpond goal plan <goal-id> [--json|--edit <instructions>] [--cwd <path>] [--goal-storage global|workspace]");
+  console.log(
+    "  openpond goal answer <question-id> --choice <choice-id>|--answer <text> [--goal-id <id>] [--cwd <path>] [--goal-storage global|workspace]"
+  );
+  console.log("  openpond goal approve <goal-id> [--note <text>]");
+  console.log("  openpond goal reject <goal-id> [--note <text>]");
+  console.log("  openpond goal pause <goal-id>");
+  console.log("  openpond goal resume <goal-id>");
+  console.log("  openpond goal cancel <goal-id>");
+  console.log("");
+  console.log("Hosted env:");
+  console.log("  OPENPOND_GOAL_API_KEY");
+  console.log("  OPENPOND_GOAL_API_URL");
+  console.log("  OPENPOND_GOAL_ID");
+  console.log("  OPENPOND_GOAL_OUTPUT=jsonl");
+}
+function optionString(options, key) {
+  const value = options[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function hasFlag(options, key) {
+  const value = options[key];
+  return value === true || value === "true";
+}
+function requireOption(options, key, usage) {
+  const value = optionString(options, key);
+  if (!value) throw new Error(usage);
+  return value;
+}
+function objectiveFromRest(rest, usage) {
+  const objective = rest.join(" ").trim();
+  if (!objective) throw new Error(usage);
+  return objective;
+}
+function arrayOption(options, key) {
+  const value = optionString(options, key);
+  return value ? [value] : [];
+}
+function goalKindFromCommand(command) {
+  if (command === "create-agent") return "create_agent";
+  if (command === "update-agent") return "update_agent";
+  return "general_code_goal";
+}
+async function localGoalPaths(options) {
+  const cwd = optionString(options, "cwd");
+  const workspace = resolveGoalWorkspace(cwd);
+  const storageLocation = await resolveGoalStorageLocation(optionString(options, "goalStorage"));
+  const storageRoot = resolveGoalStorageRoot({ cwd, location: storageLocation });
+  return {
+    workspace,
+    storageRoot,
+    storageLocation,
+    adapter: new LocalGoalStateAdapter(storageRoot)
+  };
+}
+async function readHostedGoalLaunchConfig() {
+  const launchPath = process.env.OPENPOND_GOAL_RUN_CONFIG_PATH?.trim() || DEFAULT_HOSTED_GOAL_LAUNCH_PATH;
+  try {
+    return JSON.parse(await readFile3(launchPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function resolveGoalOutputMode(params) {
+  if (hasFlag(params.options, "jsonl") || optionString(params.options, "output") === "jsonl") {
+    return "jsonl";
+  }
+  const explicit = process.env.OPENPOND_GOAL_OUTPUT?.trim();
+  if (explicit === "jsonl") return "jsonl";
+  return params.launchConfig?.output?.mode === "jsonl" ? "jsonl" : "json";
+}
+function printGoalRunOutput(result, mode) {
+  if (mode !== "jsonl") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  for (const event of result.events) {
+    console.log(JSON.stringify({ type: "goal_event", event }));
+  }
+  console.log(JSON.stringify({ type: "goal_result", result }));
+}
+async function createLocalGoal(params) {
+  const local = await localGoalPaths(params.options);
+  let state = normalizeGoalState(
+    createGoalState({
+      objective: params.objective,
+      kind: params.kind,
+      teamId: optionString(params.options, "teamId") || null,
+      projectId: optionString(params.options, "projectId") || null,
+      agentId: optionString(params.options, "agentId") || null,
+      workItemId: optionString(params.options, "workItemId") || null,
+      conversationId: optionString(params.options, "conversationId") || null,
+      verification: {
+        commands: arrayOption(params.options, "verify"),
+        successCriteria: arrayOption(params.options, "successCriteria")
+      }
+    })
+  );
+  if (shouldCreatePipelineForGoal(params.kind)) {
+    const command = params.createPipeline?.command ?? (params.kind === "update_agent" ? "/edit" : "/create");
+    const surface = params.createPipeline?.surface ?? (params.kind === "update_agent" ? "direct_prompt_edit" : "direct_prompt_create");
+    const { snapshot, approval } = createInitialCreatePipeline({
+      goal: state,
+      command,
+      surface,
+      profile: params.createPipeline?.profile ?? {
+        activeProfile: optionString(params.options, "profile") || null,
+        repoPath: null,
+        sourcePath: local.workspace,
+        localHead: null
+      }
+    });
+    state = {
+      ...state,
+      status: "awaiting_approval",
+      approvals: [approval],
+      createPipeline: snapshot,
+      events: [
+        ...state.events,
+        createGoalEvent({
+          goalId: state.id,
+          kind: "create_pipeline.created",
+          summary: "Create pipeline initialized",
+          payload: {
+            pipelineId: snapshot.id,
+            requestId: snapshot.request.id,
+            state: snapshot.state,
+            sourceAuthority: snapshot.request.adapter.sourceAuthority
+          }
+        }),
+        createGoalEvent({
+          goalId: state.id,
+          kind: "create_plan.created",
+          summary: "Create plan artifact created",
+          payload: {
+            planId: snapshot.plan?.id ?? null,
+            approvalId: approval.id,
+            status: snapshot.plan?.status ?? null
+          }
+        }),
+        createGoalEvent({
+          goalId: state.id,
+          kind: "workflow_capture.created",
+          summary: "Workflow capture artifact created",
+          payload: {
+            workflowCaptureId: snapshot.workflowCapture?.id ?? null
+          }
+        }),
+        createGoalEvent({
+          goalId: state.id,
+          kind: "approval.requested",
+          summary: approval.title,
+          payload: {
+            kind: approval.kind,
+            reason: approval.reason,
+            requestId: snapshot.request.id,
+            planId: snapshot.plan?.id ?? null
+          }
+        })
+      ]
+    };
+  }
+  await local.adapter.create(state);
+  console.log(`Goal created: ${state.id}`);
+  console.log(`State: ${goalStateDisplayPath({ storageRoot: local.storageRoot, goalId: state.id, fileName: "state.json" })}`);
+  if (state.createPipeline?.plan) {
+    console.log(`Plan: ${goalStateDisplayPath({ storageRoot: local.storageRoot, goalId: state.id, fileName: "create-plan.json" })}`);
+    console.log(`Approval required: openpond goal approve ${state.id}`);
+  }
+  return state;
+}
+async function runGoal(params) {
+  const launchConfig = await readHostedGoalLaunchConfig();
+  const outputMode = await resolveGoalOutputMode({
+    options: params.options,
+    launchConfig
+  });
+  const credential = resolveHostedGoalCredential();
+  const apiUrl = resolveHostedGoalApiUrl();
+  if (credential && apiUrl) {
+    const hosted = new HostedGoalClient(apiUrl, credential);
+    const config = await hosted.getRunConfig(params.goalId);
+    const result2 = await runGoalIteration({
+      config: {
+        ...config,
+        iterationId: launchConfig?.iterationId ?? config.iterationId ?? null
+      },
+      hostedClient: hosted
+    });
+    printGoalRunOutput(result2, outputMode);
+    return;
+  }
+  const local = await localGoalPaths(params.options);
+  const goal = await local.adapter.get(params.goalId);
+  if (!goal) throw new Error(`goal not found: ${params.goalId}`);
+  const result = await runGoalIteration({
+    config: {
+      goal,
+      mode: "local",
+      workspace: local.workspace,
+      storageRoot: local.storageRoot,
+      iterationId: null
+    },
+    localState: local.adapter
+  });
+  printGoalRunOutput(result, outputMode);
+}
+async function answerGoal(params) {
+  const optionId = optionString(params.options, "choice") || null;
+  const freeformText = optionString(params.options, "answer") || null;
+  if (!optionId && !freeformText) {
+    throw new Error("usage: goal answer <question-id> --choice <id>|--answer <text>");
+  }
+  const goalId = optionString(params.options, "goalId");
+  const answer = {
+    id: `answer_${randomUUID9()}`,
+    goalId,
+    questionId: params.questionId,
+    optionId,
+    freeformText,
+    value: {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const credential = resolveHostedGoalCredential();
+  const apiUrl = resolveHostedGoalApiUrl();
+  if (credential && apiUrl) {
+    if (!goalId) {
+      throw new Error("hosted goal answer requires --goal-id <goal-id>");
+    }
+    await new HostedGoalClient(apiUrl, credential).answerQuestion({
+      goalId,
+      questionId: params.questionId,
+      answer
+    });
+    console.log(`Answered question: ${params.questionId}`);
+    return;
+  }
+  const local = await localGoalPaths(params.options);
+  const goal = goalId ? await local.adapter.get(goalId) : await local.adapter.findGoalByQuestionId(params.questionId);
+  if (!goal) throw new Error(`goal not found for question: ${params.questionId}`);
+  await local.adapter.answerQuestion({
+    goalId: goal.id,
+    questionId: params.questionId,
+    answer: { ...answer, goalId: goal.id }
+  });
+  console.log(`Answered question: ${params.questionId}`);
+}
+async function updateGoalStatus2(params) {
+  const credential = resolveHostedGoalCredential();
+  const apiUrl = resolveHostedGoalApiUrl();
+  if (credential && apiUrl) {
+    await new HostedGoalClient(apiUrl, credential).updateStatus(
+      params.goalId,
+      params.status
+    );
+    console.log(`Goal ${params.goalId} ${params.status}`);
+    return;
+  }
+  const local = await localGoalPaths(params.options);
+  const goal = await local.adapter.get(params.goalId);
+  if (!goal) throw new Error(`goal not found: ${params.goalId}`);
+  await local.adapter.update({ ...goal, status: params.status });
+  await local.adapter.appendEvent(
+    goal.id,
+    createGoalEvent({
+      goalId: goal.id,
+      kind: "goal.status_changed",
+      summary: `Goal ${params.status}`,
+      payload: {
+        fromStatus: goal.status,
+        toStatus: params.status
+      }
+    })
+  );
+  console.log(`Goal ${params.goalId} ${params.status}`);
+}
+async function applyGoalLifecycle(params) {
+  const credential = resolveHostedGoalCredential();
+  const apiUrl = resolveHostedGoalApiUrl();
+  if (credential && apiUrl) {
+    const client = new HostedGoalClient(apiUrl, credential);
+    if (params.action === "approve") {
+      await client.approve(params.goalId, optionString(params.options, "note"));
+    } else if (params.action === "reject") {
+      await client.reject(params.goalId, optionString(params.options, "note"));
+    } else if (params.action === "pause") {
+      await client.pause(params.goalId);
+    } else if (params.action === "resume") {
+      await client.resume(params.goalId);
+    } else {
+      await client.cancel(params.goalId);
+    }
+    const completedAction = {
+      approve: "approved",
+      reject: "rejected",
+      pause: "paused",
+      resume: "resumed",
+      cancel: "cancelled"
+    };
+    console.log(`Goal ${params.goalId} ${completedAction[params.action]}`);
+    return;
+  }
+  const statusByCommand = {
+    pause: "paused",
+    resume: "queued",
+    cancel: "cancelled"
+  };
+  if (params.action === "approve" || params.action === "reject" || params.action === "cancel") {
+    const local = await localGoalPaths(params.options);
+    const goal = await local.adapter.get(params.goalId);
+    if (!goal) throw new Error(`goal not found: ${params.goalId}`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const note = optionString(params.options, "note") || null;
+    const pendingApproval = goal.approvals.find(
+      (approval) => approval.status === "pending"
+    );
+    if (!pendingApproval && params.action === "cancel") {
+      await updateGoalStatus2({
+        options: params.options,
+        goalId: params.goalId,
+        status: "cancelled"
+      });
+      return;
+    }
+    if (!pendingApproval) {
+      throw new Error(`goal has no pending approval: ${params.goalId}`);
+    }
+    const approvalStatus = params.action === "approve" ? "approved" : params.action === "reject" ? "rejected" : "cancelled";
+    const goalStatus = params.action === "approve" ? "queued" : params.action === "reject" ? "blocked" : "cancelled";
+    const approvals = goal.approvals.map(
+      (approval) => approval.id === pendingApproval?.id ? {
+        ...approval,
+        status: approvalStatus,
+        decidedAt: now,
+        decisionNote: note
+      } : approval
+    );
+    let decidedGoal = {
+      ...goal,
+      status: goalStatus,
+      approvals,
+      updatedAt: now
+    };
+    if (pendingApproval?.kind === "create_plan") {
+      if (params.action === "approve") {
+        decidedGoal = approveCreatePipelinePlan(decidedGoal, pendingApproval.id);
+      } else if (params.action === "reject") {
+        decidedGoal = rejectCreatePipelinePlan(decidedGoal, pendingApproval.id, note);
+      } else {
+        decidedGoal = cancelCreatePipelinePlan(decidedGoal, pendingApproval.id, note);
+      }
+    }
+    await local.adapter.update(decidedGoal);
+    await local.adapter.appendEvent(
+      goal.id,
+      createGoalEvent({
+        goalId: goal.id,
+        kind: "approval.decided",
+        summary: pendingApproval ? `Approval ${approvalStatus}: ${pendingApproval.title}` : `Goal ${approvalStatus}`,
+        payload: {
+          approvalId: pendingApproval?.id ?? null,
+          kind: pendingApproval?.kind ?? null,
+          status: approvalStatus,
+          decisionNote: note
+        }
+      })
+    );
+    if (pendingApproval?.kind === "create_plan") {
+      const toState = params.action === "approve" ? "applying_source" : params.action === "reject" ? "blocked" : "cancelled";
+      await local.adapter.appendEvent(
+        goal.id,
+        createGoalEvent({
+          goalId: goal.id,
+          kind: "create_pipeline.status_changed",
+          summary: params.action === "approve" ? "Create plan approved" : params.action === "reject" ? "Create plan rejected" : "Create plan cancelled",
+          payload: {
+            fromState: goal.createPipeline?.state ?? null,
+            toState,
+            approvalId: pendingApproval.id
+          }
+        })
+      );
+    }
+    console.log(`Goal ${params.goalId} ${approvalStatus}`);
+    return;
+  }
+  await updateGoalStatus2({
+    options: params.options,
+    goalId: params.goalId,
+    status: statusByCommand[params.action]
+  });
+}
+async function printGoalPlan(params) {
+  const credential = resolveHostedGoalCredential();
+  const apiUrl = resolveHostedGoalApiUrl();
+  if (credential && apiUrl) {
+    const config = await new HostedGoalClient(apiUrl, credential).getRunConfig(params.goalId);
+    printCreatePipeline(config.goal, hasFlag(params.options, "json"));
+    return;
+  }
+  const local = await localGoalPaths(params.options);
+  const goal = await local.adapter.get(params.goalId);
+  if (!goal) throw new Error(`goal not found: ${params.goalId}`);
+  printCreatePipeline(goal, hasFlag(params.options, "json"));
+}
+async function editGoalPlan(params) {
+  const credential = resolveHostedGoalCredential();
+  const apiUrl = resolveHostedGoalApiUrl();
+  if (credential && apiUrl) {
+    throw new Error("hosted create-plan editing is not available from this CLI yet");
+  }
+  const local = await localGoalPaths(params.options);
+  const goal = await local.adapter.get(params.goalId);
+  if (!goal) throw new Error(`goal not found: ${params.goalId}`);
+  const previousPlanId = goal.createPipeline?.plan?.id ?? null;
+  const revised = reviseCreatePipelinePlan(goal, { revision: params.revision });
+  await local.adapter.update(revised);
+  await local.adapter.appendEvent(
+    goal.id,
+    createGoalEvent({
+      goalId: goal.id,
+      kind: "create_plan.created",
+      summary: "Create plan revised before source mutation",
+      payload: {
+        previousPlanId,
+        planId: revised.createPipeline?.plan?.id ?? null,
+        revision: params.revision
+      }
+    })
+  );
+  if (hasFlag(params.options, "json")) {
+    console.log(JSON.stringify(revised.createPipeline, null, 2));
+    return;
+  }
+  console.log(`Goal ${params.goalId} plan revised`);
+  console.log(`Plan: ${revised.createPipeline?.plan?.id ?? "unknown"}`);
+}
+function printCreatePipeline(goal, json = false) {
+  if (!goal?.createPipeline) {
+    if (json) {
+      console.log(JSON.stringify(null, null, 2));
+      return;
+    }
+    console.log(`Goal ${goal?.id ?? "unknown"} has no create pipeline.`);
+    return;
+  }
+  const pipeline = goal.createPipeline;
+  const plan = pipeline.plan;
+  if (json) {
+    console.log(JSON.stringify(pipeline, null, 2));
+    return;
+  }
+  console.log(`Goal: ${goal.id}`);
+  console.log(`Pipeline: ${pipeline.state}`);
+  console.log(`Request: ${pipeline.request.command} ${pipeline.request.operation}`);
+  console.log(`Objective: ${pipeline.request.objective}`);
+  if (!plan) return;
+  console.log("");
+  console.log(`Plan: ${plan.status}`);
+  console.log(plan.summary);
+  console.log("");
+  console.log("Captured context:");
+  console.log(`  ${plan.capturedContextSummary}`);
+  console.log("");
+  console.log("Default chat action:");
+  console.log(`  ${plan.defaultChatAction.key ?? "none"}`);
+  const actionShape = createPipelineActionShapeFromMetadata(plan.metadata);
+  if (actionShape) {
+    console.log("");
+    console.log("Action shape:");
+    console.log(`  ${actionShape.label}: ${actionShape.detail}`);
+    if (actionShape.directActionHint) {
+      console.log(`  Direct action: ${actionShape.directActionHint}`);
+    }
+    console.log(`  Artifacts: ${actionShape.artifactPolicy}`);
+  }
+  console.log("");
+  console.log("Source plan:");
+  for (const item of plan.sourcePlan) {
+    console.log(`  - ${item.operation} ${item.path}: ${item.reason}`);
+  }
+  console.log("");
+  console.log("Requirements:");
+  if (plan.requirements.length === 0) {
+    console.log("  - none");
+  } else {
+    for (const requirement of plan.requirements) {
+      console.log(`  - ${requirement.kind} ${requirement.name} (${requirement.status})${requirement.detail ? `: ${requirement.detail}` : ""}`);
+    }
+  }
+  console.log("");
+  console.log("Checks:");
+  for (const check of plan.checks) {
+    console.log(`  - ${check.name}: ${check.command}`);
+  }
+  const pendingApproval = goal.approvals.find((approval) => approval.id === plan.approvalId);
+  if (pendingApproval?.status === "pending") {
+    console.log("");
+    console.log(`Approve: openpond goal approve ${goal.id}`);
+    console.log(`Reject: openpond goal reject ${goal.id}`);
+    console.log(`Cancel: openpond goal cancel ${goal.id}`);
+  }
+}
+async function runGoalCommand(options, rest) {
+  const subcommand = rest[0];
+  if (hasFlag(options, "help") || subcommand === "help") {
+    printGoalHelp();
+    return;
+  }
+  if (!subcommand || !["run", "create-agent", "update-agent", "plan", "answer", "approve", "reject", "pause", "resume", "cancel"].includes(subcommand)) {
+    await createLocalGoal({
+      options,
+      objective: objectiveFromRest(rest, 'usage: goal "<objective>"'),
+      kind: "general_code_goal"
+    });
+    return;
+  }
+  if (subcommand === "run") {
+    await runGoal({
+      options,
+      goalId: requireOption(options, "goalId", "usage: goal run --goal-id <id>")
+    });
+    return;
+  }
+  if (subcommand === "plan") {
+    const goalId2 = rest[1] || optionString(options, "goalId");
+    if (!goalId2) throw new Error("usage: goal plan <goal-id> [--json|--edit <instructions>]");
+    const revision = optionString(options, "edit") || optionString(options, "revision");
+    if (revision) {
+      await editGoalPlan({ options, goalId: goalId2, revision });
+      return;
+    }
+    await printGoalPlan({ options, goalId: goalId2 });
+    return;
+  }
+  if (subcommand === "create-agent" || subcommand === "update-agent") {
+    if (subcommand === "update-agent" && !optionString(options, "agentId")) {
+      throw new Error('usage: goal update-agent "<agent change>" --agent-id <id>');
+    }
+    await createLocalGoal({
+      options,
+      objective: objectiveFromRest(
+        rest.slice(1),
+        subcommand === "create-agent" ? 'usage: goal create-agent "<agent idea>"' : 'usage: goal update-agent "<agent change>" --agent-id <id>'
+      ),
+      kind: goalKindFromCommand(subcommand)
+    });
+    return;
+  }
+  if (subcommand === "answer") {
+    const questionId = rest[1];
+    if (!questionId) {
+      throw new Error("usage: goal answer <question-id> --choice <id>|--answer <text>");
+    }
+    await answerGoal({ options, questionId });
+    return;
+  }
+  const goalId = rest[1] || optionString(options, "goalId");
+  if (!goalId) {
+    throw new Error(`usage: goal ${subcommand} <goal-id>`);
+  }
+  await applyGoalLifecycle({
+    options,
+    goalId,
+    action: subcommand
+  });
+}
+
+export {
+  printGoalHelp,
+  createLocalGoal,
+  runGoalCommand
+};