@poncho-ai/cli 0.6.2 → 0.7.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-EPG7ZYDE.js";
+} from "./chunk-JIRFQFIX.js";
 
 // src/cli.ts
 void main();

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   runTests,
   startDevServer,
   updateAgentGuidance
-} from "./chunk-EPG7ZYDE.js";
+} from "./chunk-JIRFQFIX.js";
 export {
   addSkill,
   buildCli,

package/dist/run-interactive-ink-JGN4BBJB.js

@@ -0,0 +1,494 @@
+import {
+  consumeFirstRunIntro,
+  inferConversationTitle,
+  resolveHarnessEnvironment
+} from "./chunk-JIRFQFIX.js";
+
+// src/run-interactive-ink.ts
+import * as readline from "readline";
+import { stdout } from "process";
+import {
+  parseAgentFile
+} from "@poncho-ai/harness";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m"
+};
+var green = (s) => `${C.green}${s}${C.reset}`;
+var yellow = (s) => `${C.yellow}${s}${C.reset}`;
+var red = (s) => `${C.red}${s}${C.reset}`;
+var gray = (s) => `${C.gray}${s}${C.reset}`;
+var magenta = (s) => `${C.magenta}${s}${C.reset}`;
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var stringifyValue = (v) => {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+};
+var truncate = (v, max) => v.length <= max ? v : `${v.slice(0, Math.max(0, max - 3))}...`;
+var compactPreview = (v, max = 120) => truncate(stringifyValue(v).replace(/\s+/g, " "), max);
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsed = await parseAgentFile(workingDir);
+    agentName = parsed.frontmatter.name ?? agentName;
+    model = parsed.frontmatter.model?.name ?? model;
+    provider = parsed.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: resolveHarnessEnvironment()
+  };
+};
+var ask = (rl, prompt) => new Promise((res) => {
+  rl.question(prompt, (answer) => res(answer));
+});
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var streamTextAsTokens = async (text) => {
+  const tokens = text.match(/\S+\s*|\n/g) ?? [text];
+  for (const token of tokens) {
+    stdout.write(token);
+    const trimmed = token.trim();
+    const delay = trimmed.length === 0 ? 0 : Math.max(4, Math.min(18, Math.floor(trimmed.length / 2)));
+    await sleep(delay);
+  }
+};
+var OWNER_ID = "local-owner";
+var computeTurn = (messages) => Math.max(1, Math.floor(messages.length / 2) + 1);
+var formatDate = (value) => {
+  try {
+    return new Date(value).toLocaleString();
+  } catch {
+    return String(value);
+  }
+};
+var handleSlash = async (command, state, conversationStore) => {
+  const [rawCommand, ...args] = command.trim().split(/\s+/);
+  const norm = rawCommand.toLowerCase();
+  if (norm === "/help") {
+    console.log(
+      gray(
+        "commands> /help /clear /exit /tools /list /open <id> /new [title] /delete [id] /continue /reset [all]"
+      )
+    );
+    return { shouldExit: false };
+  }
+  if (norm === "/clear") {
+    process.stdout.write("\x1B[2J\x1B[H");
+    return { shouldExit: false };
+  }
+  if (norm === "/exit") {
+    return { shouldExit: true };
+  }
+  if (norm === "/list") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    if (conversations.length === 0) {
+      console.log(gray("conversations> none"));
+      return { shouldExit: false };
+    }
+    console.log(gray("conversations>"));
+    for (const conversation of conversations) {
+      const activeMarker = state.activeConversationId === conversation.conversationId ? "*" : " ";
+      console.log(
+        gray(
+          `${activeMarker} ${conversation.conversationId} | ${conversation.title} | ${formatDate(conversation.updatedAt)}`
+        )
+      );
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/open") {
+    const conversationId = args[0];
+    if (!conversationId) {
+      console.log(yellow("usage> /open <conversationId>"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(conversationId);
+    if (!conversation) {
+      console.log(yellow(`conversations> not found: ${conversationId}`));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [...conversation.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> opened ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/new") {
+    const title = args.join(" ").trim();
+    const conversation = await conversationStore.create(OWNER_ID, title || void 0);
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> new ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/delete") {
+    const targetConversationId = args[0] ?? state.activeConversationId ?? "";
+    if (!targetConversationId) {
+      console.log(yellow("usage> /delete <conversationId>"));
+      return { shouldExit: false };
+    }
+    const removed = await conversationStore.delete(targetConversationId);
+    if (!removed) {
+      console.log(yellow(`conversations> not found: ${targetConversationId}`));
+      return { shouldExit: false };
+    }
+    if (state.activeConversationId === targetConversationId) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+    }
+    console.log(gray(`conversations> deleted ${targetConversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/continue") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    const latest = conversations[0];
+    if (!latest) {
+      console.log(yellow("conversations> no conversations to continue"));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = latest.conversationId;
+    state.messages = [...latest.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> continued ${latest.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/reset") {
+    if (args[0]?.toLowerCase() === "all") {
+      const conversations = await conversationStore.list(OWNER_ID);
+      for (const conversation2 of conversations) {
+        await conversationStore.delete(conversation2.conversationId);
+      }
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> reset all"));
+      return { shouldExit: false };
+    }
+    if (!state.activeConversationId) {
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> current session reset"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(state.activeConversationId);
+    if (!conversation) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(yellow("conversations> active conversation no longer exists"));
+      return { shouldExit: false };
+    }
+    await conversationStore.update({
+      ...conversation,
+      messages: []
+    });
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> reset ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  console.log(yellow(`Unknown command: ${command}`));
+  return { shouldExit: false };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir,
+  config,
+  conversationStore,
+  onSetApprovalCallback
+}) => {
+  const metadata = await loadMetadata(workingDir);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  if (onSetApprovalCallback) {
+    onSetApprovalCallback((req) => {
+      process.stdout.write("\n");
+      const preview = compactPreview(req.input, 100);
+      rl.question(
+        `${C.yellow}${C.bold}Tool "${req.tool}" requires approval${C.reset}
+${C.gray}input: ${preview}${C.reset}
+${C.yellow}approve? (y/n): ${C.reset}`,
+        (answer) => {
+          const approved = answer.trim().toLowerCase() === "y";
+          console.log(
+            approved ? green(`  approved ${req.tool}`) : magenta(`  denied ${req.tool}`)
+          );
+          req.resolve(approved);
+        }
+      );
+    });
+  }
+  console.log(
+    gray(
+      `
+${metadata.agentName} | ${metadata.provider}/${metadata.model} | ${metadata.environment}`
+    )
+  );
+  console.log(gray('Type "exit" to quit, "/help" for commands'));
+  console.log(
+    gray("Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n")
+  );
+  const intro = await consumeFirstRunIntro(workingDir, {
+    agentName: metadata.agentName,
+    provider: metadata.provider,
+    model: metadata.model,
+    config
+  });
+  if (intro) {
+    console.log(green("assistant>"));
+    await streamTextAsTokens(intro);
+    stdout.write("\n\n");
+  }
+  let messages = intro ? [{ role: "assistant", content: intro }] : [];
+  let turn = 1;
+  let activeConversationId = null;
+  let showToolPayloads = false;
+  const prompt = `${C.cyan}you> ${C.reset}`;
+  while (true) {
+    let task;
+    try {
+      task = await ask(rl, prompt);
+    } catch {
+      break;
+    }
+    const trimmed = task.trim();
+    if (!trimmed) continue;
+    if (trimmed.toLowerCase() === "exit") break;
+    if (trimmed.startsWith("/")) {
+      if (trimmed.toLowerCase() === "/exit") break;
+      if (trimmed.toLowerCase() === "/tools") {
+        showToolPayloads = !showToolPayloads;
+        console.log(gray(`tool payloads: ${showToolPayloads ? "on" : "off"}`));
+        continue;
+      }
+      const interactiveState = {
+        messages,
+        turn,
+        activeConversationId
+      };
+      const slashResult = await handleSlash(
+        trimmed,
+        interactiveState,
+        conversationStore
+      );
+      if (slashResult.shouldExit) {
+        break;
+      }
+      messages = interactiveState.messages;
+      turn = interactiveState.turn;
+      activeConversationId = interactiveState.activeConversationId;
+      continue;
+    }
+    console.log(gray(`
+--- turn ${turn} ---`));
+    process.stdout.write(gray("thinking..."));
+    let thinkingCleared = false;
+    const clearThinking = () => {
+      if (thinkingCleared) return;
+      thinkingCleared = true;
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+    };
+    let responseText = "";
+    let streamedText = "";
+    let committedText = false;
+    let sawChunk = false;
+    let toolEvents = 0;
+    const toolTimeline = [];
+    const sections = [];
+    let currentText = "";
+    let currentTools = [];
+    let runFailed = false;
+    let usage;
+    let latestRunId = "";
+    const startedAt = Date.now();
+    try {
+      for await (const event of harness.run({
+        task: trimmed,
+        parameters: params,
+        messages
+      })) {
+        if (event.type === "run:started") {
+          latestRunId = event.runId;
+        }
+        if (event.type === "model:chunk") {
+          sawChunk = true;
+          if (currentTools.length > 0) {
+            sections.push({ type: "tools", content: currentTools });
+            currentTools = [];
+          }
+          responseText += event.content;
+          streamedText += event.content;
+          currentText += event.content;
+          if (!thinkingCleared) {
+            clearThinking();
+            process.stdout.write(`${C.green}assistant> ${C.reset}`);
+          }
+          process.stdout.write(event.content);
+        } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required" || event.type === "tool:approval:granted" || event.type === "tool:approval:denied") {
+          if (streamedText.length > 0) {
+            committedText = true;
+            streamedText = "";
+            process.stdout.write("\n");
+          }
+          clearThinking();
+          if (event.type === "tool:started") {
+            if (currentText.length > 0) {
+              sections.push({ type: "text", content: currentText });
+              currentText = "";
+            }
+            const preview = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+            console.log(yellow(`tools> start ${event.tool} input=${preview}`));
+            const toolText = `- start \`${event.tool}\``;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+            toolEvents += 1;
+          } else if (event.type === "tool:completed") {
+            const preview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+            console.log(
+              yellow(
+                `tools> done  ${event.tool} in ${formatDuration(event.duration)}`
+              )
+            );
+            if (showToolPayloads) {
+              console.log(yellow(`tools> output ${preview}`));
+            }
+            const toolText = `- done \`${event.tool}\` in ${formatDuration(event.duration)}`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:error") {
+            console.log(
+              red(`tools> error ${event.tool}: ${event.error}`)
+            );
+            const toolText = `- error \`${event.tool}\`: ${event.error}`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:approval:required") {
+            console.log(
+              magenta(`tools> approval required for ${event.tool}`)
+            );
+            const toolText = `- approval required \`${event.tool}\``;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:approval:granted") {
+            console.log(
+              gray(`tools> approval granted (${event.approvalId})`)
+            );
+            const toolText = `- approval granted (${event.approvalId})`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:approval:denied") {
+            console.log(
+              magenta(`tools> approval denied (${event.approvalId})`)
+            );
+            const toolText = `- approval denied (${event.approvalId})`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+        } else if (event.type === "run:error") {
+          clearThinking();
+          runFailed = true;
+          console.log(red(`error> ${event.error.message}`));
+        } else if (event.type === "model:response") {
+          usage = event.usage;
+        } else if (event.type === "run:completed" && !sawChunk) {
+          clearThinking();
+          responseText = event.result.response ?? "";
+          if (responseText.length > 0) {
+            process.stdout.write(
+              `${C.green}assistant> ${C.reset}${responseText}
+`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      clearThinking();
+      runFailed = true;
+      console.log(
+        red(
+          `error> ${error instanceof Error ? error.message : "Unknown error"}`
+        )
+      );
+    }
+    if (sawChunk && streamedText.length > 0) {
+      process.stdout.write("\n");
+    } else if (!sawChunk && !runFailed && responseText.length === 0) {
+      clearThinking();
+      console.log(green("assistant> (no response)"));
+    }
+    const fullResponse = responseText || streamedText;
+    if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+      console.log(
+        magenta(
+          "warning> assistant described tool execution but no real tool events occurred."
+        )
+      );
+    }
+    const durationMs = Date.now() - startedAt;
+    console.log(
+      gray(`meta> ${formatDuration(durationMs)} | tools: ${toolEvents}
+`)
+    );
+    if (!activeConversationId) {
+      const created = await conversationStore.create(
+        OWNER_ID,
+        inferConversationTitle(trimmed)
+      );
+      activeConversationId = created.conversationId;
+    }
+    if (currentTools.length > 0) {
+      sections.push({ type: "tools", content: currentTools });
+    }
+    if (currentText.length > 0) {
+      sections.push({ type: "text", content: currentText });
+    }
+    messages.push({ role: "user", content: trimmed });
+    messages.push({
+      role: "assistant",
+      content: responseText,
+      metadata: toolTimeline.length > 0 || sections.length > 0 ? {
+        toolActivity: toolTimeline,
+        sections: sections.length > 0 ? sections : void 0
+      } : void 0
+    });
+    turn = computeTurn(messages);
+    const conversation = await conversationStore.get(activeConversationId);
+    if (conversation) {
+      const maybeTitle = conversation.messages.length === 0 && (conversation.title === "New conversation" || conversation.title.trim().length === 0) ? inferConversationTitle(trimmed) : conversation.title;
+      await conversationStore.update({
+        ...conversation,
+        title: maybeTitle,
+        messages: [...messages],
+        runtimeRunId: latestRunId || conversation.runtimeRunId
+      });
+    }
+  }
+  rl.close();
+};
+export {
+  runInteractiveInk
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",
-    "url": "https://github.com/latitude-dev/poncho-ai.git",
+    "url": "https://github.com/cesr/poncho-ai.git",
     "directory": "packages/cli"
   },
   "publishConfig": {
@@ -26,8 +26,8 @@
     "react": "^19.2.4",
     "react-devtools-core": "^6.1.5",
     "yaml": "^2.8.1",
-    "@poncho-ai/harness": "0.7.1",
-    "@poncho-ai/sdk": "0.2.0"
+    "@poncho-ai/harness": "0.8.0",
+    "@poncho-ai/sdk": "0.3.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",

package/src/index.ts

@@ -15,6 +15,8 @@ import {
   LocalMcpBridge,
   TelemetryEmitter,
   createConversationStore,
+  ensureAgentIdentity,
+  generateAgentId,
   loadPonchoConfig,
   resolveStateConfig,
   type PonchoConfig,
@@ -201,9 +203,11 @@ const parseParams = (values: string[]): Record<string, string> => {
 
 const AGENT_TEMPLATE = (
   name: string,
+  id: string,
   options: { modelProvider: "anthropic" | "openai"; modelName: string },
 ): string => `---
 name: ${name}
+id: ${id}
 description: A helpful Poncho assistant
 model:
   provider: ${options.modelProvider}
@@ -727,6 +731,7 @@ export const initProject = async (
     interactive: false,
   };
   const onboarding = await runInitOnboarding(onboardingOptions);
+  const agentId = generateAgentId();
 
   const G = "\x1b[32m";
   const D = "\x1b[2m";
@@ -738,7 +743,13 @@ export const initProject = async (
   process.stdout.write("\n");
 
   const scaffoldFiles: Array<{ path: string; content: string }> = [
-    { path: "AGENT.md", content: AGENT_TEMPLATE(projectName, { modelProvider: onboarding.agentModel.provider, modelName: onboarding.agentModel.name }) },
+    {
+      path: "AGENT.md",
+      content: AGENT_TEMPLATE(projectName, agentId, {
+        modelProvider: onboarding.agentModel.provider,
+        modelName: onboarding.agentModel.name,
+      }),
+    },
     { path: "poncho.config.js", content: renderConfigFile(onboarding.config) },
     { path: "package.json", content: PACKAGE_TEMPLATE(projectName, projectDir) },
     { path: "README.md", content: README_TEMPLATE(projectName) },
@@ -935,7 +946,11 @@ export const createRequestHandler = async (options?: {
   });
   await harness.initialize();
   const telemetry = new TelemetryEmitter(config?.telemetry);
-  const conversationStore = createConversationStore(resolveStateConfig(config), { workingDir });
+  const identity = await ensureAgentIdentity(workingDir);
+  const conversationStore = createConversationStore(resolveStateConfig(config), {
+    workingDir,
+    agentId: identity.id,
+  });
   const sessionStore = new SessionStore();
   const loginRateLimiter = new LoginRateLimiter();
 
@@ -1688,6 +1703,7 @@ export const runInteractive = async (
     approvalHandler,
   });
   await harness.initialize();
+  const identity = await ensureAgentIdentity(workingDir);
   try {
     const { runInteractiveInk } = await import("./run-interactive-ink.js");
     await (
@@ -1704,7 +1720,10 @@ export const runInteractive = async (
       params,
       workingDir,
       config,
-      conversationStore: createConversationStore(resolveStateConfig(config), { workingDir }),
+      conversationStore: createConversationStore(resolveStateConfig(config), {
+        workingDir,
+        agentId: identity.id,
+      }),
       onSetApprovalCallback: (cb: (req: ApprovalRequest) => void) => {
         onApprovalRequest = cb;
         // If there's already a pending request, fire it immediately

package/src/init-feature-context.ts

@@ -1,8 +1,10 @@
-import { createHash } from "node:crypto";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import { basename, dirname, resolve } from "node:path";
-import { homedir } from "node:os";
-import type { PonchoConfig } from "@poncho-ai/harness";
+import { dirname, resolve } from "node:path";
+import {
+  ensureAgentIdentity,
+  getAgentStoreDirectory,
+  type PonchoConfig,
+} from "@poncho-ai/harness";
 import { resolveHarnessEnvironment } from "./index.js";
 
 type IntroInput = {
@@ -22,26 +24,6 @@ type OnboardingMarkerState = {
 
 const ONBOARDING_VERSION = 1;
 
-const getStateDirectory = (): string => {
-  const cwd = process.cwd();
-  const home = homedir();
-  const isServerless =
-    process.env.VERCEL === "1" ||
-    process.env.VERCEL_ENV !== undefined ||
-    process.env.VERCEL_URL !== undefined ||
-    process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined ||
-    process.env.AWS_EXECUTION_ENV?.includes("AWS_Lambda") === true ||
-    process.env.LAMBDA_TASK_ROOT !== undefined ||
-    process.env.NOW_REGION !== undefined ||
-    cwd.startsWith("/var/task") ||
-    home.startsWith("/var/task") ||
-    process.env.SERVERLESS === "1";
-  if (isServerless) {
-    return "/tmp/.poncho/state";
-  }
-  return resolve(homedir(), ".poncho", "state");
-};
-
 const summarizeConfig = (config: PonchoConfig | undefined): string[] => {
   const provider = config?.storage?.provider ?? config?.state?.provider ?? "local";
   const memoryEnabled = config?.storage?.memory?.enabled ?? config?.memory?.enabled ?? false;
@@ -55,19 +37,15 @@ const summarizeConfig = (config: PonchoConfig | undefined): string[] => {
   ];
 };
 
-const getOnboardingMarkerPath = (workingDir: string): string =>
-  resolve(
-    getStateDirectory(),
-    `${basename(workingDir).replace(/[^a-zA-Z0-9_-]+/g, "-") || "project"}-${createHash("sha256")
-      .update(workingDir)
-      .digest("hex")
-      .slice(0, 12)}-onboarding.json`,
-  );
+const getOnboardingMarkerPath = async (workingDir: string): Promise<string> => {
+  const identity = await ensureAgentIdentity(workingDir);
+  return resolve(getAgentStoreDirectory(identity), "onboarding-state.json");
+};
 
 const readMarker = async (
   workingDir: string,
 ): Promise<OnboardingMarkerState | undefined> => {
-  const markerPath = getOnboardingMarkerPath(workingDir);
+  const markerPath = await getOnboardingMarkerPath(workingDir);
   try {
     await access(markerPath);
   } catch {
@@ -85,7 +63,7 @@ const writeMarker = async (
   workingDir: string,
   state: OnboardingMarkerState,
 ): Promise<void> => {
-  const markerPath = getOnboardingMarkerPath(workingDir);
+  const markerPath = await getOnboardingMarkerPath(workingDir);
   await mkdir(dirname(markerPath), { recursive: true });
   await writeFile(markerPath, JSON.stringify(state, null, 2), "utf8");
 };