@piagent/platform 1.4.0 → 1.5.1

package/packages/piagent-webui/gateway/session-catalog.ts

@@ -13,6 +13,7 @@ export type PiSessionInfo = {
   id: string;
   cwd: string;
   name?: string;
+  parentSessionPath?: string;
   created: Date;
   modified: Date;
   messageCount: number;
@@ -20,6 +21,26 @@ export type PiSessionInfo = {
   allMessagesText: string;
 };
 
+const DELEGATED_TASK_MARKERS = [
+  "Task: You are a delegated subagent running from a fork of the parent session.",
+  "Task: You are reviving a previous subagent conversation."
+] as const;
+const INTERNAL_HELPER_NAME = /^(?:subagent(?:-|$)|piagent-(?:planner|worker|scout|reviewer|oracle)(?:-|$))/i;
+
+export function isUserConversationSession(info: PiSessionInfo): boolean {
+  const segments = path.resolve(info.path).split(path.sep);
+  const sessionsIndex = segments.lastIndexOf("sessions");
+  if (sessionsIndex >= 0 && segments[sessionsIndex + 1] === "subagent") return false;
+  const internalName = INTERNAL_HELPER_NAME.test(String(info.name ?? "").trim());
+  const hasParent = typeof info.parentSessionPath === "string" && info.parentSessionPath.length > 0;
+  const messages = typeof info.allMessagesText === "string" ? info.allMessagesText : "";
+  const internalPrompt = DELEGATED_TASK_MARKERS.some((marker) => messages.includes(marker));
+  // User-created forks also carry parentSessionPath, so lineage alone is not enough. A helper identity or the
+  // runtime-only delegation prompt plus lineage is high-confidence internal evidence. Keep this classification
+  // at the gateway boundary so catalog, read models, commands and live streams all fail closed together.
+  return !((internalName && (hasParent || internalPrompt)) || (hasParent && internalPrompt));
+}
+
 function catalogRef(key: Buffer, namespace: string, value: string): string {
   return `${namespace}_${createHmac("sha256", key).update(value).digest("base64url").slice(0, 43)}`;
 }
@@ -33,6 +54,43 @@ function display(value: unknown, maximum: number, fallback: string): string {
   return (clean || fallback).slice(0, maximum);
 }
 
+const INTERNAL_FRESH_TRANSITION = /(?:^|\b)(?:\/fresh\s+(?:task|scout|be-to-fe)|(?:task|scout|be-to-fe):)\b[\s\S]{0,180}\bRead task intake from \.pi\/task-inbox\//i;
+
+function atWordBoundary(value: string, maximum: number): string {
+  if (value.length <= maximum) return value;
+  const slice = value.slice(0, maximum + 1), boundary = slice.lastIndexOf(" ");
+  return `${slice.slice(0, boundary >= Math.floor(maximum * .6) ? boundary : maximum).trim()}…`;
+}
+
+// Session titles are a local deterministic projection. Asking a model to name
+// every chat would spend a turn and make opening the catalog non-deterministic.
+// Runtime routing commands are control-plane text, so they must never become a
+// title or preview merely because Pi records them as the first user entry.
+export function projectedSessionTitle(info: Pick<PiSessionInfo, "name" | "firstMessage" | "cwd">): { title: string; preview: string } {
+  const projectLabel = display(info.cwd ? path.basename(info.cwd) : "", 120, "Unknown project");
+  const first = info.firstMessage === "(no messages)" ? "" : display(info.firstMessage, 500, "");
+  const rawName = display(info.name, 500, ""), generatedName = /^pi:/i.test(rawName);
+  const suppliedName = rawName.replace(/^pi:\s*/i, "");
+  const normalizedName = suppliedName.toLowerCase();
+  const genericName = !suppliedName || normalizedName === projectLabel.toLowerCase()
+    || ["working", "pi agent platform", "new conversation"].includes(normalizedName);
+  const source = generatedName ? suppliedName || first : genericName ? first || suppliedName : suppliedName;
+  const internal = INTERNAL_FRESH_TRANSITION.test(source) || INTERNAL_FRESH_TRANSITION.test(first)
+    || /\.pi\/task-inbox\//i.test(source);
+  const cleaned = display(source, 500, "")
+    .replace(/^\/(?:fresh\s+)?(?:task|scout|be-to-fe)\s+/i, "")
+    .replace(/^(?:task|scout|be-to-fe):\s*/i, "")
+    .replace(/^[-#*>\s]+/, "")
+    // Keep underscores: the shared redactor deliberately emits
+    // [REDACTED_SECRET], and title cleanup must not mutate that proof marker.
+    .replace(/[`*~]+/g, "")
+    .trim();
+  const title = internal ? "Continued task" : atWordBoundary(cleaned || "New conversation", 72);
+  const preview = INTERNAL_FRESH_TRANSITION.test(first) || /\.pi\/task-inbox\//i.test(first)
+    ? "Continued in a fresh session" : atWordBoundary(first || title, 180);
+  return { title, preview };
+}
+
 function revision(key: Buffer, value: unknown): string {
   return `rev_${createHmac("sha256", key).update(JSON.stringify(value)).digest("hex")}`;
 }
@@ -40,18 +98,13 @@ function revision(key: Buffer, value: unknown): string {
 function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undefined, metadataReason: string | null,
   ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection): SessionRow {
   const projectLabel = display(info.cwd ? path.basename(info.cwd) : "", 120, "Unknown project");
-  const first = info.firstMessage === "(no messages)" ? "" : info.firstMessage;
-  const suppliedName = display(info.name, 500, "").replace(/^pi:\s*/i, "");
-  const normalizedName = suppliedName.toLowerCase();
-  const genericName = !suppliedName || normalizedName === projectLabel.toLowerCase()
-    || ["working", "pi agent platform", "new conversation"].includes(normalizedName);
-  const title = display(genericName && first ? first : suppliedName || first, 500, "New conversation").replace(/^pi:\s*/i, "") || "New conversation";
+  const projected = projectedSessionTitle(info);
   return {
     sessionRef: sessionRefForPath(key, info.path),
     projectRef: projectRefForCwd(key, info.cwd),
-    title,
+    title: projected.title,
     projectLabel,
-    preview: display(first, 280, "No messages yet"),
+    preview: projected.preview,
     createdAt: info.created.toISOString(),
     updatedAt: info.modified.toISOString(),
     state: metadata?.archived ? "archived" : ownership?.state ?? "offline",
@@ -87,7 +140,7 @@ export async function buildSessionCatalog(options: {
 }): Promise<Catalog> {
   const limit = Math.max(1, Math.min(200, options.limit ?? 200));
   try {
-    const found = await options.listSessions();
+    const found = (await options.listSessions()).filter(isUserConversationSession);
     const metadata = options.readMetadata?.() ?? { state: "ready", revision: null, sessions: new Map(), reasonCode: null };
     const sessions = found.map((info) => {
       const sessionRef = sessionRefForPath(options.key, info.path);

package/packages/piagent-webui/gateway/session-command-controller.ts

@@ -35,7 +35,10 @@ function nullableRef(value: unknown): value is string | null { return value ===
 
 function validPayload(action: SessionAction, payload: Record<string, unknown>): boolean {
   if (["session.archive", "session.unarchive", "session.acquire", "session.release"].includes(action)) return exactKeys(payload, []);
-  if (action === "session.send") return exactKeys(payload, ["delivery", "message", "messageRequestId", "expectedOperationRef"])
+  if (action === "session.send") return exactKeys(payload, ["delivery", "message", "messageRequestId", "expectedOperationRef", "attachmentRefs"])
+    && Array.isArray(payload.attachmentRefs) && payload.attachmentRefs.length <= 4
+    && new Set(payload.attachmentRefs as unknown[]).size === payload.attachmentRefs.length
+    && (payload.attachmentRefs as unknown[]).every((item) => typeof item === "string" && REF.test(item))
     && ["new-operation", "follow-up", "steer"].includes(String(payload.delivery)) && typeof payload.message === "string"
     && payload.message.length >= 1 && payload.message.length <= 32_768 && !payload.message.includes("\0") && REF.test(String(payload.messageRequestId))
     && nullableRef(payload.expectedOperationRef) && (payload.delivery === "new-operation" ? payload.expectedOperationRef === null : payload.expectedOperationRef !== null);
@@ -52,11 +55,12 @@ function validPayload(action: SessionAction, payload: Record<string, unknown>):
   if (action === "session.fork") return exactKeys(payload, ["entryRef", "title"]) && nullableRef(payload.entryRef)
     && (payload.title === null || typeof payload.title === "string" && payload.title.length >= 1 && payload.title.length <= 500
       && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(payload.title));
-  return exactKeys(payload, ["projectRef", "placeRef", "modelRef", "thinkingLevel", "message", "messageRequestId"])
+  const createKeys = ["projectRef", "placeRef", "modelRef", "thinkingLevel", "message", "messageRequestId"];
+  return (exactKeys(payload, createKeys) || exactKeys(payload, [...createKeys, "deferInitialMessage"]))
     && REF.test(String(payload.projectRef)) && REF.test(String(payload.placeRef)) && nullableRef(payload.modelRef)
     && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(String(payload.thinkingLevel))
     && typeof payload.message === "string" && payload.message.length >= 1 && payload.message.length <= 32_768 && !payload.message.includes("\0")
-    && REF.test(String(payload.messageRequestId));
+    && REF.test(String(payload.messageRequestId)) && (payload.deferInitialMessage === undefined || typeof payload.deferInitialMessage === "boolean");
 }
 
 function parseCommand(value: unknown): SessionCommand | null {
@@ -86,10 +90,15 @@ export class SessionCommandController {
   readonly #metadata: SessionMetadataStore | null;
   readonly #now: () => Date;
   readonly #chains = new Map<string, Promise<unknown>>();
+  readonly #prepareAttachments: ((sessionRef: string, refs: string[], messageRequestId: string, text: string) => Promise<{
+    text: string; images: unknown[]; commit(): void; release(): void }>) | undefined;
 
   constructor(options: { catalog(): Promise<Catalog>; runtimes: SessionRuntimeSupervisor; store: SessionCommandStore; events: GatewayEventStore;
     metadata?: SessionMetadataStore;
+    prepareAttachments?(sessionRef: string, refs: string[], messageRequestId: string, text: string): Promise<{
+      text: string; images: unknown[]; commit(): void; release(): void }>;
     now?: () => Date }) {
+    this.#prepareAttachments = options.prepareAttachments;
     this.#catalog = options.catalog; this.#runtimes = options.runtimes; this.#store = options.store; this.#events = options.events;
     this.#metadata = options.metadata ?? null;
     this.#now = options.now ?? (() => new Date());
@@ -129,8 +138,10 @@ export class SessionCommandController {
     try { this.#store.admit(command, this.#now()); }
     catch { return this.#rejected(command, current, row, "unavailable", "session-command-admission-failed"); }
     let targetSessionRef = command.sessionRef;
+    let attachmentReservation: { commit(): void; release(): void } | null = null;
+    let sendAttempted = false;
     try {
-      let resultCode: "acquired" | "released" | "started" | "queued" | "steered" | "aborted" | "model-changed" | "thinking-changed" | "permission-changed"
+      let resultCode: "created" | "acquired" | "released" | "started" | "queued" | "steered" | "aborted" | "model-changed" | "thinking-changed" | "permission-changed"
         | "renamed" | "pinned" | "unpinned" | "archived" | "unarchived" | "forked" | "no-change",
         operationRef: string | null = null;
       if (command.action === "session.create") {
@@ -138,18 +149,32 @@ export class SessionCommandController {
           command.payload.modelRef === null ? null : String(command.payload.modelRef), String(command.payload.thinkingLevel));
         const created = await this.#readyCatalog(), createdRow = created.sessions.find((item) => item.sessionRef === targetSessionRef);
         if (!createdRow) throw new Error("session-catalog-refresh-failed");
-        const sent = await this.#runtimes.send(targetSessionRef, { delivery: "new-operation", message: String(command.payload.message),
-          expectedOperationRef: null }, createdRow.sessionRevision);
-        resultCode = sent.resultCode === "started" ? "started" : sent.resultCode; operationRef = sent.operationRef;
+        if (command.payload.deferInitialMessage === true) resultCode = "created";
+        else {
+          const sent = await this.#runtimes.send(targetSessionRef, { delivery: "new-operation", message: String(command.payload.message),
+            expectedOperationRef: null }, createdRow.sessionRevision);
+          resultCode = sent.resultCode === "started" ? "started" : sent.resultCode; operationRef = sent.operationRef;
+        }
       } else if (command.action === "session.acquire") { await this.#runtimes.acquire(command.sessionRef!); resultCode = "acquired"; }
       else if (command.action === "session.release") { await this.#runtimes.release(command.sessionRef!); resultCode = "released"; }
       else if (command.action === "session.send") {
         await this.#runtimes.acquire(command.sessionRef!);
         const acquired = await this.#readyCatalog(), acquiredRow = acquired.sessions.find((item) => item.sessionRef === command.sessionRef);
         if (!acquiredRow) throw new Error("session-catalog-refresh-failed");
-        const sent = await this.#runtimes.send(command.sessionRef!, command.payload as {
-          delivery: "new-operation" | "follow-up" | "steer"; message: string; expectedOperationRef: string | null
-        }, acquiredRow.sessionRevision);
+        const payload = command.payload as { delivery: "new-operation" | "follow-up" | "steer"; message: string;
+          expectedOperationRef: string | null; messageRequestId: string; attachmentRefs: string[] };
+        // Staged refs are claimed once, here, before the runtime is asked to
+        // dispatch. Documents were turned into text at staging so they join the
+        // message; images travel on the host's own channel.
+        const prepared = this.#prepareAttachments
+          ? await this.#prepareAttachments(command.sessionRef!, payload.attachmentRefs, payload.messageRequestId, payload.message)
+          : { text: payload.message, images: [] as unknown[], commit() {}, release() {} };
+        attachmentReservation = prepared;
+        if (!this.#prepareAttachments && payload.attachmentRefs.length > 0) throw new Error("session-attachment-unavailable");
+        sendAttempted = true;
+        const sent = await this.#runtimes.send(command.sessionRef!, { ...payload, message: prepared.text, images: prepared.images },
+          acquiredRow.sessionRevision);
+        prepared.commit();
         resultCode = sent.resultCode; operationRef = sent.operationRef;
       } else if (command.action === "session.abort") {
         operationRef = String(command.payload.operationRef);
@@ -195,10 +220,18 @@ export class SessionCommandController {
       return receipt;
     } catch (cause) {
       const after = await this.#readyCatalog(), afterRow = after.sessions.find((item) => item.sessionRef === targetSessionRef) ?? row;
-      const code = cause instanceof Error && /recovery/.test(cause.message) ? "recovery-required"
-        : cause instanceof Error && /(owner-conflict|operation-conflict|runtime-busy)/.test(cause.message) ? "owner-conflict" : "effect-unknown";
+      const message = cause instanceof Error ? cause.message : "session-command-failed";
+      const noDispatchEffect = command.action === "session.send" && (!sendAttempted
+        || /^(session-runtime-unavailable|session-operation-conflict|session-owner-conflict|session-runtime-busy)$/.test(message));
+      if (attachmentReservation) {
+        try { if (noDispatchEffect) attachmentReservation.release(); else attachmentReservation.commit(); }
+        catch { /* an attempted dispatch with an unprovable reservation remains uncertain */ }
+      }
+      const code = /recovery/.test(message) ? "recovery-required"
+        : /(owner-conflict|operation-conflict|runtime-busy)/.test(message) ? "owner-conflict"
+          : noDispatchEffect || command.action === "session.send" && !sendAttempted ? "unavailable" : "effect-unknown";
       const receipt = code === "effect-unknown" ? this.#uncertain(command, after, afterRow, "session-command-effect-unknown")
-        : this.#rejected(command, after, afterRow, code, cause instanceof Error ? cause.message : "session-command-failed");
+        : this.#rejected(command, after, afterRow, code, message);
       try { this.#store.settle(command, receipt, this.#now()); } catch { /* intent remains uncertain */ }
       return receipt;
     }
@@ -219,7 +252,7 @@ export class SessionCommandController {
       sessionRevisionAfter: row?.sessionRevision ?? null, deduplicated: false };
   }
   #settled(command: SessionCommand, catalog: Catalog, row: SessionRow,
-    resultCode: "acquired" | "released" | "started" | "queued" | "steered" | "aborted" | "model-changed" | "thinking-changed" | "permission-changed"
+    resultCode: "created" | "acquired" | "released" | "started" | "queued" | "steered" | "aborted" | "model-changed" | "thinking-changed" | "permission-changed"
       | "renamed" | "pinned" | "unpinned" | "archived" | "unarchived" | "forked" | "no-change",
     operationRef: string | null): Receipt {
     return { ...this.#base(command, catalog, row), operationRef, phase: "settled", resultCode, settledAt: this.#now().toISOString(),

package/packages/piagent-webui/gateway/session-inspection-registry.ts

@@ -3,25 +3,30 @@ import path from "node:path";
 
 import { readContextTelemetry } from "../../piagent-core/extensions/context-engine.js";
 import { activeSessionTask } from "../../piagent-core/extensions/task-state.js";
-import { runtimeConnectionDefinitions, runtimeProtectedPaths } from "../../piagent-core/runtime/inspection/project-runtime-inspection.ts";
+import { runtimeConnectionDefinitions, runtimeDocumentReadRoots, runtimeProtectedPaths } from "../../piagent-core/runtime/inspection/project-runtime-inspection.ts";
 import { setRuntimeMcpEnabled } from "../../piagent-core/runtime/inspection/mcp-control.ts";
 import { webUiModelRef } from "../../piagent-core/runtime/inspection/webui-snapshot.ts";
 import { redactSensitiveText } from "../../piagent-core/security/sensitive-data.js";
 import { piApprovalBroker } from "../../piagent-core/runtime/inspection/approval-broker.ts";
+import { attachmentCapability } from "../../piagent-core/runtime/input/attachment-store.ts";
 import { CoreInspectionProvider } from "../server/core-inspection-provider.ts";
 import { ReadModelNotFound, type WebUiReadModelProvider } from "../server/read-model-provider.ts";
-import { projectRefForCwd, sessionRefForPath, type PiSessionInfo } from "./session-catalog.ts";
+import { isUserConversationSession, projectRefForCwd, sessionRefForPath, type PiSessionInfo } from "./session-catalog.ts";
 import { nativeProjectPickerAvailable } from "./native-project-picker.ts";
 import type { McpAuthBroker } from "./mcp-auth-broker.ts";
+import { inspectWebSearchCapability } from "./ai-capability-inspection.ts";
 
 type PiHost = {
   SessionManager: {
     listAll(): Promise<PiSessionInfo[]>;
     open(file: string): {
       getBranch(): unknown[];
-      buildSessionContext(): { model: { provider: string; modelId: string } | null; thinkingLevel: string };
+      buildSessionContext(): { model: { provider: string; modelId: string } | null; thinkingLevel: string; messages: unknown[] };
     };
   };
+  calculateContextTokens(usage: unknown): number;
+  estimateTokens(message: unknown): number;
+  getLatestCompactionEntry(entries: unknown[]): unknown | null;
 };
 
 type ModelRuntime = {
@@ -59,22 +64,59 @@ function safeModelId(value: unknown): string | null {
   return redactSensitiveText(value).redacted ? null : value;
 }
 
+function persistedContextUsage(host: PiHost, entries: unknown[], messages: unknown[], model: Record<string, unknown> | undefined) {
+  const contextWindow = Number(model?.contextWindow);
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0) return undefined;
+  const latestCompaction = host.getLatestCompactionEntry(entries);
+  if (latestCompaction) {
+    const boundary = entries.lastIndexOf(latestCompaction);
+    let hasPostCompactionUsage = false;
+    for (let index = entries.length - 1; index > boundary; index -= 1) {
+      const entry = entries[index] as { type?: unknown; message?: { role?: unknown; stopReason?: unknown; usage?: unknown } } | undefined;
+      const message = entry?.type === "message" ? entry.message : undefined;
+      if (message?.role === "assistant" && message.usage && message.stopReason !== "aborted" && message.stopReason !== "error"
+        && host.calculateContextTokens(message.usage) > 0) {
+        hasPostCompactionUsage = true;
+        break;
+      }
+    }
+    if (!hasPostCompactionUsage) return { tokens: null, contextWindow, percent: null };
+  }
+  let lastUsageIndex = -1, tokens = 0;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index] as { role?: unknown; stopReason?: unknown; usage?: unknown } | undefined;
+    if (message?.role !== "assistant" || !message.usage || message.stopReason === "aborted" || message.stopReason === "error") continue;
+    const measured = host.calculateContextTokens(message.usage);
+    if (measured > 0) { tokens = measured; lastUsageIndex = index; break; }
+  }
+  for (let index = lastUsageIndex + 1; index < messages.length; index += 1) tokens += host.estimateTokens(messages[index]);
+  if (!Number.isFinite(tokens) || tokens < 0) return undefined;
+  return { tokens, contextWindow, percent: tokens / contextWindow * 100 };
+}
+
 export class SessionInspectionRegistry {
   readonly #gatewayInstanceRef: string;
   readonly #host: PiHost;
+  readonly #listSessions: () => Promise<PiSessionInfo[]>;
+  readonly #openLiveSession: ((sessionRef: string) => ReturnType<PiHost["SessionManager"]["open"]> | null) | null;
   readonly #key: Buffer;
   readonly #packageRoot: string;
+  readonly #agentDir?: string;
   readonly #models?: ModelRuntime;
   readonly #projects?: ProjectSource;
   readonly #mcpAuth?: McpAuthBroker;
   readonly #providers = new Map<string, { modifiedAt: string; provider: CoreInspectionProvider }>();
 
-  constructor(options: { gatewayInstanceRef: string; host: PiHost; key: Buffer; packageRoot: string; models?: ModelRuntime; projects?: ProjectSource;
-    mcpAuth?: McpAuthBroker }) {
+  constructor(options: { gatewayInstanceRef: string; host: PiHost; key: Buffer; packageRoot: string; agentDir?: string; models?: ModelRuntime; projects?: ProjectSource;
+    mcpAuth?: McpAuthBroker; listSessions?: () => Promise<PiSessionInfo[]>;
+    openLiveSession?: (sessionRef: string) => ReturnType<PiHost["SessionManager"]["open"]> | null }) {
     this.#gatewayInstanceRef = options.gatewayInstanceRef;
     this.#host = options.host;
+    this.#listSessions = options.listSessions ?? (() => options.host.SessionManager.listAll());
+    this.#openLiveSession = options.openLiveSession ?? null;
     this.#key = options.key;
     this.#packageRoot = options.packageRoot;
+    this.#agentDir = options.agentDir;
     this.#models = options.models;
     this.#projects = options.projects;
     this.#mcpAuth = options.mcpAuth;
@@ -85,7 +127,7 @@ export class SessionInspectionRegistry {
   }
 
   async #sessionInfo(sessionRef: string): Promise<PiSessionInfo> {
-    const sessions = await this.#host.SessionManager.listAll();
+    const sessions = (await this.#listSessions()).filter(isUserConversationSession);
     const found = sessions.filter((candidate) => sessionRefForPath(this.#key, candidate.path) === sessionRef);
     if (found.length !== 1) throw new ReadModelNotFound();
     return found[0]!;
@@ -135,7 +177,7 @@ export class SessionInspectionRegistry {
   }
 
   async creationOptions(): Promise<unknown> {
-    const sessions = await this.#host.SessionManager.listAll();
+    const sessions = (await this.#listSessions()).filter(isUserConversationSession);
     const projects = new Map<string, { projectRef: string; placeRef: string; label: string }>();
     for (const info of sessions) {
       if (!info.cwd) continue;
@@ -146,7 +188,8 @@ export class SessionInspectionRegistry {
     for (const project of safeRead(() => this.#projects?.list() ?? [], [])) {
       if (!projects.has(project.projectRef)) projects.set(project.projectRef, project);
     }
-    const models = (this.#models?.getAvailableSnapshot() ?? []).slice(0, 300).flatMap((value) => {
+    const availableModels = (this.#models?.getAvailableSnapshot() ?? []).slice(0, 300);
+    const models = availableModels.flatMap((value) => {
       const provider = safeModelId(value.provider);
       const modelId = safeModelId(value.id);
       if (!provider || !modelId || typeof value.reasoning !== "boolean") return [];
@@ -154,11 +197,12 @@ export class SessionInspectionRegistry {
         ? value.thinkingLevelMap as Record<string, unknown> : {};
       const thinkingLevels = value.reasoning ? ["off", "minimal", "low", "medium", "high", "xhigh", "max"]
         .filter((level) => mapping[level] !== null && !(["xhigh", "max"].includes(level) && mapping[level] === undefined)) : ["off"];
+      const inputs = Array.isArray(value.input) ? value.input.filter((item): item is string => typeof item === "string") : null;
       return [{ modelRef: webUiModelRef(provider, modelId), provider, modelId, displayName: safeName(value.name ?? modelId),
-        reasoning: value.reasoning, thinkingLevels }];
+        reasoning: value.reasoning, imageInput: inputs ? inputs.includes("image") : null, thinkingLevels }];
     });
     return { schemaVersion: 1, version: "piagent-session-creation-options-v1", generatedAt: new Date().toISOString(),
-      projects: [...projects.values()].slice(0, 200), models,
+      projects: [...projects.values()].slice(0, 200), models, webSearch: inspectWebSearchCapability({ agentDir: this.#agentDir, models: availableModels }),
       projectImport: nativeProjectPickerAvailable() ? { status: "available", reasonCode: null }
         : { status: "unavailable", reasonCode: "native-project-picker-unavailable" },
       reasonCode: projects.size ? null : "no-known-project" };
@@ -171,11 +215,12 @@ export class SessionInspectionRegistry {
     if (cached?.modifiedAt === modifiedAt) return cached.provider;
 
     let manager: ReturnType<PiHost["SessionManager"]["open"]>;
-    try { manager = this.#host.SessionManager.open(info.path); }
+    try { manager = this.#openLiveSession?.(sessionRef) ?? this.#host.SessionManager.open(info.path); }
     catch { throw new ReadModelNotFound(); }
-    const context = safeRead(() => manager.buildSessionContext(), { model: null, thinkingLevel: "unknown" });
+    const context = safeRead(() => manager.buildSessionContext(), { model: null, thinkingLevel: "unknown", messages: [] });
     const model = context.model ? this.#models?.getModel(context.model.provider, context.model.modelId) : undefined;
     const entries = safeRead(() => manager.getBranch(), []);
+    const contextUsage = safeRead(() => persistedContextUsage(this.#host, entries, context.messages, model), undefined);
     const eventStore = {
       retention: () => ({ eventRetentionCount: 0, eventRetentionSeconds: 0 }),
       currentCursor: () => null,
@@ -191,6 +236,16 @@ export class SessionInspectionRegistry {
       activityEvents: () => safeRead(() => readContextTelemetry(info.cwd, { limit: 5_000 }), []),
       sessionEntries: () => entries,
       protectedPaths: () => runtimeProtectedPaths(this.#packageRoot, info.cwd),
+      // The document workspace lists the project plus whatever the operator
+      // granted in the profile. Without this it silently shows the project only,
+      // which reads as "the grant does not work" rather than "it was not asked for".
+      documentReadRoots: () => safeRead(() => runtimeDocumentReadRoots(this.#packageRoot, info.cwd), []),
+      // Derived from the model and the host, with no store instance involved:
+      // the store for this session is built from the very snapshot this call
+      // helps produce, so asking the store would be circular.
+      attachmentCapability: () => attachmentCapability({
+        images: Array.isArray(model?.input) && model.input.includes("image"), now: Date.now() }),
+      contextUsage: () => contextUsage,
       model: () => model,
       thinkingLevel: () => context.thinkingLevel,
       approvalProjection: () => piApprovalBroker.projection(info.cwd, info.id),

package/packages/piagent-webui/gateway/session-runtime-supervisor.ts

@@ -7,11 +7,12 @@ import { activeSessionTask } from "../../piagent-core/extensions/task-state.js";
 import { inspectTaskControlState } from "../../piagent-core/runtime/inspection/task-control-journal.ts";
 import { piApprovalBroker, type ApprovalAuthority, type ApprovalBrokerEvent } from "../../piagent-core/runtime/inspection/approval-broker.ts";
 import type { SessionOwnerProjection, PiSessionInfo } from "./session-catalog.ts";
-import { projectRefForCwd, sessionRefForPath } from "./session-catalog.ts";
+import { isUserConversationSession, projectRefForCwd, sessionRefForPath } from "./session-catalog.ts";
 import { SessionLeaseStore, type SessionLeaseSnapshot } from "./session-lease-store.ts";
 import { GatewayEventStore } from "./gateway-events.ts";
 import { GatewaySessionStream } from "./gateway-session-stream.ts";
 import { GATEWAY_RUNTIME_UI_MARKER } from "../ownership/gateway-runtime-context.ts";
+import { preferAuthoritativePiagentGuard } from "./extension-authority.ts";
 
 const MAX_WARM_RUNTIMES = 10;
 
@@ -19,7 +20,7 @@ type RuntimeHandle = { dispose(): Promise<void>; session?: any };
 type RuntimeFactory = (info: PiSessionInfo, runtimeInstanceRef: string, sessionManager?: any) => Promise<RuntimeHandle>;
 type ActiveRuntime = { runtime: RuntimeHandle; lease: SessionLeaseSnapshot; info: PiSessionInfo; operationRef: string | null;
   unsubscribe: (() => void) | null; completion: Promise<void> | null; settling: boolean; approvalWaiting: boolean;
-  unbindApproval: (() => void) | null; unsubscribeApproval: (() => void) | null };
+  unbindApproval: (() => void) | null; unsubscribeApproval: (() => void) | null; sessionManager: any | null };
 type Projection = { sessionRevision: string; liveState: "offline" | "idle" | "running" | "paused" | "waiting-approval" | "uncertain" };
 
 function rpcUiContext(): object {
@@ -55,7 +56,10 @@ function productionRuntimeFactory(options: { host: any; agentDir: string; packag
     const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent }: any) => {
       const services = await options.host.createAgentSessionServices({
         cwd, agentDir, modelRuntime: options.modelRuntime,
-        resourceLoaderOptions: { additionalExtensionPaths: [guard] }
+        resourceLoaderOptions: {
+          additionalExtensionPaths: [guard],
+          extensionsOverride: preferAuthoritativePiagentGuard(guard)
+        }
       });
       const extensionErrors = services.resourceLoader.getExtensions().errors;
       if (extensionErrors.length) throw new Error("session-runtime-extension-load-failed");
@@ -125,7 +129,7 @@ export class SessionRuntimeSupervisor {
   setProjectionReader(reader: (sessionRef: string) => Promise<Projection>): void { this.#readProjection = reader; }
 
   async listSessions(): Promise<PiSessionInfo[]> {
-    const persisted = await this.#listSessions();
+    const persisted = (await this.#listSessions()).filter(isUserConversationSession);
     const paths = new Set(persisted.map((info) => info.path));
     for (const [sessionRef, info] of this.#created) {
       if (paths.has(info.path)) this.#created.delete(sessionRef);
@@ -136,7 +140,7 @@ export class SessionRuntimeSupervisor {
   async create(projectRef: string, placeRef: string, modelRef: string | null, thinkingLevel: string): Promise<string> {
     if (this.#closed || !this.#host) throw new Error("session-create-unavailable");
     if (placeRef !== projectRef) throw new Error("session-place-mismatch");
-    const sessions = await this.#listSessions();
+    const sessions = (await this.#listSessions()).filter(isUserConversationSession);
     const imported = this.#resolveProject?.(projectRef) ?? null;
     const candidates = [...new Set([...sessions.filter((info) => projectRefForCwd(this.#key, info.cwd) === projectRef).map((info) => info.cwd),
       ...(imported ? [imported] : [])])];
@@ -162,6 +166,8 @@ export class SessionRuntimeSupervisor {
     return sessionRef;
   }
 
+  liveSessionManager(sessionRef: string): any | null { return this.#active.get(sessionRef)?.sessionManager ?? null; }
+
   async acquire(sessionRef: string): Promise<SessionLeaseSnapshot> {
     if (this.#closed) throw new Error("session-runtime-supervisor-closed");
     const active = this.#active.get(sessionRef);
@@ -175,7 +181,8 @@ export class SessionRuntimeSupervisor {
 
   async #acquire(sessionRef: string): Promise<SessionLeaseSnapshot> {
     if (this.#active.size + this.#opening.size > MAX_WARM_RUNTIMES) throw new Error("session-runtime-capacity");
-    const found = (await this.#listSessions()).filter((info) => sessionRefForPath(this.#key, info.path) === sessionRef);
+    const found = (await this.#listSessions()).filter(isUserConversationSession)
+      .filter((info) => sessionRefForPath(this.#key, info.path) === sessionRef);
     if (found.length !== 1) throw new Error(found.length ? "session-ref-ambiguous" : "session-not-found");
     return await this.#activate(sessionRef, found[0]!);
   }
@@ -197,7 +204,8 @@ export class SessionRuntimeSupervisor {
         throw new Error("session-owner-continuity-lost");
       }
       const active: ActiveRuntime = { runtime, lease: current, info, operationRef: null, unsubscribe: null, completion: null,
-        settling: false, approvalWaiting: false, unbindApproval: null, unsubscribeApproval: null };
+        settling: false, approvalWaiting: false, unbindApproval: null, unsubscribeApproval: null,
+        sessionManager: sessionManager ?? runtime.session?.sessionManager ?? null };
       this.#active.set(sessionRef, active);
       this.#bindApproval(sessionRef, active);
       return current;
@@ -267,15 +275,20 @@ export class SessionRuntimeSupervisor {
     };
   }
 
+  // `message` arrives already carrying any attached document text, and `images`
+  // already split out: the command controller claims staged refs before it calls
+  // here, so this layer only forwards what the host prompt takes.
   async send(sessionRef: string, payload: { delivery: "new-operation" | "follow-up" | "steer"; message: string;
-    expectedOperationRef: string | null }, sessionRevision: string): Promise<{ resultCode: "started" | "queued" | "steered"; operationRef: string }> {
+    expectedOperationRef: string | null; images?: unknown[] }, sessionRevision: string):
+  Promise<{ resultCode: "started" | "queued" | "steered"; operationRef: string }> {
     await this.acquire(sessionRef);
     const active = this.#active.get(sessionRef), session = active?.runtime.session;
     if (!active || !session) throw new Error("session-runtime-unavailable");
     if (payload.delivery !== "new-operation") {
       if (!active.operationRef || active.operationRef !== payload.expectedOperationRef || !session.isStreaming) throw new Error("session-operation-conflict");
-      if (payload.delivery === "follow-up") { await session.followUp(payload.message); return { resultCode: "queued", operationRef: active.operationRef }; }
-      await session.steer(payload.message); return { resultCode: "steered", operationRef: active.operationRef };
+      const images = payload.images?.length ? payload.images : undefined;
+      if (payload.delivery === "follow-up") { await session.followUp(payload.message, images); return { resultCode: "queued", operationRef: active.operationRef }; }
+      await session.steer(payload.message, images); return { resultCode: "steered", operationRef: active.operationRef };
     }
     if (payload.expectedOperationRef !== null || active.operationRef || active.settling || !session.isIdle) throw new Error("session-operation-conflict");
     const operationRef = `operation_${randomBytes(24).toString("base64url")}`;
@@ -288,7 +301,7 @@ export class SessionRuntimeSupervisor {
       created.firstMessage = payload.message; created.allMessagesText = payload.message; created.messageCount = 1; created.modified = new Date();
     }
     let prompt: Promise<void>;
-    try { prompt = session.prompt(payload.message); }
+    try { prompt = session.prompt(payload.message, payload.images?.length ? { images: payload.images } : undefined); }
     catch (error) { await this.#finishOperation(sessionRef, operationRef, stream); throw error; }
     active.completion = prompt.then(() => this.#finishOperation(sessionRef, operationRef, stream),
       () => this.#finishOperation(sessionRef, operationRef, stream));

package/packages/piagent-webui/package.json

@@ -17,7 +17,9 @@
     "@mui/icons-material": "^9.3.1",
     "@mui/material": "^9.3.1",
     "react": "19.2.8",
-    "react-dom": "19.2.8"
+    "react-dom": "19.2.8",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1"
   },
   "devDependencies": {
     "@types/react": "19.2.18",