### Fixes

- Media/audio: skip empty structured sherpa-onnx transcripts instead of treating the raw JSON payload as spoken text. (#84667) Thanks @TurboTheTurtle.

- Node/Linux: keep `OPENCLAW_GATEWAY_TOKEN` out of generated systemd unit files by writing node service token values to a node-specific env file. (#84408)

- Memory-core/dreaming: reuse stable narrative subagent session keys per workspace and phase while keeping per-run idempotency and bounded cleanup, so stale `dreaming-narrative-*` sessions do not accumulate. Fixes #68252, #69187, and #70402. (#70464) Thanks @chiyouYCH.

- Trajectory/support: tolerate partial skill snapshot entries when building support metadata so rejected skill path scans no longer abort trajectory capture. (#71185) Thanks @lukeboyett.

- Agents/Pi: disable the embedded pi-coding-agent runtime auto-retry so OpenClaw's own retry and failover loop does not replay failed tool calls through a nested SDK retry. Fixes #73781. (#74434) Thanks @yelog.

const tlsFingerprint =

normalizeOptionalString(opts.tlsFingerprint) || config?.gateway?.tlsFingerprint;

const tls = Boolean(opts.tls) || Boolean(tlsFingerprint) || Boolean(config?.gateway?.tls);

const { programArguments, workingDirectory, environment, description } =

const { programArguments, workingDirectory, environment, environmentValueSources, description } =

await buildNodeInstallPlan({

env: process.env,

host,

programArguments,

workingDirectory,

environment,

environmentValueSources,

description,

});

},

expect(plan.environment).toEqual({

OPENCLAW_SERVICE_VERSION: "2026.3.22",

});

expect(plan.environmentValueSources).toEqual({

OPENCLAW_GATEWAY_TOKEN: "file",

});

expect(mocks.resolvePreferredNodePath).not.toHaveBeenCalled();

expect(mocks.buildNodeServiceEnvironment).toHaveBeenCalledWith({

env: {},

extraPathDirs: undefined,

});

});

it("marks node gateway tokens as file-backed service env", async () => {

mocks.resolveNodeProgramArguments.mockResolvedValue({

programArguments: ["node", "node-host"],

workingDirectory: "/Users/me",

});

mocks.resolveSystemNodeInfo.mockResolvedValue({

path: "/usr/bin/node",

version: "22.0.0",

supported: true,

});

mocks.renderSystemNodeWarning.mockReturnValue(undefined);

mocks.buildNodeServiceEnvironment.mockReturnValue({

OPENCLAW_GATEWAY_TOKEN: "node-token",

OPENCLAW_SERVICE_VERSION: "2026.3.22",

});

const plan = await buildNodeInstallPlan({

env: { OPENCLAW_GATEWAY_TOKEN: "node-token" },

host: "127.0.0.1",

port: 18789,

runtime: "node",

});

expect(plan.environment.OPENCLAW_GATEWAY_TOKEN).toBe("node-token");

expect(plan.environmentValueSources).toEqual({

OPENCLAW_GATEWAY_TOKEN: "file",

});

});

});

import { formatNodeServiceDescription } from "../daemon/constants.js";

import { resolveNodeProgramArguments } from "../daemon/program-args.js";

import { buildNodeServiceEnvironment } from "../daemon/service-env.js";

import type { GatewayServiceEnvironmentValueSource } from "../daemon/service-types.js";

import {

emitDaemonInstallRuntimeWarning,

resolveDaemonInstallRuntimeInputs,

programArguments: string[];

workingDirectory?: string;

environment: Record<string, string | undefined>;

environmentValueSources?: Record<string, GatewayServiceEnvironmentValueSource | undefined>;

description?: string;

};

function buildNodeInstallEnvironmentValueSources(): Record<

string,

GatewayServiceEnvironmentValueSource | undefined

> {

return {

OPENCLAW_GATEWAY_TOKEN: "file",

};

}

export async function buildNodeInstallPlan(params: {

env: Record<string, string | undefined>;

host: string;

version: environment.OPENCLAW_SERVICE_VERSION,

});

return { programArguments, workingDirectory, environment, description };

return {

programArguments,

workingDirectory,

environment,

environmentValueSources: buildNodeInstallEnvironmentValueSources(),

description,

};

}

type ArgSplitEscapeMode = "none" | "backslash" | "backslash-quote-only";

type ArgSplitQuoteChar = '"' | "'";

type ArgSplitQuoteStart = "anywhere" | "item-start";

export function splitArgsPreservingQuotes(

value: string,

options?: { escapeMode?: ArgSplitEscapeMode },

options?: {

escapeMode?: ArgSplitEscapeMode;

quoteChars?: readonly ArgSplitQuoteChar[];

quoteStart?: ArgSplitQuoteStart;

},

): string[] {

const args: string[] = [];

let current = "";

let inQuotes = false;

let quoteChar: ArgSplitQuoteChar | null = null;

const escapeMode = options?.escapeMode ?? "none";

const quoteChars = new Set<ArgSplitQuoteChar>(options?.quoteChars ?? ['"']);

const quoteStart = options?.quoteStart ?? "anywhere";

for (let i = 0; i < value.length; i++) {

const char = value[i];

i++;

continue;

}

if (char === '"') {

inQuotes = !inQuotes;

continue;

if (quoteChars.has(char as ArgSplitQuoteChar)) {

if (quoteChar === char) {

quoteChar = null;

continue;

}

const canOpenQuote = quoteStart === "anywhere" || current.length === 0;

if (!quoteChar && canOpenQuote) {

quoteChar = char as ArgSplitQuoteChar;

continue;

}

}

if (!inQuotes && /\s/.test(char)) {

if (!quoteChar && /\s/.test(char)) {

if (current) {

args.push(current);

current = "";

}

const unquoted = (() => {

if (!(trimmed.startsWith('"') && trimmed.endsWith('"'))) {

const quote = trimmed[0];

if (!((quote === '"' || quote === "'") && trimmed.endsWith(quote))) {

return trimmed;

}

let out = "";

const value = unquoted.slice(eq + 1);

return { key, value };

}

export function parseSystemdEnvAssignments(raw: string): Array<{ key: string; value: string }> {

return splitArgsPreservingQuotes(raw, {

escapeMode: "backslash",

quoteChars: ['"', "'"],

quoteStart: "item-start",

}).flatMap((entry) => {

const parsed = parseSystemdEnvAssignment(entry);

return parsed ? [parsed] : [];

});

}

export function renderSystemdEnvAssignment(key: string, value: string): string {

return systemdEscapeArg(`${key}=${value}`);

}