@meistrari/remy-cli 1.12.0 → 1.13.0

package/README.md

@@ -46,6 +46,8 @@ Use Up/Down to select a session in the dashboard, Left/Right to load the adjacen
 
 The **Live reasoning preview** shows the newest main-agent summary as it arrives. It is a short, best-effort preview—not private chain-of-thought. Long previews show **Preview shortened.** Opening or reconnecting partway through a summary may show no preview; the final summary still appears in activity history. Disconnecting or finishing the item clears the live preview.
 
+Subagent work appears as named **Subagent · <name>** activity rather than messages from Remy. Resolved descendants stay grouped under their actual parent as a compact `Parent › Child` path; missing or contradictory ancestry remains explicitly **Unattributed subagent** instead of being assigned to the active main turn. Press `Ctrl+O` to read retained child messages, complete tool results, reasoning summaries, and child IDs. Child input does not enter your prompt history, child output does not replace Remy's main live preview, and parent or main completion does not end a still-running descendant. Child-specific Stop controls are not available.
+
 Published files and Tela Pages appear in the timeline. A Tela Page row includes its title and canonical URL so you can open it directly from the terminal.
 
 When Remy creates a plan, the session shows its checklist in the timeline and keeps `Plan <done>/<total>` with the current item pinned above the composer. Updates change the same checklist instead of producing repeated rows, and an unfinished plan remains visible after reconnecting or between turns. The collapsed timeline shows up to five plan items; press `Ctrl+O` for the complete checklist and activity detail.

package/dist/remy.js

@@ -33925,15 +33925,16 @@ var sessionWorkspaceGitRevisionEventSchema = exports_external2.object({
     trigger: exports_external2.enum(["turn-ended", "boot-reconcile"])
   }).passthrough()
 }).passthrough();
-var agentTurnEndedEventSchema = exports_external2.object({
-  type: exports_external2.literal("agent.turn.ended"),
-  turnId: exports_external2.string().min(1),
-  actor: exports_external2.object({ type: exports_external2.enum(["main", "subagent"]) }).passthrough(),
-  payload: exports_external2.object({ status: exports_external2.enum(["completed", "failed", "cancelled", "interrupted"]) }).passthrough()
+var agentTurnEndedEventSchema = wrappedTurnEndedAgentEventSchema.pick({
+  type: true,
+  turnId: true,
+  actor: true,
+  payload: true
 }).passthrough();
-var agentMessageDeltaEventSchema = exports_external2.object({
-  type: exports_external2.literal("agent.message.delta"),
-  payload: exports_external2.object({ role: exports_external2.string(), delta: exports_external2.string() }).passthrough()
+var agentMessageDeltaEventSchema = wrappedMessageDeltaAgentEventSchema.pick({
+  type: true,
+  actor: true,
+  payload: true
 }).passthrough();
 var publicMessageContentSegmentSchema = exports_external2.discriminatedUnion("type", [
   exports_external2.strictObject({ type: exports_external2.literal("text"), text: exports_external2.string() }),
@@ -33985,6 +33986,13 @@ function createSessionViewState({ detail, activeMessageId }) {
     messageTurns: {},
     retainedTurnStarts: {},
     retainedTurnEnds: {},
+    childLineage: {
+      nextOrder: 0,
+      runtimeEpochs: {},
+      seenRuntimeBoundaryEventIds: {},
+      facts: [],
+      owners: []
+    },
     context: {
       snapshot: { status: "unknown" },
       through: 0
@@ -34038,7 +34046,7 @@ function sessionTurnOutcome({ state, sessionMessageId }) {
 }
 function projectEphemeralEvent({ state, event }) {
   const messageDelta = agentMessageDeltaEventSchema.safeParse(event);
-  if (messageDelta.success && messageDelta.data.payload.role === "assistant") {
+  if (messageDelta.success && messageDelta.data.actor.type === "main" && messageDelta.data.payload.role === "assistant") {
     return {
       ...state,
       previews: { ...state.previews, assistantText: state.previews.assistantText + messageDelta.data.payload.delta }
@@ -34059,6 +34067,7 @@ function projectRetainedEvent({
   const workspaceGitRevision = sessionWorkspaceGitRevisionEventSchema.safeParse(event);
   const turnEnded = agentTurnEndedEventSchema.safeParse(event);
   let projected = messageCreated.success ? projectSessionMessageCreated({ state, event: messageCreated.data, occurredAt }) : turnAssociated.success ? projectSessionMessageTurnAssociated({ state, event: turnAssociated.data }) : workspaceGitInitialized.success ? projectSessionWorkspaceGitInitialized({ state, event: workspaceGitInitialized.data, occurredAt, retainedEventId }) : workspaceGitRevision.success ? projectSessionWorkspaceGitRevision({ state, event: workspaceGitRevision.data, occurredAt, retainedEventId }) : turnEnded.success ? projectAgentTurnEnded({ state, event: turnEnded.data, occurredAt, retainedEventId }) : projectDurableAgentEvent({ state, event, occurredAt, retainedEventId });
+  projected = recordAgentLineageEvent({ state: projected, event, retainedEventId });
   if (artifact) {
     const publication = artifact.kind === "file" ? { artifactId: artifact.artifact_id, kind: artifact.kind, title: artifact.filename } : { artifactId: artifact.artifact_id, kind: artifact.kind, title: artifact.title, url: artifact.url };
     const timelineArtifact = artifact.kind === "file" ? {
@@ -34171,19 +34180,22 @@ function projectSessionWorkspaceGitRevision({ state, event, occurredAt, retained
   });
 }
 function projectAgentTurnEnded({ state, event, occurredAt, retainedEventId }) {
-  const retainedTurnEnds = { ...state.retainedTurnEnds, [event.turnId]: { actorType: event.actor.type, outcome: event.payload.status } };
-  const messageTurns = event.actor.type === "main" ? Object.fromEntries(Object.entries(state.messageTurns).map(([messageId, turn]) => [messageId, turn.turnId === event.turnId ? { ...turn, outcome: event.payload.status } : turn])) : state.messageTurns;
-  return appendActivity({
-    state: { ...state, retainedTurnEnds, messageTurns },
-    retainedEventId,
-    occurredAt,
-    card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: "Turn failed." } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` }
+  const stateWithTurnOutcome = event.actor.type === "main" ? {
+    ...state,
+    retainedTurnEnds: { ...state.retainedTurnEnds, [event.turnId]: { actorType: event.actor.type, outcome: event.payload.status } },
+    messageTurns: Object.fromEntries(Object.entries(state.messageTurns).map(([messageId, turn]) => [messageId, turn.turnId === event.turnId ? { ...turn, outcome: event.payload.status } : turn]))
+  } : state;
+  const card = event.actor.type === "main" ? event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: "Turn failed." } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` } : createChildActivityCard({
+    identity: event.actor,
+    activityTitle: event.payload.status === "failed" ? "Turn failed" : "Turn ended",
+    card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Turn failed.") } : { kind: "lifecycle", weight: "noise", summary: `Turn ${event.payload.status}.` }
   });
+  return appendActivity({ state: stateWithTurnOutcome, retainedEventId, occurredAt, card });
 }
 function projectDurableAgentEvent({ state, event, occurredAt, retainedEventId }) {
   const agentEvent = parseDurableAgentEvent(event);
   if (agentEvent.type === "agent.message.ended")
-    return projectAgentMessageEnded({ state, event: agentEvent, occurredAt });
+    return projectAgentMessageEnded({ state, event: agentEvent, occurredAt, retainedEventId });
   if (agentEvent.type === "agent.context.updated")
     return state;
   if (agentEvent.type === "agent.work.observed" && agentEvent.actor.type === "main")
@@ -34195,6 +34207,9 @@ function projectDurableAgentEvent({ state, event, occurredAt, retainedEventId })
   } : state;
   return appendActivity({ state: stateWithTurnStart, retainedEventId, occurredAt, card: toAgentActivityCard(agentEvent) });
 }
+function hasOwnContextIdentity(identities, identity) {
+  return Object.prototype.hasOwnProperty.call(identities, identity);
+}
 function projectAgentWorkObserved({
   state,
   event,
@@ -34266,23 +34281,45 @@ function patchedWorkItemId(observation) {
     return observation.itemId;
   return null;
 }
-function projectAgentMessageEnded({ state, event, occurredAt }) {
+function projectAgentMessageEnded({ state, event, occurredAt, retainedEventId }) {
   const messageId = event.payload.messageId;
+  const text = event.payload.content.map(publicMessageContentSegmentText).join("");
+  if (event.actor.type === "subagent") {
+    const childId = terminalSafeSingleLine(event.actor.subagentId);
+    const card = createChildActivityCard({
+      identity: event.actor,
+      activityTitle: event.payload.role === "assistant" ? "Message completed" : `${capitalize(event.payload.role)} message`,
+      titleIncludesActivity: false,
+      card: {
+        kind: event.payload.role === "assistant" ? "command-output" : "progress",
+        weight: "signal",
+        summary: `${event.payload.role === "assistant" ? "Message completed." : `${capitalize(event.payload.role)} message retained.`} \xB7 ${childId}`,
+        detail: stripAnsi(text) || "[Empty message]"
+      }
+    });
+    return appendActivity({ state, retainedEventId, occurredAt, card });
+  }
   if (state.transcript.some((item) => item.kind === "message" && item.messageId === messageId))
     return state;
   const role2 = event.payload.role;
   const author = role2 === "assistant" ? { label: "Remy", role: "remy" } : role2 === "system" ? { label: "System", role: "system" } : { label: event.payload.commandId ? state.commandAuthorLabels[event.payload.commandId] ?? "Human" : "Human", role: "human" };
-  const text = event.payload.content.map(publicMessageContentSegmentText).join("") || (author.role === "remy" ? "[Remy sent an empty message]" : "[Empty message]");
+  const displayedText = text || (author.role === "remy" ? "[Remy sent an empty message]" : "[Empty message]");
   return {
     ...state,
     ...author.role === "remy" ? { previews: { ...state.previews, assistantText: "" } } : {},
-    transcript: [...state.transcript, { kind: "message", messageId, occurredAt, author, text, attachments: [] }]
+    transcript: [...state.transcript, { kind: "message", messageId, occurredAt, author, text: displayedText, attachments: [] }]
   };
 }
 function appendActivity({ state, retainedEventId, occurredAt, card }) {
   return { ...state, transcript: [...state.transcript, { kind: "activity", activityId: `activity:${retainedEventId}`, occurredAt, card }] };
 }
 function toAgentActivityCard(event) {
+  const identity = childActivityIdentity(event);
+  if (identity)
+    return toChildAgentActivityCard({ event, identity });
+  return toMainAgentActivityCard(event);
+}
+function toMainAgentActivityCard(event) {
   switch (event.type) {
     case "agent.session.started":
       return { kind: "lifecycle", weight: "noise", title: "Remy session started", summary: "Session is ready." };
@@ -34347,6 +34384,444 @@ function toAgentActivityCard(event) {
       throw new SessionProjectionProtocolError("Cannot project an unknown retained agent event.");
   }
 }
+function toChildAgentActivityCard({ event, identity }) {
+  switch (event.type) {
+    case "agent.turn.started":
+      return createChildActivityCard({ identity, activityTitle: "Turn started", card: { kind: "lifecycle", weight: "noise", summary: "Turn started." } });
+    case "agent.turn.ended":
+      return createChildActivityCard({
+        identity,
+        activityTitle: event.payload.status === "failed" ? "Turn failed" : "Turn ended",
+        card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Turn failed.") } : { kind: "lifecycle", weight: "noise", summary: `Turn ${event.payload.status}.` }
+      });
+    case "agent.work.observed":
+      return createChildActivityCard({ identity, activityTitle: "Work progress", card: { kind: "progress", weight: "noise", summary: "Subagent updated its work plan.", detail: jsonDetail(event.payload.observations) } });
+    case "agent.message.started":
+      return createChildActivityCard({ identity, activityTitle: "Message started", card: { kind: "lifecycle", weight: "noise", summary: "Subagent is composing a message." } });
+    case "agent.reasoning.started":
+      return createChildActivityCard({ identity, activityTitle: "Reasoning", card: { kind: "reasoning", weight: "noise", summary: "Subagent started a reasoning summary." } });
+    case "agent.reasoning.ended": {
+      const summary = stripAnsi(event.payload.summary ?? "").trim();
+      return createChildActivityCard({
+        identity,
+        activityTitle: "Reasoning",
+        card: summary.length > 0 ? { kind: "reasoning", weight: "signal", summary } : { kind: "reasoning", weight: "noise", summary: "Subagent completed a reasoning summary." }
+      });
+    }
+    case "agent.tool.call.started":
+      return createChildActivityCard({
+        identity,
+        activityTitle: terminalSafeSingleLine(event.payload.toolName),
+        card: {
+          kind: "tool",
+          weight: "signal",
+          summary: "Tool started.",
+          ...event.payload.input === undefined ? {} : { detail: jsonDetail(event.payload.input), detailFormat: "code" }
+        }
+      });
+    case "agent.tool.call.completed": {
+      const failed = event.payload.status === "failed" || event.payload.status === "cancelled";
+      const detail = event.payload.output === undefined ? undefined : toolOutputDetail(event.payload.output);
+      return createChildActivityCard({
+        identity,
+        activityTitle: failed ? "Tool failed" : "Tool completed",
+        card: failed ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, `Tool ${event.payload.status}.`), ...detail === undefined ? {} : { detail, detailFormat: "code" } } : { kind: "command-output", weight: "signal", summary: "Tool completed.", ...detail === undefined ? {} : { detail, detailFormat: "code" } }
+      });
+    }
+    case "agent.subagent.started":
+      return createChildActivityCard({ identity, activityTitle: "Started", card: { kind: "progress", weight: "signal", summary: providerText(event.payload.name, event.payload.subagentId) } });
+    case "agent.subagent.progress":
+      return createChildActivityCard({ identity, activityTitle: "Progress", card: { kind: "progress", weight: "signal", summary: providerText(event.payload.summary, "Subagent is working.") } });
+    case "agent.subagent.ended":
+      return createChildActivityCard({
+        identity,
+        activityTitle: event.payload.status === "failed" ? "Failed" : "Ended",
+        card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Subagent failed.") } : { kind: "progress", weight: "signal", summary: providerText(event.payload.summary, `Subagent ${event.payload.status}.`) }
+      });
+    case "agent.usage":
+      return createChildActivityCard({ identity, activityTitle: "Usage updated", card: { kind: "progress", weight: "noise", summary: "Subagent reported usage.", detail: jsonDetail(event.payload.usage) } });
+    case "agent.context.compaction.started":
+      return createChildActivityCard({ identity, activityTitle: "Context compaction started", card: { kind: "reasoning", weight: "noise", summary: "Subagent is compacting context." } });
+    case "agent.context.compaction.completed":
+      return createChildActivityCard({
+        identity,
+        activityTitle: event.payload.status === "failed" ? "Context compaction failed" : "Context compaction completed",
+        card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Context compaction failed.") } : { kind: "reasoning", weight: "noise", summary: "Subagent compacted context." }
+      });
+    case "agent.user-input.requested":
+      return createChildActivityCard({ identity, activityTitle: "Needs input", card: { kind: "approval-question", weight: "signal", summary: providerText(event.payload.prompt, "Subagent needs input."), detail: jsonDetail(event.payload.questions) } });
+    case "agent.session.started":
+    case "agent.session.configured":
+    case "agent.session.skills.updated":
+    case "agent.session.state.changed":
+    case "agent.session.ended":
+    case "agent.user-input.resolved":
+    case "agent.error":
+      throw new SessionProjectionProtocolError(`Cannot attribute non-child session event type ${event.type} to a subagent.`);
+    case "agent.message.delta":
+    case "agent.reasoning.summary.delta":
+    case "agent.tool.output.delta":
+      throw new SessionProjectionProtocolError(`Cannot project ephemeral session event type ${event.type} as retained history.`);
+    default:
+      throw new SessionProjectionProtocolError("Cannot attribute an unknown retained event to a subagent.");
+  }
+}
+function createChildActivityCard({
+  identity,
+  activityTitle,
+  titleIncludesActivity = true,
+  card
+}) {
+  const subagentId = terminalSafeSingleLine(identity.subagentId);
+  const actorId = terminalSafeSingleLine(identity.actorId);
+  const displayName = terminalSafeSingleLine(identity.name ?? "") || subagentId;
+  const identityDetail = [
+    `Subagent ID: ${subagentId}`,
+    ...actorId !== subagentId ? [`Actor ID: ${actorId}`] : []
+  ].join(`
+`);
+  const detail = card.detail === undefined ? identityDetail : `${identityDetail}
+
+${card.detail}`;
+  return {
+    ...card,
+    title: `Subagent \xB7 ${displayName}${activityTitle === undefined || !titleIncludesActivity ? "" : ` \xB7 ${activityTitle}`}`,
+    detail,
+    attribution: {
+      status: "unresolved",
+      identity,
+      ...activityTitle === undefined ? {} : { activityTitle }
+    }
+  };
+}
+function childActivityIdentity(event) {
+  if (event.type === "agent.subagent.started" || event.type === "agent.subagent.progress" || event.type === "agent.subagent.ended") {
+    if (event.actor.type === "subagent") {
+      if (!subagentLifecycleIdentityMatches({ actor: event.actor, payload: event.payload }))
+        throw new SessionProjectionProtocolError(`Retained session event type ${event.type} carried contradictory subagent actor and payload identity.`);
+      return {
+        ...event.actor,
+        ...event.actor.name === undefined && event.payload.name !== undefined ? { name: event.payload.name } : {}
+      };
+    }
+    return {
+      type: "subagent",
+      actorId: event.payload.actorId,
+      subagentId: event.payload.subagentId,
+      parentActorId: event.payload.parentActorId,
+      origin: event.payload.origin,
+      ...event.payload.parentToolCallId === undefined ? {} : { parentToolCallId: event.payload.parentToolCallId },
+      ...event.payload.name === undefined ? {} : { name: event.payload.name }
+    };
+  }
+  if ("actor" in event && event.actor.type === "subagent") {
+    return event.actor;
+  }
+  return;
+}
+function subagentLifecycleIdentityMatches({ actor, payload }) {
+  return actor.actorId === payload.actorId && actor.subagentId === payload.subagentId && actor.parentActorId === payload.parentActorId && actor.parentToolCallId === payload.parentToolCallId && subagentOriginsMatch(actor.origin, payload.origin);
+}
+function subagentOriginsMatch(left, right) {
+  if (left.type === "tool_call")
+    return right.type === "tool_call" && left.toolCallId === right.toolCallId;
+  return right.type === "provider_task" && left.taskId === right.taskId;
+}
+function recordAgentLineageEvent({
+  state,
+  event,
+  retainedEventId
+}) {
+  if (!event.type.startsWith("agent."))
+    return state;
+  let parsed;
+  try {
+    parsed = parseDurableAgentEvent(event);
+  } catch (error93) {
+    if (error93 instanceof SessionProjectionProtocolError)
+      return state;
+    throw error93;
+  }
+  const runtimeBase = lineageRuntimeBase(parsed);
+  let childLineage = state.childLineage;
+  if (parsed.type === "agent.session.started" || parsed.type === "agent.session.ended") {
+    const boundaryKey = `${runtimeBase}:${lengthPrefixed(parsed.eventId)}`;
+    if (hasOwnContextIdentity(childLineage.seenRuntimeBoundaryEventIds, boundaryKey))
+      return state;
+    childLineage = {
+      ...childLineage,
+      runtimeEpochs: parsed.type === "agent.session.started" ? { ...childLineage.runtimeEpochs, [runtimeBase]: (childLineage.runtimeEpochs[runtimeBase] ?? 0) + 1 } : childLineage.runtimeEpochs,
+      seenRuntimeBoundaryEventIds: {
+        ...childLineage.seenRuntimeBoundaryEventIds,
+        [boundaryKey]: true
+      }
+    };
+    return { ...state, childLineage };
+  }
+  if (!("turnId" in parsed))
+    return state;
+  const runtimeScope = lineageRuntimeScope({
+    runtimeBase,
+    epoch: childLineage.runtimeEpochs[runtimeBase] ?? 0
+  });
+  const order = childLineage.nextOrder;
+  const identity = childActivityIdentity(parsed);
+  const fact = identity ? {
+    retainedEventId,
+    order,
+    runtimeScope,
+    turnId: parsed.turnId,
+    eventType: parsed.type,
+    identity
+  } : parsed.type === "agent.tool.call.started" && parsed.actor.type === "main" ? {
+    retainedEventId,
+    order,
+    runtimeScope,
+    turnId: parsed.turnId,
+    eventType: parsed.type,
+    toolCallId: parsed.payload.toolCallId
+  } : undefined;
+  if (!fact)
+    return state;
+  const nextState = {
+    ...state,
+    childLineage: {
+      ...childLineage,
+      nextOrder: order + 1,
+      facts: [...childLineage.facts, fact]
+    }
+  };
+  if (!isChildLineageFact(fact) || isSubagentLifecycleType(fact.eventType))
+    return reconcileChildLineage(nextState);
+  const resolution = resolveBodyFactAgainstOwners(childLineage.owners, fact);
+  if (resolution.status === "graph-change")
+    return reconcileChildLineage(nextState);
+  if (resolution.status === "unresolved")
+    return nextState;
+  return stampResolvedAttribution({ state: nextState, retainedEventId, fact, owner: resolution.owner });
+}
+function resolveBodyFactAgainstOwners(owners, fact) {
+  const candidates = owners.filter((owner) => owner.runtimeScope === fact.runtimeScope && childIdentityMatches(owner.identity, fact.identity));
+  const turnCandidates = candidates.filter((owner) => owner.childTurnIds.has(fact.turnId));
+  if (turnCandidates.length === 1)
+    return { status: "known", owner: turnCandidates[0] };
+  if (candidates.length === 1)
+    return { status: "graph-change" };
+  return { status: "unresolved" };
+}
+function stampResolvedAttribution({ state, retainedEventId, fact, owner }) {
+  const activityId = `activity:${retainedEventId}`;
+  for (let index = state.transcript.length - 1;index >= 0; index -= 1) {
+    const item = state.transcript[index];
+    if (item.kind !== "activity" || item.activityId !== activityId)
+      continue;
+    if (!item.card.attribution)
+      return state;
+    const attribution = {
+      status: "resolved",
+      identity: fact.identity,
+      ...item.card.attribution.activityTitle === undefined ? {} : { activityTitle: item.card.attribution.activityTitle },
+      ownerKey: owner.key,
+      owningMainTurnId: owner.owningMainTurnId,
+      path: ownerPath(owner)
+    };
+    if (childAttributionEqual(item.card.attribution, attribution))
+      return state;
+    const transcript = [...state.transcript];
+    transcript[index] = { ...item, card: { ...item.card, attribution } };
+    return { ...state, transcript };
+  }
+  return state;
+}
+function lineageRuntimeBase(event) {
+  return `${lengthPrefixed(event.sessionId)}:${lengthPrefixed(event.providerSessionId)}`;
+}
+function lineageRuntimeScope({ runtimeBase, epoch }) {
+  return `${runtimeBase}:${epoch}`;
+}
+function lengthPrefixed(value) {
+  return `${value.length}:${value}`;
+}
+function isChildLineageFact(fact) {
+  return "identity" in fact;
+}
+function isSubagentLifecycleType(type) {
+  return type === "agent.subagent.started" || type === "agent.subagent.progress" || type === "agent.subagent.ended";
+}
+function childIdentityMatches(left, right) {
+  return left.actorId === right.actorId && left.subagentId === right.subagentId && left.parentActorId === right.parentActorId && left.parentToolCallId === right.parentToolCallId && subagentOriginsMatch(left.origin, right.origin);
+}
+function childIdentityCanAnchor(identity) {
+  return identity.actorId !== identity.parentActorId && (identity.origin.type !== "tool_call" || identity.parentToolCallId === undefined || identity.parentToolCallId === identity.origin.toolCallId);
+}
+function reconcileChildLineage(state) {
+  const facts = state.childLineage.facts;
+  const childFacts = facts.filter(isChildLineageFact);
+  const mainToolTurns = new Map;
+  for (const fact of facts) {
+    if (isChildLineageFact(fact))
+      continue;
+    const key = `${fact.runtimeScope}:${lengthPrefixed(fact.toolCallId)}`;
+    const turns = mainToolTurns.get(key) ?? new Set;
+    turns.add(fact.turnId);
+    mainToolTurns.set(key, turns);
+  }
+  const owners = [];
+  const ownerByFactOrder = new Map;
+  const mainTurnForToolOrigin = (fact) => {
+    if (fact.identity.origin.type !== "tool_call")
+      return;
+    const turns = mainToolTurns.get(`${fact.runtimeScope}:${lengthPrefixed(fact.identity.origin.toolCallId)}`);
+    return turns?.size === 1 ? [...turns][0] : undefined;
+  };
+  const createOwner = ({
+    fact,
+    owningMainTurnId,
+    parent
+  }) => {
+    if (!childIdentityCanAnchor(fact.identity))
+      return;
+    if (parent && ownerHasActorAncestor(parent, fact.identity.actorId))
+      return;
+    const samePlacement = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && owner2.owningMainTurnId === owningMainTurnId && owner2.parent === parent && owner2.identity.actorId === fact.identity.actorId && owner2.identity.subagentId === fact.identity.subagentId);
+    if (samePlacement.some((owner2) => !childIdentityMatches(owner2.identity, fact.identity)))
+      return;
+    const existing = samePlacement.find((owner2) => childIdentityMatches(owner2.identity, fact.identity));
+    if (existing)
+      return existing;
+    const owner = {
+      key: `${fact.runtimeScope}:${lengthPrefixed(owningMainTurnId)}:${fact.order}`,
+      identity: fact.identity,
+      runtimeScope: fact.runtimeScope,
+      owningMainTurnId,
+      parent,
+      childTurnIds: new Set
+    };
+    owners.push(owner);
+    return owner;
+  };
+  for (const fact of childFacts) {
+    if (fact.eventType !== "agent.subagent.started" || fact.identity.parentActorId !== "main")
+      continue;
+    const toolTurn = mainTurnForToolOrigin(fact);
+    if (fact.identity.origin.type === "tool_call" && toolTurn === undefined) {
+      const turns = mainToolTurns.get(`${fact.runtimeScope}:${lengthPrefixed(fact.identity.origin.toolCallId)}`);
+      if (turns && turns.size > 1)
+        continue;
+    }
+    if (toolTurn !== undefined && toolTurn !== fact.turnId)
+      continue;
+    const owner = createOwner({ fact, owningMainTurnId: fact.turnId, parent: null });
+    if (owner)
+      ownerByFactOrder.set(fact.order, owner);
+  }
+  for (const fact of childFacts) {
+    if (isSubagentLifecycleType(fact.eventType) && fact.eventType !== "agent.subagent.started" && fact.identity.parentActorId === "main") {
+      const toolTurn = mainTurnForToolOrigin(fact);
+      if (toolTurn === undefined)
+        continue;
+      const owner = owners.find((candidate) => candidate.runtimeScope === fact.runtimeScope && candidate.parent === null && candidate.owningMainTurnId === toolTurn && childIdentityMatches(candidate.identity, fact.identity)) ?? createOwner({ fact, owningMainTurnId: toolTurn, parent: null });
+      if (owner) {
+        ownerByFactOrder.set(fact.order, owner);
+        owner.childTurnIds.add(fact.turnId);
+      }
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const fact of childFacts) {
+      if (ownerByFactOrder.has(fact.order))
+        continue;
+      const candidates = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && childIdentityMatches(owner2.identity, fact.identity));
+      const turnCandidates = candidates.filter((owner2) => owner2.childTurnIds.has(fact.turnId));
+      const owner = turnCandidates.length === 1 ? turnCandidates[0] : candidates.length === 1 ? candidates[0] : undefined;
+      if (!owner || fact.eventType === "agent.subagent.started")
+        continue;
+      ownerByFactOrder.set(fact.order, owner);
+      owner.childTurnIds.add(fact.turnId);
+      changed = true;
+    }
+    for (const fact of childFacts) {
+      if (ownerByFactOrder.has(fact.order) || fact.eventType !== "agent.subagent.started" || fact.identity.parentActorId === "main" || !childIdentityCanAnchor(fact.identity)) {
+        continue;
+      }
+      const parentCandidates = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && owner2.identity.actorId === fact.identity.parentActorId);
+      const turnParents = parentCandidates.filter((owner2) => owner2.childTurnIds.has(fact.turnId));
+      const parent = turnParents.length === 1 ? turnParents[0] : parentCandidates.length === 1 ? parentCandidates[0] : undefined;
+      if (!parent)
+        continue;
+      const owner = createOwner({ fact, owningMainTurnId: parent.owningMainTurnId, parent });
+      if (!owner)
+        continue;
+      ownerByFactOrder.set(fact.order, owner);
+      changed = true;
+    }
+  }
+  const resolvedByRetainedEventId = new Map;
+  for (const fact of childFacts) {
+    const owner = ownerByFactOrder.get(fact.order);
+    if (owner)
+      resolvedByRetainedEventId.set(fact.retainedEventId, { fact, owner });
+  }
+  let transcriptChanged = false;
+  const transcript = state.transcript.map((item) => {
+    if (item.kind !== "activity" || !item.card.attribution)
+      return item;
+    const retainedEventId = item.activityId.slice("activity:".length);
+    const resolved = resolvedByRetainedEventId.get(retainedEventId);
+    const attribution = resolved ? {
+      status: "resolved",
+      identity: resolved.fact.identity,
+      ...item.card.attribution.activityTitle === undefined ? {} : { activityTitle: item.card.attribution.activityTitle },
+      ownerKey: resolved.owner.key,
+      owningMainTurnId: resolved.owner.owningMainTurnId,
+      path: ownerPath(resolved.owner)
+    } : {
+      status: "unresolved",
+      identity: item.card.attribution.identity,
+      ...item.card.attribution.activityTitle === undefined ? {} : { activityTitle: item.card.attribution.activityTitle }
+    };
+    if (childAttributionEqual(item.card.attribution, attribution))
+      return item;
+    transcriptChanged = true;
+    return { ...item, card: { ...item.card, attribution } };
+  });
+  const nextState = { ...state, childLineage: { ...state.childLineage, owners } };
+  return transcriptChanged ? { ...nextState, transcript } : nextState;
+}
+function ownerHasActorAncestor(parent, actorId) {
+  let candidate = parent;
+  while (candidate) {
+    if (candidate.identity.actorId === actorId)
+      return true;
+    candidate = candidate.parent;
+  }
+  return false;
+}
+function ownerPath(owner) {
+  const path = [];
+  let candidate = owner;
+  while (candidate) {
+    path.unshift(candidate.identity);
+    candidate = candidate.parent;
+  }
+  return path;
+}
+function childAttributionEqual(left, right) {
+  if (left.status !== right.status || left.activityTitle !== right.activityTitle || !childIdentityMatches(left.identity, right.identity)) {
+    return false;
+  }
+  if (left.status === "unresolved" || right.status === "unresolved")
+    return true;
+  return left.ownerKey === right.ownerKey && left.owningMainTurnId === right.owningMainTurnId && left.path.length === right.path.length && left.path.every((identity, index) => childIdentityMatches(identity, right.path[index]));
+}
+function terminalSafeSingleLine(value) {
+  return stripAnsi(value).replace(/\s+/gu, " ").trim();
+}
+function capitalize(value) {
+  return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
 function parseDurableAgentEvent(event) {
   if (!event.type.startsWith("agent."))
     throw new SessionProjectionProtocolError(`Cannot project retained session event type ${event.type}.`);
@@ -34383,6 +34858,9 @@ var terminalControlPattern = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
 function stripAnsi(value) {
   return value.replace(ansiEscapePattern, "").replace(terminalControlPattern, "");
 }
+function terminalSafeText(value) {
+  return stripAnsi(value);
+}
 function formatReasoningPreview(item) {
   if (item.status === "absent")
     return "";
@@ -37593,16 +38071,20 @@ function activityGlyph({ kind, inFlight }) {
     return { glyph: "\xB7", color: PALETTE.dimText };
   return { glyph: "\u2713", color: PALETTE.dimText };
 }
-function dedupeActivitySteps(items) {
-  const runs = [];
-  for (const item of items) {
-    const last = runs[runs.length - 1];
-    if (last && last.item.card.kind === item.card.kind && last.item.card.title === item.card.title && last.item.card.summary === item.card.summary)
-      last.count += 1;
-    else
-      runs.push({ item, count: 1 });
+function activityCardsHaveEqualDisclosure(left, right) {
+  return left.kind === right.kind && left.title === right.title && left.summary === right.summary && left.detail === right.detail && left.detailFormat === right.detailFormat && canonicalValuesEqual(left.attribution, right.attribution);
+}
+function canonicalValuesEqual(left, right) {
+  if (Object.is(left, right))
+    return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => canonicalValuesEqual(value, right[index]));
   }
-  return runs;
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null)
+    return false;
+  const leftEntries = Object.entries(left);
+  const rightEntries = Object.entries(right);
+  return leftEntries.length === rightEntries.length && leftEntries.every(([key, value], index) => rightEntries[index]?.[0] === key && canonicalValuesEqual(value, rightEntries[index]?.[1]));
 }
 function renderActivityGroup({ items, activityExpanded }) {
   if (items.length === 0)
@@ -37624,22 +38106,82 @@ function renderActivityGroup({ items, activityExpanded }) {
     ], `
 `);
   }
-  const steps = dedupeActivitySteps(items).map(({ item, count }) => {
-    const inFlight = item.card.kind === "tool" && items.indexOf(item) === lastInFlightIndex;
-    const { glyph, color } = activityGlyph({ kind: item.card.kind, inFlight });
-    const showSummary = item.card.summary.length > 0 && item.card.summary !== item.card.title && !boilerplateActivitySummaries.has(item.card.summary);
-    const detail = item.card.detail === undefined ? undefined : item.card.detailFormat === "code" ? renderCodeSnippet({ text: item.card.detail, indent: "      " }) : new StyledText5([dim4(fg6(PALETTE.dimText)(`      ${item.card.detail}`))]);
-    const step = new StyledText5([
-      fg6(color)(`  ${glyph} `),
-      fg6(PALETTE.bodyText)(item.card.title),
-      ...count > 1 ? [dim4(fg6(PALETTE.dimText)(`  \xD7${count}`))] : [],
-      ...showSummary ? [dim4(fg6(PALETTE.dimText)(`
-      ${item.card.summary}`))] : []
-    ]);
-    return detail ? joinStyled([step, detail], `
+  return joinStyled([summary, ...renderExpandedActivityHierarchy({ items, lastInFlightIndex })], `
+`);
+}
+function renderExpandedActivityHierarchy({ items, lastInFlightIndex }) {
+  const rendered = [];
+  let activeOwnerKey;
+  let index = 0;
+  while (index < items.length) {
+    const item = items[index];
+    const attribution = item.card.attribution;
+    if (attribution?.status === "resolved") {
+      if (activeOwnerKey !== attribution.ownerKey) {
+        rendered.push(new StyledText5([
+          dim4(fg6(PALETTE.dimText)("  ")),
+          fg6(PALETTE.bodyText)(`Subagent \xB7 ${lineagePathLabel(attribution.path)}`)
+        ]));
+      }
+      activeOwnerKey = attribution.ownerKey;
+    } else {
+      activeOwnerKey = undefined;
+    }
+    let count = 1;
+    while (items[index + count] && activityCardsHaveEqualDisclosure(item.card, items[index + count].card)) {
+      count += 1;
+    }
+    rendered.push(renderExpandedActivityStep({
+      item,
+      count,
+      inFlight: item.card.kind === "tool" && index === lastInFlightIndex,
+      nested: attribution?.status === "resolved"
+    }));
+    index += count;
+  }
+  return rendered;
+}
+function renderExpandedActivityStep({ item, count, inFlight, nested }) {
+  const { glyph, color } = activityGlyph({ kind: item.card.kind, inFlight });
+  const showSummary = item.card.summary.length > 0 && item.card.summary !== item.card.title && !boilerplateActivitySummaries.has(item.card.summary);
+  const disclosure = renderActivityDisclosure(item.card);
+  const title = expandedActivityTitle(item.card);
+  const indent = nested ? "    " : "  ";
+  const step = new StyledText5([
+    fg6(color)(`${indent}${glyph} `),
+    fg6(PALETTE.bodyText)(title),
+    ...count > 1 ? [dim4(fg6(PALETTE.dimText)(`  \xD7${count}`))] : [],
+    ...showSummary ? [dim4(fg6(PALETTE.dimText)(`
+${indent}    ${item.card.summary}`))] : []
+  ]);
+  return disclosure ? joinStyled([step, disclosure], `
 `) : step;
-  });
-  return joinStyled([summary, ...steps], `
+}
+function expandedActivityTitle(card) {
+  if (!card.attribution)
+    return card.title;
+  if (card.attribution.status === "resolved")
+    return card.attribution.activityTitle ?? "Activity";
+  const name = childIdentityLabel(card.attribution.identity);
+  return `Unattributed subagent \xB7 ${name}${card.attribution.activityTitle ? ` \xB7 ${card.attribution.activityTitle}` : ""}`;
+}
+function lineagePathLabel(path) {
+  return path.map(childIdentityLabel).join(" \u203A ");
+}
+function childIdentityLabel(identity) {
+  const safeName = terminalSafeText(identity.name ?? "").replace(/\s+/gu, " ").trim();
+  if (safeName.length > 0)
+    return safeName;
+  return terminalSafeText(identity.subagentId).replace(/\s+/gu, " ").trim();
+}
+function renderActivityDisclosure(card) {
+  const details = [];
+  if (card.detail !== undefined) {
+    const safeDetail = terminalSafeText(card.detail);
+    details.push(card.detailFormat === "code" ? renderCodeSnippet({ text: safeDetail, indent: "      " }) : new StyledText5([dim4(fg6(PALETTE.dimText)(`      ${safeDetail}`))]));
+  }
+  return details.length === 0 ? undefined : joinStyled(details, `
+
 `);
 }
 function renderActivitySummary({ items, includeTimestamp }) {
@@ -37652,9 +38194,20 @@ function renderCollapsedActivityStep({ item, inFlight }) {
   const { glyph, color } = activityGlyph({ kind: item.card.kind, inFlight });
   return new StyledText5([
     fg6(color)(`  ${glyph} `),
-    dim4(fg6(PALETTE.dimText)(item.card.title))
+    dim4(fg6(PALETTE.dimText)(collapsedActivityTitle(item.card)))
   ]);
 }
+function collapsedActivityTitle(card) {
+  const attribution = card.attribution;
+  if (!attribution)
+    return card.title;
+  if (attribution.status === "unresolved") {
+    const name = childIdentityLabel(attribution.identity);
+    return `Unattributed subagent \xB7 ${name}${attribution.activityTitle ? ` \xB7 ${attribution.activityTitle}` : ""}`;
+  }
+  const activityTitle = attribution.activityTitle ? ` \xB7 ${attribution.activityTitle}` : "";
+  return `${lineagePathLabel(attribution.path)}${activityTitle}`;
+}
 function renderSubmittedTimeline({ state, admittedSubmissions }) {
   const submitted = admittedSubmissions.filter((submission) => submission.status === "submitted" && !state.transcript.some((item) => item.kind === "message" && item.messageId === submission.messageId));
   const messages = submitted.map((submission) => {
@@ -37844,7 +38397,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.12.0";
+var remyCliVersion = "1.13.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meistrari/remy-cli",
-    "version": "1.12.0",
+    "version": "1.13.0",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {