@gguf/pigbot 0.0.1 → 0.0.2

package/dist/hooks/hooks-status.js

@@ -3,10 +3,10 @@ import { CONFIG_DIR } from "../utils.js";
 import { hasBinary, isConfigPathTruthy, resolveConfigPath, resolveHookConfig } from "./config.js";
 import { loadWorkspaceHookEntries } from "./workspace.js";
 function resolveHookKey(entry) {
-    return entry.pigbot?.hookKey ?? entry.hook.name;
+    return entry.metadata?.hookKey ?? entry.hook.name;
 }
 function normalizeInstallOptions(entry) {
-    const install = entry.pigbot?.install ?? [];
+    const install = entry.metadata?.install ?? [];
     if (install.length === 0)
         return [];
     // For hooks, we just list all install options
@@ -16,7 +16,7 @@ function normalizeInstallOptions(entry) {
         let label = (spec.label ?? "").trim();
         if (!label) {
             if (spec.kind === "bundled") {
-                label = "Bundled with Pigbot";
+                label = "Bundled with Moltbot";
             }
             else if (spec.kind === "npm" && spec.package) {
                 label = `Install ${spec.package} (npm)`;
@@ -34,21 +34,21 @@ function normalizeInstallOptions(entry) {
 function buildHookStatus(entry, config, eligibility) {
     const hookKey = resolveHookKey(entry);
     const hookConfig = resolveHookConfig(config, hookKey);
-    const managedByPlugin = entry.hook.source === "pigbot-plugin";
+    const managedByPlugin = entry.hook.source === "moltbot-plugin";
     const disabled = managedByPlugin ? false : hookConfig?.enabled === false;
-    const always = entry.pigbot?.always === true;
-    const emoji = entry.pigbot?.emoji ?? entry.frontmatter.emoji;
-    const homepageRaw = entry.pigbot?.homepage ??
+    const always = entry.metadata?.always === true;
+    const emoji = entry.metadata?.emoji ?? entry.frontmatter.emoji;
+    const homepageRaw = entry.metadata?.homepage ??
         entry.frontmatter.homepage ??
         entry.frontmatter.website ??
         entry.frontmatter.url;
     const homepage = homepageRaw?.trim() ? homepageRaw.trim() : undefined;
-    const events = entry.pigbot?.events ?? [];
-    const requiredBins = entry.pigbot?.requires?.bins ?? [];
-    const requiredAnyBins = entry.pigbot?.requires?.anyBins ?? [];
-    const requiredEnv = entry.pigbot?.requires?.env ?? [];
-    const requiredConfig = entry.pigbot?.requires?.config ?? [];
-    const requiredOs = entry.pigbot?.os ?? [];
+    const events = entry.metadata?.events ?? [];
+    const requiredBins = entry.metadata?.requires?.bins ?? [];
+    const requiredAnyBins = entry.metadata?.requires?.anyBins ?? [];
+    const requiredEnv = entry.metadata?.requires?.env ?? [];
+    const requiredConfig = entry.metadata?.requires?.config ?? [];
+    const requiredOs = entry.metadata?.os ?? [];
     const missingBins = requiredBins.filter((bin) => {
         if (hasBinary(bin))
             return false;

package/dist/hooks/install.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { LEGACY_MANIFEST_KEY } from "../compat/legacy-names.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
 import { extractArchive, fileExists, readJsonFile, resolveArchiveKind, resolvePackedRootDir, } from "../infra/archive.js";
@@ -22,14 +23,14 @@ export function resolveHookInstallDir(hookId, hooksDir) {
     const hooksBase = hooksDir ? resolveUserPath(hooksDir) : path.join(CONFIG_DIR, "hooks");
     return path.join(hooksBase, safeDirName(hookId));
 }
-async function ensurePigbotHooks(manifest) {
-    const hooks = manifest.pigbot?.hooks;
+async function ensureMoltbotHooks(manifest) {
+    const hooks = manifest.moltbot?.hooks ?? manifest[LEGACY_MANIFEST_KEY]?.hooks;
     if (!Array.isArray(hooks)) {
-        throw new Error("package.json missing pigbot.hooks");
+        throw new Error("package.json missing moltbot.hooks");
     }
     const list = hooks.map((e) => (typeof e === "string" ? e.trim() : "")).filter(Boolean);
     if (list.length === 0) {
-        throw new Error("package.json pigbot.hooks is empty");
+        throw new Error("package.json moltbot.hooks is empty");
     }
     return list;
 }
@@ -71,7 +72,7 @@ async function installHookPackageFromDir(params) {
     }
     let hookEntries;
     try {
-        hookEntries = await ensurePigbotHooks(manifest);
+        hookEntries = await ensureMoltbotHooks(manifest);
     }
     catch (err) {
         return { ok: false, error: String(err) };
@@ -208,7 +209,7 @@ export async function installHooksFromArchive(params) {
     if (!resolveArchiveKind(archivePath)) {
         return { ok: false, error: `unsupported archive: ${archivePath}` };
     }
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pigbot-hook-"));
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-hook-"));
     const extractDir = path.join(tmpDir, "extract");
     await fs.mkdir(extractDir, { recursive: true });
     logger.info?.(`Extracting ${archivePath}…`);
@@ -255,7 +256,7 @@ export async function installHooksFromNpmSpec(params) {
     const spec = params.spec.trim();
     if (!spec)
         return { ok: false, error: "missing npm spec" };
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pigbot-hook-pack-"));
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-hook-pack-"));
     logger.info?.(`Downloading ${spec}…`);
     const res = await runCommandWithTimeout(["npm", "pack", spec], {
         timeoutMs: Math.max(timeoutMs, 300_000),

package/dist/hooks/internal-hooks.js

@@ -1,5 +1,5 @@
 /**
- * Hook system for pigbot agent events
+ * Hook system for moltbot agent events
  *
  * Provides an extensible event-driven hook system for agent events
  * like command processing, session lifecycle, etc.

package/dist/hooks/llm-slug-generator.js

@@ -16,7 +16,7 @@ export async function generateSlugViaLLM(params) {
         const workspaceDir = resolveAgentWorkspaceDir(params.cfg, agentId);
         const agentDir = resolveAgentDir(params.cfg, agentId);
         // Create a temporary session file for this one-off LLM call
-        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "pigbot-slug-"));
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-slug-"));
         tempSessionFile = path.join(tempDir, "session.jsonl");
         const prompt = `Based on this conversation, generate a short 1-2 word filename slug (lowercase, hyphen-separated, no file extension).
 

package/dist/hooks/loader.js

@@ -17,7 +17,7 @@ import { shouldIncludeHook } from "./config.js";
  * 1. Directory-based discovery (bundled, managed, workspace)
  * 2. Legacy config handlers (backwards compatibility)
  *
- * @param cfg - Pigbot configuration
+ * @param cfg - Moltbot configuration
  * @param workspaceDir - Workspace directory for hook discovery
  * @returns Number of handlers successfully loaded
  *
@@ -52,14 +52,14 @@ export async function loadInternalHooks(cfg, workspaceDir) {
                 const cacheBustedUrl = `${url}?t=${Date.now()}`;
                 const mod = (await import(cacheBustedUrl));
                 // Get handler function (default or named export)
-                const exportName = entry.pigbot?.export ?? "default";
+                const exportName = entry.metadata?.export ?? "default";
                 const handler = mod[exportName];
                 if (typeof handler !== "function") {
                     console.error(`Hook error: Handler '${exportName}' from ${entry.hook.name} is not a function`);
                     continue;
                 }
                 // Register for all events listed in metadata
-                const events = entry.pigbot?.events ?? [];
+                const events = entry.metadata?.events ?? [];
                 if (events.length === 0) {
                     console.warn(`Hook warning: Hook '${entry.hook.name}' has no events defined in metadata`);
                     continue;

package/dist/hooks/plugin-hooks.js

@@ -12,13 +12,13 @@ function normalizePluginHookEntry(api, entry) {
         ...entry,
         hook: {
             ...entry.hook,
-            source: "pigbot-plugin",
+            source: "moltbot-plugin",
             pluginId: api.id,
         },
-        pigbot: {
-            ...entry.pigbot,
-            hookKey: entry.pigbot?.hookKey ?? `${api.id}:${entry.hook.name}`,
-            events: entry.pigbot?.events ?? [],
+        metadata: {
+            ...entry.metadata,
+            hookKey: entry.metadata?.hookKey ?? `${api.id}:${entry.hook.name}`,
+            events: entry.metadata?.events ?? [],
         },
     };
 }
@@ -27,7 +27,7 @@ async function loadHookHandler(entry, api) {
         const url = pathToFileURL(entry.hook.handlerPath).href;
         const cacheBustedUrl = `${url}?t=${Date.now()}`;
         const mod = (await import(cacheBustedUrl));
-        const exportName = entry.pigbot?.export ?? "default";
+        const exportName = entry.metadata?.export ?? "default";
         const handler = mod[exportName];
         if (typeof handler === "function") {
             return handler;
@@ -44,7 +44,7 @@ export async function registerPluginHooksFromDir(api, dir) {
     const resolvedDir = resolveHookDir(api, dir);
     const hooks = loadHookEntriesFromDir({
         dir: resolvedDir,
-        source: "pigbot-plugin",
+        source: "moltbot-plugin",
         pluginId: api.id,
     });
     const result = {
@@ -55,7 +55,7 @@ export async function registerPluginHooksFromDir(api, dir) {
     };
     for (const entry of hooks) {
         const normalizedEntry = normalizePluginHookEntry(api, entry);
-        const events = normalizedEntry.pigbot?.events ?? [];
+        const events = normalizedEntry.metadata?.events ?? [];
         if (events.length === 0) {
             api.logger.warn?.(`[hooks] ${entry.hook.name} has no events; skipping`);
             api.registerHook(events, async () => undefined, {

package/dist/hooks/workspace.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
+import { LEGACY_MANIFEST_KEY } from "../compat/legacy-names.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
 import { resolveBundledHooksDir } from "./bundled-dir.js";
 import { shouldIncludeHook } from "./config.js";
-import { parseFrontmatter, resolvePigbotMetadata, resolveHookInvocationPolicy, } from "./frontmatter.js";
+import { parseFrontmatter, resolveMoltbotMetadata, resolveHookInvocationPolicy, } from "./frontmatter.js";
 function filterHookEntries(entries, config, eligibility) {
     return entries.filter((entry) => shouldIncludeHook({ entry, config, eligibility }));
 }
@@ -20,7 +21,7 @@ function readHookPackageManifest(dir) {
     }
 }
 function resolvePackageHooks(manifest) {
-    const raw = manifest.pigbot?.hooks;
+    const raw = manifest.moltbot?.hooks ?? manifest[LEGACY_MANIFEST_KEY]?.hooks;
     if (!Array.isArray(raw))
         return [];
     return raw.map((entry) => (typeof entry === "string" ? entry.trim() : "")).filter(Boolean);
@@ -127,7 +128,7 @@ export function loadHookEntriesFromDir(params) {
                 pluginId: params.pluginId,
             },
             frontmatter,
-            pigbot: resolvePigbotMetadata(frontmatter),
+            metadata: resolveMoltbotMetadata(frontmatter),
             invocation: resolveHookInvocationPolicy(frontmatter),
         };
         return entry;
@@ -144,23 +145,23 @@ function loadHookEntries(workspaceDir, opts) {
     const bundledHooks = bundledHooksDir
         ? loadHooksFromDir({
             dir: bundledHooksDir,
-            source: "pigbot-bundled",
+            source: "moltbot-bundled",
         })
         : [];
     const extraHooks = extraDirs.flatMap((dir) => {
         const resolved = resolveUserPath(dir);
         return loadHooksFromDir({
             dir: resolved,
-            source: "pigbot-workspace", // Extra dirs treated as workspace
+            source: "moltbot-workspace", // Extra dirs treated as workspace
         });
     });
     const managedHooks = loadHooksFromDir({
         dir: managedHooksDir,
-        source: "pigbot-managed",
+        source: "moltbot-managed",
     });
     const workspaceHooks = loadHooksFromDir({
         dir: workspaceHooksDir,
-        source: "pigbot-workspace",
+        source: "moltbot-workspace",
     });
     const merged = new Map();
     // Precedence: extra < bundled < managed < workspace (workspace wins)
@@ -184,7 +185,7 @@ function loadHookEntries(workspaceDir, opts) {
         return {
             hook,
             frontmatter,
-            pigbot: resolvePigbotMetadata(frontmatter),
+            metadata: resolveMoltbotMetadata(frontmatter),
             invocation: resolveHookInvocationPolicy(frontmatter),
         };
     });
@@ -195,7 +196,7 @@ export function buildWorkspaceHookSnapshot(workspaceDir, opts) {
     return {
         hooks: eligible.map((entry) => ({
             name: entry.hook.name,
-            events: entry.pigbot?.events ?? [],
+            events: entry.metadata?.events ?? [],
         })),
         resolvedHooks: eligible.map((entry) => entry.hook),
         version: opts?.snapshotVersion,

package/dist/imessage/monitor/monitor-provider.js

@@ -32,7 +32,7 @@ import { deliverReplies } from "./deliver.js";
 import { normalizeAllowList, resolveRuntime } from "./runtime.js";
 /**
  * Try to detect remote host from an SSH wrapper script like:
- *   exec ssh -T pigbot@192.168.64.3 /opt/homebrew/bin/imsg "$@"
+ *   exec ssh -T moltbot@192.168.64.3 /opt/homebrew/bin/imsg "$@"
  *   exec ssh -T mac-mini imsg "$@"
  * Returns the user@host or host portion if found, undefined otherwise.
  */
@@ -43,7 +43,7 @@ async function detectRemoteHostFromCliPath(cliPath) {
             ? cliPath.replace(/^~/, process.env.HOME ?? "")
             : cliPath;
         const content = await fs.readFile(expanded, "utf8");
-        // Match user@host pattern first (e.g., pigbot@192.168.64.3)
+        // Match user@host pattern first (e.g., moltbot@192.168.64.3)
         const userHostMatch = content.match(/\bssh\b[^\n]*?\s+([a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+)/);
         if (userHostMatch)
             return userHostMatch[1];

package/dist/imessage/targets.js

@@ -21,6 +21,25 @@ export function normalizeIMessageHandle(raw) {
         return normalizeIMessageHandle(trimmed.slice(4));
     if (lowered.startsWith("auto:"))
         return normalizeIMessageHandle(trimmed.slice(5));
+    // Normalize chat_id/chat_guid/chat_identifier prefixes case-insensitively
+    for (const prefix of CHAT_ID_PREFIXES) {
+        if (lowered.startsWith(prefix)) {
+            const value = trimmed.slice(prefix.length).trim();
+            return `chat_id:${value}`;
+        }
+    }
+    for (const prefix of CHAT_GUID_PREFIXES) {
+        if (lowered.startsWith(prefix)) {
+            const value = trimmed.slice(prefix.length).trim();
+            return `chat_guid:${value}`;
+        }
+    }
+    for (const prefix of CHAT_IDENTIFIER_PREFIXES) {
+        if (lowered.startsWith(prefix)) {
+            const value = trimmed.slice(prefix.length).trim();
+            return `chat_identifier:${value}`;
+        }
+    }
     if (trimmed.includes("@"))
         return trimmed.toLowerCase();
     const normalized = normalizeE164(trimmed);

package/dist/index.js

@@ -13,7 +13,7 @@ import { ensureBinary } from "./infra/binaries.js";
 import { loadDotEnv } from "./infra/dotenv.js";
 import { normalizeEnv } from "./infra/env.js";
 import { isMainModule } from "./infra/is-main.js";
-import { ensurePigbotCliOnPath } from "./infra/path-env.js";
+import { ensureMoltbotCliOnPath } from "./infra/path-env.js";
 import { describePortOwner, ensurePortAvailable, handlePortError, PortInUseError, } from "./infra/ports.js";
 import { assertSupportedRuntime } from "./infra/runtime-guard.js";
 import { formatUncaughtError } from "./infra/errors.js";
@@ -23,7 +23,7 @@ import { runCommandWithTimeout, runExec } from "./process/exec.js";
 import { assertWebChannel, normalizeE164, toWhatsappJid } from "./utils.js";
 loadDotEnv({ quiet: true });
 normalizeEnv();
-ensurePigbotCliOnPath();
+ensureMoltbotCliOnPath();
 // Capture all console output into structured logs while keeping stdout/stderr behavior.
 enableConsoleCapture();
 // Enforce the minimum supported runtime before doing any work.
@@ -39,11 +39,11 @@ if (isMain) {
     // These log the error and exit gracefully instead of crashing without trace.
     installUnhandledRejectionHandler();
     process.on("uncaughtException", (error) => {
-        console.error("[pigbot] Uncaught exception:", formatUncaughtError(error));
+        console.error("[moltbot] Uncaught exception:", formatUncaughtError(error));
         process.exit(1);
     });
     void program.parseAsync(process.argv).catch((err) => {
-        console.error("[pigbot] CLI failed:", formatUncaughtError(err));
+        console.error("[moltbot] CLI failed:", formatUncaughtError(err));
         process.exit(1);
     });
 }

package/dist/infra/agent-events.js

@@ -16,6 +16,9 @@ export function registerAgentRunContext(runId, context) {
     if (context.verboseLevel && existing.verboseLevel !== context.verboseLevel) {
         existing.verboseLevel = context.verboseLevel;
     }
+    if (context.isHeartbeat !== undefined && existing.isHeartbeat !== context.isHeartbeat) {
+        existing.isHeartbeat = context.isHeartbeat;
+    }
 }
 export function getAgentRunContext(runId) {
     return runContextById.get(runId);

package/dist/infra/bonjour-discovery.js

@@ -139,11 +139,11 @@ function parseDnsSdBrowse(stdout) {
     const instances = new Set();
     for (const raw of stdout.split("\n")) {
         const line = raw.trim();
-        if (!line || !line.includes("_pigbot-gw._tcp"))
+        if (!line || !line.includes("_moltbot-gw._tcp"))
             continue;
         if (!line.includes("Add"))
             continue;
-        const match = line.match(/_pigbot-gw\._tcp\.?\s+(.+)$/);
+        const match = line.match(/_moltbot-gw\._tcp\.?\s+(.+)$/);
         if (match?.[1]) {
             instances.add(decodeDnsSdEscapes(match[1].trim()));
         }
@@ -199,13 +199,13 @@ function parseDnsSdResolve(stdout, instanceName) {
     return beacon;
 }
 async function discoverViaDnsSd(domain, timeoutMs, run) {
-    const browse = await run(["dns-sd", "-B", "_pigbot-gw._tcp", domain], {
+    const browse = await run(["dns-sd", "-B", "_moltbot-gw._tcp", domain], {
         timeoutMs,
     });
     const instances = parseDnsSdBrowse(browse.stdout);
     const results = [];
     for (const instance of instances) {
-        const resolved = await run(["dns-sd", "-L", instance, "_pigbot-gw._tcp", domain], {
+        const resolved = await run(["dns-sd", "-L", instance, "_moltbot-gw._tcp", domain], {
             timeoutMs,
         });
         const parsed = parseDnsSdResolve(resolved.stdout, instance);
@@ -240,7 +240,7 @@ async function discoverWideAreaViaTailnetDns(domain, timeoutMs, run) {
         return [];
     // Keep scans bounded: this is a fallback and should not block long.
     ips = ips.slice(0, 40);
-    const probeName = `_pigbot-gw._tcp.${domain.replace(/\.$/, "")}`;
+    const probeName = `_moltbot-gw._tcp.${domain.replace(/\.$/, "")}`;
     const concurrency = 6;
     let nextIndex = 0;
     let nameserver = null;
@@ -285,7 +285,7 @@ async function discoverWideAreaViaTailnetDns(domain, timeoutMs, run) {
         const ptrName = ptr.trim().replace(/\.$/, "");
         if (!ptrName)
             continue;
-        const instanceName = ptrName.replace(/\.?_pigbot-gw\._tcp\..*$/, "");
+        const instanceName = ptrName.replace(/\.?_moltbot-gw\._tcp\..*$/, "");
         const srv = await run(["dig", "+short", "+time=1", "+tries=1", nameserverArg, ptrName, "SRV"], {
             timeoutMs: Math.max(1, Math.min(350, budget)),
         }).catch(() => null);
@@ -341,10 +341,10 @@ function parseAvahiBrowse(stdout) {
         const line = raw.trimEnd();
         if (!line)
             continue;
-        if (line.startsWith("=") && line.includes("_pigbot-gw._tcp")) {
+        if (line.startsWith("=") && line.includes("_moltbot-gw._tcp")) {
             if (current)
                 results.push(current);
-            const marker = " _pigbot-gw._tcp";
+            const marker = " _moltbot-gw._tcp";
             const idx = line.indexOf(marker);
             const left = idx >= 0 ? line.slice(0, idx).trim() : line;
             const parts = left.split(/\s+/);
@@ -401,7 +401,7 @@ function parseAvahiBrowse(stdout) {
     return results;
 }
 async function discoverViaAvahi(domain, timeoutMs, run) {
-    const args = ["avahi-browse", "-rt", "_pigbot-gw._tcp"];
+    const args = ["avahi-browse", "-rt", "_moltbot-gw._tcp"];
     if (domain && domain !== "local.") {
         // avahi-browse wants a plain domain (no trailing dot)
         args.push("-d", domain.replace(/\.$/, ""));

package/dist/infra/bonjour.js

@@ -6,7 +6,7 @@ import { formatBonjourError } from "./bonjour-errors.js";
 import { isTruthyEnvValue } from "./env.js";
 import { registerUnhandledRejectionHandler } from "./unhandled-rejections.js";
 function isDisabledByEnv() {
-    if (isTruthyEnvValue(process.env.PIGBOT_DISABLE_BONJOUR))
+    if (isTruthyEnvValue(process.env.CLAWDBOT_DISABLE_BONJOUR))
         return true;
     if (process.env.NODE_ENV === "test")
         return true;
@@ -16,11 +16,11 @@ function isDisabledByEnv() {
 }
 function safeServiceName(name) {
     const trimmed = name.trim();
-    return trimmed.length > 0 ? trimmed : "Pigbot";
+    return trimmed.length > 0 ? trimmed : "Moltbot";
 }
 function prettifyInstanceName(name) {
     const normalized = name.trim().replace(/\s+/g, " ");
-    return normalized.replace(/\s+\(Pigbot\)\s*$/i, "").trim() || normalized;
+    return normalized.replace(/\s+\(Moltbot\)\s*$/i, "").trim() || normalized;
 }
 function serviceSummary(label, svc) {
     let fqdn = "unknown";
@@ -60,10 +60,10 @@ export async function startGatewayBonjourAdvertiser(opts) {
         .hostname()
         .replace(/\.local$/i, "")
         .split(".")[0]
-        .trim() || "pigbot";
+        .trim() || "moltbot";
     const instanceName = typeof opts.instanceName === "string" && opts.instanceName.trim()
         ? opts.instanceName.trim()
-        : `${hostname} (Pigbot)`;
+        : `${hostname} (Moltbot)`;
     const displayName = prettifyInstanceName(instanceName);
     const txtBase = {
         role: "gateway",
@@ -83,22 +83,29 @@ export async function startGatewayBonjourAdvertiser(opts) {
     if (typeof opts.tailnetDns === "string" && opts.tailnetDns.trim()) {
         txtBase.tailnetDns = opts.tailnetDns.trim();
     }
-    if (typeof opts.cliPath === "string" && opts.cliPath.trim()) {
+    // In minimal mode, omit cliPath to avoid exposing filesystem structure.
+    // This info can be obtained via the authenticated WebSocket if needed.
+    if (!opts.minimal && typeof opts.cliPath === "string" && opts.cliPath.trim()) {
         txtBase.cliPath = opts.cliPath.trim();
     }
     const services = [];
+    // Build TXT record for the gateway service.
+    // In minimal mode, omit sshPort to avoid advertising SSH availability.
+    const gatewayTxt = {
+        ...txtBase,
+        transport: "gateway",
+    };
+    if (!opts.minimal) {
+        gatewayTxt.sshPort = String(opts.sshPort ?? 22);
+    }
     const gateway = responder.createService({
         name: safeServiceName(instanceName),
-        type: "pigbot-gw",
+        type: "moltbot-gw",
         protocol: "tcp" /* Protocol.TCP */,
         port: opts.gatewayPort,
         domain: "local",
         hostname,
-        txt: {
-            ...txtBase,
-            sshPort: String(opts.sshPort ?? 22),
-            transport: "gateway",
-        },
+        txt: gatewayTxt,
     });
     services.push({
         label: "gateway",
@@ -108,7 +115,7 @@ export async function startGatewayBonjourAdvertiser(opts) {
     if (services.length > 0) {
         ciaoCancellationRejectionHandler = registerUnhandledRejectionHandler(ignoreCiaoCancellationRejection);
     }
-    logDebug(`bonjour: starting (hostname=${hostname}, instance=${JSON.stringify(safeServiceName(instanceName))}, gatewayPort=${opts.gatewayPort}, sshPort=${opts.sshPort ?? 22})`);
+    logDebug(`bonjour: starting (hostname=${hostname}, instance=${JSON.stringify(safeServiceName(instanceName))}, gatewayPort=${opts.gatewayPort}${opts.minimal ? ", minimal=true" : `, sshPort=${opts.sshPort ?? 22}`})`);
     for (const { label, svc } of services) {
         try {
             svc.on("name-change", (name) => {

package/dist/infra/device-identity.js

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-const DEFAULT_DIR = path.join(os.homedir(), ".pigbot", "identity");
+const DEFAULT_DIR = path.join(os.homedir(), ".clawdbot", "identity");
 const DEFAULT_FILE = path.join(DEFAULT_DIR, "device.json");
 function ensureDir(filePath) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });

package/dist/infra/diagnostic-flags.js

@@ -0,0 +1,66 @@
+const DIAGNOSTICS_ENV = "CLAWDBOT_DIAGNOSTICS";
+function normalizeFlag(value) {
+    return value.trim().toLowerCase();
+}
+function parseEnvFlags(raw) {
+    if (!raw)
+        return [];
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    const lowered = trimmed.toLowerCase();
+    if (["0", "false", "off", "none"].includes(lowered))
+        return [];
+    if (["1", "true", "all", "*"].includes(lowered))
+        return ["*"];
+    return trimmed
+        .split(/[,\s]+/)
+        .map(normalizeFlag)
+        .filter(Boolean);
+}
+function uniqueFlags(flags) {
+    const seen = new Set();
+    const out = [];
+    for (const flag of flags) {
+        const normalized = normalizeFlag(flag);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+export function resolveDiagnosticFlags(cfg, env = process.env) {
+    const configFlags = Array.isArray(cfg?.diagnostics?.flags) ? cfg?.diagnostics?.flags : [];
+    const envFlags = parseEnvFlags(env[DIAGNOSTICS_ENV]);
+    return uniqueFlags([...configFlags, ...envFlags]);
+}
+export function matchesDiagnosticFlag(flag, enabledFlags) {
+    const target = normalizeFlag(flag);
+    if (!target)
+        return false;
+    for (const raw of enabledFlags) {
+        const enabled = normalizeFlag(raw);
+        if (!enabled)
+            continue;
+        if (enabled === "*" || enabled === "all")
+            return true;
+        if (enabled.endsWith(".*")) {
+            const prefix = enabled.slice(0, -2);
+            if (target === prefix || target.startsWith(`${prefix}.`))
+                return true;
+        }
+        if (enabled.endsWith("*")) {
+            const prefix = enabled.slice(0, -1);
+            if (target.startsWith(prefix))
+                return true;
+        }
+        if (enabled === target)
+            return true;
+    }
+    return false;
+}
+export function isDiagnosticFlagEnabled(flag, cfg, env = process.env) {
+    const flags = resolveDiagnosticFlags(cfg, env);
+    return matchesDiagnosticFlag(flag, flags);
+}

package/dist/infra/dotenv.js

@@ -6,7 +6,7 @@ export function loadDotEnv(opts) {
     const quiet = opts?.quiet ?? true;
     // Load from process CWD first (dotenv default).
     dotenv.config({ quiet });
-    // Then load global fallback: ~/.pigbot/.env (or PIGBOT_STATE_DIR/.env),
+    // Then load global fallback: ~/.clawdbot/.env (or CLAWDBOT_STATE_DIR/.env),
     // without overriding any env vars already present.
     const globalEnvPath = path.join(resolveConfigDir(process.env), ".env");
     if (!fs.existsSync(globalEnvPath))

package/dist/infra/env.js

@@ -1,4 +1,26 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { parseBooleanValue } from "../utils/boolean.js";
+const log = createSubsystemLogger("env");
+const loggedEnv = new Set();
+function formatEnvValue(value, redact) {
+    if (redact)
+        return "<redacted>";
+    const singleLine = value.replace(/\s+/g, " ").trim();
+    if (singleLine.length <= 160)
+        return singleLine;
+    return `${singleLine.slice(0, 160)}…`;
+}
+export function logAcceptedEnvOption(option) {
+    if (process.env.VITEST || process.env.NODE_ENV === "test")
+        return;
+    if (loggedEnv.has(option.key))
+        return;
+    const rawValue = option.value ?? process.env[option.key];
+    if (!rawValue || !rawValue.trim())
+        return;
+    loggedEnv.add(option.key);
+    log.info(`env: ${option.key}=${formatEnvValue(rawValue, option.redact)} (${option.description})`);
+}
 export function normalizeZaiEnv() {
     if (!process.env.ZAI_API_KEY?.trim() && process.env.Z_AI_API_KEY?.trim()) {
         process.env.ZAI_API_KEY = process.env.Z_AI_API_KEY;

package/dist/infra/exec-approvals.js

@@ -8,8 +8,8 @@ const DEFAULT_SECURITY = "deny";
 const DEFAULT_ASK = "on-miss";
 const DEFAULT_ASK_FALLBACK = "deny";
 const DEFAULT_AUTO_ALLOW_SKILLS = false;
-const DEFAULT_SOCKET = "~/.pigbot/exec-approvals.sock";
-const DEFAULT_FILE = "~/.pigbot/exec-approvals.json";
+const DEFAULT_SOCKET = "~/.clawdbot/exec-approvals.sock";
+const DEFAULT_FILE = "~/.clawdbot/exec-approvals.json";
 export const DEFAULT_SAFE_BINS = ["jq", "grep", "cut", "sort", "uniq", "head", "tail", "tr", "wc"];
 function hashExecApprovalsRaw(raw) {
     return crypto