mulmoclaude 0.5.2 → 0.6.0

package/src/utils/session/sessionEntries.ts

@@ -5,22 +5,72 @@
 //
 // Tracks #175.
 
-import { makeTextResult } from "../tools/result";
-import { isTextEntry, isToolResultEntry, type ActiveSession, type SessionEntry, type SessionSummary } from "../../types/session";
+import { makeSkillResult, makeTextResult, TEXT_LIKE_RESULT_TOOL_NAMES } from "../tools/result";
+import {
+  isSessionOrigin,
+  isSkillEntry,
+  isTextEntry,
+  isToolResultEntry,
+  pluginPkgFromOrigin,
+  type ActiveSession,
+  type SessionEntry,
+  type SessionOrigin,
+  type SessionSummary,
+} from "../../types/session";
 import { EVENT_TYPES } from "../../types/events";
 import type { ToolResultComplete } from "gui-chat-protocol/vue";
 
+// Pull origin off the `session_meta` row in the entries payload, if
+// present. The on-disk meta is the source of truth; the server fills
+// `SessionSummary.origin` from it but the summary fetch (`/api/sessions`)
+// races with the per-session detail fetch (`/api/sessions/:id`) on
+// first mount of `/chat/<id>`. Codex review on PR #1237 caught this:
+// without an entries-side fallback, plugin-seeded chats opened
+// directly via URL miss the chip until the user navigates away and
+// back. Returns undefined when no meta row exists or its origin is
+// missing / malformed.
+function extractMetaOrigin(entries: readonly SessionEntry[]): SessionOrigin | undefined {
+  for (const entry of entries) {
+    if (entry.type === EVENT_TYPES.sessionMeta) {
+      const candidate = (entry as { origin?: unknown }).origin;
+      return isSessionOrigin(candidate) ? candidate : undefined;
+    }
+  }
+  return undefined;
+}
+
 // Walk the server's session entries and produce the flat
 // `toolResults` array the client keeps in `ActiveSession`. Drops
 // `session_meta` rows (they're metadata, not a result), converts
 // text entries into tool-result-shaped envelopes via
 // `makeTextResult`, and passes tool_result entries through verbatim.
-export function parseSessionEntries(entries: readonly SessionEntry[]): ToolResultComplete[] {
+//
+// When the effective origin is a `plugin:<pkg>` tag (Phase 1 of the
+// Encore plan), the FIRST user text entry is marked with
+// `seededByPlugin` so the textResponse view renders a "from <pkg>"
+// chip + muted background, indicating the seed message came from a
+// plugin's `runtime.chat.start()` call rather than the user
+// themselves. The effective origin prefers the explicit
+// `sessionOrigin` argument (from the summary) and falls back to the
+// `session_meta` row in `entries` so URL-loaded chats render the
+// chip even before the summary fetch resolves.
+export function parseSessionEntries(entries: readonly SessionEntry[], sessionOrigin?: SessionOrigin): ToolResultComplete[] {
+  const effectiveOrigin = sessionOrigin ?? extractMetaOrigin(entries);
+  const seedingPkg = pluginPkgFromOrigin(effectiveOrigin);
+  let firstUserSeen = false;
   const out: ToolResultComplete[] = [];
   for (const entry of entries) {
     if (entry.type === EVENT_TYPES.sessionMeta) continue;
-    if (isTextEntry(entry)) {
-      out.push(makeTextResult(entry.message, entry.source));
+    if (isSkillEntry(entry)) {
+      // Skill bodies are routed through the dedicated skill plugin
+      // View (collapsed by default) so they don't dump a wall of
+      // markdown into the canvas. #1218.
+      out.push(makeSkillResult(entry));
+    } else if (isTextEntry(entry)) {
+      const tagThis = !firstUserSeen && entry.source === "user" && seedingPkg !== null;
+      const seededBy = tagThis ? seedingPkg : undefined;
+      if (entry.source === "user") firstUserSeen = true;
+      out.push(makeTextResult(entry.message, entry.source, entry.attachments, seededBy ?? undefined));
     } else if (isToolResultEntry(entry)) {
       out.push(entry.result);
     }
@@ -31,27 +81,33 @@ export function parseSessionEntries(entries: readonly SessionEntry[]): ToolResul
 // Pick the `selectedResultUuid` the session should restore to.
 // Rules:
 //   1. If the URL carries `?result=<uuid>` AND that uuid actually
-//      exists in the loaded list, honour it verbatim. This lets
-//      bookmarks restore the exact result the user was viewing.
-//   2. Otherwise fall back to the heuristic: the most recent
-//      non-text tool result (images, wiki pages, etc. carry more
-//      visual information than bare text).
-//   3. If there are no non-text results, use the last result of
-//      any kind.
+//      exists in the loaded list, honour it verbatim — bookmarks
+//      restore the exact result the user was viewing.
+//   2. Otherwise pick the most recent non-text-like tool result —
+//      images, wiki pages, etc. carry more visual information
+//      than a bare text response or a collapsed skill card.
+//   3. If every result is text-like (`text-response` or `skill`,
+//      see `TEXT_LIKE_RESULT_TOOL_NAMES`), fall back to the last
+//      one — typically the most recent assistant reply, NOT the
+//      skill card that preceded it. Codex iter-4 review on PR
+//      #1220 surfaced the inconsistency between this reload-time
+//      selector and the live-run `shouldSelectAssistantText`
+//      before they were unified on the same allowlist.
 //   4. If the list is empty, return null.
+//
 export function resolveSelectedUuid(toolResults: readonly ToolResultComplete[], urlResult: string | null): string | null {
   if (urlResult && toolResults.some((result) => result.uuid === urlResult)) {
     return urlResult;
   }
-  // Iterate backwards for the "last non-text" lookup so callers
-  // don't pay for an intermediate reverse copy.
+  if (toolResults.length === 0) return null;
+  // Iterate backwards for the "last non-text-like" lookup so
+  // callers don't pay for an intermediate reverse copy.
   for (let i = toolResults.length - 1; i >= 0; i--) {
-    if (toolResults[i].toolName !== "text-response") {
+    if (!TEXT_LIKE_RESULT_TOOL_NAMES.has(toolResults[i].toolName)) {
       return toolResults[i].uuid;
     }
   }
-  const last = toolResults[toolResults.length - 1];
-  return last?.uuid ?? null;
+  return toolResults[toolResults.length - 1].uuid;
 }
 
 // Decide the `startedAt` / `updatedAt` to seed the in-memory
@@ -98,7 +154,7 @@ export function buildLoadedSession(opts: {
   const { id, entries, defaultRoleId, urlResult, serverSummary, nowIso } = opts;
   const meta = entries.find((entry) => entry.type === EVENT_TYPES.sessionMeta);
   const roleId = meta?.roleId ?? defaultRoleId;
-  const toolResults = parseSessionEntries(entries);
+  const toolResults = parseSessionEntries(entries, serverSummary?.origin);
   const selectedResultUuid = resolveSelectedUuid(toolResults, urlResult);
   const { startedAt, updatedAt } = resolveSessionTimestamps(serverSummary, nowIso);
   const resultTimestamps = interpolateTimestamps(toolResults, startedAt, updatedAt);

package/src/utils/session/sessionHelpers.ts

@@ -4,8 +4,8 @@
 
 import { v4 as uuidv4 } from "uuid";
 import type { ToolResultComplete } from "gui-chat-protocol/vue";
-import type { ActiveSession } from "../../types/session";
-import { makeTextResult } from "../tools/result";
+import type { ActiveSession, SkillScope } from "../../types/session";
+import { makeSkillResult, makeTextResult, SKILL_TOOL_NAME } from "../tools/result";
 import { shouldSelectAssistantText } from "../agent/toolCalls";
 
 /** Push a result and record its timestamp in one place. */
@@ -28,10 +28,13 @@ export function pushErrorMessage(session: ActiveSession, message: string): void
   session.selectedResultUuid = errorResult.uuid;
 }
 
-/** Append the user's message so it renders immediately. */
-export function beginUserTurn(session: ActiveSession, message: string): void {
+/** Append the user's message so it renders immediately. `attachments`
+ *  carries the workspace-relative paths the user attached for this
+ *  turn (paste/drop/file-picker) so the chat bubble can render an
+ *  icon / thumbnail chip alongside the text. */
+export function beginUserTurn(session: ActiveSession, message: string, attachments?: readonly string[]): void {
   session.updatedAt = new Date().toISOString();
-  pushResult(session, makeTextResult(message, "user"));
+  pushResult(session, makeTextResult(message, "user", attachments));
   session.runStartIndex = session.toolResults.length;
 }
 
@@ -59,11 +62,13 @@ function isDuplicateUserText(session: ActiveSession, message: string): boolean {
 /** Handle an incoming text event (user or assistant) from the
  *  agent's SSE/pubsub stream. Deduplicates user messages,
  *  streams assistant text into the last card, and selects the
- *  result when appropriate. */
-export function applyTextEvent(session: ActiveSession, message: string, source: "user" | "assistant"): void {
+ *  result when appropriate. `attachments` is forwarded for cross-tab
+ *  user-text broadcasts so observing tabs render chips identically
+ *  to the originating tab. */
+export function applyTextEvent(session: ActiveSession, message: string, source: "user" | "assistant", attachments?: readonly string[]): void {
   if (source === "user") {
     if (!isDuplicateUserText(session, message)) {
-      pushResult(session, makeTextResult(message, "user"));
+      pushResult(session, makeTextResult(message, "user", attachments));
       session.runStartIndex = session.toolResults.length;
     }
     return;
@@ -76,6 +81,42 @@ export function applyTextEvent(session: ActiveSession, message: string, source:
   }
 }
 
+/** Replace the trailing assistant text-response (the streamed skill
+ *  body from Claude CLI) with a collapsed skill card, preserving the
+ *  uuid so any view bound to that uuid (selection, scroll anchors)
+ *  doesn't lose its handle. Falls back to pushing a fresh skill
+ *  card if no assistant text-response is at the tail (e.g. flush
+ *  fired with no streamed deltas, or another result snuck in
+ *  between).  #1218 */
+export function applySkillEvent(
+  session: ActiveSession,
+  payload: {
+    skillName: string;
+    skillScope: SkillScope;
+    skillPath: string | null;
+    skillDescription: string | null;
+    message: string;
+  },
+): void {
+  const last = session.toolResults[session.toolResults.length - 1];
+  const lastData = last?.data as { role?: string } | undefined;
+  if (last?.toolName === "text-response" && lastData?.role === "assistant") {
+    const replacement = makeSkillResult(payload);
+    // Preserve uuid so selection / scroll anchors don't blink off.
+    Object.assign(last, { ...replacement, uuid: last.uuid });
+    return;
+  }
+  const skillResult = makeSkillResult(payload);
+  pushResult(session, skillResult);
+  if (shouldSelectAssistantText(session.toolResults, session.runStartIndex)) {
+    session.selectedResultUuid = skillResult.uuid;
+  }
+}
+
+// Re-export so callers don't need to import from `tools/result` for
+// the tool-name comparison constant.
+export { SKILL_TOOL_NAME };
+
 /** In-place update a result that was re-emitted by a plugin view
  *  (e.g. after the user edits a chart config). */
 export function updateResult(session: ActiveSession, updatedResult: ToolResultComplete): void {
@@ -86,8 +127,11 @@ export function updateResult(session: ActiveSession, updatedResult: ToolResultCo
 }
 
 /** Handle an incoming tool_result event: upsert into the session's
- *  result list. Selects the result only on insert; in-place updates
- *  preserve the user's current selection. */
+ *  result list. Selects the result on insert; in-place updates
+ *  preserve the user's current selection. The MCP bridge skips the
+ *  toolResult POST for narrate-only actions (handlers that omit
+ *  `data`), so every result that reaches this function is intended
+ *  to surface a card. */
 export function applyToolResultToSession(session: ActiveSession, result: ToolResultComplete): void {
   const idx = session.toolResults.findIndex((existing) => existing.uuid === result.uuid);
   if (idx >= 0) {

package/src/utils/tools/result.ts

@@ -5,36 +5,98 @@
 import type { ToolResultComplete } from "gui-chat-protocol/vue";
 import { v4 as uuidv4 } from "uuid";
 import { isRecord } from "../types";
+import type { SkillScope } from "../../types/session";
+
+/** Tool name used by the synthetic envelope `makeSkillResult`
+ *  produces for `type: "skill"` jsonl entries. The skill plugin's
+ *  registration matches on this in `getPlugin()` so the canvas
+ *  routes skill bodies through `src/plugins/skill/View.vue` instead
+ *  of the default `text-response` view (#1218). */
+export const SKILL_TOOL_NAME = "skill";
+
+/** Result tool-names that count as "assistant text" for selection
+ *  purposes. `text-response` is the original case; `skill` was
+ *  added in #1218 because the skill envelope is a collapsed card
+ *  in the same conversational lane as plain assistant prose, not a
+ *  richer plugin output (image / wiki / chart) that should hold
+ *  its own selection.
+ *
+ *  Single source of truth for the live-run selector
+ *  (`shouldSelectAssistantText`) and the reload-time selector
+ *  (`resolveSelectedUuid`) — Codex iter-3 / iter-4 review on PR
+ *  #1220 surfaced the inconsistency between the two before this
+ *  was unified. */
+export const TEXT_LIKE_RESULT_TOOL_NAMES: ReadonlySet<string> = new Set(["text-response", SKILL_TOOL_NAME]);
 
 // Type guard: a text-response entry whose `data.role` is `"user"`.
 // Used by App.vue to find the first user message in a live session
 // when building the merged history list.
 export function isUserTextResponse(res: ToolResultComplete): boolean {
   if (res.toolName !== "text-response") return false;
-  const data = res.data;
+  const { data } = res;
   if (!isRecord(data)) return false;
   return data.role === "user";
 }
 
-// Pull out the optional base64 image attached to a tool result, if
-// any. Returns `undefined` for results that have no `data.imageData`
-// or where it isn't a string.
-export function extractImageData(result: ToolResultComplete | undefined): string | undefined {
-  const data = result?.data;
-  if (isRecord(data) && typeof data.imageData === "string") {
-    return data.imageData;
-  }
-  return undefined;
-}
-
 // Build a synthetic text-response result for either a user or
 // assistant turn. Used by sendMessage and the chat history UI.
-export function makeTextResult(text: string, role: "user" | "assistant"): ToolResultComplete {
+// `attachments` is optional and only meaningful on user turns —
+// they're the workspace paths the user attached for this message
+// and surface as chips next to the bubble. `seededByPlugin` is
+// optional and set by `parseSessionEntries` on the first user turn
+// of a plugin-origin session (Phase 1 of the Encore plan); the
+// textResponse view renders a "from <pkg>" chip when present.
+export function makeTextResult(text: string, role: "user" | "assistant", attachments?: readonly string[], seededByPlugin?: string): ToolResultComplete {
+  const data: Record<string, unknown> = { text, role, transportKind: "text-rest" };
+  if (attachments && attachments.length > 0) {
+    data.attachments = [...attachments];
+  }
+  if (seededByPlugin) {
+    data.seededByPlugin = seededByPlugin;
+  }
   return {
     uuid: uuidv4(),
     toolName: "text-response",
     message: text,
     title: role === "user" ? "You" : "Assistant",
-    data: { text, role, transportKind: "text-rest" },
+    data,
+  };
+}
+
+export interface SkillResultData {
+  skillName: string;
+  skillScope: SkillScope;
+  skillPath: string | null;
+  skillDescription: string | null;
+  /** Full SKILL.md body as Claude CLI synthesised it. Available in
+   *  the data field for the View's expand toggle. */
+  body: string;
+}
+
+/** Build a synthetic skill-result envelope from a parsed jsonl
+ *  `SkillEntry`. The skill plugin's View collapses by default to
+ *  `<skillName> · <skillDescription>` and reveals `body` on toggle.
+ *  Distinct from `makeTextResult` so the canvas can render it
+ *  without the wall-of-text default applied to assistant prose. */
+export function makeSkillResult(entry: {
+  skillName: string;
+  skillScope: SkillScope;
+  skillPath: string | null;
+  skillDescription: string | null;
+  message: string;
+}): ToolResultComplete {
+  const data: SkillResultData = {
+    skillName: entry.skillName,
+    skillScope: entry.skillScope,
+    skillPath: entry.skillPath,
+    skillDescription: entry.skillDescription,
+    body: entry.message,
+  };
+  return {
+    uuid: uuidv4(),
+    toolName: SKILL_TOOL_NAME,
+    message: entry.skillDescription ?? entry.skillName,
+    title: `Skill: ${entry.skillName}`,
+    data: data as unknown as Record<string, unknown>,
   };
 }

package/src/vite-env.d.ts

@@ -2,6 +2,12 @@
 
 interface ImportMetaEnv {
   readonly VITE_LOCALE?: "en" | "ja";
+  // Set `VITE_DEV_MODE=1` in `.env` to surface `isDebugRole` roles
+  // in the dropdown. Anything else (including unset, "0", "true",
+  // "yes") hides them — the consumer side does an exact `=== "1"`
+  // check so the type stays open to whatever string Vite hands
+  // through, instead of pretending only `"1" | "0"` are reachable.
+  readonly VITE_DEV_MODE?: string;
 }
 
 interface ImportMeta {