va-claw 0.1.3 → 0.2.0

package/dist/va-claw-bundle.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // packages/cli/dist/deps.js
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 import { readFile as readFile4 } from "node:fs/promises";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
@@ -28,11 +28,13 @@ import { dirname } from "node:path";
 
 // packages/identity/dist/defaults.js
 var DEFAULT_LOOP_INTERVAL = "0 * * * *";
+var DEFAULT_WAKE_TIMEOUT_MS = 3e5;
 var DEFAULT_CONFIG = {
   name: "va-claw",
   persona: "A pragmatic CLI identity that values clarity, rigor, and continuity.",
   systemPrompt: "You are va-claw. Be direct, honest about uncertainty, and keep actions aligned with the saved identity.",
   wakePrompt: "Wake up, load the saved identity, and continue from the most recent remembered state.",
+  wakeTimeoutMs: DEFAULT_WAKE_TIMEOUT_MS,
   loopInterval: DEFAULT_LOOP_INTERVAL,
   channels: {
     discord: {
@@ -58,6 +60,9 @@ function pickString(value, fallback) {
 function pickBoolean(value, fallback) {
   return typeof value === "boolean" ? value : fallback;
 }
+function pickNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
 function getDefaultIdentity() {
   return { ...DEFAULT_CONFIG };
 }
@@ -73,6 +78,7 @@ function normalizeConfig(input) {
     persona: pickString(Reflect.get(data, "persona"), base.persona),
     systemPrompt: pickString(Reflect.get(data, "systemPrompt"), base.systemPrompt),
     wakePrompt: pickString(Reflect.get(data, "wakePrompt"), base.wakePrompt),
+    wakeTimeoutMs: pickNumber(Reflect.get(data, "wakeTimeoutMs"), base.wakeTimeoutMs ?? DEFAULT_WAKE_TIMEOUT_MS),
     loopInterval: pickString(Reflect.get(data, "loopInterval"), base.loopInterval),
     channels: {
       discord: {
@@ -136,6 +142,19 @@ function toClaudeMdSnippet(config) {
     normalized.persona,
     "",
     textBlock("System Prompt:", normalized.systemPrompt),
+    "",
+    "Operational protocol:",
+    "- Check long-running claw status with `va-claw protocol`.",
+    "- For readable text use `va-claw protocol --text`.",
+    "- Manage claws with `va-claw claw list | add | set | remove | heartbeat`.",
+    '- If asked "va/claw \u5728\u5E72\u4EC0\u4E48" / "my claws are doing what" / similar fleet questions, call `va-claw protocol --text` and answer from it.',
+    '- If the user asks a non-technical phrasing like "\u73B0\u5728\u90FD\u5728\u5E72\u561B", interpret it as a fleet status request and run `va-claw protocol --text`.',
+    "",
+    "Memory protocol:",
+    '- At session start, run `va-claw memory recall "<current topic or task>"` before answering.',
+    '- After important work, run `va-claw memory memorize "<key>" "<essence>" --tags <tags> --importance <0.0-1.0>`.',
+    "- Use importance `0.8-1.0` for decisions or hard-won knowledge; use `0.5` for routine outputs.",
+    "- Do not memorize every message; store only things worth remembering across sessions.",
     "<!-- va-claw:identity:end -->"
   ].join("\n");
 }
@@ -151,7 +170,21 @@ function toCodexSystemPrompt(config) {
     "Wake prompt:",
     normalized.wakePrompt,
     "",
-    `Loop interval: ${normalized.loopInterval}`
+    `Wake timeout (ms): ${normalized.wakeTimeoutMs ?? 3e5}`,
+    "",
+    `Loop interval: ${normalized.loopInterval}`,
+    "",
+    "Operational protocol:",
+    "Use `va-claw protocol` in terminal to get long-running claw state.",
+    'Use `va-claw protocol --text` when a user asks in plain language, including Chinese phrases like "va/claw \u5728\u5E72\u4EC0\u4E48".',
+    "Use `va-claw claw list` and `va-claw claw set <name> --status <status>` to manage claws.",
+    "If the user asks what claws are doing, run `va-claw protocol --text` and summarize only from that output.",
+    "",
+    "Memory protocol:",
+    'At session start, run `va-claw memory recall "<current topic or task>"` before answering.',
+    'After important work, run `va-claw memory memorize "<key>" "<essence>" --tags <tags> --importance <0.0-1.0>`.',
+    "Use importance `0.8-1.0` for decisions or hard-won knowledge; use `0.5` for routine outputs.",
+    "Do not memorize every message; store only things worth remembering across sessions."
   ].join("\n");
 }
 
@@ -924,7 +957,10 @@ var E = class {
 };
 
 // packages/daemon/dist/wake-cycle.js
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawn } from "node:child_process";
+import { appendFile, mkdir as mkdir3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, resolve as resolve3 } from "node:path";
 
 // packages/memory/dist/default-store.js
 import { homedir as homedir2 } from "node:os";
@@ -1861,46 +1897,211 @@ function looksLikePath(value) {
 
 // packages/daemon/dist/wake-cycle.js
 var DEFAULT_WARN2 = (message) => console.warn(message);
+var DEFAULT_WAKE_TIMEOUT_MS2 = 3e5;
+var OUTPUT_TAIL_LIMIT = 2e3;
+var OUTPUT_BUFFER_LIMIT = 10 * 1024 * 1024;
+var wakeRunning = false;
 async function runWakeCycle(config, deps = {}) {
-  const adapter = await (deps.detect ?? detectCliAdapter)({ warn: deps.warn });
-  if (!adapter) {
+  if (wakeRunning) {
+    (deps.warn ?? DEFAULT_WARN2)("[va-claw/daemon] skipping wake: previous wake still running");
     return null;
   }
-  const prompt = await resolveWakePrompt(config, deps);
-  const spawnOptions = {
-    cwd: process.cwd(),
-    encoding: "utf8",
-    env: {
-      ...readProcessEnv(),
-      CLAUDECODE: void 0,
-      CLAUDE_CODE_SESSION: void 0
-    },
-    maxBuffer: 10 * 1024 * 1024
-  };
-  const result = (deps.spawn ?? spawnSync2)(adapter.command, [...adapter.args, prompt], spawnOptions);
-  if (result.status !== 0) {
-    (deps.warn ?? DEFAULT_WARN2)(`[va-claw/daemon] ${adapter.name} wake failed: ${readStderr(result.stderr)}`);
+  wakeRunning = true;
+  try {
+    return await _runWakeCycleInner(config, deps);
+  } finally {
+    wakeRunning = false;
+  }
+}
+async function _runWakeCycleInner(config, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const startedAt = now();
+  let combinedOutput = "";
+  try {
+    const adapter = await (deps.detect ?? detectCliAdapter)({ warn: deps.warn });
+    if (!adapter) {
+      return null;
+    }
+    const prompt = await resolveWakePrompt(config, deps);
+    const timeoutMs = resolveWakeTimeoutMs(config);
+    const wakeArgs = [...adapter.args, prompt];
+    const wakeOptions = {
+      cwd: process.cwd(),
+      env: {
+        ...readProcessEnv(),
+        CLAUDECODE: void 0,
+        CLAUDE_CODE_SESSION: void 0
+      }
+    };
+    const result = await (deps.executeWake ?? executeWakeProcess)(adapter.command, wakeArgs, wakeOptions, timeoutMs);
+    combinedOutput = result.combinedOutput;
+    const finishedAt = now();
+    const durationMs = finishedAt.getTime() - startedAt.getTime();
+    if (result.exitCode !== 0) {
+      await writeWakeLogSafe({
+        ts: startedAt.toISOString(),
+        duration_ms: Math.max(0, durationMs),
+        exit_code: result.exitCode,
+        output_tail: tailOutput(result.combinedOutput)
+      }, deps);
+      (deps.warn ?? DEFAULT_WARN2)(result.exitCode === "timeout" ? `[va-claw/daemon] ${adapter.name} wake timed out after ${timeoutMs}ms.` : `[va-claw/daemon] ${adapter.name} wake failed: ${readFailureOutput(result.stderr, result.combinedOutput)}`);
+      return null;
+    }
+    await (deps.storeMemory ?? store)(result.stdout, {
+      source: "va-claw-daemon",
+      kind: "wake",
+      cli: adapter.name,
+      identity: config.name,
+      wokeAt: finishedAt.toISOString()
+    });
+    await writeWakeLogSafe({
+      ts: startedAt.toISOString(),
+      duration_ms: Math.max(0, durationMs),
+      exit_code: 0,
+      output_tail: tailOutput(result.combinedOutput)
+    }, deps);
+    return finishedAt;
+  } catch (error) {
+    const failedAt = now();
+    await writeWakeLogSafe({
+      ts: startedAt.toISOString(),
+      duration_ms: Math.max(0, failedAt.getTime() - startedAt.getTime()),
+      exit_code: "crash",
+      output_tail: tailOutput(combinedOutput)
+    }, deps);
+    (deps.warn ?? DEFAULT_WARN2)(`[va-claw/daemon] wake crashed: ${String(error)}`);
     return null;
   }
-  const wokeAt = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
-  await (deps.storeMemory ?? store)(result.stdout ?? "", {
-    source: "va-claw-daemon",
-    kind: "wake",
-    cli: adapter.name,
-    identity: config.name,
-    wokeAt: wokeAt.toISOString()
-  });
-  return wokeAt;
 }
-function readStderr(stderr) {
-  if (typeof stderr === "string" && stderr.trim() !== "") {
-    return stderr.trim();
+async function executeWakeProcess(command, args, options, timeoutMs) {
+  let child;
+  try {
+    child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    return {
+      combinedOutput: String(error),
+      exitCode: "spawn_error",
+      stderr: String(error),
+      stdout: ""
+    };
   }
-  return "unknown error";
+  let stdout2 = "";
+  let stderr = "";
+  let combinedOutput = "";
+  let settled = false;
+  let combinedSize = 0;
+  let stdoutSize = 0;
+  let stderrSize = 0;
+  child.stdout.on("data", (chunk) => {
+    const text2 = String(chunk);
+    if (stdoutSize < OUTPUT_BUFFER_LIMIT) {
+      stdout2 += text2;
+      stdoutSize += text2.length;
+    }
+    if (combinedSize < OUTPUT_BUFFER_LIMIT) {
+      combinedOutput += text2;
+      combinedSize += text2.length;
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    const text2 = String(chunk);
+    if (stderrSize < OUTPUT_BUFFER_LIMIT) {
+      stderr += text2;
+      stderrSize += text2.length;
+    }
+    if (combinedSize < OUTPUT_BUFFER_LIMIT) {
+      combinedOutput += text2;
+      combinedSize += text2.length;
+    }
+  });
+  return await new Promise((resolve5) => {
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      child.kill("SIGTERM");
+      const killTimer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+      const timeoutResult = {
+        combinedOutput,
+        exitCode: "timeout",
+        stderr,
+        stdout: stdout2
+      };
+      child.once("close", () => {
+        clearTimeout(killTimer);
+        resolve5(timeoutResult);
+      });
+    }, timeoutMs);
+    child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      const message = String(error);
+      stderr = stderr === "" ? message : `${stderr}
+${message}`;
+      combinedOutput += message;
+      resolve5({
+        combinedOutput,
+        exitCode: "spawn_error",
+        stderr,
+        stdout: stdout2
+      });
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve5({
+        combinedOutput,
+        exitCode: typeof code === "number" ? code : 1,
+        stderr,
+        stdout: stdout2
+      });
+    });
+  });
 }
 function readProcessEnv() {
   return process.env ?? {};
 }
+function readFailureOutput(stderr, combinedOutput) {
+  const candidate = stderr.trim() !== "" ? stderr : combinedOutput;
+  const text2 = candidate.trim();
+  return text2 === "" ? "unknown error" : tailOutput(text2, 200);
+}
+function resolveWakeTimeoutMs(config) {
+  return typeof config.wakeTimeoutMs === "number" && Number.isFinite(config.wakeTimeoutMs) && config.wakeTimeoutMs > 0 ? config.wakeTimeoutMs : DEFAULT_WAKE_TIMEOUT_MS2;
+}
+function tailOutput(text2, limit = OUTPUT_TAIL_LIMIT) {
+  return text2.length <= limit ? text2 : text2.slice(-limit);
+}
+async function writeWakeLogSafe(entry, deps) {
+  try {
+    await (deps.writeWakeLog ?? writeWakeLog)(entry);
+  } catch (error) {
+    (deps.warn ?? DEFAULT_WARN2)(`[va-claw/daemon] failed to write wake.log: ${String(error)}`);
+  }
+}
+async function writeWakeLog(entry) {
+  const logPath = resolve3(homedir4(), ".va-claw", "wake.log");
+  await mkdir3(dirname3(logPath), { recursive: true });
+  await appendFile(logPath, `${JSON.stringify(entry)}
+`, "utf8");
+}
 async function resolveWakePrompt(config, deps) {
   try {
     const skills = await (deps.listSkills ?? listSkills)();
@@ -1970,29 +2171,29 @@ async function getDaemonStatus() {
 }
 
 // packages/daemon/dist/service.js
-import { mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname4 } from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { mkdir as mkdir4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
 
 // packages/daemon/dist/service-files.js
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, join as join4, resolve as resolve3 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join4, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function createServiceDefinition(type) {
-  const packageRoot = resolve3(dirname3(fileURLToPath(import.meta.url)), "..");
-  const repoRoot = resolve3(packageRoot, "../..");
+  const packageRoot = resolve4(dirname4(fileURLToPath(import.meta.url)), "..");
+  const repoRoot = resolve4(packageRoot, "../..");
   const runnerPath = join4(packageRoot, "dist", "runner.js");
   const nodePath = process.execPath;
   if (type === "launchd") {
     return {
-      path: join4(homedir4(), "Library", "LaunchAgents", "com.va-claw.daemon.plist"),
+      path: join4(homedir5(), "Library", "LaunchAgents", "com.va-claw.daemon.plist"),
       content: renderLaunchdPlist(repoRoot, [nodePath, runnerPath]),
       command: "launchctl",
-      args: ["load", join4(homedir4(), "Library", "LaunchAgents", "com.va-claw.daemon.plist")]
+      args: ["load", join4(homedir5(), "Library", "LaunchAgents", "com.va-claw.daemon.plist")]
     };
   }
   return {
-    path: join4(homedir4(), ".config", "systemd", "user", "va-claw.service"),
+    path: join4(homedir5(), ".config", "systemd", "user", "va-claw.service"),
     content: renderSystemdUnit(repoRoot, [nodePath, runnerPath]),
     command: "systemctl",
     args: ["--user", "enable", "--now", "va-claw.service"]
@@ -2002,7 +2203,7 @@ function createUninstallCommand(type) {
   if (type === "launchd") {
     return {
       command: "launchctl",
-      args: ["unload", join4(homedir4(), "Library", "LaunchAgents", "com.va-claw.daemon.plist")]
+      args: ["unload", join4(homedir5(), "Library", "LaunchAgents", "com.va-claw.daemon.plist")]
     };
   }
   return {
@@ -2057,7 +2258,7 @@ function quoteSystemdArg(value) {
 // packages/daemon/dist/service.js
 async function installDaemonService(type) {
   const definition = createServiceDefinition(type);
-  await mkdir3(dirname4(definition.path), { recursive: true });
+  await mkdir4(dirname5(definition.path), { recursive: true });
   await writeFile3(definition.path, definition.content, "utf8");
   if (type === "systemd") {
     runCommand("systemctl", ["--user", "daemon-reload"]);
@@ -2074,7 +2275,7 @@ async function uninstallDaemonService(type) {
   }
 }
 function runCommand(command, args, allowFailure = false) {
-  const result = spawnSync3(command, args, { encoding: "utf8" });
+  const result = spawnSync2(command, args, { encoding: "utf8" });
   if (allowFailure || result.status === 0) {
     return;
   }
@@ -2083,9 +2284,9 @@ function runCommand(command, args, allowFailure = false) {
 }
 
 // packages/cli/dist/install-files.js
-import { access as access2, mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, join as join5 } from "node:path";
+import { access as access2, mkdir as mkdir5, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname6, join as join5 } from "node:path";
 var CLAUDE_MARKERS = {
   start: "<!-- va-claw:identity:start -->",
   end: "<!-- va-claw:identity:end -->"
@@ -2094,15 +2295,18 @@ var CODEX_MARKERS = {
   start: "<!-- va-claw:codex:start -->",
   end: "<!-- va-claw:codex:end -->"
 };
-function resolveClaudeMdPath(home = homedir5()) {
+function resolveClaudeMdPath(home = homedir6()) {
   return join5(home, ".claude", "CLAUDE.md");
 }
-function resolveCodexInstructionsPath(home = homedir5()) {
+function resolveCodexInstructionsPath(home = homedir6()) {
   return join5(home, ".codex", "instructions.md");
 }
-function resolveMemoryDbPath(home = homedir5()) {
+function resolveMemoryDbPath(home = homedir6()) {
   return join5(home, ".va-claw", "memory.db");
 }
+function resolveClawRegistryPath(home = homedir6()) {
+  return join5(home, ".va-claw", "claws.json");
+}
 async function fileExists(path) {
   try {
     await access2(path);
@@ -2114,7 +2318,7 @@ async function fileExists(path) {
 async function upsertManagedBlock(path, block, markers) {
   const current = (await readOptionalFile(path)).trim();
   const next = appendManagedBlock(current, block, markers);
-  await mkdir4(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile4(path, next, "utf8");
 }
 async function removeManagedBlock(path, markers) {
@@ -2123,7 +2327,7 @@ async function removeManagedBlock(path, markers) {
     return;
   }
   const next = stripManagedBlock(current, markers).trim();
-  await mkdir4(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile4(path, next === "" ? "" : `${next}
 `, "utf8");
 }
@@ -2165,8 +2369,9 @@ function createDefaultCliDeps() {
     codexPath: resolveCodexInstructionsPath(),
     configPath: DEFAULT_CONFIG_PATH,
     memoryDbPath: resolveMemoryDbPath(),
+    clawRegistryPath: resolveClawRegistryPath(),
     platform: process.platform,
-    spawnSync: spawnSync4,
+    spawnSync: spawnSync3,
     stdout: process.stdout,
     stderr: process.stderr,
     fileExists,
@@ -2269,6 +2474,25 @@ function formatSkills(skills) {
     `  path: ${skill.path}`
   ].join("\n")).join("\n\n");
 }
+function formatClawDefinitions(claws) {
+  if (claws.length === 0) {
+    return "No claws registered.";
+  }
+  return claws.map((claw) => {
+    const lines = [
+      `${claw.name} [${claw.status}]`,
+      `  goal: ${claw.goal || "(no goal)"}`,
+      `  cli: ${claw.cliCommand || "va-claw"}`,
+      `  tags: ${claw.tags.join(", ") || "(none)"}`,
+      `  note: ${claw.note || "(none)"}`,
+      `  updatedAt: ${claw.updatedAt}`
+    ];
+    if (claw.lastSeenAt) {
+      lines.push(`  lastSeenAt: ${claw.lastSeenAt}`);
+    }
+    return lines.join("\n");
+  }).join("\n\n");
+}
 function writeLine(stream, message) {
   stream.write(`${message}
 `);
@@ -2276,7 +2500,7 @@ function writeLine(stream, message) {
 
 // packages/cli/dist/wait.js
 async function waitForStopSignal(stop) {
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     let stopping = false;
     const cleanup = () => {
       process.off("SIGINT", onSignal);
@@ -2289,7 +2513,7 @@ async function waitForStopSignal(stop) {
       stopping = true;
       void stop().then(() => {
         cleanup();
-        resolve4();
+        resolve5();
       }, (error) => {
         cleanup();
         reject(error);
@@ -2420,7 +2644,7 @@ function parseMetadata2(raw) {
 }
 
 // packages/cli/dist/platform.js
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { join as join6 } from "node:path";
 function detectServiceType(platform) {
   if (platform === "darwin") {
@@ -2431,27 +2655,163 @@ function detectServiceType(platform) {
   }
   throw new Error(`Unsupported platform for va-claw daemon service: ${platform}`);
 }
-function probeServiceRunning(type, spawnSync5) {
+function probeServiceRunning(type, spawnSync4) {
   if (type === "launchd") {
-    return spawnSync5("launchctl", ["list", "com.va-claw.daemon"], { encoding: "utf8" }).status === 0;
+    return spawnSync4("launchctl", ["list", "com.va-claw.daemon"], { encoding: "utf8" }).status === 0;
   }
-  const result = spawnSync5("systemctl", ["--user", "is-active", "va-claw.service"], {
+  const result = spawnSync4("systemctl", ["--user", "is-active", "va-claw.service"], {
     encoding: "utf8"
   });
   return result.status === 0 && result.stdout.trim() === "active";
 }
-function stopInstalledService(type, spawnSync5) {
+function stopInstalledService(type, spawnSync4) {
   if (type === "launchd") {
-    spawnSync5("launchctl", ["unload", resolveLaunchdPath()], { encoding: "utf8" });
+    spawnSync4("launchctl", ["unload", resolveLaunchdPath()], { encoding: "utf8" });
     return;
   }
-  spawnSync5("systemctl", ["--user", "stop", "va-claw.service"], { encoding: "utf8" });
+  spawnSync4("systemctl", ["--user", "stop", "va-claw.service"], { encoding: "utf8" });
 }
 function resolveLaunchdPath() {
-  return join6(homedir6(), "Library", "LaunchAgents", "com.va-claw.daemon.plist");
+  return join6(homedir7(), "Library", "LaunchAgents", "com.va-claw.daemon.plist");
+}
+
+// packages/cli/dist/claw-store.js
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname7 } from "node:path";
+var DEFAULT_CLAW_STATUS = "idle";
+var KNOWN_STATUSES = /* @__PURE__ */ new Set(["running", "working", "idle", "waiting", "error", "offline", "stopped"]);
+var REGISTRY_VERSION = 1;
+var DEFAULT_NOW = () => /* @__PURE__ */ new Date();
+function isClawStatus(value) {
+  return KNOWN_STATUSES.has(value ?? "");
+}
+function pickString2(value, fallback = "") {
+  return typeof value === "string" ? value.trim() : fallback;
+}
+function pickTags(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+}
+function normalizeStatus(value) {
+  return isClawStatus(typeof value === "string" ? value : void 0) ? value : DEFAULT_CLAW_STATUS;
+}
+function validateClawStatus(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return isClawStatus(normalized) ? normalized : null;
+}
+function normalizeClawDefinition(raw) {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const name = pickString2(Reflect.get(raw, "name"));
+  if (name === "") {
+    return null;
+  }
+  const createdAt = pickString2(Reflect.get(raw, "createdAt"), (/* @__PURE__ */ new Date(0)).toISOString());
+  const updatedAt = pickString2(Reflect.get(raw, "updatedAt"), createdAt);
+  return {
+    name,
+    goal: pickString2(Reflect.get(raw, "goal")),
+    status: normalizeStatus(Reflect.get(raw, "status")),
+    cliCommand: pickString2(Reflect.get(raw, "cliCommand"), "va-claw"),
+    note: pickString2(Reflect.get(raw, "note")),
+    tags: pickTags(Reflect.get(raw, "tags")),
+    lastSeenAt: pickString2(Reflect.get(raw, "lastSeenAt"), "").trim() || void 0,
+    createdAt,
+    updatedAt
+  };
+}
+function normalizeClawRegistry(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { version: REGISTRY_VERSION, claws: [] };
+  }
+  const version = typeof Reflect.get(raw, "version") === "number" ? Reflect.get(raw, "version") : REGISTRY_VERSION;
+  const rawClaws = Reflect.get(raw, "claws");
+  const claws = Array.isArray(rawClaws) ? rawClaws.map(normalizeClawDefinition).filter(Boolean) : [];
+  return { version: Number(version) > 0 ? Number(version) : REGISTRY_VERSION, claws };
+}
+async function listClaws(registryPath) {
+  const registry = await loadClawRegistry(registryPath);
+  return [...registry.claws];
+}
+async function registerClaw(registryPath, input, now = DEFAULT_NOW) {
+  const registry = await loadClawRegistry(registryPath);
+  const exists2 = registry.claws.some((entry) => entry.name === input.name);
+  if (exists2) {
+    throw new Error(`Claw already exists: ${input.name}`);
+  }
+  const timestamp = now().toISOString();
+  const claw = {
+    name: input.name,
+    goal: pickString2(input.goal),
+    status: input.status ?? DEFAULT_CLAW_STATUS,
+    cliCommand: pickString2(input.cliCommand, "va-claw"),
+    note: pickString2(input.note),
+    tags: Array.isArray(input.tags) ? input.tags.filter((tag) => tag.trim() !== "") : [],
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+  registry.claws = [claw, ...registry.claws];
+  await saveClawRegistry(registryPath, registry);
+  return claw;
+}
+async function updateClaw(registryPath, name, updates, now = DEFAULT_NOW) {
+  const registry = await loadClawRegistry(registryPath);
+  const index = registry.claws.findIndex((entry) => entry.name === name);
+  if (index < 0) {
+    return null;
+  }
+  const nowIso = now().toISOString();
+  const current = registry.claws[index];
+  const next = {
+    ...current,
+    goal: updates.goal ?? current.goal,
+    status: updates.status ?? current.status,
+    cliCommand: updates.cliCommand ?? current.cliCommand,
+    note: updates.note ?? current.note,
+    tags: Array.isArray(updates.tags) ? updates.tags.filter((tag) => tag.trim() !== "") : current.tags,
+    lastSeenAt: updates.seen ? nowIso : current.lastSeenAt,
+    updatedAt: nowIso
+  };
+  registry.claws[index] = next;
+  await saveClawRegistry(registryPath, registry);
+  return next;
+}
+async function removeClaw(registryPath, name) {
+  const registry = await loadClawRegistry(registryPath);
+  const before = registry.claws.length;
+  registry.claws = registry.claws.filter((entry) => entry.name !== name);
+  if (registry.claws.length === before) {
+    return false;
+  }
+  await saveClawRegistry(registryPath, registry);
+  return true;
+}
+async function loadClawRegistry(registryPath) {
+  try {
+    const rawText = await readFile5(registryPath, "utf8");
+    return normalizeClawRegistry(JSON.parse(rawText));
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return { version: REGISTRY_VERSION, claws: [] };
+    }
+    throw error;
+  }
+}
+async function saveClawRegistry(registryPath, registry) {
+  await mkdir6(dirname7(registryPath), { recursive: true });
+  await writeFile5(registryPath, `${JSON.stringify({ ...registry, version: REGISTRY_VERSION }, null, 2)}
+`, "utf8");
 }
 
 // packages/cli/dist/handlers.js
+var CLAW_FLEET_PROTOCOL_SKILL_URL = "https://raw.githubusercontent.com/Vadaski/va-claw/main/skills/claw-fleet-protocol.md";
+var MEMORY_SKILL_URL = "https://raw.githubusercontent.com/Vadaski/va-claw/main/skills/memory-protocol.md";
 async function runInstall(target, deps) {
   const installTarget = normalizeInstallTarget(target);
   const config = await deps.fileExists(deps.configPath) ? await deps.loadIdentity() : await deps.runInstallWizard();
@@ -2468,6 +2828,14 @@ async function runInstall(target, deps) {
   const serviceType = detectServiceType(deps.platform);
   await deps.installDaemonService(serviceType);
   summary.push(`Daemon service: ${serviceType}`);
+  const fleetSkillName = await installFleetProtocolSkill(deps);
+  if (fleetSkillName) {
+    summary.push(`Claw fleet protocol skill: ${fleetSkillName}`);
+  }
+  const memorySkillName = await installMemoryProtocolSkill(deps);
+  if (memorySkillName) {
+    summary.push(`Memory protocol skill: ${memorySkillName}`);
+  }
   for (const line of summary) {
     writeLine(deps.stdout, line);
   }
@@ -2500,6 +2868,150 @@ async function runStatus(deps) {
   writeLine(deps.stdout, `Last wake: ${lastWakeAt ?? "never"}`);
   writeLine(deps.stdout, `Memory entries: ${memoryCount}`);
 }
+async function runClawStatus(deps) {
+  const clawStatus = await buildProtocolReport(deps);
+  writeLine(deps.stdout, formatClawDefinitions(clawStatus.claws));
+  writeLine(deps.stdout, `Daemon running: ${clawStatus.runtime.running ? "yes" : "no"} | service: ${clawStatus.runtime.serviceRunning ? "running" : "stopped"} | wakeCount: ${clawStatus.runtime.wakeCount}`);
+}
+async function runClawList(deps) {
+  const claws = await listClaws(deps.clawRegistryPath);
+  writeLine(deps.stdout, formatClawDefinitions(claws));
+}
+async function runClawAdd(name, options, deps) {
+  const normalizedName = name.trim();
+  if (normalizedName === "") {
+    throw new Error("Claw name cannot be empty.");
+  }
+  const status = options.status ? validateClawStatus(options.status) : null;
+  if (options.status && status === null) {
+    throw new Error(`Invalid claw status: ${options.status}`);
+  }
+  const claw = await registerClaw(deps.clawRegistryPath, {
+    name: normalizedName,
+    goal: options.goal,
+    status: status ?? void 0,
+    cliCommand: options.cliCommand,
+    note: options.note,
+    tags: options.tags ? splitCommaList(options.tags) : []
+  });
+  writeLine(deps.stdout, formatClawDefinitions([claw]));
+}
+async function runClawUpdate(name, options, deps) {
+  const status = options.status ? validateClawStatus(options.status) : null;
+  const normalizedName = name.trim();
+  if (normalizedName === "") {
+    throw new Error("Claw name cannot be empty.");
+  }
+  if (options.status && status === null) {
+    throw new Error(`Invalid claw status: ${options.status}`);
+  }
+  const patch = {
+    goal: options.goal,
+    status: status ?? void 0,
+    cliCommand: options.cliCommand,
+    note: options.note,
+    tags: options.tags ? splitCommaList(options.tags) : void 0,
+    seen: options.seen === "1" || options.seen === "true" || options.seen === "yes"
+  };
+  const claw = await updateClaw(deps.clawRegistryPath, normalizedName, patch);
+  if (!claw) {
+    writeLine(deps.stdout, `Claw not found: ${name}`);
+    return;
+  }
+  writeLine(deps.stdout, formatClawDefinitions([claw]));
+}
+async function runClawRemove(name, deps) {
+  const normalizedName = name.trim();
+  if (normalizedName === "") {
+    throw new Error("Claw name cannot be empty.");
+  }
+  const removed = await removeClaw(deps.clawRegistryPath, normalizedName);
+  writeLine(deps.stdout, removed ? `Removed claw: ${normalizedName}` : `Claw not found: ${normalizedName}`);
+}
+async function runClawHeartbeat(name, deps) {
+  const normalizedName = name.trim();
+  if (normalizedName === "") {
+    throw new Error("Claw name cannot be empty.");
+  }
+  const claw = await updateClaw(deps.clawRegistryPath, normalizedName, { seen: true, status: "running" });
+  if (!claw) {
+    writeLine(deps.stdout, `Claw not found: ${name}`);
+    return;
+  }
+  writeLine(deps.stdout, formatClawDefinitions([claw]));
+}
+async function runProtocol(deps, textMode = false) {
+  const report = await buildProtocolReport(deps);
+  if (textMode) {
+    writeLine(deps.stdout, `protocol: ${report.protocol}`);
+    writeLine(deps.stdout, `timestamp: ${report.timestamp}`);
+    writeLine(deps.stdout, `daemon.running: ${report.runtime.running}`);
+    writeLine(deps.stdout, `daemon.serviceRunning: ${report.runtime.serviceRunning}`);
+    writeLine(deps.stdout, `daemon.discord: ${report.runtime.discord}`);
+    writeLine(deps.stdout, `daemon.wakeCount: ${report.runtime.wakeCount}`);
+    writeLine(deps.stdout, `daemon.lastWakeAt: ${report.runtime.lastWakeAt ?? "never"}`);
+    writeLine(deps.stdout, `memory.entries: ${report.memory.entries}`);
+    writeLine(deps.stdout, `memory.lastWakeAt: ${report.memory.lastWakeAt ?? "never"}`);
+    writeLine(deps.stdout, "");
+    writeLine(deps.stdout, "Claws:");
+    writeLine(deps.stdout, formatClawDefinitions(report.claws));
+    return;
+  }
+  writeLine(deps.stdout, JSON.stringify(report, null, 2));
+}
+async function buildProtocolReport(deps) {
+  const runtime = await deps.getDaemonStatus();
+  const serviceType = safeDetectServiceType(deps.platform);
+  const serviceRunning = serviceType ? probeServiceRunning(serviceType, deps.spawnSync) : false;
+  const runtimeLastWakeAt = runtime.lastWakeAt?.toISOString() ?? null;
+  const fallbackLastWakeAt = await findLastWakeAt(deps.memoryDbPath, deps.fileExists);
+  const memoryCount = await countMemoryEntries(deps.memoryDbPath, deps.fileExists);
+  const claws = await listClaws(deps.clawRegistryPath);
+  return {
+    protocol: "va-claw-claw-protocol-1",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    runtime: {
+      running: runtime.running,
+      serviceRunning,
+      discord: runtime.discord,
+      wakeCount: runtime.wakeCount,
+      lastWakeAt: runtimeLastWakeAt ?? fallbackLastWakeAt
+    },
+    memory: {
+      entries: memoryCount,
+      lastWakeAt: runtimeLastWakeAt ?? fallbackLastWakeAt
+    },
+    claws: claws.map((claw) => ({
+      name: claw.name,
+      goal: claw.goal,
+      status: claw.status,
+      cliCommand: claw.cliCommand,
+      note: claw.note,
+      tags: claw.tags,
+      lastSeenAt: claw.lastSeenAt,
+      createdAt: claw.createdAt,
+      updatedAt: claw.updatedAt
+    }))
+  };
+}
+async function installFleetProtocolSkill(deps) {
+  return installRemoteSkill(deps, CLAW_FLEET_PROTOCOL_SKILL_URL, "claw-fleet-protocol");
+}
+async function installMemoryProtocolSkill(deps) {
+  return installRemoteSkill(deps, MEMORY_SKILL_URL, "memory-protocol");
+}
+async function installRemoteSkill(deps, url, name) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return null;
+    }
+    const content = await response.text();
+    return await deps.skillInstall(content, name);
+  } catch {
+    return null;
+  }
+}
 async function runMemorySearch(query, deps) {
   writeLine(deps.stdout, formatMemoryEntries(await deps.memorySearch(query, 10)));
 }
@@ -2769,6 +3281,7 @@ function createCliProgram(deps = createDefaultCliDeps()) {
   program.command("stop").description("Stop the daemon.").action(async () => runStop(deps));
   program.command("status").description("Show daemon and memory status.").action(async () => runStatus(deps));
   program.command("uninstall").description("Remove daemon service and injected prompts.").action(async () => runUninstall(deps));
+  program.command("protocol").description("Emit a machine-readable protocol summary for agent-facing integrations.").option("--text", "Print a human-readable protocol summary instead of JSON.").action(async (options) => runProtocol(deps, Boolean(options.text)));
   const memory = program.command("memory").description("Memory operations.");
   memory.command("search").description("Search memory.").argument("<query>").action(async (query) => runMemorySearch(query, deps));
   memory.command("memorize").description("Store or update a memory entry by key.").argument("<key>").argument("<essence>").option("--tags <tags>", "Comma-separated tags.").option("--details <details>", "Details text.").option("--importance <importance>", "Importance from 0 to 1.").action((key, essence, options) => runMemoryMemorize(key, essence, options, deps));
@@ -2798,6 +3311,13 @@ function createCliProgram(deps = createDefaultCliDeps()) {
   slack.command("setup").description("Configure Slack bot credentials.").option("--bot-token <token>", "Slack bot token").option("--app-token <token>", "Slack app token").option("--cli-command <command>", "CLI command to invoke for each message").action(async (options) => runSlackChannelSetup(options.botToken, options.appToken, options.cliCommand, deps));
   slack.command("start").description("Start the Slack channel in the foreground.").action(async () => runSlackChannelStart(deps));
   slack.command("status").description("Show Slack channel status.").action(async () => runSlackChannelStatus(deps));
+  const claw = program.command("claw").description("Long-running claw operations.");
+  claw.command("status").description("Show claw status and daemon summary.").action(async () => runClawStatus(deps));
+  claw.command("list").description("List all registered claws.").action(async () => runClawList(deps));
+  claw.command("add").description("Register a long-running claw.").argument("<name>").option("--goal <goal>", "Describe what this claw is responsible for.").option("--status <status>", "running | working | idle | waiting | error | offline | stopped.").option("--cli-command <command>", "Command to execute this claw's actions (default: va-claw).").option("--note <note>", "Single-line note for this claw.").option("--tags <tags>", "Comma-separated tags.").action((name, options) => runClawAdd(name, options, deps));
+  claw.command("set").description("Update a claw's state.").argument("<name>").option("--goal <goal>", "New goal for this claw.").option("--status <status>", "running | working | idle | waiting | error | offline | stopped.").option("--cli-command <command>", "Update command used for this claw.").option("--note <note>", "Update note.").option("--tags <tags>", "Replace tags, comma-separated.").option("--seen", "Mark claw as alive now.").action((name, options) => runClawUpdate(name, { ...options, seen: options.seen ? "true" : void 0 }, deps));
+  claw.command("heartbeat").description("Mark a claw as active and update lastSeenAt.").argument("<name>").action((name) => runClawHeartbeat(name, deps));
+  claw.command("remove").description("Unregister a claw.").argument("<name>").action((name) => runClawRemove(name, deps));
   return program;
 }
 async function runCli(argv = process.argv, deps) {