fix(actions): skip non-string entries in formatActionSimiles/Tags

Production observation (2026-04-28): the bot dropped a user message
in cozy ("@remilio nubilio would you like that? look what me and shaw
were just talking about ...") and stayed silent. Bot log showed:

  [PLUGIN:DISCORD] Error handling message
    (error=undefined is not an object (evaluating 'tag.trim'))

Trace: plugin-discord's messageCreate handler called the runtime's
formatActions to build the planner prompt. One of the registered
actions had `tags` containing a non-string entry (undefined or null —
the array was malformed somewhere upstream). The chain
`(action.tags ?? []).map((tag) => tag.trim())` then called .trim()
on undefined and threw. plugin-discord caught the throw as the
generic "Error handling message" and aborted the entire message
pipeline before reaching the planner. No reply, no specific log line
about which action / which tag — just silence.

Same shape exists in formatActionSimiles for action.similes.

Fix: filter out non-string entries before .trim() in both helpers.
String entries still trim/dedupe/empty-filter the same way.

```diff
 function formatActionTags(action: Action): string | null {
   const tags = [
-    ...new Set((action.tags ?? []).map((tag) => tag.trim())),
+    ...new Set(
+      (action.tags ?? [])
+        .filter((tag): tag is string => typeof tag === "string")
+        .map((tag) => tag.trim()),
+    ),
   ].filter((tag) => tag.length > 0 && tag !== "always-include");
```

Why filter rather than rely on the Action type contract: action.tags
and action.similes are `string[]` per the Action type, but external
plugin authors are not always strict — a malformed entry from an
inadequately-typed source poisoning the array crashes the entire
planner-prompt builder, which silently kills message handling for
every message the bot receives until the offending plugin is fixed.
The cost of a `typeof === "string"` filter is negligible; the failure
mode it prevents (silent bot, no actionable diagnostic) is severe.

Tests: two regression cases in actions.test.ts covering action.tags
and action.similes with mixed [undefined, null, string, number]
arrays. Both should produce a normal formatted output with only the
real string entries surviving.

Author: NubsCarson

packages/typescript/src/__tests__/actions.test.ts

@@ -298,6 +298,70 @@ describe("Actions", () => {
 			const formatted = formatActions([]);
 			expect(formatted).toBe("");
 		});
+
+		// Production observation (2026-04-28): a plugin's action shipped with
+		// `tags: [undefined, "foo"]` (a malformed entry from elsewhere in the
+		// runtime). When the planner-prompt builder formatted that action, the
+		// `(action.tags ?? []).map((tag) => tag.trim())` chain crashed with
+		// "undefined is not an object (evaluating 'tag.trim')". plugin-discord
+		// caught that exception as "Error handling message" and the bot
+		// silently dropped the user's message — no reply, no log line about
+		// the cause beyond the bare error message.
+		//
+		// formatActions must be defensive against non-string entries in
+		// action.tags / action.similes since Action consumers don't always
+		// validate their own arrays.
+		it("skips non-string entries in action.tags without throwing", () => {
+			const formatted = formatActions([
+				{
+					name: "WIDGET",
+					description: "Do widget things.",
+					examples: [],
+					similes: [],
+					tags: [
+						undefined as unknown as string,
+						null as unknown as string,
+						"  alpha  ",
+						42 as unknown as string,
+						"beta",
+					],
+					handler: async () => {
+						throw new Error("Not implemented");
+					},
+					validate: async () => {
+						throw new Error("Not implemented");
+					},
+				},
+			]);
+
+			expect(formatted).toContain("- WIDGET:");
+			expect(formatted).toContain("tags[2]: alpha, beta");
+		});
+
+		it("skips non-string entries in action.similes without throwing", () => {
+			const formatted = formatActions([
+				{
+					name: "GREET",
+					description: "Say hi.",
+					examples: [],
+					similes: [
+						undefined as unknown as string,
+						null as unknown as string,
+						"  hi  ",
+						"hello",
+					],
+					handler: async () => {
+						throw new Error("Not implemented");
+					},
+					validate: async () => {
+						throw new Error("Not implemented");
+					},
+				},
+			]);
+
+			expect(formatted).toContain("- GREET:");
+			expect(formatted).toContain("aliases[2]: hi, hello");
+		});
 	});
 
 	describe("Action benchmark cases", () => {

packages/typescript/src/actions.ts

@@ -212,7 +212,11 @@ function shuffleActions<T>(items: T[], seed = "actions"): T[] {
 
 function formatActionSimiles(action: Action): string | null {
 	const similes = [
-		...new Set((action.similes ?? []).map((simile) => simile.trim())),
+		...new Set(
+			(action.similes ?? [])
+				.filter((simile): simile is string => typeof simile === "string")
+				.map((simile) => simile.trim()),
+		),
 	].filter((simile) => simile.length > 0);
 
 	if (similes.length === 0) {
@@ -224,7 +228,11 @@ function formatActionSimiles(action: Action): string | null {
 
 function formatActionTags(action: Action): string | null {
 	const tags = [
-		...new Set((action.tags ?? []).map((tag) => tag.trim())),
+		...new Set(
+			(action.tags ?? [])
+				.filter((tag): tag is string => typeof tag === "string")
+				.map((tag) => tag.trim()),
+		),
 	].filter((tag) => tag.length > 0 && tag !== "always-include");
 
 	if (tags.length === 0) {