openpond 0.0.38 → 0.0.40

package/dist/chunks/{src-RPW5TOPI.js → src-35JYS27L.js}

@@ -3,7 +3,7 @@ import { createRequire as __openpondCreateRequire } from "node:module"; var requ
 import {
   createReadyLineParser,
   openUrlWithSystemBrowser
-} from "./chunk-QRM7XMAO.js";
+} from "./chunk-ZTE6A2VE.js";
 import {
   ApprovalSchema,
   ContextUsageSnapshotSchema,
@@ -12,13 +12,14 @@ import {
   DEFAULT_OPENPOND_CHAT_MODEL,
   DEFAULT_OPENPOND_COMMAND_ACCESS_MODE,
   OpenPondCommandAccessModeSchema
-} from "./chunk-LZZM3IHS.js";
+} from "./chunk-2SF6HLT7.js";
 import {
   CONNECTED_APP_CATALOG,
   buildConnectedAppInstallUrl,
   connectedAppById
-} from "./chunk-XEJ7XXUQ.js";
+} from "./chunk-M2NXTLH2.js";
 import "./chunk-WYDVQOBL.js";
+import "./chunk-KHNHUA2H.js";
 import "./chunk-UACZUFIA.js";
 
 // ../terminal/src/index.ts
@@ -153,7 +154,7 @@ var SLASH_COMMANDS = [
   { name: "agents", usage: "/agents", description: "list agents" },
   { name: "agent", usage: "/agent <id>", description: "select agent", requiresArgument: true },
   { name: "run", usage: "/run <action> [json]", description: "run profile action", requiresArgument: true },
-  { name: "settings", usage: "/settings [goal-storage global|workspace]", description: "show or update settings" },
+  { name: "settings", usage: "/settings", description: "show settings" },
   { name: "logs", usage: "/logs", description: "show recent events" },
   { name: "compact", usage: "/compact", description: "compact current session" },
   { name: "clear", usage: "/clear", description: "clear terminal transcript" },
@@ -970,7 +971,6 @@ var OPENAI_COMPATIBLE_CHAT_PROVIDER_IDS = [
   "moonshot",
   "together",
   "groq",
-  "fireworks",
   "custom-openai-compatible"
 ];
 var RUNNABLE_CHAT_PROVIDER_IDS = [
@@ -1266,6 +1266,7 @@ function parseTerminalArgs(argv, defaultCwd = process.cwd()) {
     provider: DEFAULT_CHAT_PROVIDER,
     model: null,
     cwd: defaultCwd,
+    agent: null,
     project: null,
     resume: null,
     noServerStart: false,
@@ -1292,6 +1293,8 @@ function parseTerminalArgs(argv, defaultCwd = process.cwd()) {
     } else if (arg === "--cwd") {
       options.cwd = path.resolve(rest[++i] ?? options.cwd);
       options.cwdExplicit = true;
+    } else if (arg === "--agent") {
+      options.agent = readStringArg(rest, ++i, "agent");
     } else if (arg === "--project") {
       options.project = rest[++i] ?? null;
     } else if (arg === "--resume") {
@@ -2060,7 +2063,7 @@ ${formatTerminalProjects(latest)}`, "warning"));
     return;
   }
   if (command.type === "settings") {
-    await handleSettingsCommand(command.args, context, connection);
+    await handleSettingsCommand(command.args, context);
     return;
   }
   if (command.type === "logs") {
@@ -2164,40 +2167,21 @@ async function patchTerminalSessionCommandAccess(connection, sessionId, mode) {
     body: JSON.stringify({ openPondCommandAccessMode: mode })
   });
 }
-async function handleSettingsCommand(args, context, connection) {
+async function handleSettingsCommand(args, context) {
   const latest = context.getPayload() ?? await context.refreshBootstrap();
   const subcommand = args[0] ?? "show";
   if (subcommand === "show") {
     context.addItem(systemItem(formatTerminalSettings(latest)));
     return;
   }
-  if (subcommand !== "goal-storage") {
-    context.addItem(systemItem("Usage: /settings [goal-storage global|workspace]", "warning"));
-    return;
-  }
-  const location = args[1];
-  if (location !== "global" && location !== "workspace") {
-    context.addItem(systemItem("Usage: /settings goal-storage global|workspace", "warning"));
-    return;
-  }
-  const updated = await apiFetch(connection.server, connection.token, "/v1/preferences", {
-    method: "PATCH",
-    body: JSON.stringify({ goalStorageLocation: location })
-  });
-  context.setPayload(updated);
-  context.addItem(systemItem(`Goal storage set to ${goalStorageLabel(updated.preferences.goalStorageLocation)}.`));
+  context.addItem(systemItem("Usage: /settings", "warning"));
 }
 function formatTerminalSettings(payload) {
   return [
     "Settings:",
-    `Goal storage: ${goalStorageLabel(payload.preferences.goalStorageLocation)}`,
-    "",
-    "Change it with /settings goal-storage global or /settings goal-storage workspace."
+    `Default chat: ${payload.preferences.defaultChatProvider} / ${payload.preferences.defaultChatModel}`
   ].join("\n");
 }
-function goalStorageLabel(location) {
-  return location === "workspace" ? ".openpond/goals in the working directory" : "~/.openpond/goals";
-}
 async function handleProfileCommand(args, context, connection) {
   const subcommand = args[0] ?? "current";
   if (subcommand === "init") {
@@ -2733,6 +2717,18 @@ async function runOneShotChat(options, io = {}) {
       }
     });
     await deadline.run("event stream readiness", eventStream.ready);
+    const profileActionCatalog = (payload.profile.actionCatalog ?? []).filter(
+      (action) => profileActionMatchesAgent(action, options.agent) && (!action.agentId || payload.profile.agents.some(
+        (agent) => agent.enabled && agent.id === action.agentId
+      ))
+    ).map((action) => ({
+      ...action,
+      implementation: {
+        ...action.implementation ?? {},
+        type: "openpond-profile-action",
+        actionId: action.id
+      }
+    }));
     await deadline.run("turn submission", apiFetch(connection.server, connection.token, `/v1/sessions/${activeSessionId}/turns`, {
       method: "POST",
       body: JSON.stringify({
@@ -2740,6 +2736,7 @@ async function runOneShotChat(options, io = {}) {
         ...options.cwdExplicit || !options.project && !options.resume ? { cwd: options.cwd } : {},
         model: modelId,
         modelRef: activeModelRef(options, payload.providers),
+        ...profileActionCatalog.length > 0 ? { openPondActionCatalog: profileActionCatalog } : {},
         approvalPolicy: options.yes ? "never" : options.approvalPolicy,
         sandbox: options.sandbox,
         metadata: {
@@ -2747,7 +2744,8 @@ async function runOneShotChat(options, io = {}) {
           openpondTerminal: {
             mode: "one-shot",
             nonInteractive: true,
-            sandbox: options.sandbox
+            sandbox: options.sandbox,
+            ...options.agent ? { agentId: options.agent } : {}
           }
         }
       }),
@@ -2810,6 +2808,10 @@ async function runOneShotChat(options, io = {}) {
     if (timedOut && !options.json) output2.write("\n[turn timeout]\n");
   }
 }
+function profileActionMatchesAgent(action, agentId) {
+  if (!agentId) return true;
+  return action.agentId === agentId || action.id === agentId || action.id.startsWith(`${agentId}.`);
+}
 function createOneShotDeadline(timeoutSec) {
   const controller = new AbortController();
   let phase = "startup";
@@ -3585,7 +3587,7 @@ async function runOpenPondTerminalCli(argv = process.argv.slice(2)) {
   const { command, options } = parseTerminalArgs(argv);
   if (command !== "chat") {
     output.write(
-      "Usage: openpond-app chat [--server URL] [--provider PROVIDER] [--model MODEL] [--cwd DIR] [--project APP_ID] [--resume SESSION_ID] (--message TEXT|--message-file PATH|--stdin) --non-interactive [--yes] [--approval-policy POLICY] [--json] [--timeout-sec SEC] [--max-output-bytes BYTES] [--sandbox MODE]\n"
+      "Usage: openpond-app chat [--server URL] [--provider PROVIDER] [--model MODEL] [--agent AGENT_ID] [--cwd DIR] [--project APP_ID] [--resume SESSION_ID] (--message TEXT|--message-file PATH|--stdin) --non-interactive [--yes] [--approval-policy POLICY] [--json] [--timeout-sec SEC] [--max-output-bytes BYTES] [--sandbox MODE]\n"
     );
     return;
   }

package/dist/chunks/{teams-bot-PSL3ZO6Z.js → teams-bot-L4SR2SWM.js}

@@ -1,10 +1,12 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   resolveSandboxClient
-} from "./chunk-275WCETC.js";
-import "./chunk-GDZYDLEL.js";
-import "./chunk-XCATKTK3.js";
-import "./chunk-ZI4GDAUB.js";
+} from "./chunk-FCVVOMIP.js";
+import "./chunk-KHNHUA2H.js";
+import "./chunk-KSOI7GFA.js";
+import "./chunk-SMNFI2FU.js";
+import "./chunk-QHUJ2XVJ.js";
+import "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
 import {
   optionString,

package/dist/chunks/training-BR5A7SPU.js

@@ -0,0 +1,320 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  resolveApiBaseUrlOption
+} from "./chunk-SMNFI2FU.js";
+import "./chunk-KSRWKXRB.js";
+import {
+  optionString,
+  parseBooleanOption,
+  parseIntegerOption,
+  parseNumberOption
+} from "./chunk-MUMPWI4O.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/training.ts
+import { readFile } from "node:fs/promises";
+import { request as requestHttp } from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+var DEFAULT_LOCAL_TRAINING_API_URL = "http://127.0.0.1:17874";
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "cancelled",
+  "completed",
+  "failed",
+  "succeeded"
+]);
+async function runTrainingCommand(options, rest, dependencies = {}) {
+  const subcommand = rest[0];
+  const id = rest[1];
+  if (!subcommand || ![
+    "start",
+    "status",
+    "watch",
+    "logs",
+    "cancel",
+    "artifacts"
+  ].includes(
+    subcommand
+  ) || !id) {
+    throw new Error(
+      "usage: training <start|status|watch|logs|cancel|artifacts> <model-run-id|run-id>"
+    );
+  }
+  if (rest.length > 2) {
+    throw new Error(`training ${subcommand} accepts exactly one identifier`);
+  }
+  const baseUrl = resolveApiBaseUrlOption(options) ?? process.env.OPENPOND_LOCAL_API_URL?.replace(/\/$/, "") ?? DEFAULT_LOCAL_TRAINING_API_URL;
+  const client = new TrainingApiClient({
+    baseUrl,
+    request: dependencies.request ?? await createLocalAuthenticatedRequest(baseUrl)
+  });
+  const json = parseBooleanOption(options.json);
+  if (subcommand === "start") {
+    await startTraining({
+      client,
+      dependencies,
+      json,
+      modelRunId: id,
+      options
+    });
+    return;
+  }
+  if (subcommand === "watch") {
+    await watchTraining({
+      client,
+      runId: id,
+      json,
+      intervalMs: parseIntegerOption(options.intervalMs, "interval-ms") ?? 2e3,
+      sleep: dependencies.sleep
+    });
+    return;
+  }
+  const endpoint = subcommand === "status" ? "status" : subcommand === "logs" ? "logs" : subcommand === "artifacts" ? "artifacts" : "cancel";
+  const result = await client.modelRun(
+    id,
+    endpoint,
+    subcommand === "cancel" ? "POST" : "GET"
+  );
+  printResult(result, json);
+}
+async function createLocalAuthenticatedRequest(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "::1"].includes(url.hostname)) {
+    return fetch;
+  }
+  const appHome = process.env.OPENPOND_APP_HOME?.trim() || path.join(os.homedir(), ".openpond", "openpond-app");
+  const token = (await readFile(path.join(appHome, "token"), "utf8")).trim();
+  if (!token) {
+    throw new Error("OpenPond local capability token is empty.");
+  }
+  return (async (resource, init = {}) => {
+    const target = resource instanceof Request ? new URL(resource.url) : new URL(String(resource));
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${token}`);
+    const nodeHeaders = {};
+    headers.forEach((value, name) => {
+      nodeHeaders[name] = value;
+    });
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const request = requestHttp(
+        target,
+        {
+          method: init.method ?? "GET",
+          headers: nodeHeaders
+        },
+        (response) => {
+          const chunks = [];
+          response.on("data", (chunk) => chunks.push(chunk));
+          response.once("error", rejectOnce);
+          response.once("end", () => {
+            if (settled) return;
+            settled = true;
+            const responseHeaders = new Headers();
+            for (const [name, value] of Object.entries(response.headers)) {
+              if (Array.isArray(value)) {
+                for (const item of value) responseHeaders.append(name, item);
+              } else if (value !== void 0) {
+                responseHeaders.set(name, value);
+              }
+            }
+            resolve(
+              new Response(new Uint8Array(Buffer.concat(chunks)), {
+                status: response.statusCode ?? 500,
+                statusText: response.statusMessage,
+                headers: responseHeaders
+              })
+            );
+          });
+        }
+      );
+      const rejectOnce = (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      };
+      request.once("error", rejectOnce);
+      if (init.signal) {
+        const abort = () => request.destroy(
+          init.signal?.reason instanceof Error ? init.signal.reason : new Error("Training API request aborted.")
+        );
+        if (init.signal.aborted) abort();
+        else init.signal.addEventListener("abort", abort, { once: true });
+      }
+      if (init.body !== void 0 && init.body !== null) {
+        if (typeof init.body !== "string" && !(init.body instanceof Uint8Array)) {
+          request.destroy(
+            new Error("Local Training API supports string or byte request bodies.")
+          );
+          return;
+        }
+        request.write(init.body);
+      }
+      request.end();
+    });
+  });
+}
+var TrainingApiClient = class {
+  baseUrl;
+  request;
+  constructor(input) {
+    this.baseUrl = input.baseUrl.replace(/\/$/, "");
+    this.request = input.request ?? fetch;
+  }
+  modelRun(id, action, method, body) {
+    return this.json(
+      `/v1/training/model-runs/${encodeURIComponent(id)}/${action}`,
+      method,
+      body
+    );
+  }
+  async json(pathname, method, body) {
+    const response = await this.request(`${this.baseUrl}${pathname}`, {
+      method,
+      headers: body === void 0 ? { Accept: "application/json" } : {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = text;
+      }
+    }
+    if (!response.ok) {
+      const message = payload && typeof payload === "object" && "error" in payload && typeof payload.error === "string" ? payload.error : `${response.status} ${response.statusText}`.trim();
+      throw new Error(`Training API request failed: ${message}`);
+    }
+    return payload;
+  }
+};
+async function startTraining(input) {
+  const maximumSpendUsd = parseNumberOption(
+    input.options.maxSpend,
+    "max-spend"
+  ) ?? null;
+  if (maximumSpendUsd !== null && maximumSpendUsd < 0) {
+    throw new Error("max-spend must be non-negative");
+  }
+  const retentionDays = parseIntegerOption(input.options.retentionDays, "retention-days") ?? null;
+  if (retentionDays !== null && retentionDays <= 0) {
+    throw new Error("retention-days must be a positive integer");
+  }
+  const manifestPath = optionString(input.options, "manifest");
+  const manifest = manifestPath ? await readManifest(manifestPath) : void 0;
+  const controls = { maximumSpendUsd, retentionDays };
+  const preparation = await input.client.modelRun(
+    input.modelRunId,
+    "prepare",
+    "POST",
+    controls
+  );
+  if (!input.json) {
+    console.log("Preparation:");
+    console.log(JSON.stringify(preparation, null, 2));
+  }
+  const confirmed = parseBooleanOption(input.options.yes) || await confirmStart(input.dependencies.confirm);
+  if (!confirmed) {
+    throw new Error("Training start cancelled.");
+  }
+  const result = await input.client.modelRun(
+    input.modelRunId,
+    "start",
+    "POST",
+    { ...controls, manifest }
+  );
+  printResult(result, input.json);
+  if (parseBooleanOption(input.options.detach)) return;
+  const runId = readRunId(result) ?? input.modelRunId;
+  await watchTraining({
+    client: input.client,
+    runId,
+    json: input.json,
+    intervalMs: 2e3,
+    sleep: input.dependencies.sleep
+  });
+}
+async function watchTraining(input) {
+  if (input.intervalMs < 250) {
+    throw new Error("interval-ms must be at least 250");
+  }
+  const sleep = input.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  let previous = "";
+  for (; ; ) {
+    const status = await input.client.modelRun(
+      input.runId,
+      "status",
+      "GET"
+    );
+    const serialized = JSON.stringify(status);
+    if (input.json || serialized !== previous) {
+      printResult(status, input.json);
+      previous = serialized;
+    }
+    if (TERMINAL_STATUSES.has(readStatus(status))) return;
+    await sleep(input.intervalMs);
+  }
+}
+async function readManifest(path2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path2, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Could not read Harness Run Manifest ${path2}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Harness Run Manifest must be a JSON object.");
+  }
+  return parsed;
+}
+async function confirmStart(injected) {
+  const message = "Start this exact prepared training run? Downloads, provisioning, or spend may begin.";
+  if (injected) return injected(message);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "training start requires --yes when standard input is not interactive"
+    );
+  }
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await prompt.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    prompt.close();
+  }
+}
+function readRunId(value) {
+  if (!value || typeof value !== "object") return null;
+  const job = "job" in value ? value.job : null;
+  if (!job || typeof job !== "object" || !("id" in job)) return null;
+  return typeof job.id === "string" ? job.id : null;
+}
+function readStatus(value) {
+  if (!value || typeof value !== "object") return "";
+  if ("state" in value && typeof value.state === "string") {
+    return value.state;
+  }
+  return "status" in value && typeof value.status === "string" ? value.status : "";
+}
+function printResult(value, json) {
+  if (json) {
+    console.log(JSON.stringify(value));
+    return;
+  }
+  console.log(JSON.stringify(value, null, 2));
+}
+export {
+  TrainingApiClient,
+  runTrainingCommand
+};

package/dist/chunks/{workspaces-BPXC2DHT.js → workspaces-NGDIBOKQ.js}

@@ -45,8 +45,8 @@ import {
   truncatePatch,
   uniqueSortedPaths,
   workspaceImageContentType
-} from "./chunk-AHNFNWUN.js";
-import "./chunk-HS2AGRDV.js";
+} from "./chunk-HHALVXPK.js";
+import "./chunk-CZG4XKVF.js";
 import "./chunk-UACZUFIA.js";
 export {
   MACOS_GIT_MISSING_DEVELOPER_TOOLS_ERROR,

package/dist/cli.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  parseArgs,
+  parseArgs
+} from "./chunks/chunk-KSOI7GFA.js";
+import {
   resolveAccountOption,
   resolveBaseUrlOption
-} from "./chunks/chunk-GDZYDLEL.js";
+} from "./chunks/chunk-SMNFI2FU.js";
 import {
   getInstalledCliVersion,
   runCliCommand
-} from "./chunks/chunk-XCATKTK3.js";
+} from "./chunks/chunk-QHUJ2XVJ.js";
 import "./chunks/chunk-KSRWKXRB.js";
 import {
   parseBooleanOption
@@ -35,11 +37,11 @@ async function runOpenPondCli(argv = process.argv.slice(2)) {
     return;
   }
   if (action === "check-update") {
-    await (await import("./chunks/core-commands-YN4RMWA3.js")).runCheckUpdate();
+    await (await import("./chunks/core-commands-D66KZEHU.js")).runCheckUpdate();
     return;
   }
   if (action === "help") {
-    (await import("./chunks/help-VREQNA4I.js")).printHelp();
+    (await import("./chunks/help-7QG4UITV.js")).printHelp();
     return;
   }
   const selectedAccount = resolveAccountOption(options);
@@ -51,31 +53,41 @@ async function runOpenPondCli(argv = process.argv.slice(2)) {
     process.env.OPENPOND_BASE_URL = selectedBaseUrl;
   }
   if (action === "tui") {
-    await (await import("./chunks/app-layer-DPUJRNO2.js")).runOpenPondTerminalCommand(options, rest);
+    await (await import("./chunks/app-layer-UPNMLDO5.js")).runOpenPondTerminalCommand(options, rest);
     return;
   }
   if (action === "ui") {
-    await (await import("./chunks/app-layer-DPUJRNO2.js")).runOpenPondServerCommand("web", options, rest);
+    await (await import("./chunks/app-layer-UPNMLDO5.js")).runOpenPondServerCommand("web", options, rest);
     return;
   }
   if (await runCliCommand({ command, options, rest })) {
     return;
   }
-  (await import("./chunks/help-VREQNA4I.js")).printHelp();
+  (await import("./chunks/help-7QG4UITV.js")).printHelp();
   process.exit(1);
 }
 async function runEmbeddedCompanion(argv) {
+  if (argv[0] === "__app-server") {
+    process.argv = [process.execPath, "openpond-app-server", ...argv.slice(1)];
+    const [{ createOpenPondAppServer }, { runOpenPondAppServerCli }] = await Promise.all([
+      import("./chunks/app-server-runtime-2WTZXXOF.js"),
+      import("./chunks/cli-ZIY4LAYZ.js")
+    ]);
+    await runOpenPondAppServerCli(createOpenPondAppServer);
+    return true;
+  }
   if (argv[0] === "__server") {
     process.argv = [process.execPath, "openpond-server", ...argv.slice(1)];
     const [{ createOpenPondServer }, { runOpenPondServerCli }] = await Promise.all([
-      import("./chunks/src-MWDIK56B.js"),
-      import("./chunks/cli-7BKDWFNU.js")
+      import("./chunks/src-23HDSVNH.js"),
+      import("./chunks/cli-ZIY4LAYZ.js")
     ]);
-    await runOpenPondServerCli(createOpenPondServer);
+    const { createOpenPondAppServer } = await import("./chunks/app-server-runtime-2WTZXXOF.js");
+    await runOpenPondServerCli({ createOpenPondServer, createOpenPondAppServer });
     return true;
   }
   if (argv[0] === "__terminal") {
-    await (await import("./chunks/src-RPW5TOPI.js")).runOpenPondTerminalCli(argv.slice(1));
+    await (await import("./chunks/src-35JYS27L.js")).runOpenPondTerminalCli(argv.slice(1));
     return true;
   }
   return false;

package/dist/config.d.ts

@@ -26,7 +26,6 @@ export type LocalOpenPondProfileCheckStatus = {
 export type LocalOpenPondProfileHostedSourceCheckStatus = {
     status: string;
     agentId?: string | null;
-    workItemId?: string | null;
     deployPlanStatus?: string | null;
     canRun?: boolean | null;
     canDeploy?: boolean | null;
@@ -126,13 +125,20 @@ export type LocalOpenPondProfileConfig = {
     mode: "local";
     lastCheck?: LocalOpenPondProfileCheckStatus;
     lastPush?: LocalOpenPondProfilePushStatus;
+    profiles?: LocalOpenPondProfileCatalogEntry[];
+};
+export type LocalOpenPondProfileCatalogEntry = {
+    source: "local" | "github" | "openpond_git";
+    repositoryId: string;
+    repoPath: string;
+    profile: string;
+    lastCheck?: LocalOpenPondProfileCheckStatus;
+    lastPush?: LocalOpenPondProfilePushStatus;
 };
-export type LocalGoalStorageLocation = "global" | "workspace";
 export type LocalConfig = {
     accounts?: LocalAccountConfig[];
     activeProfile?: ActiveProfileSelector;
     openpondProfile?: LocalOpenPondProfileConfig;
-    goalStorageLocation?: LocalGoalStorageLocation;
     baseUrl?: string;
     apiBaseUrl?: string;
     chatApiBaseUrl?: string;