@piagent/platform 1.22.0 → 1.23.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-coozlgfe.js"></script>
+    <script type="module" crossorigin src="/assets/index-CDVdO4C7.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-ZLemRWyJ.css">
   </head>
   <body>

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

@@ -31,6 +31,13 @@ const KINDS = new Set<GatewayEventKind>(["catalog.changed", "session.changed", "
   "message.completed", "operation.settled", "tool.started", "tool.completed"]);
 const LOOPBACK = /^http:\/\/127\.0\.0\.1:\d{1,5}$/;
 const CATALOG_REUSE_MS = 5_000;
+// A company Gateway that takes the connection and never answers (found on
+// Windows/WSL) kept every list of the dashboard loading: the browser waits for
+// the catalog without a limit, and the catalog waited for the company rows.
+// A read is given this long, a change as long as a command; a Gateway that
+// missed one is left alone for a while, not asked again by every read.
+const READ_TIMEOUT_MS = 15_000, ANSWER_TIMEOUT_MS = 5_000, CHANGE_TIMEOUT_MS = 120_000, STALL_RETRY_MS = 60_000;
+const timedOut = (error: unknown) => error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
 const failure = (error: unknown, fallback: string) => error instanceof Error && /^[a-z][a-z0-9:._-]{2,95}$/.test(error.message) ? error.message : fallback;
 
 export class CompanyRelay {
@@ -54,11 +61,15 @@ export class CompanyRelay {
   #retry: NodeJS.Timeout | null = null;
   #closed = false;
   #lastAttach = 0;
+  #stalledAt = 0;
+  readonly #readTimeoutMs: number;
+  readonly #answerTimeoutMs: number;
 
   constructor(options: { connector: CompanyConnector; events: GatewayEventStore; hubProject(cwd: string): string;
-    folder(projectRef: string): Promise<string | null> }) {
+    folder(projectRef: string): Promise<string | null>; readTimeoutMs?: number; answerTimeoutMs?: number }) {
     this.#connector = options.connector; this.#events = options.events;
     this.#hubProject = options.hubProject; this.#folder = options.folder;
+    this.#readTimeoutMs = options.readTimeoutMs ?? READ_TIMEOUT_MS; this.#answerTimeoutMs = options.answerTimeoutMs ?? ANSWER_TIMEOUT_MS;
   }
 
   status(): CompanyStatus {
@@ -91,9 +102,12 @@ export class CompanyRelay {
         if (!socket) throw new Error("company-gateway-stopped");
         this.#link = await this.#bootstrap(socket);
         await this.#open(this.#link);
+        // Ready only once a read is answered: the reads of the dashboard wait on it.
+        await this.#answers(this.#link);
         this.#state = "ready"; this.#fresh = false;
       } catch (error) {
         const reason = failure(error, "company-connect-failed");
+        if (reason === "company-gateway-timeout") this.#drop();
         // Agent Watch re-imports after an update on its own, so a changed
         // binding is not kept once a later attach finds nothing running.
         this.#state = "unavailable";
@@ -128,7 +142,7 @@ export class CompanyRelay {
     if (typeof launch !== "string") throw new Error("company-gateway-starting");
     const url = new URL(launch), capability = new URLSearchParams(url.hash.slice(1)).get("bootstrap");
     if (!LOOPBACK.test(url.origin) || !capability) throw new Error("company-gateway-invalid");
-    const response = await fetch(`${url.origin}/api/v1/bootstrap`, { method: "POST", redirect: "error",
+    const response = await fetch(`${url.origin}/api/v1/bootstrap`, { method: "POST", redirect: "error", signal: AbortSignal.timeout(this.#readTimeoutMs),
       headers: { Origin: url.origin, "Content-Type": "application/json", Accept: "application/json" }, body: JSON.stringify({ capability }) });
     const cookie = response.headers.get("set-cookie")?.split(";", 1)[0], body = await response.json().catch(() => null) as { csrfToken?: unknown } | null;
     if (!response.ok || !cookie || typeof body?.csrfToken !== "string") throw new Error("company-gateway-auth-failed");
@@ -177,6 +191,33 @@ export class CompanyRelay {
     });
   }
 
+  // Lets go of a company Gateway that does not answer, without waiting for its socket to close.
+  #drop(): void {
+    this.#stalledAt = Date.now();
+    const ws = this.#ws; this.#ws = null; this.#link = null; ws?.terminate();
+    for (const [, pending] of this.#pending) { clearTimeout(pending.timer); pending.reject(new Error("company-gateway-timeout")); }
+    this.#pending.clear();
+  }
+
+  async #answers(link: Link): Promise<void> {
+    try {
+      const response = await fetch(`${link.origin}/api/v1/session-live-state`, { redirect: "error", signal: AbortSignal.timeout(this.#answerTimeoutMs),
+        headers: { Accept: "application/json", Origin: link.origin, Cookie: link.cookie } });
+      await response.arrayBuffer();
+    } catch (error) { throw timedOut(error) ? new Error("company-gateway-timeout") : error; }
+  }
+
+  // A read that was not answered in time: the company rows are left out and
+  // the Gateway is asked again later, so the dashboard's own lists keep loading.
+  #stalled(): void {
+    this.#drop();
+    this.#state = "unavailable"; this.#reason = "company-gateway-timeout";
+    this.#events.publish("catalog.changed", { reasonCode: "company-unavailable" });
+    if (this.#closed) return;
+    if (this.#retry) clearTimeout(this.#retry);
+    this.#retry = setTimeout(() => void this.connect(false), STALL_RETRY_MS); this.#retry.unref();
+  }
+
   // Reads only attach; starting the company runtime (and possibly asking for
   // Keychain access) is left to commands and the explicit connect route.
   async #ready(launch = false): Promise<Link> {
@@ -190,10 +231,18 @@ export class CompanyRelay {
   async http(method: "GET" | "POST", path: string, body?: unknown): Promise<{ status: number; value: unknown }> {
     for (let attempt = 0; ; attempt += 1) {
       const link = await this.#ready();
-      const response = await fetch(`${link.origin}${path}`, { method, redirect: "error",
-        headers: { Accept: "application/json", Origin: link.origin, Cookie: link.cookie,
-          ...(method === "POST" ? { "Content-Type": "application/json", "X-Piagent-CSRF": link.csrf } : {}) },
-        body: method === "POST" ? JSON.stringify(body) : undefined });
+      let response: Response;
+      try {
+        response = await fetch(`${link.origin}${path}`, { method, redirect: "error",
+          signal: AbortSignal.timeout(method === "GET" ? this.#readTimeoutMs : CHANGE_TIMEOUT_MS),
+          headers: { Accept: "application/json", Origin: link.origin, Cookie: link.cookie,
+            ...(method === "POST" ? { "Content-Type": "application/json", "X-Piagent-CSRF": link.csrf } : {}) },
+          body: method === "POST" ? JSON.stringify(body) : undefined });
+      } catch (error) {
+        if (!timedOut(error)) throw error;
+        if (method === "GET" && this.#link === link) this.#stalled();
+        throw new Error("company-gateway-timeout");
+      }
       if (response.status === 401 && attempt === 0) { this.#link = await this.#bootstrap(link.socket); continue; }
       // The browser's own session is not the one refused here.
       if (response.status === 401 || response.status === 403) return { status: 503, value: { error: { code: "company-auth-failed" } } };
@@ -232,7 +281,7 @@ export class CompanyRelay {
   #attachSoon(): void {
     if (this.#closed || this.#connecting || this.#state === "ready" || !this.#connector.configured()) return;
     const now = Date.now();
-    if (now - this.#lastAttach < 10_000) return;
+    if (now - this.#lastAttach < 10_000 || now - this.#stalledAt < STALL_RETRY_MS) return;
     this.#lastAttach = now; void this.connect(false);
   }
 

package/packages/piagent-webui/gateway/managed-gateway.mjs

@@ -1,4 +1,4 @@
-import { managedThinkingLevels } from '../../piagent-core/managed/capabilities.mjs';
+import { managedThinkingLevels, nearestLevel } from '../../piagent-core/managed/capabilities.mjs';
 import { ManagedBrokerClient } from '../../piagent-core/managed/broker-client.mjs';
 import { ManagedSession } from '../../piagent-core/managed/session.mjs';
 import fs from 'node:fs';
@@ -30,7 +30,9 @@ export async function startManagedGateway({ config, configPath, cwd, agentDir, p
       try {
         runtime=await ManagedSession.create({sdkRoot:config.sdk_root,cwd:info.cwd,origin:config.origin,broker,agentDir,
           sessionManager:manager??host.SessionManager.open(info.path),protectedRoots:[configPath,agentDir],renewBroker:newBroker,bindingRevision});
-        if(initial) runtime.session.setThinkingLevel(initial.thinkingLevel);
+        // The page may still offer the levels of the Harness before an administrator
+        // changed it: the conversation takes the nearest level the Harness allows now.
+        if(initial) runtime.session.setThinkingLevel(nearestLevel(initial.thinkingLevel,managedThinkingLevels(runtime.manifest,runtime.modelRuntime,runtime.session.model)));
         await runtime.session.bindExtensions({mode:'rpc',uiContext:rpcUiContext()});
         return {session:runtime.session,dispose:()=>runtime.dispose()};
       } catch(error) { if(runtime) await runtime.dispose(); else await broker.dispose(); throw error; }

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

@@ -26,7 +26,9 @@ export function managedProjection(context: any, entries: any[]) {
   const maximum = Number.isInteger(counter?.maximum) && counter.maximum >= 0 && counter.maximum <= 4 ? counter.maximum : 2;
   // The member's access choice: "trusted-full-access" is Bypass.
   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},
+  // Fast mode, only where the conversation's Harness allows it (fast-mode.mjs).
+  const fast = last('agent-watch-fast');
+  return {modelLabel:'agent-watch-auto', managedPermission: permission, ...(fast?.allowed === true ? {managedFast: fast.enabled === true ? 'on' as const : 'off' as const} : {}), 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} : {}), ...(turnEnd ? {managedTurnEnd:turnEnd} : {})};
 }

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

@@ -32,6 +32,15 @@ export async function executePermissionCommand(session: any,
   if (!profile || profile.mode !== permissionMode || profile.warning) throw new Error("session-permission-unavailable");
 }
 
+// Fast mode of a company conversation, where its Harness allows it. Like the
+// permission, the runtime reads it at each request, so it may change mid-turn.
+// True when the conversation's setting changed.
+export function executeFastCommand(session: any, fast: boolean): boolean {
+  if (!session) throw new Error("session-runtime-unavailable");
+  if (!session.managedExecution || typeof session.managedSetFast !== "function") throw new Error("managed-fast-unavailable");
+  return session.managedSetFast(fast) === true;
+}
+
 export async function executeRuntimeCommand(session: any, command: string): Promise<{
   outputs: RuntimeCommandOutput[];
   modelCallObserved: boolean;

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

@@ -49,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" | "managedTurnEnd">;
+export type SessionOptionProjection = Pick<SessionRow, "modelLabel" | "thinkingLevel" | "managedHelpers" | "managedThinkingLevels" | "managedPermission" | "managedFast" | "managedPlan" | "managedProcess" | "managedTurnEnd">;
 
 function display(value: unknown, maximum: number, fallback: string): string {
   const clean = redactSensitiveText(String(value ?? "")).text
@@ -135,6 +135,7 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
       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?.managedFast ? {managedFast:sessionOptions.managedFast} : {}),
     ...(sessionOptions?.managedPlan ? {managedPlan:sessionOptions.managedPlan} : {}),
     ...(sessionOptions?.managedProcess ? {managedProcess:sessionOptions.managedProcess} : {}),
     ...(sessionOptions?.managedTurnEnd ? {managedTurnEnd:sessionOptions.managedTurnEnd} : {}),
@@ -146,7 +147,7 @@ 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, sessionOptions?.managedTurnEnd,
+      sessionOptions?.modelLabel ?? null, sessionOptions?.thinkingLevel ?? "unknown", sessionOptions?.managedHelpers, sessionOptions?.managedThinkingLevels, sessionOptions?.managedPermission ?? null, sessionOptions?.managedFast ?? 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"]),

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

@@ -13,7 +13,7 @@ import { SessionMetadataStore } from "./session-metadata-store.ts";
 const REF = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,159}$/;
 const REVISION = /^[A-Za-z0-9][A-Za-z0-9._:~-]{0,159}$/;
 const IDEMPOTENCY = /^[A-Za-z0-9_-]{22,96}$/;
-const ACTIONS: SessionAction[] = ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.rename", "session.pin", "session.archive",
+const ACTIONS: SessionAction[] = ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.set-fast", "session.rename", "session.pin", "session.archive",
   "session.unarchive", "session.fork", "session.acquire", "session.release"];
 
 type SessionCommand = SessionCommandIdentity & {
@@ -58,6 +58,7 @@ function validPayload(action: SessionAction, payload: Record<string, unknown>):
     && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(String(payload.thinkingLevel));
   if (action === "session.set-permission") return exactKeys(payload, ["permissionMode"])
     && ["read-only", "workspace-write", "trusted-full-access"].includes(String(payload.permissionMode));
+  if (action === "session.set-fast") return exactKeys(payload, ["fast"]) && typeof payload.fast === "boolean";
   if (action === "session.rename") return exactKeys(payload, ["title"]) && typeof payload.title === "string"
     && payload.title.length >= 1 && payload.title.length <= 500 && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(payload.title);
   if (action === "session.pin") return exactKeys(payload, ["pinned"]) && typeof payload.pinned === "boolean";
@@ -160,7 +161,7 @@ export class SessionCommandController {
     let deferredDispatch: Pick<SessionSendResult, "dispatch" | "cancel"> | null = null;
     let observedCatalog = current, observedRow = row;
     try {
-      let resultCode: "created" | "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" | "fast-changed" | "permission-changed"
         | "renamed" | "pinned" | "unpinned" | "archived" | "unarchived" | "forked" | "no-change",
         operationRef: string | null = null;
       if (command.action === "session.create") {
@@ -228,6 +229,8 @@ export class SessionCommandController {
       } else if (command.action === "session.set-permission") {
         resultCode = await this.#runtimes.setPermission(command.sessionRef!, String(command.payload.permissionMode) as
           "read-only" | "workspace-write" | "trusted-full-access");
+      } else if (command.action === "session.set-fast") {
+        resultCode = await this.#runtimes.setFast(command.sessionRef!, command.payload.fast === true);
       } else if (command.action === "session.rename") {
         resultCode = await this.#runtimes.rename(command.sessionRef!, String(command.payload.title).trim());
       } else if (command.action === "session.fork") {
@@ -320,7 +323,7 @@ export class SessionCommandController {
       sessionRevisionAfter: row?.sessionRevision ?? null, deduplicated: false };
   }
   #settled(command: SessionCommand, catalog: Catalog, row: SessionRow,
-    resultCode: "created" | "acquired" | "released" | "started" | "queued" | "steered" | "aborted" | "model-changed" | "thinking-changed" | "permission-changed"
+    resultCode: "created" | "acquired" | "released" | "started" | "queued" | "steered" | "aborted" | "model-changed" | "thinking-changed" | "fast-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-command-store.ts

@@ -11,7 +11,7 @@ const REF = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,159}$/;
 const REVISION = /^[A-Za-z0-9][A-Za-z0-9._:~-]{0,159}$/;
 const REASON = /^[a-z0-9][a-z0-9.-]{0,95}$/;
 const DIGEST = /^sha256:[a-f0-9]{64}$/;
-const ACTIONS = ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.rename", "session.pin", "session.archive",
+const ACTIONS = ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.set-fast", "session.rename", "session.pin", "session.archive",
   "session.unarchive", "session.fork", "session.acquire", "session.release"] as const;
 
 export type SessionAction = typeof ACTIONS[number];
@@ -72,14 +72,14 @@ export function validSessionReceipt(value: unknown): value is Receipt {
   const settled = exactTimestamp(receipt.settledAt), evidence = typeof receipt.evidenceRef === "string" && REF.test(receipt.evidenceRef);
   if (receipt.phase === "accepted") return receipt.resultCode === "accepted" && receipt.settledAt === null && receipt.evidenceRef === null && receipt.error === null;
   if (receipt.phase === "settled") {
-    const results = ["created", "started", "queued", "steered", "aborted", "model-changed", "thinking-changed", "permission-changed", "renamed", "pinned", "unpinned", "archived", "unarchived",
+    const results = ["created", "started", "queued", "steered", "aborted", "model-changed", "thinking-changed", "permission-changed", "fast-changed", "renamed", "pinned", "unpinned", "archived", "unarchived",
       "forked", "acquired", "released", "no-change"];
     const actionResults: Partial<Record<SessionAction, string[]>> = {
       "session.create": ["created", "started"],
       "session.acquire": ["acquired", "no-change"], "session.release": ["released", "no-change"],
       "session.send": ["started", "queued", "steered"], "session.abort": ["aborted", "no-change"],
       "session.set-model": ["model-changed", "no-change"], "session.set-thinking": ["thinking-changed", "no-change"],
-      "session.set-permission": ["permission-changed", "no-change"], "session.rename": ["renamed", "no-change"],
+      "session.set-permission": ["permission-changed", "no-change"], "session.set-fast": ["fast-changed", "no-change"], "session.rename": ["renamed", "no-change"],
       "session.pin": ["pinned", "unpinned", "no-change"], "session.archive": ["archived", "no-change"],
       "session.unarchive": ["unarchived", "no-change"], "session.fork": ["forked"]
     };

package/packages/piagent-webui/gateway/session-effective-options.ts

@@ -34,7 +34,12 @@ export function inspectEffectiveSessionOptions(session: any, modelRef: string |
     thinkingLevel: null, reasonCode: "session-thinking-effect-unknown" };
   if (modelRef && effectiveModel !== modelRef) return { state: "mismatch", modelRef: effectiveModel,
     thinkingLevel: effectiveThinking, reasonCode: "session-model-mismatch" };
-  if (effectiveThinking !== thinkingLevel) return { state: "mismatch", modelRef: effectiveModel,
+  // A company conversation thinks at a level its Harness allows. The new chat
+  // page can still offer the levels of the Harness before an administrator
+  // changed it (high, when the Harness now fixes max): the runtime takes the
+  // nearest allowed level, and that is the conversation's level, not a create
+  // that failed. Refusing it left the message unsent under a "resyncing" notice.
+  if (effectiveThinking !== thinkingLevel && session?.managedExecution !== true) return { state: "mismatch", modelRef: effectiveModel,
     thinkingLevel: effectiveThinking, reasonCode: "session-thinking-mismatch" };
   return { state: "confirmed", modelRef: effectiveModel, thinkingLevel: effectiveThinking, reasonCode: null };
 }

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

@@ -11,7 +11,7 @@ import { isUserConversationSession, projectRefForCwd, sessionRefForPath, type Se
 import { SessionLeaseStore, type SessionLeaseSnapshot } from "./session-lease-store.ts";
 import { GatewayEventStore } from "./gateway-events.ts";
 import { GatewaySessionStream } from "./gateway-session-stream.ts";
-import { executePermissionCommand, executeRuntimeCommand } from "./runtime-session-controls.ts";
+import { executeFastCommand, executePermissionCommand, executeRuntimeCommand } from "./runtime-session-controls.ts";
 import { inspectEffectiveSessionOptions, effectiveModelRef, effectiveThinkingLevel, type EffectiveSessionOptions } from "./session-effective-options.ts";
 import { launchSessionPrompt, type LaunchedSessionPrompt, type SessionSendResult } from "./session-prompt-dispatch.ts";
 import { WEBUI_MESSAGE_CORRELATION_ENTRY_TYPE } from "../shared/message-correlation.ts";
@@ -348,22 +348,19 @@ export class SessionRuntimeSupervisor {
     const effective = effectiveModelRef(session);
     if (!effective) throw new Error("session-model-effect-unknown");
     if (effective !== modelRef) throw new Error("session-model-mismatch");
-    this.#touchCreated(sessionRef);
-    return "model-changed";
+    this.#touchCreated(sessionRef); return "model-changed";
   }
   async setThinking(sessionRef: string, thinkingLevel: string): Promise<"thinking-changed" | "no-change"> {
     await this.acquire(sessionRef);
     const active = this.#active.get(sessionRef), session = active?.runtime.session;
     if (!active || !session) throw new Error("session-runtime-unavailable");
     if (active.operationRef || !session.isIdle) throw new Error("session-runtime-busy");
-    const current = effectiveThinkingLevel(session);
-    if (current === thinkingLevel) return "no-change";
+    if (effectiveThinkingLevel(session) === thinkingLevel) return "no-change";
     await session.setThinkingLevel(thinkingLevel);
     const effective = effectiveThinkingLevel(session);
     if (!effective) throw new Error("session-thinking-effect-unknown");
     if (effective !== thinkingLevel) throw new Error("session-thinking-mismatch");
-    this.#touchCreated(sessionRef);
-    return "thinking-changed";
+    this.#touchCreated(sessionRef); return "thinking-changed";
   }
   async setPermission(sessionRef: string, permissionMode: "read-only" | "workspace-write" | "trusted-full-access"): Promise<"permission-changed"> {
     await this.acquire(sessionRef);
@@ -371,8 +368,11 @@ export class SessionRuntimeSupervisor {
     if (!active || !session) throw new Error("session-runtime-unavailable");
     if (!session.managedExecution && (active.operationRef || !session.isIdle)) throw new Error("session-runtime-busy");
     await executePermissionCommand(session, permissionMode);
-    this.#touchCreated(sessionRef);
-    return "permission-changed";
+    this.#touchCreated(sessionRef); return "permission-changed";
+  }
+  async setFast(sessionRef: string, fast: boolean): Promise<"fast-changed" | "no-change"> {
+    await this.acquire(sessionRef); const changed = executeFastCommand(this.#active.get(sessionRef)?.runtime.session, fast);
+    this.#touchCreated(sessionRef); return changed ? "fast-changed" : "no-change";
   }
   async runRuntimeCommand(sessionRef: string, command: string): Promise<RuntimeCommandResult> {
     await this.acquire(sessionRef);

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

@@ -14,7 +14,8 @@ export const LAUNCH_REASONS: Record<string, [string, string]> = {
   "managed-launch-binding-changed": ["Agent Watch hoặc Piagent vừa cập nhật. Nhập lại cấu hình cho Piagent trong Agent Watch (trên Windows: Kết nối Piagent trong WSL).", "Agent Watch or Piagent changed. Import the Piagent configuration again in Agent Watch (on Windows: Connect Piagent in WSL)."],
   "managed-launch-version-mismatch": ["Agent Watch đang dùng một bản Piagent khác với dashboard này. Mở Agent Watch → Studio, bấm Áp dụng cho Piagent rồi kết nối lại.", "Agent Watch points at another Piagent install than this dashboard. Open Agent Watch → Studio, apply for Piagent, then connect again."],
   "managed-launch-stale-runtime": ["Phiên công ty của bản Piagent cũ chưa dừng được. Thử kết nối lại sau ít giây.", "The company runtime from the previous Piagent did not stop yet. Connect again in a few seconds."],
-  "managed-launch-timeout": ["Phiên công ty khởi động quá lâu. Kết nối lại.", "The company runtime took too long to start. Connect again."]
+  "managed-launch-timeout": ["Phiên công ty khởi động quá lâu. Kết nối lại.", "The company runtime took too long to start. Connect again."],
+  "company-gateway-timeout": ["Phiên công ty đang chạy nhưng không trả lời. Đóng Piagent, chạy `pkill -f piagent-studio.mjs` trong Terminal (Windows: trong Ubuntu), rồi mở lại.", "The company runtime is running but does not answer. Close Piagent, run `pkill -f piagent-studio.mjs` in a terminal (Windows: in Ubuntu), then open it again."]
 };
 
 export type Copy = { title: [string, string]; text: [string, string] };

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

@@ -92,7 +92,7 @@
         "composerAvailable": { "type": "boolean" },
         "needsAttention": { "type": "boolean" },
         "managedHelpers": { "type": "object", "additionalProperties": false, "required": ["active", "maximum"], "properties": {"active": {"type": ["integer", "null"], "minimum": 0, "maximum": 4}, "maximum": {"type": "integer", "minimum": 0, "maximum": 4}} },
-        "managedThinkingLevels": {"type": "array", "uniqueItems": true, "maxItems": 7, "items": {"enum": ["off","minimal","low","medium","high","xhigh","max"]}}, "managedPermission": {"enum": ["workspace-write","trusted-full-access"]},
+        "managedThinkingLevels": {"type": "array", "uniqueItems": true, "maxItems": 7, "items": {"enum": ["off","minimal","low","medium","high","xhigh","max"]}}, "managedPermission": {"enum": ["workspace-write","trusted-full-access"]}, "managedFast": {"enum": ["off","on"]},
         "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", "deferred"] } } } } } },

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

@@ -29,7 +29,7 @@
         "messageType": { "const": "command" },
         "commandId": { "$ref": "common-v1.schema.json#/$defs/opaqueRef" },
         "idempotencyKey": { "$ref": "#/$defs/idempotencyKey" },
-        "action": { "enum": ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.rename", "session.pin", "session.archive", "session.unarchive", "session.fork", "session.acquire", "session.release"] },
+        "action": { "enum": ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.set-fast", "session.rename", "session.pin", "session.archive", "session.unarchive", "session.fork", "session.acquire", "session.release"] },
         "requestedAt": { "$ref": "common-v1.schema.json#/$defs/timestamp" },
         "expiresAt": { "$ref": "common-v1.schema.json#/$defs/timestamp" },
         "sessionRef": { "$ref": "common-v1.schema.json#/$defs/nullableOpaqueRef" },
@@ -144,7 +144,7 @@
         {
           "type": "object",
           "properties": {
-            "action": { "enum": ["session.set-model", "session.set-thinking", "session.set-permission"] },
+            "action": { "enum": ["session.set-model", "session.set-thinking", "session.set-permission", "session.set-fast"] },
             "sessionRef": { "$ref": "common-v1.schema.json#/$defs/opaqueRef" },
             "expectedSessionRevision": { "$ref": "common-v1.schema.json#/$defs/revisionToken" },
             "payload": {
@@ -166,6 +166,12 @@
                   "additionalProperties": false,
                   "required": ["permissionMode"],
                   "properties": { "permissionMode": { "$ref": "#/$defs/permissionMode" } }
+                },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["fast"],
+                  "properties": { "fast": { "type": "boolean" } }
                 }
               ]
             }
@@ -185,6 +191,11 @@
               "if": { "properties": { "action": { "const": "session.set-permission" } }, "required": ["action"] },
               "then": { "properties": { "payload": { "type": "object", "required": ["permissionMode"],
                 "properties": { "permissionMode": { "$ref": "#/$defs/permissionMode" } } } } }
+            },
+            {
+              "if": { "properties": { "action": { "const": "session.set-fast" } }, "required": ["action"] },
+              "then": { "properties": { "payload": { "type": "object", "required": ["fast"],
+                "properties": { "fast": { "type": "boolean" } } } } }
             }
           ]
         }
@@ -290,9 +301,9 @@
         "messageType": { "const": "receipt" },
         "commandId": { "$ref": "common-v1.schema.json#/$defs/opaqueRef" },
         "idempotencyKeyDigest": { "$ref": "common-v1.schema.json#/$defs/digest" },
-        "action": { "enum": ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.rename", "session.pin", "session.archive", "session.unarchive", "session.fork", "session.acquire", "session.release"] },
+        "action": { "enum": ["session.create", "session.send", "session.abort", "session.set-model", "session.set-thinking", "session.set-permission", "session.set-fast", "session.rename", "session.pin", "session.archive", "session.unarchive", "session.fork", "session.acquire", "session.release"] },
         "phase": { "enum": ["accepted", "settled", "uncertain", "rejected"] },
-        "resultCode": { "enum": ["accepted", "created", "started", "queued", "steered", "aborted", "model-changed", "thinking-changed", "permission-changed", "renamed", "pinned", "unpinned", "archived", "unarchived", "forked", "acquired", "released", "no-change", "stale-revision", "owner-conflict", "recovery-required", "invalid-command", "expired", "unavailable", "effect-unknown"] },
+        "resultCode": { "enum": ["accepted", "created", "started", "queued", "steered", "aborted", "model-changed", "thinking-changed", "permission-changed", "fast-changed", "renamed", "pinned", "unpinned", "archived", "unarchived", "forked", "acquired", "released", "no-change", "stale-revision", "owner-conflict", "recovery-required", "invalid-command", "expired", "unavailable", "effect-unknown"] },
         "requestedAt": { "$ref": "common-v1.schema.json#/$defs/timestamp" },
         "settledAt": { "anyOf": [{ "$ref": "common-v1.schema.json#/$defs/timestamp" }, { "type": "null" }] },
         "sessionRef": { "$ref": "common-v1.schema.json#/$defs/nullableOpaqueRef" },
@@ -325,7 +336,7 @@
           "if": { "properties": { "phase": { "const": "settled" } }, "required": ["phase"] },
           "then": {
             "properties": {
-              "resultCode": { "enum": ["created", "started", "queued", "steered", "aborted", "model-changed", "thinking-changed", "permission-changed", "renamed", "pinned", "unpinned", "archived", "unarchived", "forked", "acquired", "released", "no-change"] },
+              "resultCode": { "enum": ["created", "started", "queued", "steered", "aborted", "model-changed", "thinking-changed", "permission-changed", "fast-changed", "renamed", "pinned", "unpinned", "archived", "unarchived", "forked", "acquired", "released", "no-change"] },
               "settledAt": { "$ref": "common-v1.schema.json#/$defs/timestamp" },
               "evidenceRef": { "$ref": "common-v1.schema.json#/$defs/opaqueRef" },
               "error": { "type": "null" }
@@ -367,6 +378,10 @@
           "if": { "properties": { "action": { "const": "session.set-permission" }, "phase": { "const": "settled" } }, "required": ["action", "phase"] },
           "then": { "properties": { "resultCode": { "enum": ["permission-changed", "no-change"] } } }
         },
+        {
+          "if": { "properties": { "action": { "const": "session.set-fast" }, "phase": { "const": "settled" } }, "required": ["action", "phase"] },
+          "then": { "properties": { "resultCode": { "enum": ["fast-changed", "no-change"] } } }
+        },
         {
           "if": { "properties": { "action": { "const": "session.send" }, "phase": { "const": "settled" } }, "required": ["action", "phase"] },
           "then": { "properties": { "resultCode": { "enum": ["started", "queued", "steered"] }, "operationRef": { "$ref": "common-v1.schema.json#/$defs/opaqueRef" } } }

package/scripts/company-terminal.mjs

@@ -83,6 +83,28 @@ export function companyTerminalExtension({ managed, packageRoot, sdkRoot, bindin
         ctx.ui.notify(PERMISSION_TEXT[session.permission] ?? PERMISSION_TEXT['workspace-write'], 'info');
       } });
 
+    // Fast mode, where the team's Harness allows it; off until the member turns it on.
+    const showFast = (ctx) => ctx.ui?.setStatus?.('agent-watch-fast', managed()?.session?.managedFastState?.() === 'on' ? 'Fast' : undefined);
+    pi.on('session_start', async (_event, ctx) => showFast(ctx));
+    pi.registerCommand('fast', {
+      description: 'Bật/tắt Fast cho cuộc trò chuyện công ty này (on, off, status); chỉ có khi Harness của team cho phép',
+      getArgumentCompletions: (prefix) => ['on', 'off', 'status'].filter((v) => v.startsWith(prefix)).map((value) => ({ value, label: value })),
+      handler: async (args, ctx) => {
+        const session = managed()?.session, state = session?.managedFastState?.();
+        if (typeof session?.managedSetFast !== 'function') { ctx.ui.notify('Cuộc trò chuyện này chưa sẵn sàng.', 'error'); return; }
+        if (!state) { ctx.ui.notify('Harness của team không cho phép Fast. Admin bật trong Agent Studio → Harness → Fast mode.', 'warning'); return; }
+        const arg = args.trim().toLowerCase();
+        if (!['', 'on', 'off', 'status'].includes(arg)) { ctx.ui.notify('Cách dùng: /fast on|off|status', 'warning'); return; }
+        if (arg === 'on' || arg === 'off') session.managedSetFast(arg === 'on');
+        else if (arg === '') session.managedSetFast(state !== 'on');
+        showFast(ctx);
+        ctx.ui.notify(session.managedFastState() === 'on'
+          ? session.managedFastServed?.() === false
+            ? 'Fast đang bật nhưng model hiện tại của main agent không hỗ trợ Fast (chỉ các model GPT qua Codex): các lượt vẫn chạy tốc độ thường, quota tính như thường.'
+            : 'Fast đang bật: main agent trả lời nhanh hơn trên model GPT, token tính vào quota gấp 2,5 lần. Model và mức suy luận không đổi.'
+          : 'Fast đang tắt: các lượt chạy tốc độ thường.', 'info');
+      } });
+
     // The Harness's notes carry English for the agent; the member reads them in Vietnamese.
     pi.registerMessageRenderer('agent-watch-process', (message, _options, theme) => {
       const lines = processLines(message.details);