### Fixes

- Core/plugins: harden clawpatch-reported edge cases across gateway auth cleanup, Claude session id paths, plugin activation policy, apply-patch hunk handling, diagnostic redaction, and plugin metadata validation.

- Mac app: keep app-level menu commands and Dashboard failure states reachable when the remote Gateway is disconnected, and keep the Settings sidebar toggle in the leading titlebar area.

- Gateway/webchat: hide internal runtime-context and other `display: false` transcript messages from Chat history and live message events. Fixes #83216. Thanks @EmpireCreator.

- CLI/help: keep `gateway`, `doctor`, `status`, and `health` help registration out of action/runtime imports so subcommand `--help` stays lightweight in constrained terminals. Fixes #83228. Thanks @dfguerrerom.

if (!clause?.namedBindings) {

continue;

}

if (clause.isTypeOnly) {

continue;

}

if (ts.isNamedImports(clause.namedBindings)) {

for (const element of clause.namedBindings.elements) {

if (element.isTypeOnly) {

continue;

}

const importedName = element.propertyName?.text ?? element.name.text;

const record = recordMap.get(importedName);

if (!record) {

};

export function renderTextReport(envelope: TopologyEnvelope, limit: number): string {

return reportModules[envelope.report].describe(envelope, limit);

const reportModule = reportModules[envelope.report];

if (!reportModule) {

throw new Error(`Unsupported topology report: ${envelope.report}`);

}

return reportModule.describe(envelope, limit);

}

expect(source.sha256).toBe(crypto.createHash("sha256").update("QUJDRA==").digest("hex"));

expect(event.payloadDigest).toMatch(/^[a-f0-9]{64}$/u);

});

it("sanitizes usage and error fields before writing logs", () => {

const lines: string[] = [];

const logger = createAnthropicPayloadLogger({

env: { OPENCLAW_ANTHROPIC_PAYLOAD_LOG: "1" },

writer: {

filePath: "memory",

write: (line) => lines.push(line),

flush: async () => undefined,

},

});

logger?.recordUsage(

[

{

role: "assistant",

content: "",

usage: {

input: 1,

authorization: "Bearer sk-secret", // pragma: allowlist secret

},

} as never,

],

new Error("failed with Bearer sk-secret"), // pragma: allowlist secret

);

const event = JSON.parse(lines[0]?.trim() ?? "{}") as Record<string, unknown>;

expect(event.error).toBe("failed with Bearer <redacted>");

expect(event.usage).toEqual({ input: 1 });

});

});

function formatError(error: unknown): string | undefined {

if (error instanceof Error) {

return error.message;

const redacted = sanitizeDiagnosticPayload(error.message);

return typeof redacted === "string" ? redacted : error.message;

}

if (typeof error === "string") {

return error;

const redacted = sanitizeDiagnosticPayload(error);

return typeof redacted === "string" ? redacted : error;

}

if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {

return String(error);

}

if (error && typeof error === "object") {

return safeJsonStringify(error) ?? "unknown error";

return safeJsonStringify(sanitizeDiagnosticPayload(error)) ?? "unknown error";

}

return undefined;

}

...base,

ts: new Date().toISOString(),

stage: "usage",

usage,

usage: sanitizeDiagnosticPayload(usage) as Record<string, unknown>,

error: errorMessage,

});

log.info("anthropic usage", {

if (chunk.oldLines.length === 0) {

const insertionIndex =

originalLines.length > 0 && originalLines[originalLines.length - 1] === ""

? originalLines.length - 1

: originalLines.length;

chunk.changeContext && !chunk.isEndOfFile

? lineIndex

: originalLines.length > 0 && originalLines[originalLines.length - 1] === ""

? originalLines.length - 1

: originalLines.length;

replacements.push([insertionIndex, 0, chunk.newLines]);

lineIndex = insertionIndex;

continue;

}

expect(result.summary.modified).toEqual(["dest.txt"]);

});

it("updates in place when move target resolves to the source file", async () => {

const memory = createMemoryPatchSandbox({

"source.txt": "foo\nbar\n",

});

const patch = `*** Begin Patch

*** Update File: source.txt

*** Move to: ./source.txt

@@

foo

-bar

+baz

*** End Patch`;

const result = await applyPatch(patch, memory.options);

expect(memory.files.get("/sandbox/source.txt")).toBe("foo\nbaz\n");

expect(result.summary.modified).toEqual(["source.txt"]);

});

it("applies context-only insertions at the requested context", async () => {

const memory = createMemoryPatchSandbox({

"source.txt": "alpha\nanchor\nomega\n",

});

const patch = `*** Begin Patch

*** Update File: source.txt

@@ anchor

+inserted

*** End Patch`;

await applyPatch(patch, memory.options);

expect(memory.files.get("/sandbox/source.txt")).toBe("alpha\nanchor\ninserted\nomega\n");

});

it("keeps later insertion contexts in original file coordinates", async () => {

const memory = createMemoryPatchSandbox({

"source.txt": "a\nb\nc\n",

});

const patch = `*** Begin Patch

*** Update File: source.txt

@@ a

+after-a

@@ b

+after-b

*** End Patch`;

await applyPatch(patch, memory.options);

expect(memory.files.get("/sandbox/source.txt")).toBe("a\nafter-a\nb\nafter-b\nc\n");

});

it("supports end-of-file inserts", async () => {

const memory = createMemoryPatchSandbox({

"end.txt": "line1\n",

const moveTarget = await resolvePatchPath(hunk.movePath, options);

await assertPatchParentPath(hunk.movePath, options);

await ensureDir(moveTarget.resolved, fileOps);

await fileOps.writeFile(moveTarget.resolved, applied);

await fileOps.remove(target.resolved);

recordSummary(summary, seen, "modified", moveTarget.display);

const moveResolvesToSource =

path.resolve(moveTarget.resolved) === path.resolve(target.resolved);

await fileOps.writeFile(

moveResolvesToSource ? target.resolved : moveTarget.resolved,

applied,

);

if (!moveResolvesToSource) {

await fileOps.remove(target.resolved);

}

recordSummary(

summary,

seen,

"modified",

moveResolvesToSource ? target.display : moveTarget.display,

);

} else {

await fileOps.writeFile(target.resolved, applied);

recordSummary(summary, seen, "modified", target.display);

});

const client = new Client({ name: "fake-claude", version: "1.0.0" });

await client.connect(transport);

const tools = await client.listTools();

if (!tools.tools.some((tool) => tool.name === "bundle_probe")) {

throw new Error("bundle_probe tool not exposed");

}

const result = await client.callTool({ name: "bundle_probe", arguments: {} });

await transport.close();

const result = await (async () => {

try {

const tools = await client.listTools();

if (!tools.tools.some((tool) => tool.name === "bundle_probe")) {

throw new Error("bundle_probe tool not exposed");

}

return await client.callTool({ name: "bundle_probe", arguments: {} });

} finally {

await transport.close();

}

})();

const text = Array.isArray(result.content)

? result.content

vi.useRealTimers();

});

it("removes abort listener when stopped manually", () => {

const signal = new AbortController().signal;

const addEventListener = vi.spyOn(signal, "addEventListener");

const removeEventListener = vi.spyOn(signal, "removeEventListener");

const monitor = startDefaultMonitor(createMockChannelManager(), { abortSignal: signal });

monitor.stop();

expect(addEventListener).toHaveBeenCalledWith("abort", expect.any(Function), { once: true });

expect(removeEventListener).toHaveBeenCalledWith("abort", addEventListener.mock.calls[0]?.[1]);

});

it("does not run before the grace period", async () => {

const manager = createMockChannelManager();

const monitor = startDefaultMonitor(manager, { startupGraceMs: 60_000 });