@chrysb/alphaclaw 0.4.6-beta.3 → 0.4.6-beta.4

package/lib/public/js/components/doctor/index.js

@@ -462,9 +462,8 @@ export const DoctorTab = ({ isActive = false, onOpenFile = () => {} }) => {
                 ? html`
                     <div class="ac-surface-inset rounded-xl p-4">
                       <div
-                        class="flex items-center gap-2 text-xs leading-5 text-gray-300"
+                        class="text-xs leading-5 text-gray-400"
                       >
-                        <${LoadingSpinner} className="h-3.5 w-3.5" />
                         <span
                           >Run in progress. Findings will appear when analysis
                           completes.</span

package/lib/public/js/components/general/use-general-tab.js

@@ -0,0 +1,233 @@
+import { useEffect, useState } from "https://esm.sh/preact/hooks";
+import {
+  approveDevice,
+  approvePairing,
+  fetchDashboardUrl,
+  fetchDevicePairings,
+  fetchPairings,
+  rejectDevice,
+  rejectPairing,
+  triggerWatchdogRepair,
+  updateSyncCron,
+} from "../../lib/api.js";
+import { usePolling } from "../../hooks/usePolling.js";
+import { showToast } from "../toast.js";
+import { ALL_CHANNELS } from "../channels.js";
+
+const kDefaultSyncCronSchedule = "0 * * * *";
+
+export const useGeneralTab = ({
+  statusData = null,
+  watchdogData = null,
+  doctorStatusData = null,
+  onRefreshStatuses = () => {},
+  isActive = false,
+  restartSignal = 0,
+} = {}) => {
+  const [dashboardLoading, setDashboardLoading] = useState(false);
+  const [repairingWatchdog, setRepairingWatchdog] = useState(false);
+  const [syncCronEnabled, setSyncCronEnabled] = useState(true);
+  const [syncCronSchedule, setSyncCronSchedule] = useState(kDefaultSyncCronSchedule);
+  const [savingSyncCron, setSavingSyncCron] = useState(false);
+  const [syncCronChoice, setSyncCronChoice] = useState(kDefaultSyncCronSchedule);
+
+  const status = statusData;
+  const watchdogStatus = watchdogData;
+  const doctorStatus = doctorStatusData;
+  const gatewayStatus = status?.gateway ?? null;
+  const channels = status?.channels ?? null;
+  const repo = status?.repo || null;
+  const syncCron = status?.syncCron || null;
+  const openclawVersion = status?.openclawVersion || null;
+
+  const hasUnpaired = ALL_CHANNELS.some((channel) => {
+    const info = channels?.[channel];
+    return info && info.status !== "paired";
+  });
+
+  const pairingsPoll = usePolling(
+    async () => {
+      const data = await fetchPairings();
+      return data.pending || [];
+    },
+    1000,
+    { enabled: hasUnpaired && gatewayStatus === "running" },
+  );
+  const pending = pairingsPoll.data || [];
+
+  const devicePoll = usePolling(
+    async () => {
+      const data = await fetchDevicePairings();
+      return data.pending || [];
+    },
+    2000,
+    { enabled: gatewayStatus === "running" },
+  );
+  const devicePending = devicePoll.data || [];
+
+  useEffect(() => {
+    if (!isActive) return;
+    onRefreshStatuses();
+    pairingsPoll.refresh();
+    devicePoll.refresh();
+  }, [devicePoll.refresh, isActive, onRefreshStatuses, pairingsPoll.refresh]);
+
+  useEffect(() => {
+    if (!restartSignal || !isActive) return;
+    onRefreshStatuses();
+    pairingsPoll.refresh();
+    devicePoll.refresh();
+    const t1 = setTimeout(() => {
+      onRefreshStatuses();
+      pairingsPoll.refresh();
+      devicePoll.refresh();
+    }, 1200);
+    const t2 = setTimeout(() => {
+      onRefreshStatuses();
+      pairingsPoll.refresh();
+      devicePoll.refresh();
+    }, 3500);
+    return () => {
+      clearTimeout(t1);
+      clearTimeout(t2);
+    };
+  }, [
+    devicePoll.refresh,
+    isActive,
+    onRefreshStatuses,
+    pairingsPoll.refresh,
+    restartSignal,
+  ]);
+
+  useEffect(() => {
+    if (!syncCron) return;
+    setSyncCronEnabled(syncCron.enabled !== false);
+    setSyncCronSchedule(syncCron.schedule || kDefaultSyncCronSchedule);
+    setSyncCronChoice(
+      syncCron.enabled === false ? "disabled" : syncCron.schedule || kDefaultSyncCronSchedule,
+    );
+  }, [syncCron?.enabled, syncCron?.schedule]);
+
+  const refreshAfterPairingAction = () => {
+    setTimeout(pairingsPoll.refresh, 500);
+    setTimeout(pairingsPoll.refresh, 2000);
+    setTimeout(onRefreshStatuses, 3000);
+  };
+
+  const saveSyncCronSettings = async ({
+    enabled = syncCronEnabled,
+    schedule = syncCronSchedule,
+  } = {}) => {
+    if (savingSyncCron) return;
+    setSavingSyncCron(true);
+    try {
+      const data = await updateSyncCron({ enabled, schedule });
+      if (!data.ok) {
+        throw new Error(data.error || "Could not save sync settings");
+      }
+      showToast("Sync schedule updated", "success");
+      onRefreshStatuses();
+    } catch (err) {
+      showToast(err.message || "Could not save sync settings", "error");
+    } finally {
+      setSavingSyncCron(false);
+    }
+  };
+
+  const handleSyncCronChoiceChange = async (nextChoice) => {
+    setSyncCronChoice(nextChoice);
+    const nextEnabled = nextChoice !== "disabled";
+    const nextSchedule = nextEnabled ? nextChoice : syncCronSchedule;
+    setSyncCronEnabled(nextEnabled);
+    setSyncCronSchedule(nextSchedule);
+    await saveSyncCronSettings({
+      enabled: nextEnabled,
+      schedule: nextSchedule,
+    });
+  };
+
+  const handleApprove = async (id, channel) => {
+    await approvePairing(id, channel);
+    refreshAfterPairingAction();
+  };
+
+  const handleReject = async (id, channel) => {
+    await rejectPairing(id, channel);
+    refreshAfterPairingAction();
+  };
+
+  const handleDeviceApprove = async (id) => {
+    await approveDevice(id);
+    setTimeout(devicePoll.refresh, 500);
+    setTimeout(devicePoll.refresh, 2000);
+  };
+
+  const handleDeviceReject = async (id) => {
+    await rejectDevice(id);
+    setTimeout(devicePoll.refresh, 500);
+    setTimeout(devicePoll.refresh, 2000);
+  };
+
+  const handleWatchdogRepair = async () => {
+    if (repairingWatchdog) return;
+    setRepairingWatchdog(true);
+    try {
+      const data = await triggerWatchdogRepair();
+      if (!data.ok) throw new Error(data.error || "Repair failed");
+      showToast("Repair triggered", "success");
+      setTimeout(() => {
+        onRefreshStatuses();
+      }, 800);
+    } catch (err) {
+      showToast(err.message || "Could not run repair", "error");
+    } finally {
+      setRepairingWatchdog(false);
+    }
+  };
+
+  const handleOpenDashboard = async () => {
+    if (dashboardLoading) return;
+    setDashboardLoading(true);
+    try {
+      const data = await fetchDashboardUrl();
+      console.log("[dashboard] response:", JSON.stringify(data));
+      window.open(data.url || "/openclaw", "_blank");
+    } catch (err) {
+      console.error("[dashboard] error:", err);
+      window.open("/openclaw", "_blank");
+    } finally {
+      setDashboardLoading(false);
+    }
+  };
+
+  return {
+    state: {
+      channels,
+      dashboardLoading,
+      devicePending,
+      doctorStatus,
+      gatewayStatus,
+      hasUnpaired,
+      openclawVersion,
+      pending,
+      repairingWatchdog,
+      repo,
+      savingSyncCron,
+      syncCron,
+      syncCronChoice,
+      syncCronEnabled,
+      syncCronSchedule,
+      syncCronStatusText: syncCronEnabled ? "Enabled" : "Disabled",
+      watchdogStatus,
+    },
+    actions: {
+      handleApprove,
+      handleDeviceApprove,
+      handleDeviceReject,
+      handleOpenDashboard,
+      handleReject,
+      handleSyncCronChoiceChange,
+      handleWatchdogRepair,
+    },
+  };
+};

package/lib/server/doctor/prompt.js

@@ -37,7 +37,9 @@ Important:
 - Return ONLY valid JSON. No markdown fences. No extra prose.
 
 OpenClaw context injection:
-- OpenClaw automatically injects ALL root-level \`.md\` files (e.g. AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, USER.md, HEARTBEAT.md) into the agent's context window as "project context" on every turn.
+- 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 default context:
@@ -106,6 +108,7 @@ ${renderResolvedCards(resolvedCards)}Constraints:
 - Do not re-suggest findings that appear in the "Previously resolved" list above
 - Do not create cards for healthy default-template behavior
 - Do not create cards whose primary recommendation is to refactor AlphaClaw-managed file structure
+- fixPrompt must only reference files the agent can edit. Never suggest editing files listed in "AlphaClaw locked/managed paths" above — they are managed by AlphaClaw, so manual edits would be lost.
 - If there are no meaningful findings, return an empty cards array
 - promptVersion: ${promptVersion}
 `.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.4.6-beta.3",
+  "version": "0.4.6-beta.4",
   "publishConfig": {
     "access": "public"
   },