@chrysb/alphaclaw 0.4.6-beta.6 → 0.4.6-beta.8

package/lib/public/js/components/webhooks.js

@@ -6,8 +6,10 @@ import {
   createWebhook,
   deleteWebhook,
   fetchWebhookDetail,
+  fetchWebhookRequest,
   fetchWebhookRequests,
   fetchWebhooks,
+  sendAgentMessage,
 } from "../lib/api.js";
 import {
   formatLocaleDateTime,
@@ -17,6 +19,7 @@ import { showToast } from "./toast.js";
 import { PageHeader } from "./page-header.js";
 import { ConfirmDialog } from "./confirm-dialog.js";
 import { ActionButton } from "./action-button.js";
+import { AgentSendModal } from "./agent-send-modal.js";
 import { ModalShell } from "./modal-shell.js";
 import { Badge } from "./badge.js";
 import { CloseIcon } from "./icons.js";
@@ -82,6 +85,40 @@ const jsonPretty = (value) => {
   }
 };
 
+const buildWebhookDebugMessage = ({
+  hookName = "",
+  webhook = null,
+  request = null,
+}) => {
+  const hookPath =
+    String(webhook?.path || "").trim() ||
+    (hookName ? `/hooks/${hookName}` : "/hooks/unknown");
+  const gatewayStatus =
+    request?.gatewayStatus == null ? "n/a" : String(request.gatewayStatus);
+  return [
+    "Investigate this failed webhook request and share findings before fixing anything.",
+    "Reply with your diagnosis first, including the likely root cause, any relevant risks, and what you would change if I approve a fix.",
+    "",
+    `Webhook: ${hookPath}`,
+    `Request ID: ${String(request?.id || "unknown")}`,
+    `Time: ${String(request?.createdAt || "unknown")}`,
+    `Method: ${String(request?.method || "unknown")}`,
+    `Source IP: ${String(request?.sourceIp || "unknown")}`,
+    `Gateway status: ${gatewayStatus}`,
+    `Transform path: ${String(webhook?.transformPath || "unknown")}`,
+    `Payload truncated: ${request?.payloadTruncated ? "yes" : "no"}`,
+    "",
+    "Headers:",
+    jsonPretty(request?.headers),
+    "",
+    "Payload:",
+    jsonPretty(request?.payload),
+    "",
+    "Gateway response:",
+    jsonPretty(request?.gatewayBody),
+  ].join("\n");
+};
+
 const CreateWebhookModal = ({
   visible,
   name,
@@ -197,6 +234,8 @@ export const Webhooks = ({
   const [expandedRows, setExpandedRows] = useState(() => new Set());
   const [sendingTestWebhook, setSendingTestWebhook] = useState(false);
   const [replayingRequestId, setReplayingRequestId] = useState(null);
+  const [debugLoadingRequestId, setDebugLoadingRequestId] = useState(null);
+  const [debugRequest, setDebugRequest] = useState(null);
 
   const listPoll = usePolling(fetchWebhooks, 15000);
   const webhooks = listPoll.data?.webhooks || [];
@@ -496,6 +535,31 @@ export const Webhooks = ({
   }, []);
 
   const isListLoading = !listPoll.data && !listPoll.error;
+  const debugAgentMessage = useMemo(
+    () =>
+      buildWebhookDebugMessage({
+        hookName: selectedHookName,
+        webhook: selectedWebhook,
+        request: debugRequest,
+      }),
+    [debugRequest, selectedHookName, selectedWebhook],
+  );
+
+  const handleAskAgentToDebug = useCallback(
+    async (item) => {
+      if (!selectedHookName || !item?.id || debugLoadingRequestId === item.id) return;
+      try {
+        setDebugLoadingRequestId(item.id);
+        const data = await fetchWebhookRequest(selectedHookName, item.id);
+        setDebugRequest(data?.request || item);
+      } catch (err) {
+        showToast(err.message || "Could not load webhook request details", "error");
+      } finally {
+        setDebugLoadingRequestId(null);
+      }
+    },
+    [debugLoadingRequestId, selectedHookName],
+  );
 
   return html`
     <div class="space-y-4">
@@ -841,7 +905,7 @@ export const Webhooks = ({
                                       >
 ${jsonPretty(item.headers)}</pre
                                       >
-                                      <div class="mt-2 flex justify-start">
+                                      <div class="mt-2 flex justify-start gap-2">
                                         <button
                                           class="h-7 text-xs px-2.5 rounded-lg ac-btn-secondary"
                                           onclick=${() =>
@@ -905,7 +969,7 @@ ${jsonPretty(item.payload)}</pre
                                       >
 ${jsonPretty(item.gatewayBody)}</pre
                                       >
-                                      <div class="mt-2 flex justify-start">
+                                      <div class="mt-2 flex justify-start gap-2">
                                         <button
                                           class="h-7 text-xs px-2.5 rounded-lg ac-btn-secondary"
                                           onclick=${() =>
@@ -916,6 +980,19 @@ ${jsonPretty(item.gatewayBody)}</pre
                                         >
                                           Copy
                                         </button>
+                                        ${item.status === "error"
+                                          ? html`<${ActionButton}
+                                              onClick=${() =>
+                                                handleAskAgentToDebug(item)}
+                                              loading=${debugLoadingRequestId ===
+                                              item.id}
+                                              tone="primary"
+                                              size="sm"
+                                              idleLabel="Ask agent to debug"
+                                              loadingLabel="Loading..."
+                                              className="h-7 px-2.5"
+                                            />`
+                                          : null}
                                       </div>
                                     </div>
                                   </div>
@@ -1058,6 +1135,30 @@ ${jsonPretty(item.gatewayBody)}</pre
         }}
         onConfirm=${handleDeleteConfirmed}
       />
+      <${AgentSendModal}
+        visible=${!!debugRequest}
+        title="Ask agent to debug"
+        messageLabel="Debug request"
+        messageRows=${12}
+        initialMessage=${debugAgentMessage}
+        resetKey=${String(debugRequest?.id || "")}
+        submitLabel="Send debug request"
+        loadingLabel="Sending..."
+        onClose=${() => setDebugRequest(null)}
+        onSubmit=${async ({ selectedSessionKey, message }) => {
+          try {
+            await sendAgentMessage({
+              message,
+              sessionKey: selectedSessionKey,
+            });
+            showToast("Debug request sent to agent", "success");
+            return true;
+          } catch (err) {
+            showToast(err.message || "Could not send debug request", "error");
+            return false;
+          }
+        }}
+      />
     </div>
   `;
 };

package/lib/server/constants.js

@@ -6,6 +6,7 @@ const { parsePositiveInt } = require("./utils/number");
 // Portable root directory: --root-dir flag sets ALPHACLAW_ROOT_DIR before require
 const kRootDir =
   process.env.ALPHACLAW_ROOT_DIR || path.join(os.homedir(), ".alphaclaw");
+const ALPHACLAW_DIR = kRootDir;
 const kPackageRoot = path.resolve(__dirname, "..");
 const kNpmPackageRoot = path.resolve(kPackageRoot, "..");
 const kSetupDir = path.join(kPackageRoot, "setup");
@@ -18,6 +19,8 @@ const OPENCLAW_DIR = path.join(kRootDir, ".openclaw");
 const GATEWAY_TOKEN = process.env.OPENCLAW_GATEWAY_TOKEN || "";
 const ENV_FILE_PATH = path.join(kRootDir, ".env");
 const WORKSPACE_DIR = path.join(OPENCLAW_DIR, "workspace");
+const kOnboardingMarkerPath = path.join(ALPHACLAW_DIR, "onboarded.json");
+const kControlUiSkillPath = path.join(OPENCLAW_DIR, "skills", "control-ui", "SKILL.md");
 const AUTH_PROFILES_PATH = path.join(
   OPENCLAW_DIR,
   "agents",
@@ -346,6 +349,7 @@ const SETUP_API_PREFIXES = [
 ];
 
 module.exports = {
+  ALPHACLAW_DIR,
   kRootDir,
   kPackageRoot,
   kNpmPackageRoot,
@@ -358,6 +362,8 @@ module.exports = {
   GATEWAY_TOKEN,
   ENV_FILE_PATH,
   WORKSPACE_DIR,
+  kOnboardingMarkerPath,
+  kControlUiSkillPath,
   AUTH_PROFILES_PATH,
   CODEX_PROFILE_ID,
   CODEX_OAUTH_CLIENT_ID,

package/lib/server/doctor/bootstrap-context.js

@@ -0,0 +1,191 @@
+const fs = require("fs");
+const path = require("path");
+
+const kDoctorBootstrapMaxChars = 20000;
+const kDoctorBootstrapTotalMaxChars = 150000;
+const kDoctorBootstrapNearLimitRatio = 0.9;
+const kDoctorContextTruncationGuidance =
+  "OpenClaw trims oversized injected files by keeping the first 70%, keeping the last 20%, and cutting the middle 10% without a warning.";
+
+const kDoctorRootContextFiles = [
+  { path: "AGENTS.md", injectMode: "always" },
+  { path: "SOUL.md", injectMode: "always" },
+  { path: "TOOLS.md", injectMode: "always" },
+  { path: "IDENTITY.md", injectMode: "always" },
+  { path: "USER.md", injectMode: "always" },
+  { path: "HEARTBEAT.md", injectMode: "always" },
+  { path: "BOOTSTRAP.md", injectMode: "first_run_only" },
+];
+
+const kDoctorBootstrapExtraFiles = [
+  { path: "hooks/bootstrap/AGENTS.md", injectMode: "always" },
+  { path: "hooks/bootstrap/TOOLS.md", injectMode: "always" },
+];
+
+const kDoctorBootstrapContextFiles = [...kDoctorRootContextFiles, ...kDoctorBootstrapExtraFiles];
+
+const readWorkspaceFileChars = (workspaceRoot, relativePath) => {
+  const fullPath = path.join(workspaceRoot, relativePath);
+  try {
+    const content = fs.readFileSync(fullPath, "utf8");
+    return {
+      exists: true,
+      chars: content.length,
+    };
+  } catch {
+    return {
+      exists: false,
+      chars: 0,
+    };
+  }
+};
+
+const analyzeBootstrapContext = ({
+  workspaceRoot = "",
+  bootstrapMaxChars = kDoctorBootstrapMaxChars,
+  bootstrapTotalMaxChars = kDoctorBootstrapTotalMaxChars,
+} = {}) => {
+  const files = kDoctorBootstrapContextFiles.map((spec) => {
+    const fileState = readWorkspaceFileChars(workspaceRoot, spec.path);
+    const rawChars = fileState.chars;
+    const fileLimitChars = Math.min(rawChars, bootstrapMaxChars);
+    const nearFileLimit = rawChars > 0 && rawChars >= Math.floor(bootstrapMaxChars * kDoctorBootstrapNearLimitRatio);
+    return {
+      ...spec,
+      exists: fileState.exists,
+      rawChars,
+      fileLimitChars,
+      injectedChars: 0,
+      truncatedByFileLimit: rawChars > bootstrapMaxChars,
+      truncatedByTotalLimit: false,
+      truncated: rawChars > bootstrapMaxChars,
+      nearFileLimit: nearFileLimit && rawChars <= bootstrapMaxChars,
+      active: spec.injectMode === "always",
+      reason: rawChars > bootstrapMaxChars ? "file_limit" : "",
+    };
+  });
+
+  let injectedTotalChars = 0;
+  for (const file of files) {
+    if (!file.active || !file.exists) continue;
+    const remainingChars = Math.max(0, bootstrapTotalMaxChars - injectedTotalChars);
+    file.injectedChars = Math.min(file.fileLimitChars, remainingChars);
+    file.truncatedByTotalLimit = file.fileLimitChars > file.injectedChars;
+    file.truncated = file.truncatedByFileLimit || file.truncatedByTotalLimit;
+    if (file.truncatedByFileLimit && file.truncatedByTotalLimit) {
+      file.reason = "file_and_total_limit";
+    } else if (file.truncatedByFileLimit) {
+      file.reason = "file_limit";
+    } else if (file.truncatedByTotalLimit) {
+      file.reason = "total_limit";
+    }
+    injectedTotalChars += file.injectedChars;
+  }
+
+  const activeFiles = files.filter((file) => file.active && file.exists);
+  const activeTruncatedFiles = activeFiles.filter((file) => file.truncated);
+  const activeNearLimitFiles = activeFiles.filter((file) => file.nearFileLimit && !file.truncated);
+  const inactiveTruncatedFiles = files.filter((file) => !file.active && file.exists && file.truncated);
+  const hasTotalLimitTruncation = activeTruncatedFiles.some(
+    (file) => file.reason === "total_limit" || file.reason === "file_and_total_limit",
+  );
+
+  return {
+    bootstrapMaxChars,
+    bootstrapTotalMaxChars,
+    truncationGuidance: kDoctorContextTruncationGuidance,
+    files,
+    activeFiles,
+    activeRawChars: activeFiles.reduce((sum, file) => sum + file.rawChars, 0),
+    activeInjectedChars: activeFiles.reduce((sum, file) => sum + file.injectedChars, 0),
+    hasActiveTruncation: activeTruncatedFiles.length > 0,
+    hasActiveNearLimitFiles: activeNearLimitFiles.length > 0,
+    hasActiveWarnings: activeTruncatedFiles.length > 0 || activeNearLimitFiles.length > 0,
+    hasAnyTruncation: activeTruncatedFiles.length > 0 || inactiveTruncatedFiles.length > 0,
+    activeTruncatedFiles,
+    activeNearLimitFiles,
+    inactiveTruncatedFiles,
+    hasTotalLimitTruncation,
+    totalLimitReached: injectedTotalChars >= bootstrapTotalMaxChars,
+  };
+};
+
+const formatChars = (value = 0) => `${Number(value || 0).toLocaleString()} chars`;
+
+const buildBootstrapTruncationCards = (bootstrapContext = null) => {
+  if (!bootstrapContext?.hasActiveTruncation) return [];
+
+  const cards = bootstrapContext.activeTruncatedFiles
+    .filter((file) => file.reason === "file_limit")
+    .map((file) => ({
+      priority: "P0",
+      category: "project context",
+      title: `${file.path} is being truncated in Project Context`,
+      summary:
+        `${file.path} is ${formatChars(file.rawChars)}, above the per-file Project Context limit ` +
+        `of ${formatChars(bootstrapContext.bootstrapMaxChars)}. The agent is not seeing the full file.`,
+      recommendation:
+        `Move the most important rules to the top of ${file.path}, shorten or split low-priority content, ` +
+        `and increase OpenClaw's bootstrap limits if this file legitimately needs more room. ` +
+        kDoctorContextTruncationGuidance,
+      evidence: [
+        { type: "path", path: file.path },
+        {
+          type: "text",
+          text:
+            `Raw size: ${formatChars(file.rawChars)}. ` +
+            `Per-file limit: ${formatChars(bootstrapContext.bootstrapMaxChars)}.`,
+        },
+      ],
+      targetPaths: [{ path: file.path }],
+      fixPrompt:
+        `Reorganize ${file.path} so the most important instructions appear at the top and reduce unnecessary length. ` +
+        `Do not change unrelated behavior.`,
+      status: "open",
+    }));
+
+  const totalLimitedFiles = bootstrapContext.activeTruncatedFiles.filter(
+    (file) => file.reason === "total_limit" || file.reason === "file_and_total_limit",
+  );
+  if (totalLimitedFiles.length > 0) {
+    cards.unshift({
+      priority: "P0",
+      category: "project context",
+      title: "Project Context total bootstrap limit is truncating injected files",
+      summary:
+        `Injected workspace guidance needs ${formatChars(bootstrapContext.activeRawChars)} raw across active ` +
+        `Project Context files, exceeding the total bootstrap budget of ` +
+        `${formatChars(bootstrapContext.bootstrapTotalMaxChars)}.`,
+      recommendation:
+        `Reduce total Project Context size across injected guidance files, keep critical instructions near the top, ` +
+        `and raise OpenClaw's total bootstrap budget if the workspace legitimately needs more injected guidance. ` +
+        kDoctorContextTruncationGuidance,
+      evidence: totalLimitedFiles.map((file) => ({
+        type: "text",
+        text:
+          `${file.path}: raw ${formatChars(file.rawChars)}, injected ${formatChars(file.injectedChars)} ` +
+          `before the total limit stopped more content from being included.`,
+      })),
+      targetPaths: totalLimitedFiles.map((file) => ({ path: file.path })),
+      fixPrompt:
+        `Reduce the combined size of the affected Project Context files and keep the most important instructions near the top. ` +
+        `Only edit the files listed in the finding.`,
+      status: "open",
+    });
+  }
+
+  return cards;
+};
+
+module.exports = {
+  analyzeBootstrapContext,
+  buildBootstrapTruncationCards,
+  formatChars,
+  kDoctorBootstrapContextFiles,
+  kDoctorBootstrapExtraFiles,
+  kDoctorBootstrapMaxChars,
+  kDoctorBootstrapNearLimitRatio,
+  kDoctorBootstrapTotalMaxChars,
+  kDoctorContextTruncationGuidance,
+  kDoctorRootContextFiles,
+};

package/lib/server/doctor/prompt.js

@@ -1,6 +1,17 @@
+const {
+  kDoctorBootstrapExtraFiles,
+  kDoctorBootstrapMaxChars,
+  kDoctorBootstrapTotalMaxChars,
+  kDoctorContextTruncationGuidance,
+  kDoctorRootContextFiles,
+} = require("./bootstrap-context");
+
 const renderList = (items = []) =>
   items.length ? items.map((item) => `- ${item}`).join("\n") : "- (none)";
 
+const renderContextFileList = (files = []) =>
+  files.map((file) => `\`${file.path}\``).join(", ");
+
 const renderResolvedCards = (cards = []) => {
   if (!cards.length) return "";
   const lines = cards.map(
@@ -37,10 +48,15 @@ Important:
 - Return ONLY valid JSON. No markdown fences. No extra prose.
 
 OpenClaw context injection:
-- OpenClaw automatically injects a fixed set of named workspace files into the agent's context window ("Project Context") on every turn. The exact set is: \`AGENTS.md\`, \`SOUL.md\`, \`TOOLS.md\`, \`IDENTITY.md\`, \`USER.md\`, \`HEARTBEAT.md\`, and \`BOOTSTRAP.md\` (first-run only).
-- Only these specific files are auto-injected. Other \`.md\` files at the workspace root (e.g. INTERESTS.md, MEMORY.md, README.md) are NOT injected and must be explicitly read by the agent.
-- Do not flag auto-injected files as orphaned or unreferenced — they are loaded by the runtime, not by explicit file references in AGENTS.md.
-- Additionally, AlphaClaw injects bootstrap files from \`hooks/bootstrap/\` (e.g. AGENTS.md, TOOLS.md) as extra context on every turn.
+- OpenClaw automatically injects these workspace files into the agent's Project Context: ${renderContextFileList(
+    kDoctorRootContextFiles,
+  )}.
+- \`BOOTSTRAP.md\` is first-run only; the others above are injected on normal turns when present.
+- Additionally, AlphaClaw injects these extra bootstrap files on normal turns when present: ${renderContextFileList(
+    kDoctorBootstrapExtraFiles,
+  )}.
+- Large injected files are truncated per-file at ${kDoctorBootstrapMaxChars} chars by default, and total bootstrap injection across files is capped at ${kDoctorBootstrapTotalMaxChars} chars by default.
+- ${kDoctorContextTruncationGuidance}
 
 OpenClaw default context:
 - \`AGENTS.md\` is the workspace home file in the default OpenClaw template. It may intentionally include first-run instructions, session-startup guidance, memory conventions, safety rules, tool pointers, and optional behavioral guidance.

package/lib/server/doctor/service.js

@@ -1,5 +1,9 @@
 const fs = require("fs");
 const path = require("path");
+const {
+  analyzeBootstrapContext,
+  buildBootstrapTruncationCards,
+} = require("./bootstrap-context");
 const { buildDoctorPrompt } = require("./prompt");
 const { normalizeDoctorResult } = require("./normalize");
 const { calculateWorkspaceDelta, computeWorkspaceSnapshot } = require("./workspace-fingerprint");
@@ -137,6 +141,7 @@ const createDoctorService = ({
   };
 
   const buildStatus = () => {
+    const bootstrapContext = analyzeBootstrapContext({ workspaceRoot });
     const recentRuns = listDoctorRuns({ limit: 10 });
     const latestRun = recentRuns[0] || null;
     const latestCompletedRun =
@@ -179,6 +184,7 @@ const createDoctorService = ({
       lastRunAgeMs,
       needsInitialRun: !latestCompletedRun,
       stale,
+      bootstrapContext,
       changeSummary: {
         ...delta,
         hasBaseline: hasManifestBaseline,
@@ -245,10 +251,14 @@ const createDoctorService = ({
         console.error(`[doctor] run ${runId} stderr end`);
         throw error;
       }
-      captureEvidenceSnippets(normalizedResult.cards, workspaceRoot);
+      const bootstrapTruncationCards = buildBootstrapTruncationCards(
+        analyzeBootstrapContext({ workspaceRoot }),
+      );
+      const cards = [...bootstrapTruncationCards, ...normalizedResult.cards];
+      captureEvidenceSnippets(cards, workspaceRoot);
       insertDoctorCards({
         runId,
-        cards: normalizedResult.cards,
+        cards,
       });
       completeDoctorRun({
         id: runId,
@@ -342,7 +352,11 @@ const createDoctorService = ({
       throw new Error("Doctor import requires raw output");
     }
     const normalizedResult = normalizeDoctorResult(normalizedRawOutput);
-    captureEvidenceSnippets(normalizedResult.cards, workspaceRoot);
+    const bootstrapTruncationCards = buildBootstrapTruncationCards(
+      analyzeBootstrapContext({ workspaceRoot }),
+    );
+    const cards = [...bootstrapTruncationCards, ...normalizedResult.cards];
+    captureEvidenceSnippets(cards, workspaceRoot);
     const workspaceSnapshot = getCurrentWorkspaceSnapshot();
     const runId = createDoctorRun({
       status: kDoctorRunStatus.completed,
@@ -354,7 +368,7 @@ const createDoctorService = ({
     });
     insertDoctorCards({
       runId,
-      cards: normalizedResult.cards,
+      cards,
     });
     completeDoctorRun({
       id: runId,

package/lib/server/gateway.js

@@ -1,3 +1,4 @@
+const path = require("path");
 const { spawn, execSync } = require("child_process");
 const fs = require("fs");
 const net = require("net");
@@ -5,7 +6,9 @@ const {
   OPENCLAW_DIR,
   GATEWAY_HOST,
   GATEWAY_PORT,
+  kControlUiSkillPath,
   kChannelDefs,
+  kOnboardingMarkerPath,
   kRootDir,
 } = require("./constants");
 
@@ -45,7 +48,7 @@ const gatewayEnv = () => ({
   XDG_CONFIG_HOME: OPENCLAW_DIR,
 });
 
-const isOnboarded = () => {
+const hasOnboardingModelConfig = () => {
   const configPath = `${OPENCLAW_DIR}/openclaw.json`;
   if (!fs.existsSync(configPath)) return false;
   try {
@@ -59,6 +62,43 @@ const isOnboarded = () => {
   }
 };
 
+const hasLegacyOnboardingArtifacts = () => fs.existsSync(kControlUiSkillPath);
+
+const writeOnboardingMarker = (reason) => {
+  try {
+    fs.mkdirSync(path.dirname(kOnboardingMarkerPath), { recursive: true });
+    fs.writeFileSync(
+      kOnboardingMarkerPath,
+      JSON.stringify(
+        {
+          onboarded: true,
+          reason: String(reason || "unknown"),
+          markedAt: new Date().toISOString(),
+        },
+        null,
+        2,
+      ),
+    );
+    return true;
+  } catch (err) {
+    console.error(`[alphaclaw] Failed to write onboarding marker: ${err.message}`);
+    return false;
+  }
+};
+
+const isOnboarded = () => {
+  if (fs.existsSync(kOnboardingMarkerPath)) return true;
+  if (hasOnboardingModelConfig()) {
+    writeOnboardingMarker("config_primary_model");
+    return true;
+  }
+  if (hasLegacyOnboardingArtifacts()) {
+    writeOnboardingMarker("legacy_artifact_backfill");
+    return true;
+  }
+  return false;
+};
+
 const isGatewayRunning = () =>
   new Promise((resolve) => {
     const sock = net.createConnection(GATEWAY_PORT, GATEWAY_HOST);

package/lib/server/gmail-watch.js

@@ -70,19 +70,22 @@ const ensureTopicPathForClient = ({
   const normalizedClient = String(client || "default").trim() || "default";
   const push = getGmailPushConfig(state);
   const existingTopic = String(push.topics?.[normalizedClient] || "").trim();
-  if (existingTopic) {
+  const requestedProjectId = String(projectIdOverride || "").trim();
+  const existingProjectId = parseProjectIdFromTopicPath(existingTopic);
+  if (existingTopic && (!requestedProjectId || requestedProjectId === existingProjectId)) {
     return { state, topicPath: existingTopic };
   }
   const credentials = readGoogleCredentials(normalizedClient);
   const projectId =
-    String(projectIdOverride || "").trim() ||
+    requestedProjectId ||
     String(credentials?.projectId || "").trim();
   if (!projectId) {
     throw new Error(
       `Could not detect GCP project_id for client "${normalizedClient}". Save Google credentials first.`,
     );
   }
-  const topicName = createTopicNameForClient(normalizedClient);
+  const topicName =
+    parseTopicName(existingTopic) || createTopicNameForClient(normalizedClient);
   const topicPath = `projects/${projectId}/topics/${topicName}`;
   const updated = setGmailPushConfig({
     state,

package/lib/server/onboarding/index.js

@@ -34,7 +34,7 @@ const createOnboardingService = ({
   getBaseUrl,
   startGateway,
 }) => {
-  const { OPENCLAW_DIR, WORKSPACE_DIR } = constants;
+  const { OPENCLAW_DIR, WORKSPACE_DIR, kOnboardingMarkerPath } = constants;
 
   const verifyGithubSetup = async ({
     githubRepoInput,
@@ -160,6 +160,19 @@ const createOnboardingService = ({
 
     installHourlyGitSyncScript({ fs, openclawDir: OPENCLAW_DIR });
     await installHourlyGitSyncCron({ fs, openclawDir: OPENCLAW_DIR });
+    fs.mkdirSync(path.dirname(kOnboardingMarkerPath), { recursive: true });
+    fs.writeFileSync(
+      kOnboardingMarkerPath,
+      JSON.stringify(
+        {
+          onboarded: true,
+          reason: "onboarding_complete",
+          markedAt: new Date().toISOString(),
+        },
+        null,
+        2,
+      ),
+    );
 
     try {
       await shellCmd(`alphaclaw git-sync -m "initial setup"`, {