@botcord/daemon 0.2.50 → 0.2.52

package/dist/gateway/channels/botcord.js

@@ -768,6 +768,8 @@ function normalizeBlockForHub(block, seq) {
     if (kind === "assistant_text") {
         // Claude Code: {type:"assistant", message:{content:[{type:"text",text}]}}
         // Codex:       {type:"item.completed", item:{type:"agent_message", text}}
+        // DeepSeek:    {event:"message.delta", payload:{content}} or
+        //              {event:"item.delta", payload:{payload:{kind:"agent_message", delta}}}
         let text = "";
         const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
         for (const c of contents) {
@@ -776,6 +778,15 @@ function normalizeBlockForHub(block, seq) {
         }
         if (!text && typeof raw?.item?.text === "string")
             text = raw.item.text;
+        if (!text && raw?.event === "message.delta" && typeof raw?.payload?.content === "string") {
+            text = raw.payload.content;
+        }
+        if (!text &&
+            raw?.event === "item.delta" &&
+            raw?.payload?.payload?.kind === "agent_message" &&
+            typeof raw?.payload?.payload?.delta === "string") {
+            text = raw.payload.payload.delta;
+        }
         return { kind: "assistant", seq, payload: { text } };
     }
     if (kind === "tool_use") {

package/dist/gateway/runtimes/kimi.d.ts

@@ -8,7 +8,7 @@ export declare function probeKimi(deps?: ProbeDeps): RuntimeProbeResult;
 /**
  * Kimi CLI adapter — spawns:
  *
- *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --prompt <text>
  *
  * `--session <sid>` resumes an existing session or creates a new session with
  * that id, so the adapter generates a UUID on first turn and persists it for

package/dist/gateway/runtimes/kimi.js

@@ -17,6 +17,108 @@ function isValidKimiSessionId(sessionId) {
 function invalidKimiSessionIdError() {
     return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
 }
+const KIMI_EXTRA_FLAGS_WITH_VALUE = new Set([
+    "--add-dir",
+    "--agent",
+    "--agent-file",
+    "--config",
+    "--config-file",
+    "--max-ralph-iterations",
+    "--max-retries-per-step",
+    "--max-steps-per-turn",
+    "--mcp-config",
+    "--mcp-config-file",
+    "--model",
+    "--skills-dir",
+    "-m",
+]);
+const KIMI_EXTRA_BOOLEAN_FLAGS = new Set([
+    "--afk",
+    "--auto-approve",
+    "--debug",
+    "--no-thinking",
+    "--plan",
+    "--thinking",
+    "--verbose",
+    "--yes",
+    "--yolo",
+    "-y",
+]);
+// Flags owned by the adapter because BotCord depends on Kimi's non-interactive
+// stream-json contract, cwd isolation, prompt placement, and session routing.
+const KIMI_ADAPTER_OWNED_FLAGS = new Set([
+    "--acp",
+    "--command",
+    "--continue",
+    "--final-message-only",
+    "--help",
+    "--input-format",
+    "--output-format",
+    "--print",
+    "--prompt",
+    "--quiet",
+    "--resume",
+    "--session",
+    "--version",
+    "--wire",
+    "--work-dir",
+    "-C",
+    "-S",
+    "-V",
+    "-c",
+    "-h",
+    "-p",
+    "-r",
+    "-w",
+]);
+function flagName(arg) {
+    if (!arg.startsWith("-"))
+        return arg;
+    const eq = arg.indexOf("=");
+    return eq === -1 ? arg : arg.slice(0, eq);
+}
+function nextValue(args, index) {
+    const next = args[index + 1];
+    if (typeof next !== "string")
+        return undefined;
+    if (!next.startsWith("-"))
+        return next;
+    return /^-\d/.test(next) ? next : undefined;
+}
+function sanitizeKimiExtraArgs(extraArgs) {
+    if (!extraArgs?.length)
+        return [];
+    const out = [];
+    for (let i = 0; i < extraArgs.length; i += 1) {
+        const arg = extraArgs[i];
+        const name = flagName(arg);
+        if (KIMI_ADAPTER_OWNED_FLAGS.has(name)) {
+            if (!arg.includes("=") && nextValue(extraArgs, i) !== undefined)
+                i += 1;
+            continue;
+        }
+        if (KIMI_EXTRA_FLAGS_WITH_VALUE.has(name)) {
+            if (arg.includes("=")) {
+                out.push(arg);
+                continue;
+            }
+            const value = nextValue(extraArgs, i);
+            if (value !== undefined) {
+                out.push(arg, value);
+                i += 1;
+            }
+            continue;
+        }
+        if (KIMI_EXTRA_BOOLEAN_FLAGS.has(name)) {
+            out.push(arg);
+            continue;
+        }
+        if (arg.startsWith("-") && !arg.includes("=") && nextValue(extraArgs, i) !== undefined) {
+            i += 1;
+        }
+    }
+    return out;
+}
 /** Resolve the Kimi CLI executable on PATH. */
 export function resolveKimiCommand(deps = {}) {
     return resolveCommandOnPath("kimi", deps);
@@ -35,7 +137,7 @@ export function probeKimi(deps = {}) {
 /**
  * Kimi CLI adapter — spawns:
  *
- *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --prompt <text>
  *
  * `--session <sid>` resumes an existing session or creates a new session with
  * that id, so the adapter generates a UUID on first turn and persists it for
@@ -83,8 +185,7 @@ export class KimiAdapter extends NdjsonStreamAdapter {
             sessionId,
             "--afk",
         ];
-        if (opts.extraArgs?.length)
-            args.push(...opts.extraArgs);
+        args.push(...sanitizeKimiExtraArgs(opts.extraArgs));
         args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
         return args;
     }

package/dist/openclaw-discovery.js

@@ -3,8 +3,8 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { log as daemonLog } from "./log.js";
 import { probeOpenclawAgents } from "./provision.js";
-const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "/etc/openclaw/"];
-const DEFAULT_PORTS = [18789, 16200];
+const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "~/.qclaw/", "/etc/openclaw/"];
+const DEFAULT_PORTS = [18789, 16200, 28789];
 const DEFAULT_TOKEN_FILE_PATHS = [
     "/run/openclaw/gateway-token",
     "/var/run/openclaw/gateway-token",
@@ -346,6 +346,9 @@ function discoverFromConfigDir(root) {
 }
 function parseJsonConfig(raw) {
     const obj = JSON.parse(raw);
+    const qclaw = pickQclawGatewayValues(obj);
+    if (qclaw)
+        return qclaw;
     // Prefer OpenClaw's native shape: `gateway.port` + `gateway.auth.token`.
     // The legacy `acp.url` shape is also supported for explicit user-authored configs.
     const native = pickOpenclawGatewayValues(obj?.gateway);
@@ -354,6 +357,34 @@ function parseJsonConfig(raw) {
     const acp = obj?.acp ?? obj?.gateway?.acp ?? obj?.gateway ?? obj;
     return pickConfigValues(acp);
 }
+function pickQclawGatewayValues(obj) {
+    if (!obj || typeof obj !== "object")
+        return null;
+    const port = typeof obj.port === "number" ? obj.port : undefined;
+    const configPath = typeof obj.configPath === "string" && obj.configPath.trim()
+        ? obj.configPath.trim()
+        : undefined;
+    if (!port && !configPath)
+        return null;
+    const fromConfig = configPath ? readGatewayValuesFromConfigPath(configPath) : null;
+    if (fromConfig)
+        return fromConfig;
+    if (!port)
+        return null;
+    return { url: `ws://127.0.0.1:${port}` };
+}
+function readGatewayValuesFromConfigPath(configPath) {
+    try {
+        const raw = readFileSync(expandHome(configPath), "utf8");
+        const parsed = parseJsonConfig(raw);
+        if (parsed?.url)
+            return parsed;
+    }
+    catch {
+        // qclaw.json may be copied without its referenced openclaw.json.
+    }
+    return null;
+}
 function pickOpenclawGatewayValues(gw) {
     if (!gw || typeof gw !== "object")
         return null;

package/dist/provision.js

@@ -1075,10 +1075,10 @@ function localOpenclawAcpDisabled(rawUrl) {
     if (!isLoopbackUrl(rawUrl))
         return false;
     try {
-        const file = path.join(homedir(), ".openclaw", "openclaw.json");
-        if (!existsSync(file))
+        const source = pickLocalOpenclawConfig(rawUrl);
+        if (!source)
             return false;
-        const cfg = JSON.parse(readFileSync(file, "utf8"));
+        const cfg = JSON.parse(readFileSync(source.file, "utf8"));
         return cfg?.acp?.enabled === false;
     }
     catch {
@@ -1491,12 +1491,13 @@ export async function probeOpenclawAgents(profile, opts = {}) {
         token: prepared.resolvedToken,
         timeoutMs: opts.timeoutMs ?? 3000,
     });
-    // For loopback gateways the agent roster lives in `~/.openclaw/openclaw.json`
+    // For loopback gateways the agent roster lives in local OpenClaw config
+    // (`~/.openclaw/openclaw.json`, or QClaw's `~/.qclaw/openclaw.json`)
     // and is the source of truth — listing it over the wire would require a
     // paired device identity (operator.read scope). When the WS probe is the
     // default (i.e. no test injection) we enrich the result from disk.
     if (result.ok && !result.agents && !opts.probe && isLoopbackUrl(profile.url)) {
-        const local = readLocalOpenclawAgents();
+        const local = readLocalOpenclawAgents(profile.url);
         if (local && local.length > 0)
             result.agents = local;
     }
@@ -1511,17 +1512,18 @@ function isLoopbackUrl(raw) {
         return false;
     }
 }
-function readLocalOpenclawAgents() {
+function readLocalOpenclawAgents(rawUrl) {
     try {
-        const file = path.join(homedir(), ".openclaw", "openclaw.json");
-        if (!existsSync(file))
-            return readLocalOpenclawAgentDirs() ?? [{ id: "default" }];
+        const source = pickLocalOpenclawConfig(rawUrl);
+        if (!source)
+            return readLocalOpenclawAgentDirs(path.join(homedir(), ".openclaw")) ?? [{ id: "default" }];
+        const { file, stateDir } = source;
         const cfg = JSON.parse(readFileSync(file, "utf8"));
         const list = Array.isArray(cfg?.agents?.list) ? cfg.agents.list : [];
         const explicitDefaultId = typeof cfg?.agents?.defaults?.id === "string" && cfg.agents.defaults.id
             ? cfg.agents.defaults.id
             : null;
-        const dirAgents = readLocalOpenclawAgentDirs();
+        const dirAgents = readLocalOpenclawAgentDirs(stateDir);
         const defaultId = explicitDefaultId ?? (list.length === 0 && !dirAgents ? "default" : null);
         const seen = new Set();
         const out = [];
@@ -1565,16 +1567,52 @@ function readLocalOpenclawAgents() {
         return null;
     }
 }
-function readLocalOpenclawAgentDirs() {
+function pickLocalOpenclawConfig(rawUrl) {
+    const candidates = [
+        { file: path.join(homedir(), ".openclaw", "openclaw.json"), stateDir: path.join(homedir(), ".openclaw") },
+        { file: path.join(homedir(), ".qclaw", "openclaw.json"), stateDir: path.join(homedir(), ".qclaw") },
+    ];
+    const targetPort = urlPort(rawUrl);
+    let firstExisting = null;
+    for (const candidate of candidates) {
+        if (!existsSync(candidate.file))
+            continue;
+        firstExisting ??= candidate;
+        if (!targetPort)
+            continue;
+        try {
+            const cfg = JSON.parse(readFileSync(candidate.file, "utf8"));
+            if (Number(cfg?.gateway?.port) === targetPort)
+                return candidate;
+        }
+        catch {
+            // Try the next local config.
+        }
+    }
+    return firstExisting;
+}
+function urlPort(rawUrl) {
+    if (!rawUrl)
+        return null;
     try {
-        const dir = path.join(homedir(), ".openclaw", "agents");
+        const u = new URL(rawUrl);
+        const port = Number(u.port || (u.protocol === "wss:" ? 443 : 80));
+        return Number.isInteger(port) && port > 0 ? port : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readLocalOpenclawAgentDirs(stateDir) {
+    try {
+        const dir = path.join(stateDir, "agents");
         if (!existsSync(dir))
             return null;
         const agents = readdirSync(dir, { withFileTypes: true })
             .filter((entry) => entry.isDirectory() && entry.name.length > 0)
             .map((entry) => ({
             id: entry.name,
-            workspace: path.join(dir, entry.name),
+            workspace: resolveAgentDirWorkspace(dir, entry.name),
         }));
         if (agents.length === 0)
             return null;
@@ -1591,6 +1629,10 @@ function readLocalOpenclawAgentDirs() {
         return null;
     }
 }
+function resolveAgentDirWorkspace(agentsDir, agentId) {
+    const nested = path.join(agentsDir, agentId, "agent");
+    return existsSync(nested) ? nested : path.join(agentsDir, agentId);
+}
 function resolveOpenclawIdentityName(agentId, workspace, cfg) {
     const root = workspace ?? resolveOpenclawWorkspace(agentId, cfg);
     if (!root)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.50",
+  "version": "0.2.52",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/openclaw-discovery.test.ts

@@ -128,6 +128,41 @@ describe("discoverLocalOpenclawGateways", () => {
     ]);
   });
 
+  it("discovers QClaw's state config and referenced OpenClaw config", async () => {
+    const dir = tempDir();
+    const openclawConfig = path.join(dir, "openclaw.json");
+    writeFileSync(
+      openclawConfig,
+      JSON.stringify({
+        gateway: {
+          port: 28789,
+          bind: "loopback",
+          auth: { mode: "token", token: "qclaw-token" },
+        },
+      }),
+    );
+    writeFileSync(
+      path.join(dir, "qclaw.json"),
+      JSON.stringify({
+        configPath: openclawConfig,
+        port: 28789,
+      }),
+    );
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [dir],
+      defaultPorts: [],
+    });
+
+    expect(found).toEqual([
+      expect.objectContaining({
+        url: "ws://127.0.0.1:28789",
+        token: "qclaw-token",
+        source: "config-file",
+      }),
+    ]);
+  });
+
   it("uses OPENCLAW_ACP_URL and token env vars", async () => {
     const found = await discoverLocalOpenclawGateways({
       searchPaths: [],
@@ -269,8 +304,8 @@ describe("discoverLocalOpenclawGateways", () => {
     ]);
   });
 
-  it("includes 16200 in default discovery ports", () => {
-    expect(defaultOpenclawDiscoveryPorts()).toEqual(expect.arrayContaining([18789, 16200]));
+  it("includes OpenClaw and QClaw ports in default discovery ports", () => {
+    expect(defaultOpenclawDiscoveryPorts()).toEqual(expect.arrayContaining([18789, 16200, 28789]));
   });
 
   it("adds default-port candidates only when the probe succeeds", async () => {

package/src/__tests__/provision.test.ts

@@ -27,6 +27,7 @@ vi.mock("../config.js", async () => {
 const {
   addAgentToConfig,
   adoptDiscoveredOpenclawAgents,
+  probeOpenclawAgents,
   removeAgentFromConfig,
   reloadConfig,
   setRoute,
@@ -34,6 +35,7 @@ const {
 } = await import("../provision.js");
 const { CONTROL_FRAME_TYPES } = await import("@botcord/protocol-core");
 import type { DaemonConfig } from "../config.js";
+import type { WsEndpointProbeFn } from "../provision.js";
 import type {
   GatewayChannelConfig,
   GatewayRoute,
@@ -1139,7 +1141,7 @@ describe("adoptDiscoveredOpenclawAgents", () => {
         openclawGateways: [{ name: "local", url: "ws://127.0.0.1:18789" }],
       };
       const register = vi.fn();
-      const probe = vi.fn<Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["probe"]>(
+      const probe = vi.fn<WsEndpointProbeFn>(
         async () => ({ ok: true, agents: [{ id: "main" }] }),
       );
 
@@ -1224,6 +1226,70 @@ describe("adoptDiscoveredOpenclawAgents", () => {
   });
 });
 
+describe("probeOpenclawAgents local profiles", () => {
+  it("enriches loopback QClaw gateways from ~/.qclaw/openclaw.json", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      const { WebSocketServer } = await import("ws");
+      const qclawDir = nodePath.join(tmp, ".qclaw");
+      fs.mkdirSync(qclawDir, { recursive: true });
+
+      const wss = new WebSocketServer({ host: "127.0.0.1", port: 0 });
+      await new Promise<void>((resolve) => wss.once("listening", resolve));
+      const address = wss.address();
+      if (typeof address === "string" || address === null) {
+        throw new Error("expected tcp websocket address");
+      }
+
+      fs.writeFileSync(
+        nodePath.join(qclawDir, "openclaw.json"),
+        JSON.stringify({
+          agents: {
+            defaults: {
+              workspace: nodePath.join(qclawDir, "workspace"),
+              model: { primary: "qclaw/modelroute" },
+            },
+            list: [{ id: "main", name: "QClaw" }],
+          },
+          gateway: {
+            port: address.port,
+            auth: { mode: "token", token: "qclaw-token" },
+          },
+        }),
+      );
+
+      wss.on("connection", (ws) => {
+        ws.send(JSON.stringify({ type: "event", event: "connect.challenge", payload: { nonce: "n" } }));
+        ws.on("message", (raw) => {
+          const msg = JSON.parse(raw.toString("utf8"));
+          if (msg.method === "connect") {
+            ws.send(
+              JSON.stringify({
+                type: "res",
+                id: msg.id,
+                ok: true,
+                payload: { type: "hello-ok", server: { version: "2026.4.21" } },
+              }),
+            );
+          }
+        });
+      });
+
+      try {
+        const res = await probeOpenclawAgents({
+          url: `ws://127.0.0.1:${address.port}`,
+          token: "qclaw-token",
+        });
+
+        expect(res.ok).toBe(true);
+        expect(res.version).toBe("2026.4.21");
+        expect(res.agents).toEqual([{ id: "main", name: "QClaw" }]);
+      } finally {
+        await new Promise<void>((resolve) => wss.close(() => resolve()));
+      }
+    });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // revoke_agent — new flag semantics (plan §11.3)
 // ---------------------------------------------------------------------------

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -618,6 +618,92 @@ describe("createBotCordChannel — streamBlock()", () => {
     }
   });
 
+  it("normalizes DeepSeek message.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 4,
+          raw: {
+            event: "message.delta",
+            payload: { thread_id: "thr_1", turn_id: "turn_1", content: "hello " },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 4,
+        payload: { text: "hello " },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
+  it("normalizes DeepSeek item.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 5,
+          raw: {
+            event: "item.delta",
+            payload: {
+              thread_id: "thr_1",
+              turn_id: "turn_1",
+              payload: { kind: "agent_message", delta: "deepseek" },
+            },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 5,
+        payload: { text: "deepseek" },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
   it("normalizes a thinking block with phase/label/source payload", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;

package/src/gateway/__tests__/kimi-adapter.test.ts

@@ -18,7 +18,7 @@ afterAll(() => {
   rmSync(tmpRoot, { recursive: true, force: true });
 });
 
-function runAdapter(script: string, sessionId: string | null = null) {
+function runAdapter(script: string, sessionId: string | null = null, extraArgs?: string[]) {
   const adapter = new KimiAdapter({ binary: script });
   const ctrl = new AbortController();
   return adapter.run({
@@ -28,6 +28,7 @@ function runAdapter(script: string, sessionId: string | null = null) {
     cwd: tmpRoot,
     signal: ctrl.signal,
     trustLevel: "owner",
+    extraArgs,
   });
 }
 
@@ -69,6 +70,89 @@ process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(ar
     expect(argv).toContain("--afk");
   });
 
+  it("drops non-Kimi inherited extraArgs and their values", async () => {
+    const script = makeScript(
+      "filter-foreign-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123", [
+      "--permission-mode",
+      "bypassPermissions",
+      "--model",
+      "kimi-k2",
+    ]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv).not.toContain("--permission-mode");
+    expect(argv).not.toContain("bypassPermissions");
+    expect(argv).toContain("--model");
+    expect(argv[argv.indexOf("--model") + 1]).toBe("kimi-k2");
+  });
+
+  it("preserves Kimi value flags with negative numeric values", async () => {
+    const script = makeScript(
+      "negative-value-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123", [
+      "--max-ralph-iterations",
+      "-1",
+      "--max-steps-per-turn=3",
+    ]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv).toContain("--max-ralph-iterations");
+    expect(argv[argv.indexOf("--max-ralph-iterations") + 1]).toBe("-1");
+    expect(argv).toContain("--max-steps-per-turn=3");
+  });
+
+  it("drops incomplete Kimi value flags instead of passing invalid argv", async () => {
+    const script = makeScript(
+      "incomplete-value-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123", ["--model", "--plan"]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv).not.toContain("--model");
+    expect(argv).toContain("--plan");
+  });
+
+  it("does not let extraArgs override adapter-owned stream/session/prompt flags", async () => {
+    const script = makeScript(
+      "filter-owned-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "real-session", [
+      "--output-format",
+      "text",
+      "--session",
+      "evil-session",
+      "--prompt",
+      "evil prompt",
+      "--plan",
+    ]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv.filter((a) => a === "--output-format")).toHaveLength(1);
+    expect(argv[argv.indexOf("--output-format") + 1]).toBe("stream-json");
+    expect(argv.filter((a) => a === "--session")).toHaveLength(1);
+    expect(argv[argv.indexOf("--session") + 1]).toBe("real-session");
+    expect(argv.filter((a) => a === "--prompt")).toHaveLength(1);
+    expect(argv[argv.indexOf("--prompt") + 1]).toBe("hi");
+    expect(argv).toContain("--plan");
+    expect(argv).not.toContain("evil-session");
+    expect(argv).not.toContain("evil prompt");
+  });
+
   it("rejects session ids that could be parsed as flags", async () => {
     const script = makeScript(
       "should-not-spawn.js",

package/src/gateway/channels/botcord.ts

@@ -907,12 +907,25 @@ function normalizeBlockForHub(
   if (kind === "assistant_text") {
     // Claude Code: {type:"assistant", message:{content:[{type:"text",text}]}}
     // Codex:       {type:"item.completed", item:{type:"agent_message", text}}
+    // DeepSeek:    {event:"message.delta", payload:{content}} or
+    //              {event:"item.delta", payload:{payload:{kind:"agent_message", delta}}}
     let text = "";
     const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
     for (const c of contents) {
       if (c?.type === "text" && typeof c.text === "string") text += c.text;
     }
     if (!text && typeof raw?.item?.text === "string") text = raw.item.text;
+    if (!text && raw?.event === "message.delta" && typeof raw?.payload?.content === "string") {
+      text = raw.payload.content;
+    }
+    if (
+      !text &&
+      raw?.event === "item.delta" &&
+      raw?.payload?.payload?.kind === "agent_message" &&
+      typeof raw?.payload?.payload?.delta === "string"
+    ) {
+      text = raw.payload.payload.delta;
+    }
     return { kind: "assistant", seq, payload: { text } };
   }
 

package/src/gateway/runtimes/kimi.ts

@@ -22,6 +22,113 @@ function invalidKimiSessionIdError(): string {
   return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
 }
 
+const KIMI_EXTRA_FLAGS_WITH_VALUE = new Set([
+  "--add-dir",
+  "--agent",
+  "--agent-file",
+  "--config",
+  "--config-file",
+  "--max-ralph-iterations",
+  "--max-retries-per-step",
+  "--max-steps-per-turn",
+  "--mcp-config",
+  "--mcp-config-file",
+  "--model",
+  "--skills-dir",
+  "-m",
+]);
+
+const KIMI_EXTRA_BOOLEAN_FLAGS = new Set([
+  "--afk",
+  "--auto-approve",
+  "--debug",
+  "--no-thinking",
+  "--plan",
+  "--thinking",
+  "--verbose",
+  "--yes",
+  "--yolo",
+  "-y",
+]);
+
+// Flags owned by the adapter because BotCord depends on Kimi's non-interactive
+// stream-json contract, cwd isolation, prompt placement, and session routing.
+const KIMI_ADAPTER_OWNED_FLAGS = new Set([
+  "--acp",
+  "--command",
+  "--continue",
+  "--final-message-only",
+  "--help",
+  "--input-format",
+  "--output-format",
+  "--print",
+  "--prompt",
+  "--quiet",
+  "--resume",
+  "--session",
+  "--version",
+  "--wire",
+  "--work-dir",
+  "-C",
+  "-S",
+  "-V",
+  "-c",
+  "-h",
+  "-p",
+  "-r",
+  "-w",
+]);
+
+function flagName(arg: string): string {
+  if (!arg.startsWith("-")) return arg;
+  const eq = arg.indexOf("=");
+  return eq === -1 ? arg : arg.slice(0, eq);
+}
+
+function nextValue(args: string[], index: number): string | undefined {
+  const next = args[index + 1];
+  if (typeof next !== "string") return undefined;
+  if (!next.startsWith("-")) return next;
+  return /^-\d/.test(next) ? next : undefined;
+}
+
+function sanitizeKimiExtraArgs(extraArgs: string[] | undefined): string[] {
+  if (!extraArgs?.length) return [];
+  const out: string[] = [];
+  for (let i = 0; i < extraArgs.length; i += 1) {
+    const arg = extraArgs[i];
+    const name = flagName(arg);
+
+    if (KIMI_ADAPTER_OWNED_FLAGS.has(name)) {
+      if (!arg.includes("=") && nextValue(extraArgs, i) !== undefined) i += 1;
+      continue;
+    }
+
+    if (KIMI_EXTRA_FLAGS_WITH_VALUE.has(name)) {
+      if (arg.includes("=")) {
+        out.push(arg);
+        continue;
+      }
+      const value = nextValue(extraArgs, i);
+      if (value !== undefined) {
+        out.push(arg, value);
+        i += 1;
+      }
+      continue;
+    }
+
+    if (KIMI_EXTRA_BOOLEAN_FLAGS.has(name)) {
+      out.push(arg);
+      continue;
+    }
+
+    if (arg.startsWith("-") && !arg.includes("=") && nextValue(extraArgs, i) !== undefined) {
+      i += 1;
+    }
+  }
+  return out;
+}
+
 /** Resolve the Kimi CLI executable on PATH. */
 export function resolveKimiCommand(deps: ProbeDeps = {}): string | null {
   return resolveCommandOnPath("kimi", deps);
@@ -41,7 +148,7 @@ export function probeKimi(deps: ProbeDeps = {}): RuntimeProbeResult {
 /**
  * Kimi CLI adapter — spawns:
  *
- *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --prompt <text>
  *
  * `--session <sid>` resumes an existing session or creates a new session with
  * that id, so the adapter generates a UUID on first turn and persists it for
@@ -93,7 +200,7 @@ export class KimiAdapter extends NdjsonStreamAdapter {
       sessionId,
       "--afk",
     ];
-    if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+    args.push(...sanitizeKimiExtraArgs(opts.extraArgs));
     args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
     return args;
   }

package/src/openclaw-discovery.ts

@@ -34,8 +34,8 @@ export interface MergeOpenclawGatewayResult {
   added: OpenclawGatewayProfile[];
 }
 
-const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "/etc/openclaw/"];
-const DEFAULT_PORTS = [18789, 16200];
+const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "~/.qclaw/", "/etc/openclaw/"];
+const DEFAULT_PORTS = [18789, 16200, 28789];
 const DEFAULT_TOKEN_FILE_PATHS = [
   "/run/openclaw/gateway-token",
   "/var/run/openclaw/gateway-token",
@@ -382,6 +382,8 @@ function discoverFromConfigDir(root: string): DiscoveredOpenclawGateway[] {
 
 function parseJsonConfig(raw: string): { url?: string; token?: string; tokenFile?: string } | null {
   const obj = JSON.parse(raw) as any;
+  const qclaw = pickQclawGatewayValues(obj);
+  if (qclaw) return qclaw;
   // Prefer OpenClaw's native shape: `gateway.port` + `gateway.auth.token`.
   // The legacy `acp.url` shape is also supported for explicit user-authored configs.
   const native = pickOpenclawGatewayValues(obj?.gateway);
@@ -390,6 +392,35 @@ function parseJsonConfig(raw: string): { url?: string; token?: string; tokenFile
   return pickConfigValues(acp);
 }
 
+function pickQclawGatewayValues(
+  obj: any,
+): { url?: string; token?: string; tokenFile?: string } | null {
+  if (!obj || typeof obj !== "object") return null;
+  const port = typeof obj.port === "number" ? obj.port : undefined;
+  const configPath = typeof obj.configPath === "string" && obj.configPath.trim()
+    ? obj.configPath.trim()
+    : undefined;
+  if (!port && !configPath) return null;
+
+  const fromConfig = configPath ? readGatewayValuesFromConfigPath(configPath) : null;
+  if (fromConfig) return fromConfig;
+  if (!port) return null;
+  return { url: `ws://127.0.0.1:${port}` };
+}
+
+function readGatewayValuesFromConfigPath(
+  configPath: string,
+): { url?: string; token?: string; tokenFile?: string } | null {
+  try {
+    const raw = readFileSync(expandHome(configPath), "utf8");
+    const parsed = parseJsonConfig(raw);
+    if (parsed?.url) return parsed;
+  } catch {
+    // qclaw.json may be copied without its referenced openclaw.json.
+  }
+  return null;
+}
+
 function pickOpenclawGatewayValues(
   gw: any,
 ): { url?: string; token?: string; tokenFile?: string } | null {

package/src/provision.ts

@@ -1362,9 +1362,9 @@ export async function adoptDiscoveredOpenclawAgents(ctx: {
 function localOpenclawAcpDisabled(rawUrl: string): boolean {
   if (!isLoopbackUrl(rawUrl)) return false;
   try {
-    const file = path.join(homedir(), ".openclaw", "openclaw.json");
-    if (!existsSync(file)) return false;
-    const cfg = JSON.parse(readFileSync(file, "utf8")) as any;
+    const source = pickLocalOpenclawConfig(rawUrl);
+    if (!source) return false;
+    const cfg = JSON.parse(readFileSync(source.file, "utf8")) as any;
     return cfg?.acp?.enabled === false;
   } catch {
     return false;
@@ -1838,12 +1838,13 @@ export async function probeOpenclawAgents(
     token: prepared.resolvedToken,
     timeoutMs: opts.timeoutMs ?? 3000,
   });
-  // For loopback gateways the agent roster lives in `~/.openclaw/openclaw.json`
+  // For loopback gateways the agent roster lives in local OpenClaw config
+  // (`~/.openclaw/openclaw.json`, or QClaw's `~/.qclaw/openclaw.json`)
   // and is the source of truth — listing it over the wire would require a
   // paired device identity (operator.read scope). When the WS probe is the
   // default (i.e. no test injection) we enrich the result from disk.
   if (result.ok && !result.agents && !opts.probe && isLoopbackUrl(profile.url)) {
-    const local = readLocalOpenclawAgents();
+    const local = readLocalOpenclawAgents(profile.url);
     if (local && local.length > 0) result.agents = local;
   }
   return result;
@@ -1858,22 +1859,23 @@ function isLoopbackUrl(raw: string): boolean {
   }
 }
 
-function readLocalOpenclawAgents(): Array<{
+function readLocalOpenclawAgents(rawUrl?: string): Array<{
   id: string;
   name?: string;
   workspace?: string;
   model?: { name?: string; provider?: string };
 }> | null {
   try {
-    const file = path.join(homedir(), ".openclaw", "openclaw.json");
-    if (!existsSync(file)) return readLocalOpenclawAgentDirs() ?? [{ id: "default" }];
+    const source = pickLocalOpenclawConfig(rawUrl);
+    if (!source) return readLocalOpenclawAgentDirs(path.join(homedir(), ".openclaw")) ?? [{ id: "default" }];
+    const { file, stateDir } = source;
     const cfg = JSON.parse(readFileSync(file, "utf8")) as any;
     const list = Array.isArray(cfg?.agents?.list) ? cfg.agents.list : [];
     const explicitDefaultId =
       typeof cfg?.agents?.defaults?.id === "string" && cfg.agents.defaults.id
         ? cfg.agents.defaults.id
         : null;
-    const dirAgents = readLocalOpenclawAgentDirs();
+    const dirAgents = readLocalOpenclawAgentDirs(stateDir);
     const defaultId = explicitDefaultId ?? (list.length === 0 && !dirAgents ? "default" : null);
     const seen = new Set<string>();
     const out: Array<{ id: string; name?: string; workspace?: string; model?: { name?: string; provider?: string } }> = [];
@@ -1906,18 +1908,50 @@ function readLocalOpenclawAgents(): Array<{
   }
 }
 
-function readLocalOpenclawAgentDirs(): Array<{
+function pickLocalOpenclawConfig(rawUrl?: string): { file: string; stateDir: string } | null {
+  const candidates = [
+    { file: path.join(homedir(), ".openclaw", "openclaw.json"), stateDir: path.join(homedir(), ".openclaw") },
+    { file: path.join(homedir(), ".qclaw", "openclaw.json"), stateDir: path.join(homedir(), ".qclaw") },
+  ];
+  const targetPort = urlPort(rawUrl);
+  let firstExisting: { file: string; stateDir: string } | null = null;
+  for (const candidate of candidates) {
+    if (!existsSync(candidate.file)) continue;
+    firstExisting ??= candidate;
+    if (!targetPort) continue;
+    try {
+      const cfg = JSON.parse(readFileSync(candidate.file, "utf8")) as any;
+      if (Number(cfg?.gateway?.port) === targetPort) return candidate;
+    } catch {
+      // Try the next local config.
+    }
+  }
+  return firstExisting;
+}
+
+function urlPort(rawUrl?: string): number | null {
+  if (!rawUrl) return null;
+  try {
+    const u = new URL(rawUrl);
+    const port = Number(u.port || (u.protocol === "wss:" ? 443 : 80));
+    return Number.isInteger(port) && port > 0 ? port : null;
+  } catch {
+    return null;
+  }
+}
+
+function readLocalOpenclawAgentDirs(stateDir: string): Array<{
   id: string;
   workspace?: string;
 }> | null {
   try {
-    const dir = path.join(homedir(), ".openclaw", "agents");
+    const dir = path.join(stateDir, "agents");
     if (!existsSync(dir)) return null;
     const agents = readdirSync(dir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && entry.name.length > 0)
       .map((entry) => ({
         id: entry.name,
-        workspace: path.join(dir, entry.name),
+        workspace: resolveAgentDirWorkspace(dir, entry.name),
       }));
     if (agents.length === 0) return null;
     agents.sort((a, b) => {
@@ -1931,6 +1965,11 @@ function readLocalOpenclawAgentDirs(): Array<{
   }
 }
 
+function resolveAgentDirWorkspace(agentsDir: string, agentId: string): string {
+  const nested = path.join(agentsDir, agentId, "agent");
+  return existsSync(nested) ? nested : path.join(agentsDir, agentId);
+}
+
 function resolveOpenclawIdentityName(
   agentId: string,
   workspace?: string,