@piagent/platform 1.18.0 → 1.20.0

package/packages/piagent-webui/dist/client/index.html

@@ -7,7 +7,7 @@
     <meta name="csp-nonce" content="__PIAGENT_CSP_NONCE__" />
     <meta name="piagent-webui-mode" content="__PIAGENT_WEBUI_MODE__" />
     <title>Piagent WebUI</title>
-    <script type="module" crossorigin src="/assets/index-BGxsZHB5.js"></script>
+    <script type="module" crossorigin src="/assets/index-CM9cs-gP.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Z91z6SlN.css">
   </head>
   <body>

package/packages/piagent-webui/gateway/company-relay.ts

@@ -4,6 +4,8 @@ import { WebSocket } from "ws";
 import type { Catalog, SessionRow } from "../contracts/generated/session-catalog-v1.ts";
 import { webUiModelRef } from "../../piagent-core/runtime/inspection/webui-snapshot.ts";
 import { requestGatewayControl } from "./control-socket.ts";
+import { gitHeadReader } from "./git-head.ts";
+import { childRepositoryReader } from "./git-repositories.ts";
 import type { GatewayEventKind, GatewayEventStore } from "./gateway-events.ts";
 
 // The personal dashboard lists and drives company sessions through this relay.
@@ -250,12 +252,22 @@ export class CompanyRelay {
     const company = await this.catalog();
     if (personal.state !== "ready" || !personal.catalogRevision) return personal;
     const ready = this.#state === "ready";
+    // The Git facts of a company conversation's folder are read here, on the
+    // same Mac: the company Gateway may run an earlier release (Agent Watch
+    // restarts it only now and then) that does not report them.
+    const readHead = gitHeadReader(), readRepositories = childRepositoryReader();
     const rows: SessionRow[] = (company?.state === "ready" ? company.sessions : []).map((row) => {
       const folder = this.#paths.get(row.projectRef);
-      return { ...row, projectRef: folder ? this.#hubProject(folder) : row.projectRef, composerAvailable: ready && row.composerAvailable };
+      const { gitBranch: _branch, gitRepositories: _repositories, ...rest } = row;
+      const head = folder ? readHead(folder) : null, repositories = folder && !head ? readRepositories(folder) : [];
+      return { ...rest, projectRef: folder ? this.#hubProject(folder) : row.projectRef, composerAvailable: ready && row.composerAvailable,
+        ...(folder ? {} : _branch ? { gitBranch: _branch } : {}), ...(folder ? {} : _repositories ? { gitRepositories: _repositories } : {}),
+        ...(head ? { gitBranch: head } : {}),
+        ...(repositories.length ? { gitRepositories: repositories.map((repository) => ({ name: repository.name, branch: repository.head })) } : {}) };
     });
     const sessions = [...personal.sessions, ...rows].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
-    const digest = createHash("sha256").update(JSON.stringify([personal.catalogRevision, company?.catalogRevision ?? null, ready])).digest("hex");
+    const digest = createHash("sha256").update(JSON.stringify([personal.catalogRevision, company?.catalogRevision ?? null, ready,
+      rows.map((row) => [row.gitBranch ?? null, row.gitRepositories ?? null])])).digest("hex");
     return { ...personal, catalogRevision: `rev_${digest}`, sessions,
       page: { ...personal.page, returned: sessions.length, total: personal.page.total + rows.length } };
   }

package/packages/piagent-webui/gateway/gateway-service.ts

@@ -21,6 +21,7 @@ import {
 import { buildSessionCatalog, projectRefForCwd } from "./session-catalog.ts";
 import { suggestPaths } from "./path-suggestions.ts";
 import { GitBranchError, listBranches, switchBranch, type SwitchRequest } from "./git-branches.ts";
+import { childRepositories, childRepositoryFolder } from "./git-repositories.ts";
 import { listAgentCommands } from "../../piagent-core/runtime/resources/agent-resources.mjs";
 import { sessionRefForPath } from "../ownership/session-refs.ts";
 import { SessionMetadataStore } from "./session-metadata-store.ts";
@@ -309,25 +310,36 @@ export async function startPiagentGateway(options: {
       // The project's Git branches and a switch between them. A switch waits
       // until no conversation in the folder runs (company ones included): the
       // agent would find its files changed under it.
-      listBranches: async (projectRef) => {
+      // A folder that is not a repository answers with the repositories one
+      // level down; `repository` then names the one to read or switch.
+      listBranches: async (projectRef, repository) => {
         const root = await projectFolder(projectRef);
         if (!root) return null;
-        const [list, running] = await Promise.all([listBranches(root), runningInProject(projectRef)]);
-        return list ? { ...list, running } : { repository: false, running };
+        const folder = repository === null ? root : childRepositoryFolder(root, repository);
+        if (!folder) throw new GitBranchError("not-a-git-repository");
+        const [list, running] = await Promise.all([listBranches(folder), runningInProject(projectRef)]);
+        if (list) return { ...list, running, ...(repository === null ? {} : { name: repository }) };
+        const repositories = repository === null ? await Promise.all(childRepositories(root).map(async (child) => {
+          const branches = await listBranches(path.join(root, child.name));
+          return { name: child.name, head: child.head, changedFiles: branches?.changedFiles ?? 0 };
+        })) : [];
+        return { repository: false, running, repositories };
       },
       switchBranch: async (projectRef, request) => {
         const root = await projectFolder(projectRef);
         if (!root) return null;
-        const value = request as Partial<SwitchRequest> | null;
+        const value = request as (Partial<SwitchRequest> & { repository?: string }) | null;
         if (!value || typeof value !== "object" || Array.isArray(value) || typeof value.branch !== "string"
-          || Object.keys(value).some((name) => !["branch", "create", "remote"].includes(name))
+          || Object.keys(value).some((name) => !["branch", "create", "remote", "repository"].includes(name))
+          || (value.repository !== undefined && typeof value.repository !== "string")
           || (value.create !== undefined && typeof value.create !== "boolean")
           || (value.remote !== undefined && value.remote !== null && typeof value.remote !== "string")) throw new GitBranchError("branch-request-invalid");
-        if (!(await listBranches(root))) throw new GitBranchError("not-a-git-repository");
+        const folder = value.repository === undefined ? root : childRepositoryFolder(root, value.repository);
+        if (!folder || !(await listBranches(folder))) throw new GitBranchError("not-a-git-repository");
         if (await runningInProject(projectRef) > 0) throw new GitBranchError("branch-switch-blocked-running");
-        const head = await switchBranch(root, { branch: value.branch, create: value.create === true, remote: value.remote ?? null });
+        const head = await switchBranch(folder, { branch: value.branch, create: value.create === true, remote: value.remote ?? null });
         events.publish("catalog.changed", { reasonCode: "git-branch-switched" });
-        return { head, branches: await listBranches(root) };
+        return { head, branches: await listBranches(folder) };
       },
       updates: { status: () => updates!.status(), check: () => updates!.check(), apply: (request) => updates!.apply(request) },
       answerSessionQuestion: (sessionRef, questionRef, answer) => company(sessionRef)

package/packages/piagent-webui/gateway/git-repositories.ts

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { readGitHead, type GitHead } from "./git-head.ts";
+
+// A project folder that is not itself in a repository may hold several (a
+// workspace folder with the front end, the back end and other projects side
+// by side, each its own repository). Like an editor's source control view,
+// the dashboard looks one level down for them: each child folder with its
+// own `.git` (a folder, or a worktree's file) is a repository, shown with
+// its branch. Hidden folders and dependency folders are skipped.
+export type ChildRepository = { name: string; path: string; head: GitHead | null };
+
+const MAX_REPOSITORIES = 30;
+const SKIPPED = new Set(["node_modules", "vendor", "target", "dist", "build", "Pods", "venv", "__pycache__"]);
+
+export function childRepositories(cwd: string): ChildRepository[] {
+  if (!cwd || readGitHead(cwd)) return [];
+  let entries: fs.Dirent[];
+  try { entries = fs.readdirSync(cwd, { withFileTypes: true }); } catch { return []; }
+  const found: ChildRepository[] = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || SKIPPED.has(entry.name)) continue;
+    const folder = path.join(cwd, entry.name);
+    try { fs.lstatSync(path.join(folder, ".git")); } catch { continue; }
+    found.push({ name: entry.name, path: entry.name, head: readGitHead(folder) });
+    if (found.length === MAX_REPOSITORIES) break;
+  }
+  return found;
+}
+
+// The folder of one child repository, or null when `name` is not one: a
+// single folder name, never a path that climbs out of the project.
+export function childRepositoryFolder(cwd: string, name: string): string | null {
+  if (!name || name.length > 255 || name.startsWith(".") || name.includes("/") || name.includes("\\") || /[\u0000-\u001f\u007f]/.test(name)) return null;
+  return childRepositories(cwd).some((repository) => repository.name === name) ? path.join(cwd, name) : null;
+}
+
+// One read per project folder while a catalog is built.
+export function childRepositoryReader(): (cwd: string) => ChildRepository[] {
+  const seen = new Map<string, ChildRepository[]>();
+  return (cwd) => {
+    if (!seen.has(cwd)) seen.set(cwd, childRepositories(cwd));
+    return seen.get(cwd)!;
+  };
+}

package/packages/piagent-webui/gateway/managed-projection.ts

@@ -1,5 +1,6 @@
+import { turnEndOf } from '../shared/turn-end.ts';
 // Public managed state contains no provider/model route or credential.
-const STATUS = ['pending', 'in_progress', 'completed'];
+const STATUS = ['pending', 'in_progress', 'completed', 'deferred'];
 const OUTCOMES = ['no_change', 'interrupted', 'disputed', 'blocking_open', 'unverified', 'review_unavailable', 'unreviewed', 'clean'];
 export function managedProjection(context: any, entries: any[]) {
   if (context?.model?.provider !== 'agent_watch_managed') return {};
@@ -14,6 +15,12 @@ export function managedProjection(context: any, entries: any[]) {
   const final = entries.filter(e => e.type === 'custom_message' && e.customType === 'agent-watch-process' && e.details?.phase === 'final').at(-1)?.details;
   const process = final && OUTCOMES.includes(final.outcome) ? { outcome: final.outcome, verified: final.verified === true, reviewed: final.reviewed === true,
     blockingOpen: Number.isInteger(final.blockingOpen) && final.blockingOpen >= 0 ? Math.min(final.blockingOpen, 1000) : 0, ...(final.planSkipped === true ? { planSkipped: true as const } : {}) } : null;
+  // How the member's last message ended, unless a newer message is running.
+  const lastIndex = (match: (e: any) => boolean) => { for (let i = entries.length - 1; i >= 0; i -= 1) if (match(entries[i])) return i; return -1; };
+  const lastUser = lastIndex(e => e.type === 'message' && e.message?.role === 'user');
+  const endAt = lastIndex(e => e.type === 'custom' && e.customType === 'agent-watch-turn-end');
+  const end = endAt > lastUser ? turnEndOf(entries[endAt].data) : null;
+  const turnEnd = end ? { state: end.state, planSteps: end.planSteps, planDone: end.planDone, ...(end.planDeferred ? { planDeferred: end.planDeferred } : {}), ...(end.reason ? { reason: end.reason } : {}) } : null;
   // Helpers the Harness enables (up to four); a conversation recorded before
   // that was known says two.
   const maximum = Number.isInteger(counter?.maximum) && counter.maximum >= 0 && counter.maximum <= 4 ? counter.maximum : 2;
@@ -21,5 +28,5 @@ export function managedProjection(context: any, entries: any[]) {
   const permission = last('agent-watch-permission')?.mode === 'trusted-full-access' ? 'trusted-full-access' : 'workspace-write';
   return {modelLabel:'agent-watch-auto', managedPermission: permission, managedHelpers:{active:Number.isInteger(counter?.active) && counter.active>=0 && counter.active<=maximum ? counter.active : 0, maximum},
     ...(Array.isArray(capabilities)?{managedThinkingLevels:levels.filter(level=>capabilities.includes(level))}:{}),
-    ...(steps ? {managedPlan:{steps}} : {}), ...(process ? {managedProcess:process} : {})};
+    ...(steps ? {managedPlan:{steps}} : {}), ...(process ? {managedProcess:process} : {}), ...(turnEnd ? {managedTurnEnd:turnEnd} : {})};
 }

package/packages/piagent-webui/gateway/project-registry.ts

@@ -78,12 +78,16 @@ export class ProjectRegistry {
     if (!stat.isDirectory() || stat.isSymbolicLink() || cwd === path.parse(cwd).root) throw new Error("project-import-folder-invalid");
     const current = this.#read(), projectRef = projectRefForCwd(this.#key, cwd);
     const existing = current.projects.find((item) => item.projectRef === projectRef);
-    if (!existing) {
-      if (current.projects.length >= MAX_PROJECTS) throw new Error("project-registry-limit");
-      current.projects.push({ projectRef, cwd, label: cleanLabel(path.basename(cwd)), importedAt: now.toISOString() });
-      this.#write(current);
-    }
-    const item = existing ?? current.projects.at(-1)!;
+    // Added again: it moves to the newest place, so it outlives older folders.
+    const others = current.projects.filter((item) => item.projectRef !== projectRef);
+    const item = { projectRef, cwd, label: existing?.label ?? cleanLabel(path.basename(cwd)), importedAt: now.toISOString() };
+    // The list is the menu's memory of added folders, not where conversations
+    // live (their folders come from the sessions): a full list makes room by
+    // forgetting folders gone from the disk, then the folders added longest ago.
+    const kept = others.length < MAX_PROJECTS ? others : others.filter((other) => {
+      try { return fs.realpathSync(other.cwd) === other.cwd && fs.lstatSync(other.cwd).isDirectory(); } catch { return false; }
+    }).sort((left, right) => Date.parse(left.importedAt) - Date.parse(right.importedAt)).slice(-(MAX_PROJECTS - 1));
+    this.#write({ ...current, projects: [...kept, item] });
     return { projectRef: item.projectRef, placeRef: item.projectRef, label: item.label };
   }
 

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

@@ -7,6 +7,7 @@ import type { Catalog, SessionRow } from "../contracts/generated/session-catalog
 import type { MetadataSnapshot, SessionMetadata } from "./session-metadata-store.ts";
 import { projectRefForCwd, sessionRefForPath } from "../ownership/session-refs.ts";
 import { gitHeadReader, type GitHead } from "./git-head.ts";
+import { childRepositoryReader, type ChildRepository } from "./git-repositories.ts";
 
 export { projectRefForCwd, sessionRefForPath } from "../ownership/session-refs.ts";
 
@@ -48,7 +49,7 @@ function catalogRef(key: Buffer, namespace: string, value: string): string {
 }
 
 export type SessionOwnerProjection = Pick<SessionRow, "state" | "liveState" | "composerAvailable" | "needsAttention" | "owner" | "reasonCode">;
-export type SessionOptionProjection = Pick<SessionRow, "modelLabel" | "thinkingLevel" | "managedHelpers" | "managedThinkingLevels" | "managedPermission" | "managedPlan" | "managedProcess">;
+export type SessionOptionProjection = Pick<SessionRow, "modelLabel" | "thinkingLevel" | "managedHelpers" | "managedThinkingLevels" | "managedPermission" | "managedPlan" | "managedProcess" | "managedTurnEnd">;
 
 function display(value: unknown, maximum: number, fallback: string): string {
   const clean = redactSensitiveText(String(value ?? "")).text
@@ -106,8 +107,11 @@ function revision(key: Buffer, value: unknown): string {
 }
 
 function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undefined, metadataReason: string | null,
-  ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection, gitHead?: GitHead | null): SessionRow {
+  ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection, gitHead?: GitHead | null, repositories: ChildRepository[] = []): SessionRow {
   const gitBranch = gitHead ? { name: display(gitHead.name, 200, "HEAD"), detached: gitHead.detached } : null;
+  // A folder that is not a repository but holds some (front end, back end…).
+  const gitRepositories = gitBranch ? [] : repositories.map((repository) => ({ name: display(repository.name, 255, "repository").replace(/[/\\]/g, "-"),
+    branch: repository.head ? { name: display(repository.head.name, 200, "HEAD"), detached: repository.head.detached } : null }));
   const projectLabel = display(info.cwd ? path.basename(info.cwd) : "", 120, "Unknown project");
   const projected = projectedSessionTitle(info);
   return {
@@ -126,12 +130,14 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
     composerAvailable: metadata?.archived ? false : ownership?.composerAvailable ?? false,
     needsAttention: metadata?.archived ? false : ownership?.needsAttention ?? false,
     ...(gitBranch ? { gitBranch } : {}),
+    ...(gitRepositories.length ? { gitRepositories } : {}),
     ...(sessionOptions?.managedHelpers ? {managedHelpers:{...sessionOptions.managedHelpers,
       active: ownership?.liveState === 'idle' ? 0 : ownership?.liveState === 'running' || ownership?.liveState === 'waiting-approval' ? sessionOptions.managedHelpers.active : null}} : {}),
     ...(sessionOptions?.managedThinkingLevels ? {managedThinkingLevels:sessionOptions.managedThinkingLevels} : {}),
     ...(sessionOptions?.managedPermission ? {managedPermission:sessionOptions.managedPermission} : {}),
     ...(sessionOptions?.managedPlan ? {managedPlan:sessionOptions.managedPlan} : {}),
     ...(sessionOptions?.managedProcess ? {managedProcess:sessionOptions.managedProcess} : {}),
+    ...(sessionOptions?.managedTurnEnd ? {managedTurnEnd:sessionOptions.managedTurnEnd} : {}),
     modelLabel: sessionOptions?.modelLabel ?? null,
     thinkingLevel: sessionOptions?.thinkingLevel ?? "unknown",
     contextUsage: { usedTokens: null, contextWindow: null, ratio: null, state: "unknown" },
@@ -140,8 +146,8 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
       ? { kind: "none", ownerEpoch: null, gatewayInstanceRef: null, runtimeInstanceRef: null, continuity: "released" }
       : ownership?.owner ?? { kind: "none", ownerEpoch: null, gatewayInstanceRef: null, runtimeInstanceRef: null, continuity: "unknown" },
     sessionRevision: revision(key, [info.path, info.modified.toISOString(), info.messageCount, info.name ?? null, metadata?.revision ?? null,
-      sessionOptions?.modelLabel ?? null, sessionOptions?.thinkingLevel ?? "unknown", sessionOptions?.managedHelpers, sessionOptions?.managedThinkingLevels, sessionOptions?.managedPermission ?? null, sessionOptions?.managedPlan, sessionOptions?.managedProcess,
-      gitBranch,
+      sessionOptions?.modelLabel ?? null, sessionOptions?.thinkingLevel ?? "unknown", sessionOptions?.managedHelpers, sessionOptions?.managedThinkingLevels, sessionOptions?.managedPermission ?? null, sessionOptions?.managedPlan, sessionOptions?.managedProcess, sessionOptions?.managedTurnEnd,
+      gitBranch, gitRepositories,
       metadata?.archived ? "archived" : ownership ? [ownership.state, ownership.liveState, ownership.owner.kind,
         ownership.owner.ownerEpoch, ownership.owner.runtimeInstanceRef, ownership.reasonCode] : "offline"]),
     reasonCode: metadata?.archived ? metadataReason : ownership?.reasonCode ?? metadataReason
@@ -156,17 +162,18 @@ export async function buildSessionCatalog(options: {
   readOwnership?(sessionRef: string): SessionOwnerProjection;
   readSessionOptions?(info: PiSessionInfo): SessionOptionProjection;
   readGitHead?(cwd: string): GitHead | null;
+  readChildRepositories?(cwd: string): ChildRepository[];
   limit?: number;
 }): Promise<Catalog> {
   const limit = Math.max(1, Math.min(200, options.limit ?? 200));
   try {
     const found = (await options.listSessions()).filter(isUserConversationSession);
-    const readHead = options.readGitHead ?? gitHeadReader();
+    const readHead = options.readGitHead ?? gitHeadReader(), readRepositories = options.readChildRepositories ?? childRepositoryReader();
     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);
       return row(options.key, info, metadata.sessions.get(sessionRef), metadata.reasonCode, options.readOwnership?.(sessionRef),
-        options.readSessionOptions?.(info), readHead(info.cwd));
+        options.readSessionOptions?.(info), readHead(info.cwd), readRepositories(info.cwd));
     }).sort((left, right) => Number(right.pinned) - Number(left.pinned)
       || Date.parse(right.updatedAt) - Date.parse(left.updatedAt)).slice(0, limit);
     return {

package/packages/piagent-webui/server/loopback-server.ts

@@ -72,7 +72,7 @@ export async function startLoopbackServer(options: {
   answerSessionQuestion?: (sessionRef: string, questionRef: string, answer: unknown) => unknown | Promise<unknown>;
   suggestPaths?: (projectRef: string, query: string) => unknown | Promise<unknown>;
   listCommands?: (projectRef: string) => unknown | Promise<unknown>;
-  listBranches?: (projectRef: string) => unknown | Promise<unknown>;
+  listBranches?: (projectRef: string, repository: string | null) => unknown | Promise<unknown>;
   switchBranch?: (projectRef: string, request: unknown) => unknown | Promise<unknown>;
   updates?: UpdateRoutes;
   bootstrapTtlMs?: number;

package/packages/piagent-webui/server/member-routes.ts

@@ -37,7 +37,7 @@ type Options = {
   listCommands?: (projectRef: string) => unknown | Promise<unknown>;
   // The project's Git branches, and a switch to one of them (or a new one);
   // null as above.
-  listBranches?: (projectRef: string) => unknown | Promise<unknown>;
+  listBranches?: (projectRef: string, repository: string | null) => unknown | Promise<unknown>;
   switchBranch?: (projectRef: string, request: unknown) => unknown | Promise<unknown>;
   updates?: UpdateRoutes;
 };
@@ -111,9 +111,12 @@ export async function routeMemberRequest(context: Context, options: Options): Pr
     const projectRef = decodeURIComponent(branches[1]);
     if (request.method === "GET") {
       if (!auth.authenticate(request)) { errorResponse(response, 401, "authentication-required"); return true; }
-      if (!CURSOR.test(projectRef)) { errorResponse(response, 400, "invalid-project-ref"); return true; }
+      const repository = url.searchParams.get("repository");
+      if (!CURSOR.test(projectRef) || repository !== null && (repository.length === 0 || repository.length > 255 || /[\x00-\x1f/\\]/.test(repository))) {
+        errorResponse(response, 400, "invalid-project-ref"); return true;
+      }
       try {
-        const value = await options.listBranches!(projectRef);
+        const value = await options.listBranches!(projectRef, repository);
         if (value === null) errorResponse(response, 404, "project-not-found"); else jsonResponse(response, 200, value);
       } catch { errorResponse(response, 503, "branches-unavailable"); }
       return true;

package/packages/piagent-webui/server/tool-call-summary.ts

@@ -8,7 +8,7 @@ import { redactSensitiveText } from "../../piagent-core/extensions/redaction-cor
 // and a bounded result preview. Every string is ANSI-stripped and redacted;
 // raw arguments and results never leave the server.
 export type ToolKind = "read" | "write" | "edit" | "command" | "search" | "list" | "web-search" | "web-fetch"
-  | "subagent" | "network" | "git" | "plan" | "other";
+  | "subagent" | "network" | "docker" | "git" | "plan" | "other";
 export type ToolSummary = { kind: ToolKind; target: string | null; detail: string | null };
 export type ToolChange = { added: number; removed: number; preview: string; truncated: boolean };
 export type ToolResult = { text: string; truncated: boolean; isError: boolean };
@@ -139,6 +139,8 @@ export function summarizeToolCall(name: unknown, input: unknown, cwd?: string):
     }
     case "run_with_network":
       return { summary: { kind: "network", target: commandParts(args.command, cwd).target, detail: clean(args.reason, DETAIL_CHARS) } };
+    case "run_with_docker":
+      return { summary: { kind: "docker", target: commandParts(args.command, cwd).target, detail: clean(args.reason, DETAIL_CHARS) } };
     case "grep": case "find": {
       const where = [displayPath(args.path, cwd), clean(args.glob, 120)].filter(Boolean).join(" · ");
       return { summary: { kind: "search", target: clean(args.pattern, TARGET_CHARS), detail: where || null } };

package/packages/piagent-webui/server/transcript-projection.ts

@@ -5,6 +5,7 @@ import { looksLikeCompletionClaim } from "../../piagent-core/runtime/session/com
 import { isLightweightNonAuthorizingChangeLanguage } from "../../piagent-core/runtime/workflows/change-clarification.ts";
 import { workflowCommandPattern } from "../../piagent-core/runtime/workflows/webui-workflow.ts";
 import { hasVisibleText } from "../shared/text-visibility.ts";
+import { turnEndOf, type TurnEnd } from "../shared/turn-end.ts";
 import { effectiveStopReason } from "./message-stop-reason.ts";
 import { WEBUI_MESSAGE_CORRELATION_ENTRY_TYPE, webUiMessageCorrelationEntry,
   type WebUiMessageCorrelation } from "../shared/message-correlation.ts";
@@ -33,11 +34,11 @@ type TranscriptItem = { messageRef: string; parentMessageRef: string | null; rol
   agentOperationId: string | null; messageRequestId?: string; turnIndex: number | null; content: TranscriptContent;
   attachments?: TranscriptAttachment[];
   toolCalls: Array<{ toolCallRef: string; toolName: string; state: "requested" | "completed" | "failed" | "unknown";
-    summary?: ToolSummary; change?: ToolChange; result?: ToolResult }>; usage?: TurnUsage; model?: string; process?: HarnessProcess };
+    summary?: ToolSummary; change?: ToolChange; result?: ToolResult }>; usage?: TurnUsage; model?: string; process?: HarnessProcess; turnEnd?: TurnEnd };
 type HarnessFinding = { severity: "blocking" | "major" | "minor"; file: string; line: number | null; issue: string };
 type HarnessIssue = { kind: "wrong_premise" | "conflicts_with_request" | "ambiguous" | "out_of_scope"; detail: string };
-type HarnessProcess = { phase: "plan" | "verify" | "review" | "final" | "objection" | "answer" | "claims" | "rejudge" | "dispute"; outcome?: string; loop?: number; maxLoops?: number;
-  verified?: boolean; reviewed?: boolean; blockingOpen?: number; planOpen?: number; planSkipped?: true; verifyPolicy?: string; reviewPolicy?: string; reviewUnavailable?: string;
+type HarnessProcess = { phase: "plan" | "verify" | "review" | "final" | "objection" | "answer" | "claims" | "rejudge" | "dispute" | "continue"; outcome?: string; loop?: number; maxLoops?: number;
+  verified?: boolean; reviewed?: boolean; blockingOpen?: number; planOpen?: number; planDone?: number; planSteps?: number; round?: number; maxRounds?: number; idle?: number; planSkipped?: true; verifyPolicy?: string; reviewPolicy?: string; reviewUnavailable?: string;
   findings?: HarnessFinding[]; role?: "scout" | "research" | "verify" | "review"; by?: "main" | "harness"; disputes?: number; unchanged?: true; issues?: HarnessIssue[]; claims?: { claim: string }[] };
 export type TranscriptDocument = { schemaVersion: 1; version: "piagent-webui-transcript-v1"; generatedAt: string; identity: TranscriptIdentity;
   revision: TranscriptRevision; eventCursor: string; state: "ready" | "unavailable"; items: TranscriptItem[];
@@ -173,7 +174,8 @@ function toolCalls(message: any, sessionRef: string, role: TranscriptItem["role"
 // agent before a code-changing turn ended, and how that turn ended.
 const PROCESS_OUTCOMES = ["no_change", "interrupted", "disputed", "blocking_open", "unverified", "review_unavailable", "unreviewed", "clean"];
 // A helper's objection to its brief, a failed claim, a disagreement handed to the member.
-const PROCESS_PHASES = ["plan", "verify", "review", "final", "objection", "answer", "claims", "rejudge", "dispute"];
+// "continue": the harness sent the agent back to a checklist with open steps.
+const PROCESS_PHASES = ["plan", "verify", "review", "final", "objection", "answer", "claims", "rejudge", "dispute", "continue"];
 const ISSUE_KINDS = ["wrong_premise", "conflicts_with_request", "ambiguous", "out_of_scope"], HELPER_ROLES = ["scout", "research", "verify", "review"];
 const POLICY_MODES = ["off", "suggest", "require"];
 function harnessProcess(details: any): HarnessProcess | null {
@@ -187,6 +189,12 @@ function harnessProcess(details: any): HarnessProcess | null {
   if (typeof details.reviewed === "boolean") out.reviewed = details.reviewed;
   if (Number.isInteger(details.blockingOpen) && details.blockingOpen >= 0) out.blockingOpen = Math.min(details.blockingOpen, 1000);
   if (Number.isInteger(details.planOpen) && details.planOpen >= 1 && details.planOpen <= 30) out.planOpen = details.planOpen;
+  const upTo = (n: unknown, low: number, high: number): n is number => Number.isInteger(n) && (n as number) >= low && (n as number) <= high;
+  if (upTo(details.planDone, 0, 30)) out.planDone = details.planDone;
+  if (upTo(details.planSteps, 1, 30)) out.planSteps = details.planSteps;
+  if (upTo(details.round, 1, 30)) out.round = details.round;
+  if (upTo(details.maxRounds, 1, 30)) out.maxRounds = details.maxRounds;
+  if (upTo(details.idle, 1, 2)) out.idle = details.idle;
   if (details.planSkipped === true) out.planSkipped = true;
   if (POLICY_MODES.includes(details.policy?.verify)) out.verifyPolicy = details.policy.verify;
   if (POLICY_MODES.includes(details.policy?.review)) out.reviewPolicy = details.policy.review;
@@ -262,6 +270,14 @@ function correlatedTranscriptItems(entries: unknown[], identity: TranscriptIdent
       pending = webUiMessageCorrelationEntry(entry);
       continue;
     }
+    // How the member's message ended: an entry, not a message the model reads.
+    if (entry?.type === "custom" && entry.customType === "agent-watch-turn-end") {
+      const turnEnd = turnEndOf(entry.data);
+      const projected = turnEnd && item({ ...entry, type: "message", message: { role: "custom", content: "" } }, identity, true);
+      if (projected) values.push({ entry, item: { ...projected, turnEnd, ...(turn ? { agentOperationId: turn.operationRef, messageRequestId: turn.messageRequestId } : {}) },
+        cursor: opaque("transcript", [identity.sessionRef, entry.id]) });
+      continue;
+    }
     if (entry?.type === "custom_message" && entry.customType === "agent-watch-process") {
       const process = harnessProcess(entry.details);
       const projected = process && item({ ...entry, type: "message", message: { role: "custom", content: entry.content } }, identity, true);

package/packages/piagent-webui/shared/process-copy.ts

@@ -4,7 +4,7 @@ import { failureRoleText, type CopyLocale, type FailureRole } from "./company-co
 
 export type ProcessCopyInput = {
   phase?: string; outcome?: string; loop?: number; maxLoops?: number; verified?: boolean; reviewed?: boolean; blockingOpen?: number;
-  planOpen?: number; planSkipped?: boolean; verifyPolicy?: string; reviewPolicy?: string; reviewUnavailable?: string; role?: FailureRole;
+  planOpen?: number; planDone?: number; planSteps?: number; round?: number; maxRounds?: number; idle?: number; planSkipped?: boolean; verifyPolicy?: string; reviewPolicy?: string; reviewUnavailable?: string; role?: FailureRole;
   disputes?: number; unchanged?: boolean;
   findings?: Array<{ severity: string; file?: string; line?: number | null; issue: string }>;
   claims?: Array<{ claim: string }>; issues?: Array<{ kind: string; detail: string }>;
@@ -41,6 +41,8 @@ export function headlineText(process: ProcessCopyInput, locale: CopyLocale): str
   const round = process.loop && process.maxLoops ? pick(locale, ` (vòng ${process.loop}/${process.maxLoops})`, ` (round ${process.loop}/${process.maxLoops})`) : "";
   const who = failureRoleText(process.role ?? "review", locale), count = (process.findings ?? process.claims ?? process.issues ?? []).length;
   switch (process.phase) {
+    case "continue": return pick(locale, `Harness: checklist còn ${process.planOpen ?? 0} bước (${process.planDone ?? 0}/${process.planSteps ?? 0} xong), cho main agent làm tiếp · vòng ${process.round ?? 1}${process.idle ? " (vòng trước không xong thêm bước nào)" : ""}`,
+      `Harness: the checklist has ${process.planOpen ?? 0} open step(s) (${process.planDone ?? 0}/${process.planSteps ?? 0} done); sent the main agent on · round ${process.round ?? 1}${process.idle ? " (the previous round finished no step)" : ""}`);
     case "plan": return pick(locale, `Harness: plan còn ${process.planOpen ?? 0} bước chưa đánh dấu xong, yêu cầu agent cập nhật`, `Harness: ${process.planOpen ?? 0} plan step(s) not marked completed; asked the agent to update the plan`);
     case "verify": return pick(locale, `Harness: chưa có check nào pass trên code hiện tại, yêu cầu agent chạy check${round}`, `Harness: no check has passed on the current code; asked the agent to run checks${round}`);
     case "review": return pick(locale, `Harness: review tìm thấy ${count} lỗi blocking, gửi lại agent để fix hoặc giải thích${round}`, `Harness: the review found ${count} blocking issue(s); sent back to the agent to fix or answer${round}`);

package/packages/piagent-webui/shared/turn-end.ts

@@ -0,0 +1,68 @@
+// How a member's message ended in a company conversation ("agent-watch-turn-end"),
+// read the same way by the transcript, the session list and the company
+// Terminal: every checklist step done, stopped with steps open, failed (which
+// harness role), or stopped by the member.
+import { failureRoleText, type CopyLocale, type FailureRole } from "./company-copy.ts";
+
+export type TurnEndState = "done" | "midway" | "failed" | "cancelled";
+export type TurnEnd = { state: TurnEndState; planSteps: number; planDone: number; planDeferred?: number; rounds: number;
+  reason?: "idle" | "limit" | "policy"; role?: FailureRole; code?: string };
+const ROLES: FailureRole[] = ["main", "scout", "research", "verify", "review"];
+// The harness gives up after this many rounds in a row without progress, and
+// runs at most this many (packages/piagent-core/managed/continuation.mjs).
+export const IDLE_ROUNDS = 2, MAX_ROUNDS = 30;
+
+// The recorded details, checked; null when they do not have the expected shape.
+export function turnEndOf(details: any): TurnEnd | null {
+  const count = (n: unknown): n is number => Number.isInteger(n) && (n as number) >= 0 && (n as number) <= 30;
+  if (!["done", "midway", "failed", "cancelled"].includes(details?.state) || !count(details.planSteps) || !count(details.planDone)
+    || !count(details.rounds) || (details.planDeferred !== undefined && !count(details.planDeferred))
+    || details.planDone + (details.planDeferred ?? 0) > details.planSteps) return null;
+  const out: TurnEnd = { state: details.state, planSteps: details.planSteps, planDone: details.planDone, rounds: details.rounds };
+  if (details.planDeferred) out.planDeferred = details.planDeferred;
+  if (details.state === "midway" && ["idle", "limit", "policy"].includes(details.reason)) out.reason = details.reason;
+  if (details.state === "failed") {
+    out.role = ROLES.includes(details.role) ? details.role : "main";
+    if (typeof details.code === "string" && /^[a-z0-9_]{1,64}$/.test(details.code)) out.code = details.code;
+  }
+  return out;
+}
+
+const pick = (locale: CopyLocale, vi: string, en: string) => locale === "vi" ? vi : en;
+export type TurnEndCopy = { tone: "success" | "warning" | "error" | "info"; title: string; text: string; continuable: boolean };
+
+// What the member reads under the last answer: is the task finished, and if
+// not, why the agent stopped and what to do.
+export function turnEndCopy(end: TurnEnd, locale: CopyLocale): TurnEndCopy {
+  const later = end.planDeferred ?? 0, open = end.planSteps - end.planDone - later;
+  const rounds = end.rounds ? pick(locale, ` Harness đã cho agent làm tiếp ${end.rounds} vòng.`, ` The harness sent the agent back ${end.rounds} time(s).`) : "";
+  if (end.state === "cancelled") return { tone: "info", continuable: true, title: pick(locale, "Bạn đã dừng lượt này", "You stopped this turn"),
+    text: pick(locale, `Task chưa xong${end.planSteps ? ` (${end.planDone}/${end.planSteps} bước)` : ""}. Bấm Tiếp tục để agent làm tiếp từ chỗ dừng.`,
+      `The task is not finished${end.planSteps ? ` (${end.planDone}/${end.planSteps} steps)` : ""}. Choose Continue to pick up where it stopped.`) };
+  if (end.state === "failed") return { tone: "error", continuable: true,
+    title: pick(locale, `Lượt dừng vì lỗi · ${failureRoleText(end.role ?? "main", locale)}`, `Turn stopped by a failure · ${failureRoleText(end.role ?? "main", locale)}`),
+    text: pick(locale, `Task chưa xong${end.planSteps ? `: còn ${open}/${end.planSteps} bước` : ""}. Xem lỗi phía trên; khi đã xử lý, bấm Tiếp tục để chạy lại từ chỗ dừng.`,
+      `The task is not finished${end.planSteps ? `: ${open} of ${end.planSteps} steps open` : ""}. See the failure above; once it is resolved, choose Continue.`) + (end.code ? ` [${end.code}]` : "") };
+  if (end.state === "midway") {
+    const why = end.reason === "idle" ? pick(locale, `Main agent dừng ${IDLE_ROUNDS} vòng liên tiếp mà không xong thêm bước nào: đọc câu trả lời cuối để biết vướng gì.`,
+      `The main agent stopped ${IDLE_ROUNDS} rounds in a row without finishing a step: its last answer says what is in the way.`)
+      : end.reason === "limit" ? pick(locale, `Đã tới giới hạn ${MAX_ROUNDS} vòng tự làm tiếp cho một tin nhắn.`, `The limit of ${MAX_ROUNDS} automatic rounds for one message was reached.`)
+      : pick(locale, "Harness của team không bắt buộc plan nên không tự làm tiếp.", "The team's Harness does not require a plan, so it does not continue on its own.");
+    return { tone: "warning", continuable: true, title: pick(locale, `Dừng giữa chừng · còn ${open}/${end.planSteps} bước`, `Stopped midway · ${open} of ${end.planSteps} steps open`),
+      text: `${why}${rounds} ${pick(locale, "Bấm Tiếp tục để làm tiếp.", "Choose Continue to go on.")}` };
+  }
+  // Steps left for later at the member's word (or no longer needed): done as asked, not all done.
+  if (later) return { tone: "info", continuable: true, title: pick(locale, `Dừng theo yêu cầu · ${end.planDone}/${end.planSteps} bước xong, ${later} bước để sau`, `Stopped as asked · ${end.planDone} of ${end.planSteps} steps done, ${later} left for later`),
+    text: pick(locale, "Các bước còn lại được để sau theo yêu cầu hoặc vì không cần nữa: câu trả lời cuối nói lý do. Bấm Tiếp tục khi muốn làm nốt.", "The other steps were left for later as asked, or are no longer needed: the last answer says why. Choose Continue to do them.") + rounds };
+  return { tone: "success", continuable: false, title: end.planSteps ? pick(locale, `Hoàn thành · ${end.planSteps}/${end.planSteps} bước`, `Done · ${end.planSteps}/${end.planSteps} steps`) : pick(locale, "Xong lượt", "Turn finished"),
+    text: (end.planSteps ? pick(locale, "Mọi bước trong checklist đã xong.", "Every checklist step is completed.") : pick(locale, "Main agent đã trả lời xong; lượt này không có checklist.", "The main agent finished its answer; this turn had no checklist.")) + rounds };
+}
+
+// The short label of the session list.
+export function turnEndShort(end: Pick<TurnEnd, "state" | "planSteps" | "planDone" | "planDeferred">, locale: CopyLocale): string {
+  if (end.state === "done" && end.planDeferred) return pick(locale, `Xong ${end.planDone}/${end.planSteps}, để sau ${end.planDeferred}`, `Done ${end.planDone}/${end.planSteps}, ${end.planDeferred} later`);
+  if (end.state === "midway") return pick(locale, `Dừng giữa chừng ${end.planDone}/${end.planSteps}`, `Stopped ${end.planDone}/${end.planSteps}`);
+  if (end.state === "failed") return pick(locale, "Lỗi, chưa xong", "Failed");
+  if (end.state === "cancelled") return pick(locale, "Đã dừng", "Stopped");
+  return end.planSteps ? pick(locale, `Xong ${end.planSteps}/${end.planSteps}`, `Done ${end.planSteps}/${end.planSteps}`) : pick(locale, "Xong", "Done");
+}

package/schemas/piagent-webui/session-catalog-v1.schema.json

@@ -95,13 +95,23 @@
         "managedThinkingLevels": {"type": "array", "uniqueItems": true, "maxItems": 7, "items": {"enum": ["off","minimal","low","medium","high","xhigh","max"]}}, "managedPermission": {"enum": ["workspace-write","trusted-full-access"]},
         "managedPlan": { "type": "object", "additionalProperties": false, "required": ["steps"], "properties": {
           "steps": { "type": "array", "minItems": 1, "maxItems": 30, "items": { "type": "object", "additionalProperties": false, "required": ["step", "status"], "properties": {
-            "step": { "type": "string", "minLength": 1, "maxLength": 200 }, "status": { "enum": ["pending", "in_progress", "completed"] } } } } } },
+            "step": { "type": "string", "minLength": 1, "maxLength": 200 }, "status": { "enum": ["pending", "in_progress", "completed", "deferred"] } } } } } },
         "managedProcess": { "type": "object", "additionalProperties": false, "required": ["outcome", "verified", "reviewed", "blockingOpen"], "properties": {
           "outcome": { "enum": ["no_change", "interrupted", "disputed", "blocking_open", "unverified", "review_unavailable", "unreviewed", "clean"] },
           "verified": { "type": "boolean" }, "reviewed": { "type": "boolean" }, "blockingOpen": { "type": "integer", "minimum": 0, "maximum": 1000 }, "planSkipped": { "const": true } } },
+        "managedTurnEnd": { "type": "object", "additionalProperties": false, "required": ["state", "planSteps", "planDone"], "properties": {
+          "state": { "enum": ["done", "midway", "failed", "cancelled"] },
+          "planSteps": { "type": "integer", "minimum": 0, "maximum": 30 }, "planDone": { "type": "integer", "minimum": 0, "maximum": 30 },
+          "planDeferred": { "type": "integer", "minimum": 1, "maximum": 30 },
+          "reason": { "enum": ["idle", "limit", "policy"] } } },
         "gitBranch": { "type": "object", "additionalProperties": false, "required": ["name", "detached"], "properties": {
           "name": { "type": "string", "minLength": 1, "maxLength": 200, "pattern": "^[^\\u0000-\\u001F\\u007F]*$" },
           "detached": { "type": "boolean" } } },
+        "gitRepositories": { "type": "array", "maxItems": 30, "items": { "type": "object", "additionalProperties": false, "required": ["name", "branch"], "properties": {
+          "name": { "type": "string", "minLength": 1, "maxLength": 255, "pattern": "^[^\\u0000-\\u001F\\u007F/\\\\]*$" },
+          "branch": { "anyOf": [{ "type": "null" }, { "type": "object", "additionalProperties": false, "required": ["name", "detached"], "properties": {
+            "name": { "type": "string", "minLength": 1, "maxLength": 200, "pattern": "^[^\\u0000-\\u001F\\u007F]*$" },
+            "detached": { "type": "boolean" } } }] } } } },
         "modelLabel": { "$ref": "common-v1.schema.json#/$defs/nullableDisplayText" },
         "thinkingLevel": { "enum": ["off", "minimal", "low", "medium", "high", "xhigh", "max", "unknown"] },
         "contextUsage": { "$ref": "#/$defs/contextUsage" },

package/schemas/piagent-webui/transcript-v1.schema.json

@@ -157,7 +157,7 @@
       "additionalProperties": false,
       "required": ["phase"],
       "properties": {
-        "phase": { "enum": ["plan", "verify", "review", "final", "objection", "answer", "claims", "rejudge", "dispute"] },
+        "phase": { "enum": ["plan", "verify", "review", "final", "objection", "answer", "claims", "rejudge", "dispute", "continue"] },
         "outcome": { "enum": ["no_change", "interrupted", "disputed", "blocking_open", "unverified", "review_unavailable", "unreviewed", "clean"] },
         "role": { "enum": ["scout", "research", "verify", "review"] },
         "by": { "enum": ["main", "harness"] },
@@ -192,6 +192,11 @@
         "reviewed": { "type": "boolean" },
         "blockingOpen": { "type": "integer", "minimum": 0, "maximum": 1000 },
         "planOpen": { "type": "integer", "minimum": 1, "maximum": 30 },
+        "planDone": { "type": "integer", "minimum": 0, "maximum": 30 },
+        "planSteps": { "type": "integer", "minimum": 1, "maximum": 30 },
+        "round": { "type": "integer", "minimum": 1, "maximum": 30 },
+        "maxRounds": { "type": "integer", "minimum": 1, "maximum": 30 },
+        "idle": { "type": "integer", "minimum": 1, "maximum": 2 },
         "planSkipped": { "const": true },
         "verifyPolicy": { "enum": ["off", "suggest", "require"] },
         "reviewPolicy": { "enum": ["off", "suggest", "require"] },
@@ -213,6 +218,21 @@
         }
       }
     },
+    "turnEnd": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["state", "planSteps", "planDone", "rounds"],
+      "properties": {
+        "state": { "enum": ["done", "midway", "failed", "cancelled"] },
+        "planSteps": { "type": "integer", "minimum": 0, "maximum": 30 },
+        "planDone": { "type": "integer", "minimum": 0, "maximum": 30 },
+        "planDeferred": { "type": "integer", "minimum": 1, "maximum": 30 },
+        "rounds": { "type": "integer", "minimum": 0, "maximum": 30 },
+        "reason": { "enum": ["idle", "limit", "policy"] },
+        "role": { "enum": ["main", "scout", "research", "verify", "review"] },
+        "code": { "type": "string", "pattern": "^[a-z0-9_]{1,64}$" }
+      }
+    },
     "companyFailure": {
       "type": "object",
       "additionalProperties": false,
@@ -243,7 +263,7 @@
           "additionalProperties": false,
           "required": ["kind", "target", "detail"],
           "properties": {
-            "kind": { "enum": ["read", "write", "edit", "command", "search", "list", "web-search", "web-fetch", "subagent", "network", "git", "plan", "other"] },
+            "kind": { "enum": ["read", "write", "edit", "command", "search", "list", "web-search", "web-fetch", "subagent", "network", "docker", "git", "plan", "other"] },
             "target": { "anyOf": [{ "type": "string", "maxLength": 400 }, { "type": "null" }] },
             "detail": { "anyOf": [{ "type": "string", "maxLength": 400 }, { "type": "null" }] }
           }
@@ -315,6 +335,7 @@
         "model": { "type": "string", "minLength": 1, "maxLength": 120, "pattern": "^[A-Za-z0-9._:@/-]{1,120}$" },
         "failure": { "$ref": "#/$defs/companyFailure" },
         "process": { "$ref": "#/$defs/harnessProcess" },
+        "turnEnd": { "$ref": "#/$defs/turnEnd" },
         "toolCalls": {
           "type": "array",
           "maxItems": 64,