@syengup/friday-channel-next 0.1.38 → 0.1.40

package/dist/src/agent/subagent-registry.d.ts

@@ -25,6 +25,10 @@ type SpawnIntent = {
 };
 /** Called by forwardAgentEventRaw on lifecycle start so we can resolve parentRunId. */
 export declare function registerSessionKeyForRun(sessionKey: string, runId: string): void;
+export declare function parseAnnounceRunId(runId: string): {
+    childSessionKey: string;
+    bareRunId: string;
+} | null;
 /** Look up subagent entry by any runId form (announce compound or bare). */
 export declare function lookupByRunId(runId: string): SubagentEntry | undefined;
 /** Look up subagent entry by childSessionKey. */

package/dist/src/agent/subagent-registry.js

@@ -16,7 +16,7 @@ export function registerSessionKeyForRun(sessionKey, runId) {
  *   → { childSessionKey: "agent:main:subagent:uuid", bareRunId: "runId" }
  */
 const ANNOUNCE_RUN_ID_RE = /^announce:v\d+:(agent:.+?):([^:]+)$/;
-function parseAnnounceRunId(runId) {
+export function parseAnnounceRunId(runId) {
     const m = runId.match(ANNOUNCE_RUN_ID_RE);
     if (!m)
         return null;

package/dist/src/friday-session.js

@@ -6,7 +6,7 @@ import { observeAgentEventForActiveRuns } from "./agent/active-runs.js";
 import { getRunMetadata, ingestAgentEventMetadata } from "./run-metadata.js";
 import { consumeRunUsage } from "./agent/run-usage-accumulator.js";
 import { readSessionUsageSnapshotFromStore } from "./session-usage-store.js";
-import { lookupByRunId, registerSessionKeyForRun, registerSpawnIntent, consumeSpawnIntent, ensureSubagentFromSpawnTool, registerEnded as registerSubagentEnded, } from "./agent/subagent-registry.js";
+import { lookupByRunId, lookupByChildSessionKey, parseAnnounceRunId, registerSessionKeyForRun, registerSpawnIntent, consumeSpawnIntent, ensureSubagentFromSpawnTool, registerEnded as registerSubagentEnded, } from "./agent/subagent-registry.js";
 /** Last `data.text` per run for `stream: "thinking"` — OpenClaw core may send cumulative `delta`; we rewrite true increments for the app. */
 const lastThinkingTextByRun = new Map();
 function commonPrefixLength(a, b) {
@@ -323,6 +323,10 @@ export function forwardAgentEventRaw(evt) {
                     phase: "spawning",
                     childSessionKey: null,
                     runId: null,
+                    // A2: the spawn tool-call id is the only stable correlation key before the
+                    // gateway assigns childSessionKey/runId — the app mints the placeholder window
+                    // under it, then rekeys to childSessionKey on spawned.
+                    toolCallId,
                     label: intent.label ?? null,
                     parentRunId: intent.parentRunId,
                     depth: intent.depth,
@@ -357,6 +361,9 @@ export function forwardAgentEventRaw(evt) {
                     phase: "spawned",
                     runId: compoundRunId,
                     childSessionKey: entry.childSessionKey,
+                    // A2: echo the spawn toolCallId so the app deterministically links this
+                    // spawned event to the placeholder window it minted at spawning time.
+                    toolCallId: toolCallId || null,
                     label: entry.label ?? null,
                     parentRunId: entry.parentRunId ?? null,
                     depth: entry.depth,
@@ -365,6 +372,28 @@ export function forwardAgentEventRaw(evt) {
             }, entry.deviceId);
         }
     }
+    // Phase 3 (A3): announce-summary delivery to the parent. OpenClaw emits the parent's
+    // `lifecycle.start` under the announce compound runId once a subagent's result is being
+    // folded back in. We parse the authoritative childSessionKey here (the registry already
+    // knows how) and broadcast an explicit `dismissed` subagent event, so the app removes the
+    // settled window by childSessionKey instead of re-parsing the announce runId itself.
+    if (evt.stream === "lifecycle" && evt.data.phase === "start") {
+        const announced = parseAnnounceRunId(evt.runId);
+        if (announced) {
+            const entry = lookupByChildSessionKey(announced.childSessionKey) ?? lookupByRunId(evt.runId);
+            sseEmitter.broadcast({
+                type: "subagent",
+                data: {
+                    phase: "dismissed",
+                    childSessionKey: entry?.childSessionKey ?? announced.childSessionKey,
+                    runId: entry?.runId ?? announced.bareRunId ?? null,
+                    parentRunId: entry?.parentRunId ?? null,
+                    depth: entry?.depth ?? 1,
+                    deviceId: deviceIdRaw,
+                },
+            }, deviceIdRaw);
+        }
+    }
     const subagentEntry = lookupByRunId(evt.runId);
     // Only annotate events that originate from the subagent itself
     // (sessionKey matches childSessionKey). Main-agent delivery events
@@ -375,6 +404,11 @@ export function forwardAgentEventRaw(evt) {
             label: subagentEntry.label,
             parentRunId: subagentEntry.parentRunId,
             depth: subagentEntry.depth,
+            // A1: ship the authoritative childSessionKey + lifecycle status on every
+            // subagent agent-delta so the app routes/identifies by stable keys instead of
+            // guessing from runId.
+            childSessionKey: subagentEntry.childSessionKey,
+            status: subagentEntry.status,
         }
         : undefined;
     let outgoingData = { ...evt.data };

package/dist/src/http/handlers/agents-list.js

@@ -82,8 +82,12 @@ function resolveConfiguredAgents() {
     const agents = cfg?.agents;
     const list = agents?.list;
     if (!Array.isArray(list) || list.length === 0) {
+        // Implicit `main` agent (no `agents.list`): config carries no name, so fall
+        // back to the workspace IDENTITY.md `Name` — the same source ControlUI and
+        // the list branch below use — instead of letting the app show the raw id.
+        const name = readWorkspaceIdentityName(rt, cfg, DEFAULT_AGENT_ID);
         return {
-            agents: [{ id: DEFAULT_AGENT_ID, isDefault: true }],
+            agents: [{ id: DEFAULT_AGENT_ID, isDefault: true, ...(name ? { name } : {}) }],
             defaultAgentId: DEFAULT_AGENT_ID,
         };
     }

package/dist/src/skills-discovery.d.ts

@@ -17,12 +17,19 @@
  *                in another agent's workspace (main is just another agent, not a shared pool)
  *  - installed : managed skills dir (`<configDir>/skills`, sibling of the workspace)
  *  - built-in  : bundled core skills (`<openclaw>/skills`)
- *  - extra     : skills from ENABLED extensions (`<openclaw>/dist/extensions/<ext>/skills`,
- *                gated by `plugins.allow`/`entries.enabled` like ControlUI) + config
- *                `skills.load.extraDirs` — mirrors ControlUI's "EXTRA" bucket
- *                (core tags extension skills `source: "extension"`).
+ *  - extra     : everything ControlUI buckets as "EXTRA" —
+ *                  • `<configDir>/plugin-skills/` : OpenClaw's symlink dir where every ACTIVATED
+ *                    plugin's skills land, incl. third-party plugins (e.g. the miloco-* set)
+ *                  • `<workspace>/.agents/skills`  : project-level agents skills (target agent)
+ *                  • `~/.agents/skills`            : personal agents skills
+ *                  • config `skills.load.extraDirs`
+ *                  • ENABLED bundled extensions (`<openclaw>/dist/extensions/<ext>/skills`,
+ *                    gated by `plugins.allow`/`entries.enabled`) — now mostly redundant with
+ *                    plugin-skills, kept as a belt-and-suspenders fallback
  *
  * Dedup is by skill id, first source wins (workspace > installed > extra > built-in).
+ * The walk FOLLOWS symlinked directories — plugin-skills entries are symlinks, so without
+ * this the entire plugin-provided set is invisible.
  *
  * A skill's id is the `name:` field in its `SKILL.md` frontmatter (falling back to
  * the containing dir name) — NOT the dir name itself, which often differs (e.g. the

package/dist/src/skills-discovery.js

@@ -17,12 +17,19 @@
  *                in another agent's workspace (main is just another agent, not a shared pool)
  *  - installed : managed skills dir (`<configDir>/skills`, sibling of the workspace)
  *  - built-in  : bundled core skills (`<openclaw>/skills`)
- *  - extra     : skills from ENABLED extensions (`<openclaw>/dist/extensions/<ext>/skills`,
- *                gated by `plugins.allow`/`entries.enabled` like ControlUI) + config
- *                `skills.load.extraDirs` — mirrors ControlUI's "EXTRA" bucket
- *                (core tags extension skills `source: "extension"`).
+ *  - extra     : everything ControlUI buckets as "EXTRA" —
+ *                  • `<configDir>/plugin-skills/` : OpenClaw's symlink dir where every ACTIVATED
+ *                    plugin's skills land, incl. third-party plugins (e.g. the miloco-* set)
+ *                  • `<workspace>/.agents/skills`  : project-level agents skills (target agent)
+ *                  • `~/.agents/skills`            : personal agents skills
+ *                  • config `skills.load.extraDirs`
+ *                  • ENABLED bundled extensions (`<openclaw>/dist/extensions/<ext>/skills`,
+ *                    gated by `plugins.allow`/`entries.enabled`) — now mostly redundant with
+ *                    plugin-skills, kept as a belt-and-suspenders fallback
  *
  * Dedup is by skill id, first source wins (workspace > installed > extra > built-in).
+ * The walk FOLLOWS symlinked directories — plugin-skills entries are symlinks, so without
+ * this the entire plugin-provided set is invisible.
  *
  * A skill's id is the `name:` field in its `SKILL.md` frontmatter (falling back to
  * the containing dir name) — NOT the dir name itself, which often differs (e.g. the
@@ -36,6 +43,7 @@
  * `skills[]` config, already returned separately by the config view.
  */
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { getFridayAgentForwardRuntime } from "./agent-forward-runtime.js";
@@ -100,9 +108,24 @@ function collectSkills(root, source, out, depth = 0) {
         return; // a skill is a leaf — don't treat its internals as nested skills
     }
     for (const e of entries) {
-        if (e.isDirectory() && !e.name.startsWith(".") && !IGNORED_WALK_DIRS.has(e.name)) {
-            collectSkills(path.join(root, e.name), source, out, depth + 1);
+        if (e.name.startsWith(".") || IGNORED_WALK_DIRS.has(e.name))
+            continue;
+        const full = path.join(root, e.name);
+        // Follow symlinked dirs: `readdirSync(withFileTypes)` reports a symlink as
+        // `isSymbolicLink()` (never `isDirectory()`), and OpenClaw publishes plugin
+        // skills as symlinks under `<configDir>/plugin-skills/` — so without this the
+        // entire plugin-skills (e.g. the miloco-* set) source would be silently skipped.
+        let isDir = e.isDirectory();
+        if (!isDir && e.isSymbolicLink()) {
+            try {
+                isDir = fs.statSync(full).isDirectory();
+            }
+            catch {
+                isDir = false; // broken/unreadable symlink
+            }
         }
+        if (isDir)
+            collectSkills(full, source, out, depth + 1);
     }
 }
 let cachedOpenClawRoot;
@@ -216,24 +239,44 @@ export function discoverAvailableSkills(cfg, agentId) {
         // leaked main's skills into every other agent's catalog.
         try {
             const ws = resolveWs(cfg, agentId);
-            if (ws)
+            if (ws) {
                 sources.push({ dir: path.join(ws, "skills"), source: "workspace" });
+                // Project-level agents skills: `<workspace>/.agents/skills` (core source
+                // `agents-skills-project`), scoped to this same target agent's workspace.
+                sources.push({ dir: path.join(ws, ".agents", "skills"), source: "extra" });
+            }
         }
         catch {
             // skip unresolvable workspace
         }
-        // Managed skills dir: `<configDir>/skills`. It is agent-independent; anchor it off the
-        // DEFAULT agent's workspace parent (the default workspace lives directly under configDir,
-        // whereas non-default workspaces may be nested under it).
+        // Managed (`<configDir>/skills`) + plugin-skills (`<configDir>/plugin-skills`) dirs. Both are
+        // agent-independent; anchor off the DEFAULT agent's workspace parent (the default workspace
+        // lives directly under configDir, whereas non-default workspaces may be nested under it).
         try {
             const defaultWs = resolveWs(cfg, resolveDefaultAgentId(c));
-            if (defaultWs)
-                sources.push({ dir: path.join(path.dirname(defaultWs), "skills"), source: "installed" });
+            if (defaultWs) {
+                const configDir = path.dirname(defaultWs);
+                sources.push({ dir: path.join(configDir, "skills"), source: "installed" });
+                // OpenClaw symlinks every ACTIVATED plugin's skills (incl. third-party plugins under
+                // `<configDir>/extensions/*`, e.g. the miloco-* set) into `<configDir>/plugin-skills/`
+                // and loads it as an "extra" source. The old dist/extensions scan only caught BUNDLED
+                // extensions, so plugin-provided skills were missing entirely.
+                sources.push({ dir: path.join(configDir, "plugin-skills"), source: "extra" });
+            }
         }
         catch {
             // skip unresolvable managed dir
         }
     }
+    // Personal agents skills: `~/.agents/skills` (core source `agents-skills-personal`).
+    try {
+        const home = os.homedir();
+        if (home)
+            sources.push({ dir: path.join(home, ".agents", "skills"), source: "extra" });
+    }
+    catch {
+        // home dir unresolvable on this platform — skip
+    }
     const extraDirs = c?.skills?.load?.extraDirs;
     if (Array.isArray(extraDirs)) {
         for (const d of extraDirs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",
@@ -12,19 +12,6 @@
     "tsconfig.json",
     "openclaw.plugin.json"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "prepublishOnly": "pnpm build && rm -rf dist/attachments",
-    "test": "npm run test:unit && npm run test:e2e",
-    "test:unit": "vitest run",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:smoke": "node scripts/e2e-smoke.mjs",
-    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
-  },
   "bin": {
     "friday-channel-next": "install.js"
   },
@@ -75,5 +62,17 @@
     "typescript-eslint": "^8.61.1",
     "vitest": "^4.1.5",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:smoke": "node scripts/e2e-smoke.mjs",
+    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
   }
-}
+}

package/src/agent/subagent-registry.ts

@@ -48,7 +48,9 @@ export function registerSessionKeyForRun(sessionKey: string, runId: string): voi
  */
 const ANNOUNCE_RUN_ID_RE = /^announce:v\d+:(agent:.+?):([^:]+)$/;
 
-function parseAnnounceRunId(runId: string): { childSessionKey: string; bareRunId: string } | null {
+export function parseAnnounceRunId(
+  runId: string,
+): { childSessionKey: string; bareRunId: string } | null {
   const m = runId.match(ANNOUNCE_RUN_ID_RE);
   if (!m) return null;
   return { childSessionKey: m[1] ?? "", bareRunId: m[2] ?? "" };

package/src/e2e/subagent.e2e.test.ts

@@ -295,6 +295,9 @@ describe("subagent via sessions_spawn tool", () => {
         label: "cr",
         parentRunId: mainRunId,
         depth: 1,
+        // A1: annotation now ships stable identity (childSessionKey) + lifecycle status.
+        childSessionKey: childKey,
+        status: "running",
       });
     });
 
@@ -524,6 +527,9 @@ describe("subagent via sessions_spawn tool", () => {
         label: "reviewer",
         parentRunId: mainRunId,
         depth: 1,
+        // A1: annotation now ships stable identity (childSessionKey) + lifecycle status.
+        childSessionKey: childKeyA,
+        status: "running",
       });
 
       // sessions_spawn for B (nested from A's tool call — but parentRunId should come from the context)

package/src/friday-session.forward-agent.test.ts

@@ -16,6 +16,10 @@ import {
 } from "./agent/run-usage-accumulator.js";
 import { sseEmitter } from "./sse/emitter.js";
 import { toSessionStoreKey } from "./session/session-manager.js";
+import {
+  ensureSubagentFromSpawnTool,
+  resetForTest as resetSubagentRegistryForTest,
+} from "./agent/subagent-registry.js";
 
 describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
   const runId = "run-thinking-test";
@@ -395,3 +399,126 @@ function commonPrefixLen(a: string, b: string): number {
   while (i < len && a.charCodeAt(i) === b.charCodeAt(i)) i++;
   return i;
 }
+
+// P1 of the subagent streaming redo (see subagent-streaming-redo-plan.md):
+// the plugin ships authoritative correlation keys so the app stops self-deriving identity.
+describe("forwardAgentEventRaw (subagent stable-identity fields: A1/A2/A3)", () => {
+  const sessionKey = "agent:main:friday-session-test";
+  const deviceId = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE";
+  const childKey = "agent:main:subagent:abc";
+
+  type SubagentBroadcast = { type: string; data: Record<string, unknown> };
+
+  function subagentBroadcasts(phase: string): Record<string, unknown>[] {
+    return (sseEmitter.broadcast as ReturnType<typeof vi.fn>).mock.calls
+      .map((c) => c[0] as SubagentBroadcast)
+      .filter((m) => m.type === "subagent" && m.data.phase === phase)
+      .map((m) => m.data);
+  }
+
+  beforeEach(() => {
+    sseEmitter.resetForTest();
+    resetThinkingStreamAccumStateForTest();
+    resetOpenClawRunDeviceMappingForTest();
+    resetSubagentRegistryForTest();
+    registerFridaySessionDeviceMapping(sessionKey, deviceId);
+    vi.spyOn(sseEmitter, "broadcastToRun").mockImplementation(() => {});
+    vi.spyOn(sseEmitter, "broadcast").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // A2: spawning carries the spawn tool-call id as a stable correlation key.
+  it("spawning event carries the spawn toolCallId", () => {
+    forwardAgentEventRaw({
+      runId: "parent-run",
+      seq: 1,
+      stream: "tool",
+      sessionKey,
+      data: {
+        name: "sessions_spawn",
+        phase: "start",
+        toolCallId: "tc-1",
+        args: { taskName: "weather" },
+      },
+    });
+
+    const spawning = subagentBroadcasts("spawning");
+    expect(spawning).toHaveLength(1);
+    expect(spawning[0].toolCallId).toBe("tc-1");
+    expect(spawning[0].childSessionKey).toBeNull();
+    expect(spawning[0].runId).toBeNull();
+    expect(spawning[0].label).toBe("weather");
+  });
+
+  // A1: a subagent's own agent-delta is annotated with childSessionKey + status.
+  it("subagent agent-delta annotation includes childSessionKey and status", () => {
+    ensureSubagentFromSpawnTool({
+      childSessionKey: childKey,
+      bareRunId: "sub-bare",
+      label: "weather",
+      deviceId,
+      parentRunId: "parent-run",
+      requesterSessionKey: sessionKey,
+    });
+
+    forwardAgentEventRaw({
+      runId: "sub-bare",
+      seq: 1,
+      stream: "thinking",
+      sessionKey: childKey, // subagent's own event → sessionKey === childSessionKey
+      data: { text: "looking up", delta: "looking up" },
+    });
+
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+    const payload = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
+    const subagent = payload.subagent as Record<string, unknown>;
+    expect(subagent).toBeDefined();
+    expect(subagent.childSessionKey).toBe(childKey);
+    expect(subagent.status).toBe("running");
+    expect(subagent.label).toBe("weather");
+    expect(subagent.parentRunId).toBe("parent-run");
+  });
+
+  // A3: the parent's announce-summary lifecycle.start emits an explicit dismiss keyed by
+  // childSessionKey — replacing the app's fragile announce-runId string parsing.
+  it("announce-summary lifecycle.start emits a dismissed subagent event by childSessionKey", () => {
+    ensureSubagentFromSpawnTool({
+      childSessionKey: childKey,
+      bareRunId: "sub-bare",
+      label: "weather",
+      deviceId,
+      parentRunId: "parent-run",
+      requesterSessionKey: sessionKey,
+    });
+
+    const announceRunId = `announce:v1:${childKey}:sub-bare`;
+    forwardAgentEventRaw({
+      runId: announceRunId,
+      seq: 1,
+      stream: "lifecycle",
+      sessionKey, // parent's sessionKey, not the child's
+      data: { phase: "start" },
+    });
+
+    const dismissed = subagentBroadcasts("dismissed");
+    expect(dismissed).toHaveLength(1);
+    expect(dismissed[0].childSessionKey).toBe(childKey);
+    expect(dismissed[0].runId).toBe("sub-bare");
+    expect(dismissed[0].parentRunId).toBe("parent-run");
+  });
+
+  // A3 must not fire on ordinary (non-announce) lifecycle.start frames.
+  it("does not emit dismissed for a normal lifecycle.start", () => {
+    forwardAgentEventRaw({
+      runId: "parent-run",
+      seq: 1,
+      stream: "lifecycle",
+      sessionKey,
+      data: { phase: "start" },
+    });
+    expect(subagentBroadcasts("dismissed")).toHaveLength(0);
+  });
+});

package/src/friday-session.ts

@@ -9,6 +9,8 @@ import type { FridaySessionUsagePayload } from "./session-usage-snapshot.js";
 import { readSessionUsageSnapshotFromStore } from "./session-usage-store.js";
 import {
   lookupByRunId,
+  lookupByChildSessionKey,
+  parseAnnounceRunId,
   registerSessionKeyForRun,
   registerSpawnIntent,
   consumeSpawnIntent,
@@ -234,7 +236,13 @@ function completeAgentEventForward(params: {
   deviceIdRaw: string;
   outgoingData: Record<string, unknown>;
   isTerminalLifecycle: boolean;
-  subagentMeta?: { label?: string; parentRunId?: string; depth: number };
+  subagentMeta?: {
+    label?: string;
+    parentRunId?: string;
+    depth: number;
+    childSessionKey?: string;
+    status?: string;
+  };
 }): void {
   const { evt, sk, deviceIdRaw, outgoingData, isTerminalLifecycle, subagentMeta } = params;
 
@@ -367,6 +375,10 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
             phase: "spawning",
             childSessionKey: null,
             runId: null,
+            // A2: the spawn tool-call id is the only stable correlation key before the
+            // gateway assigns childSessionKey/runId — the app mints the placeholder window
+            // under it, then rekeys to childSessionKey on spawned.
+            toolCallId,
             label: intent.label ?? null,
             parentRunId: intent.parentRunId,
             depth: intent.depth,
@@ -408,6 +420,9 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
             phase: "spawned",
             runId: compoundRunId,
             childSessionKey: entry.childSessionKey,
+            // A2: echo the spawn toolCallId so the app deterministically links this
+            // spawned event to the placeholder window it minted at spawning time.
+            toolCallId: toolCallId || null,
             label: entry.label ?? null,
             parentRunId: entry.parentRunId ?? null,
             depth: entry.depth,
@@ -419,6 +434,33 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
     }
   }
 
+  // Phase 3 (A3): announce-summary delivery to the parent. OpenClaw emits the parent's
+  // `lifecycle.start` under the announce compound runId once a subagent's result is being
+  // folded back in. We parse the authoritative childSessionKey here (the registry already
+  // knows how) and broadcast an explicit `dismissed` subagent event, so the app removes the
+  // settled window by childSessionKey instead of re-parsing the announce runId itself.
+  if (evt.stream === "lifecycle" && evt.data.phase === "start") {
+    const announced = parseAnnounceRunId(evt.runId);
+    if (announced) {
+      const entry =
+        lookupByChildSessionKey(announced.childSessionKey) ?? lookupByRunId(evt.runId);
+      sseEmitter.broadcast(
+        {
+          type: "subagent",
+          data: {
+            phase: "dismissed",
+            childSessionKey: entry?.childSessionKey ?? announced.childSessionKey,
+            runId: entry?.runId ?? announced.bareRunId ?? null,
+            parentRunId: entry?.parentRunId ?? null,
+            depth: entry?.depth ?? 1,
+            deviceId: deviceIdRaw,
+          },
+        },
+        deviceIdRaw,
+      );
+    }
+  }
+
   const subagentEntry = lookupByRunId(evt.runId);
   // Only annotate events that originate from the subagent itself
   // (sessionKey matches childSessionKey). Main-agent delivery events
@@ -429,6 +471,11 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
         label: subagentEntry.label,
         parentRunId: subagentEntry.parentRunId,
         depth: subagentEntry.depth,
+        // A1: ship the authoritative childSessionKey + lifecycle status on every
+        // subagent agent-delta so the app routes/identifies by stable keys instead of
+        // guessing from runId.
+        childSessionKey: subagentEntry.childSessionKey,
+        status: subagentEntry.status,
       }
     : undefined;
 

package/src/http/handlers/agents-list.test.ts

@@ -71,6 +71,34 @@ describe("handleAgentsList", () => {
     expect(body.agents).toEqual([{ id: "main", isDefault: true }]);
   });
 
+  it("resolves the implicit main name from IDENTITY.md when no agents.list exists", async () => {
+    const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "friday-identity-main-"));
+    fs.writeFileSync(
+      path.join(workspace, "IDENTITY.md"),
+      "# IDENTITY.md\n\n- **Name:** F.R.I.D.A.Y\n- **Emoji:** 🌿\n",
+    );
+    try {
+      setFridayAgentForwardRuntime({
+        runtime: {
+          agent: {
+            session: { resolveStorePath: () => "", loadSessionStore: () => ({}) },
+            resolveAgentWorkspaceDir: () => workspace,
+          },
+          config: { current: () => ({ agents: { defaults: {} } }) },
+        },
+      } as any);
+
+      const res = new MockRes();
+      await handleAgentsList(makeReq(AUTH), res as any);
+
+      const body = JSON.parse(res.body);
+      expect(body.defaultAgentId).toBe("main");
+      expect(body.agents).toEqual([{ id: "main", name: "F.R.I.D.A.Y", isDefault: true }]);
+    } finally {
+      fs.rmSync(workspace, { recursive: true, force: true });
+    }
+  });
+
   it("lists configured agents with normalized ids and resolved fields", async () => {
     setConfig({
       agents: {

package/src/http/handlers/agents-list.ts

@@ -106,8 +106,12 @@ function resolveConfiguredAgents(): ResolvedAgents {
   const list = agents?.list as Array<Record<string, unknown>> | undefined;
 
   if (!Array.isArray(list) || list.length === 0) {
+    // Implicit `main` agent (no `agents.list`): config carries no name, so fall
+    // back to the workspace IDENTITY.md `Name` — the same source ControlUI and
+    // the list branch below use — instead of letting the app show the raw id.
+    const name = readWorkspaceIdentityName(rt, cfg, DEFAULT_AGENT_ID);
     return {
-      agents: [{ id: DEFAULT_AGENT_ID, isDefault: true }],
+      agents: [{ id: DEFAULT_AGENT_ID, isDefault: true, ...(name ? { name } : {}) }],
       defaultAgentId: DEFAULT_AGENT_ID,
     };
   }

package/src/skills-discovery.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -22,6 +22,8 @@ function makeSkills(parent: string, ids: string[]): void {
 
 describe("discoverAvailableSkills", () => {
   let root: string;
+  let emptyHome: string;
+  let savedHome: string | undefined;
 
   function wire(configRoot: string, cfg: unknown): void {
     setFridayAgentForwardRuntime({
@@ -39,10 +41,21 @@ describe("discoverAvailableSkills", () => {
     } as never);
   }
 
+  beforeEach(() => {
+    // Isolate `~/.agents/skills` (a real discovery source) from the dev machine's
+    // home so exact-match assertions don't pick up the operator's actual skills.
+    savedHome = process.env.HOME;
+    emptyHome = fs.mkdtempSync(path.join(os.tmpdir(), "friday-home-"));
+    process.env.HOME = emptyHome;
+  });
+
   afterEach(() => {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
     resetFridayAgentForwardRuntimeForTest();
     resetOpenClawRootCacheForTest();
     if (root) fs.rmSync(root, { recursive: true, force: true });
+    if (emptyHome) fs.rmSync(emptyHome, { recursive: true, force: true });
   });
 
   it("scans only the target agent's own workspace (not the default agent's), plus managed + extra dirs, deduped and sorted", () => {
@@ -118,6 +131,42 @@ describe("discoverAvailableSkills", () => {
     expect(result.find((s) => s.id === "self-improvement")?.description).toBe("x");
   });
 
+  it("discovers plugin-skills (symlinks), plus project + personal agents skills as 'extra'", () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "friday-disc-"));
+    const configRoot = path.join(root, "configdir");
+    const operatorWs = path.join(configRoot, "workspace", "agents", "operator");
+
+    // target agent's own workspace skills
+    makeSkills(path.join(operatorWs, "skills"), ["own-skill"]);
+    // project-level agents skills: <workspace>/.agents/skills
+    makeSkills(path.join(operatorWs, ".agents", "skills"), ["project-skill"]);
+    // personal agents skills: <home>/.agents/skills  (HOME isolated in beforeEach)
+    makeSkills(path.join(emptyHome, ".agents", "skills"), ["personal-skill"]);
+
+    // plugin-skills: real plugin skill dirs SYMLINKED into <configDir>/plugin-skills/,
+    // exactly how OpenClaw publishes third-party plugin skills (e.g. the miloco-* set).
+    const pluginPkg = path.join(root, "miloco-openclaw-plugin", "skills");
+    makeSkills(pluginPkg, ["miloco-devices", "miloco-notify"]);
+    const pluginSkillsDir = path.join(configRoot, "plugin-skills");
+    fs.mkdirSync(pluginSkillsDir, { recursive: true });
+    for (const id of ["miloco-devices", "miloco-notify"]) {
+      fs.symlinkSync(path.join(pluginPkg, id), path.join(pluginSkillsDir, id), "dir");
+    }
+
+    const cfg = { agents: { list: [{ id: "main", default: true }, { id: "operator" }] } };
+    wire(configRoot, cfg);
+
+    const result = discoverAvailableSkills(cfg, "operator");
+    const bySource = Object.fromEntries(result.map((s) => [s.id, s.source]));
+    expect(bySource).toEqual({
+      "own-skill": "workspace",
+      "project-skill": "extra",
+      "personal-skill": "extra",
+      "miloco-devices": "extra", // followed through the symlink — the miloco regression
+      "miloco-notify": "extra",
+    });
+  });
+
   it("returns [] without throwing when nothing is resolvable", () => {
     resetFridayAgentForwardRuntimeForTest();
     expect(discoverAvailableSkills({}, "main")).toEqual([]);

package/src/skills-discovery.ts

@@ -17,12 +17,19 @@
  *                in another agent's workspace (main is just another agent, not a shared pool)
  *  - installed : managed skills dir (`<configDir>/skills`, sibling of the workspace)
  *  - built-in  : bundled core skills (`<openclaw>/skills`)
- *  - extra     : skills from ENABLED extensions (`<openclaw>/dist/extensions/<ext>/skills`,
- *                gated by `plugins.allow`/`entries.enabled` like ControlUI) + config
- *                `skills.load.extraDirs` — mirrors ControlUI's "EXTRA" bucket
- *                (core tags extension skills `source: "extension"`).
+ *  - extra     : everything ControlUI buckets as "EXTRA" —
+ *                  • `<configDir>/plugin-skills/` : OpenClaw's symlink dir where every ACTIVATED
+ *                    plugin's skills land, incl. third-party plugins (e.g. the miloco-* set)
+ *                  • `<workspace>/.agents/skills`  : project-level agents skills (target agent)
+ *                  • `~/.agents/skills`            : personal agents skills
+ *                  • config `skills.load.extraDirs`
+ *                  • ENABLED bundled extensions (`<openclaw>/dist/extensions/<ext>/skills`,
+ *                    gated by `plugins.allow`/`entries.enabled`) — now mostly redundant with
+ *                    plugin-skills, kept as a belt-and-suspenders fallback
  *
  * Dedup is by skill id, first source wins (workspace > installed > extra > built-in).
+ * The walk FOLLOWS symlinked directories — plugin-skills entries are symlinks, so without
+ * this the entire plugin-provided set is invisible.
  *
  * A skill's id is the `name:` field in its `SKILL.md` frontmatter (falling back to
  * the containing dir name) — NOT the dir name itself, which often differs (e.g. the
@@ -37,6 +44,7 @@
  */
 
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { getFridayAgentForwardRuntime } from "./agent-forward-runtime.js";
@@ -107,9 +115,21 @@ function collectSkills(
     return; // a skill is a leaf — don't treat its internals as nested skills
   }
   for (const e of entries) {
-    if (e.isDirectory() && !e.name.startsWith(".") && !IGNORED_WALK_DIRS.has(e.name)) {
-      collectSkills(path.join(root, e.name), source, out, depth + 1);
+    if (e.name.startsWith(".") || IGNORED_WALK_DIRS.has(e.name)) continue;
+    const full = path.join(root, e.name);
+    // Follow symlinked dirs: `readdirSync(withFileTypes)` reports a symlink as
+    // `isSymbolicLink()` (never `isDirectory()`), and OpenClaw publishes plugin
+    // skills as symlinks under `<configDir>/plugin-skills/` — so without this the
+    // entire plugin-skills (e.g. the miloco-* set) source would be silently skipped.
+    let isDir = e.isDirectory();
+    if (!isDir && e.isSymbolicLink()) {
+      try {
+        isDir = fs.statSync(full).isDirectory();
+      } catch {
+        isDir = false; // broken/unreadable symlink
+      }
     }
+    if (isDir) collectSkills(full, source, out, depth + 1);
   }
 }
 
@@ -227,22 +247,42 @@ export function discoverAvailableSkills(cfg: unknown, agentId: string): Discover
     // leaked main's skills into every other agent's catalog.
     try {
       const ws = resolveWs(cfg, agentId);
-      if (ws) sources.push({ dir: path.join(ws, "skills"), source: "workspace" });
+      if (ws) {
+        sources.push({ dir: path.join(ws, "skills"), source: "workspace" });
+        // Project-level agents skills: `<workspace>/.agents/skills` (core source
+        // `agents-skills-project`), scoped to this same target agent's workspace.
+        sources.push({ dir: path.join(ws, ".agents", "skills"), source: "extra" });
+      }
     } catch {
       // skip unresolvable workspace
     }
-    // Managed skills dir: `<configDir>/skills`. It is agent-independent; anchor it off the
-    // DEFAULT agent's workspace parent (the default workspace lives directly under configDir,
-    // whereas non-default workspaces may be nested under it).
+    // Managed (`<configDir>/skills`) + plugin-skills (`<configDir>/plugin-skills`) dirs. Both are
+    // agent-independent; anchor off the DEFAULT agent's workspace parent (the default workspace
+    // lives directly under configDir, whereas non-default workspaces may be nested under it).
     try {
       const defaultWs = resolveWs(cfg, resolveDefaultAgentId(c));
-      if (defaultWs)
-        sources.push({ dir: path.join(path.dirname(defaultWs), "skills"), source: "installed" });
+      if (defaultWs) {
+        const configDir = path.dirname(defaultWs);
+        sources.push({ dir: path.join(configDir, "skills"), source: "installed" });
+        // OpenClaw symlinks every ACTIVATED plugin's skills (incl. third-party plugins under
+        // `<configDir>/extensions/*`, e.g. the miloco-* set) into `<configDir>/plugin-skills/`
+        // and loads it as an "extra" source. The old dist/extensions scan only caught BUNDLED
+        // extensions, so plugin-provided skills were missing entirely.
+        sources.push({ dir: path.join(configDir, "plugin-skills"), source: "extra" });
+      }
     } catch {
       // skip unresolvable managed dir
     }
   }
 
+  // Personal agents skills: `~/.agents/skills` (core source `agents-skills-personal`).
+  try {
+    const home = os.homedir();
+    if (home) sources.push({ dir: path.join(home, ".agents", "skills"), source: "extra" });
+  } catch {
+    // home dir unresolvable on this platform — skip
+  }
+
   const extraDirs = (
     (c?.skills as Record<string, unknown> | undefined)?.load as Record<string, unknown> | undefined
   )?.extraDirs;