@hachej/boring-agent 0.1.93 → 0.1.95

package/dist/{chunk-4TKUT7IL.js → chunk-2EMAKBVR.js}

@@ -11,7 +11,7 @@ import {
   AgentEffectAdmissionError,
   createAgentRuntimeBridge,
   isObservedSynchronousServiceError
-} from "./chunk-CJ2BW2W2.js";
+} from "./chunk-EOMY2HDT.js";
 import {
   AgentDefinitionValidationError,
   AgentDeploymentValidationError,
@@ -4077,12 +4077,22 @@ var HarnessPiChatService = class {
   }
   async readStateBeforeDispose(ctx, sessionId) {
     const sessionKey2 = this.sessionKey(ctx, sessionId);
-    const channel = this.channels.get(sessionKey2);
+    let channel = this.channels.get(sessionKey2);
     if (!channel && !this.harnessMayHaveLiveSession(ctx, sessionId)) {
       const persisted = await this.readPersistedState(ctx, sessionId);
-      if (persisted) return persisted;
+      channel = this.channels.get(sessionKey2);
+      if (persisted && !channel && !this.harnessMayHaveLiveSession(ctx, sessionId)) return persisted;
     }
     const adapter = await this.getAdapter(ctx, sessionId, "");
+    if (this.canRefreshFromPersistedState(sessionKey2, adapter)) {
+      const persisted = await this.readPersistedState(ctx, sessionId);
+      if (persisted && this.canRefreshFromPersistedState(sessionKey2, adapter)) {
+        return this.enrichSyntheticPromptFailures(
+          sessionKey2,
+          this.messageMetadata.enrichSnapshot(sessionKey2, persisted)
+        );
+      }
+    }
     const snapshot = this.messageMetadata.enrichSnapshot(sessionKey2, buildPiChatSnapshot(adapter, {
       seq: channel?.buffer.latestSeq ?? 0,
       sessionId,
@@ -4091,6 +4101,11 @@ var HarnessPiChatService = class {
     }));
     return this.enrichSyntheticPromptFailures(sessionKey2, snapshot);
   }
+  canRefreshFromPersistedState(sessionKey2, adapter) {
+    if (this.activePromptRuns.has(sessionKey2)) return false;
+    const snapshot = adapter.readSnapshot();
+    return !snapshot.isStreaming && !snapshot.isRetrying && snapshot.pendingMessageCount === 0 && snapshot.steeringMessages.length === 0 && snapshot.followUpMessages.length === 0;
+  }
   harnessMayHaveLiveSession(ctx, sessionId) {
     return typeof this.harness.hasPiSession === "function" ? this.harness.hasPiSession(sessionId, toSessionCtx(ctx)) : true;
   }
@@ -4605,6 +4620,18 @@ var HarnessPiChatService = class {
     const seq = envelope?.chunk?.seq;
     return typeof seq === "number" && Number.isInteger(seq) && seq >= 0 ? seq : tailIndex + 1;
   }
+  /**
+   * Validate the persisted session identity and instantiate its lazily-created
+   * Pi adapter under the same full cache key. This is intentionally a narrow
+   * trusted-host seam rather than another browser route.
+   */
+  async ensurePiSessionBound(ctx, sessionId) {
+    this.lifecycle.assertOpen();
+    await this.assertCanAccessSession(ctx, sessionId);
+    const adapter = await this.getAdapter(ctx, sessionId, "", { authorize: false });
+    await this.ensureChannel(ctx, sessionId, adapter);
+    this.lifecycle.assertOpen();
+  }
   async assertCanAccessSession(ctx, sessionId) {
     try {
       await this.sessionStore.load(toSessionCtx(ctx), sessionId);
@@ -7311,7 +7338,16 @@ var EmbeddedAgentGateway = class {
         });
         this.runtime.activity.set(claim.workspaceScopeId, ref, "running");
         return { ...receipt, disposition: "prompt" };
-      }, true);
+      }, {
+        duplicateReceipt: true,
+        guard: async () => await this.promptAdmission(
+          scope,
+          claim,
+          ref,
+          command.requestId,
+          command.requireIdle === true
+        )
+      });
     }
     return await this.sessionEffect(ref, claim, "session.followup", command.requestId, command, async () => {
       const receipt = await service.followUp(context(claim, command.requestId), ref.sessionId, {
@@ -7321,7 +7357,7 @@ var EmbeddedAgentGateway = class {
         clientSeq: command.clientSeq
       });
       return { ...receipt, disposition: "followup" };
-    }, true);
+    }, { duplicateReceipt: true });
   }
   async renameSession(input) {
     const claim = await this.verify(input.scope);
@@ -7395,16 +7431,18 @@ var EmbeddedAgentGateway = class {
     if (!summary) throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     return summary;
   }
-  sessionEffect(ref, claim, operation, requestId, payload, action, duplicateReceipt = false, legacyAlias = false) {
+  sessionEffect(ref, claim, operation, requestId, payload, action, options = {}) {
     return this.effect(
       claim,
       operation,
       sessionTarget(ref),
       requestId,
       payload,
-      () => this.withWriter(claim.workspaceScopeId, ref, action),
-      duplicateReceipt,
-      legacyAlias
+      action,
+      {
+        ...options,
+        serialize: (effect) => this.withWriter(claim.workspaceScopeId, ref, effect)
+      }
     );
   }
   /** Internal legacy-alias seam; never exposed through the public Gateway contract. */
@@ -7419,8 +7457,7 @@ var EmbeddedAgentGateway = class {
         input.requestId,
         input.payload,
         input.action,
-        false,
-        true
+        { legacyAlias: true }
       );
     }
     if (input.target.kind !== "session") throw new TypeError(`${input.operation} requires a session target`);
@@ -7431,12 +7468,20 @@ var EmbeddedAgentGateway = class {
       input.requestId,
       input.payload,
       input.action,
-      false,
-      true
+      {
+        legacyAlias: true,
+        guard: input.retryableGuard
+      }
     );
   }
-  async effect(claim, operation, target, requestId, payload, action, duplicateReceipt = false, legacyAlias = false) {
+  async effect(claim, operation, target, requestId, payload, action, options = {}) {
     this.assertOpen();
+    const {
+      duplicateReceipt = false,
+      legacyAlias = false,
+      serialize,
+      guard
+    } = options;
     const key = {
       workspaceScopeId: claim.workspaceScopeId,
       authSubjectId: claim.authSubjectId,
@@ -7452,8 +7497,9 @@ var EmbeddedAgentGateway = class {
     const id = requestKeyString(key);
     const existing = this.effects.get(id);
     if (existing) return this.replayReceipt(await existing, duplicateReceipt);
-    const running = this.runtime.trackEffect((async () => {
+    const execute = async () => {
       const current = await this.runtime.ledger.read(key);
+      let admissionReceipt;
       if (current?.state === "pending-admission") {
         const admission = await this.runtime.effectAdmission.admit({ key, digest: digest2, scope: claim, operation, target });
         if (admission.type === "retryable") throw gatewayError(admission.error);
@@ -7461,71 +7507,87 @@ var EmbeddedAgentGateway = class {
           await this.runtime.ledger.reject(key, { kind: "gateway", error: admission.error });
           throw gatewayError(admission.error);
         }
-        await this.runtime.ledger.acceptAdmission(key, admission.admissionReceipt);
-      }
-      await this.runtime.ledger.beginEffect(key);
-      let actionResult;
-      try {
-        actionResult = action();
-      } catch (error) {
-        if (legacyAlias) {
-          if (error instanceof AgentEffectAdmissionError) {
+        admissionReceipt = admission.admissionReceipt;
+      }
+      const runEffect = async () => {
+        const locked = await this.runtime.ledger.read(key);
+        if (locked?.state === "pending-admission") {
+          if (admissionReceipt === void 0) {
+            throw new AgentGatewayError(
+              AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
+              "request admission receipt was unavailable"
+            );
+          }
+          const retryableGuardError = await guard?.();
+          if (retryableGuardError) throw gatewayError(retryableGuardError);
+          await this.runtime.ledger.acceptAdmission(key, admissionReceipt);
+        }
+        await this.runtime.ledger.beginEffect(key);
+        let actionResult;
+        try {
+          actionResult = action();
+        } catch (error) {
+          if (legacyAlias) {
+            if (error instanceof AgentEffectAdmissionError) {
+              const details = projectJson(error.details);
+              const failure2 = {
+                kind: "legacy-admission",
+                code: error.code,
+                statusCode: 500,
+                message: error.message,
+                ...details === void 0 ? {} : { details }
+              };
+              await this.runtime.ledger.reject(key, failure2);
+              throw this.failure(failure2, true);
+            }
+            const failure = legacyServiceFailure(error);
+            await this.runtime.ledger.reject(key, failure);
+            throw this.failure(failure, true);
+          }
+          const unknown = new AgentGatewayError(
+            AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
+            "effect outcome could not be safely replayed"
+          );
+          await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
+          });
+          throw error;
+        }
+        try {
+          const receipt = await actionResult;
+          this.runtime.assertOpen();
+          await this.runtime.ledger.complete(key, receipt);
+          return receipt;
+        } catch (error) {
+          if (legacyAlias && error instanceof AgentEffectAdmissionError) {
             const details = projectJson(error.details);
-            const failure2 = {
+            const failure = {
               kind: "legacy-admission",
               code: error.code,
               statusCode: 500,
               message: error.message,
               ...details === void 0 ? {} : { details }
             };
-            await this.runtime.ledger.reject(key, failure2);
-            throw this.failure(failure2, true);
+            await this.runtime.ledger.reject(key, failure);
+            throw this.failure(failure, true);
           }
-          const failure = legacyServiceFailure(error);
-          await this.runtime.ledger.reject(key, failure);
-          throw this.failure(failure, true);
-        }
-        const unknown = new AgentGatewayError(
-          AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
-          "effect outcome could not be safely replayed"
-        );
-        await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
-        });
-        throw error;
-      }
-      try {
-        const receipt = await actionResult;
-        this.runtime.assertOpen();
-        await this.runtime.ledger.complete(key, receipt);
-        return receipt;
-      } catch (error) {
-        if (legacyAlias && error instanceof AgentEffectAdmissionError) {
-          const details = projectJson(error.details);
-          const failure = {
-            kind: "legacy-admission",
-            code: error.code,
-            statusCode: 500,
-            message: error.message,
-            ...details === void 0 ? {} : { details }
-          };
-          await this.runtime.ledger.reject(key, failure);
-          throw this.failure(failure, true);
-        }
-        if (legacyAlias && (isObservedSynchronousServiceError(error) || isKnownLegacyServiceFailure(error))) {
-          const failure = legacyServiceFailure(error);
-          await this.runtime.ledger.reject(key, failure);
-          throw this.failure(failure, true);
+          if (legacyAlias && (isObservedSynchronousServiceError(error) || isKnownLegacyServiceFailure(error))) {
+            const failure = legacyServiceFailure(error);
+            await this.runtime.ledger.reject(key, failure);
+            throw this.failure(failure, true);
+          }
+          const unknown = new AgentGatewayError(
+            AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
+            "effect outcome could not be safely replayed"
+          );
+          await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
+          });
+          if (legacyAlias) throw unknown;
+          throw error;
         }
-        const unknown = new AgentGatewayError(
-          AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
-          "effect outcome could not be safely replayed"
-        );
-        await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
-        });
-        if (legacyAlias) throw unknown;
-        throw error;
-      }
-    })(), key);
+      };
+      return serialize ? serialize(runEffect) : runEffect();
+    };
+    const running = this.runtime.trackEffect(execute(), key);
     this.effects.set(id, running);
     try {
       return await running;
@@ -7558,6 +7620,20 @@ var EmbeddedAgentGateway = class {
       "effect admission was rejected"
     );
   }
+  async promptAdmission(scope, claim, ref, requestId, requireIdle) {
+    const binding = await this.bindingForSession(scope, claim, ref);
+    const snapshot = await binding.composition.service.readState(
+      context(claim, requestId, binding.scope.identity),
+      ref.sessionId
+    );
+    const admissible = requireIdle ? snapshot.status === "idle" : snapshot.status === "idle" || snapshot.status === "error";
+    if (admissible) return void 0;
+    return new AgentGatewayError(
+      AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE,
+      requireIdle ? "session is not idle" : "prompt is invalid in current state",
+      { status: snapshot.status }
+    ).toJSON();
+  }
   async withWriter(workspaceScopeId, ref, action) {
     const key = sessionKey(workspaceScopeId, ref);
     const previous = this.writerTails.get(key) ?? Promise.resolve();
@@ -8167,6 +8243,7 @@ var PromptBodySchema = z4.object({
   clientNonce: NonEmptyString.max(128),
   content: NonEmptyString.max(1e6),
   displayContent: NonEmptyString.max(1e6).optional(),
+  requireIdle: z4.literal(true).optional(),
   model: ChatModelSelectionSchema.optional(),
   thinkingLevel: z4.enum(["off", "low", "medium", "high"]).optional(),
   attachments: z4.array(ChatAttachmentPayloadSchema).max(20).optional()
@@ -8486,7 +8563,8 @@ function createLegacyPiChatCompatibilityService(input) {
     target: options.target,
     requestId: options.requestId,
     payload: jsonProjection(options.payload),
-    action: options.action
+    action: options.action,
+    ...options.retryableGuard ? { retryableGuard: options.retryableGuard } : {}
   });
   return {
     ...input.service.listSessions ? { listSessions: (ctx, options) => input.service.listSessions(ctx, options) } : {},
@@ -8517,6 +8595,17 @@ function createLegacyPiChatCompatibilityService(input) {
       target: sessionTarget2(input.agentTypeId, sessionId),
       requestId: requestIdForPayload(ctx, payload.clientNonce),
       payload,
+      ...payload.requireIdle ? {
+        retryableGuard: async () => {
+          const snapshot = await input.service.readState(ctx, sessionId);
+          if (snapshot.status === "idle") return void 0;
+          return new AgentGatewayError(
+            AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE,
+            "session is not idle",
+            { status: snapshot.status }
+          ).toJSON();
+        }
+      } : {},
       action: () => input.service.prompt(ctx, sessionId, payload)
     }),
     followUp: (ctx, sessionId, payload) => effect({
@@ -9732,7 +9821,7 @@ async function dispatchGatewayInput(binding, input) {
     scope: binding.scope,
     agentTypeId: binding.agentTypeId,
     requestId,
-    title: contentToText(input.content ?? input.message).slice(0, 80) || void 0
+    title: input.title?.trim() || contentToText(input.content ?? input.message).slice(0, 80) || void 0
   });
   const connection = await binding.gateway.connectSession({
     scope: binding.scope,
@@ -10897,6 +10986,75 @@ async function mountOrderedAgentHostLegacyRoutes(input) {
   );
 }
 
+// src/server/trustedPiSessionBinding.ts
+async function bindTrustedPiSession(input) {
+  const sessionContext = trustedPiSessionContext(input.ctx, input.request, input.requested);
+  await input.withServices(async ({ binding }) => {
+    if (!binding.ensurePiSessionBound) {
+      throw createWorkspaceAgentDispatcherError(
+        ErrorCode.enum.INTERNAL_ERROR,
+        "Pi session binding is unavailable",
+        500
+      );
+    }
+    return await binding.ensurePiSessionBound(sessionContext, input.sessionId);
+  });
+  return {
+    visibleUserMessageTarget: {
+      async isIdle() {
+        return await input.withServices(async ({ binding }) => {
+          const snapshot = await binding.readState(sessionContext, input.sessionId);
+          return snapshot.status === "idle";
+        });
+      },
+      async sendIfIdle(sendInput) {
+        const requestId = sendInput.requestId.trim();
+        if (!requestId) throw new TypeError("requestId must be a non-empty string");
+        try {
+          const receipt = await input.withServices(async ({ prompt }) => await prompt.prompt(
+            sessionContext,
+            input.sessionId,
+            {
+              message: sendInput.message,
+              displayMessage: sendInput.displayMessage ?? sendInput.message,
+              clientNonce: requestId,
+              requireIdle: true
+            }
+          ));
+          return {
+            status: "accepted",
+            cursor: receipt.cursor,
+            ...receipt.duplicate ? { duplicate: true } : {}
+          };
+        } catch (error) {
+          if (error instanceof AgentGatewayError && error.code === AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE) {
+            return { status: "busy" };
+          }
+          if (isGoneSessionError(error)) return { status: "gone" };
+          throw error;
+        }
+      }
+    }
+  };
+}
+function isGoneSessionError(error) {
+  const code = error?.code;
+  return code === AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND || code === AgentGatewayErrorCode.AGENT_SCOPE_DENIED || code === AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH || code === ErrorCode.enum.SESSION_NOT_FOUND || code === ErrorCode.enum.UNAUTHORIZED;
+}
+function trustedPiSessionContext(ctx, request, requested) {
+  if (requested?.workspaceId && requested.workspaceId !== ctx.workspaceId) {
+    throw createWorkspaceAgentDispatcherError(ErrorCode.enum.UNAUTHORIZED, "Pi session workspace context mismatch", 401);
+  }
+  if (requested?.userId && requested.userId !== ctx.userId) {
+    throw createWorkspaceAgentDispatcherError(ErrorCode.enum.UNAUTHORIZED, "Pi session user context mismatch", 401);
+  }
+  return {
+    workspaceId: requested?.workspaceId ?? ctx.workspaceId,
+    authSubject: requested?.userId ?? ctx.userId,
+    requestId: request?.id ?? `trusted:${ctx.workspaceId}:${ctx.userId}`
+  };
+}
+
 // src/server/agentHostLegacyRouteRuntime.ts
 var DEFAULT_WORKSPACE_ID6 = "default";
 var STANDARD_AGENT_TOOL_NAMES = ["bash", "read", "write", "edit", "find", "grep", "ls"];
@@ -11391,6 +11549,11 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
       tools,
       readyTracker,
       piChatService: composition.service,
+      trustedPiChatService: agentHost.createPiChatService({
+        service: composition.service,
+        scope: authorizedScope,
+        agentTypeId: defaultAgentTypeId
+      }),
       authorizedScope,
       hostScope
     };
@@ -11526,6 +11689,7 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
           throw error;
         }
         return {
+          binding,
           dispatcher: createBoundWorkspaceAgentDispatcher({
             gateway: agentHost.gateway,
             scope: binding.authorizedScope,
@@ -11538,6 +11702,25 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
       binding = await getOrCreateRuntimeBinding(boundCtx.workspaceId, void 0, { trustedCtx: boundCtx });
     }
   }
+  async function ensureTrustedPiSessionBound(initialBinding, boundCtx, boundSessionId, request, requestedSessionCtx) {
+    return await bindTrustedPiSession({
+      ctx: boundCtx,
+      request,
+      sessionId: boundSessionId,
+      requested: requestedSessionCtx,
+      withServices: async (effect) => {
+        const operation = await acquireDispatcherOperation(initialBinding, boundCtx, request);
+        try {
+          return await effect({
+            binding: operation.binding.piChatService,
+            prompt: operation.binding.trustedPiChatService
+          });
+        } finally {
+          operation.release();
+        }
+      }
+    });
+  }
   function createLeasedWorkspaceAgentDispatcher(initialBinding, boundCtx, request) {
     return {
       async dispatch(input) {
@@ -11616,14 +11799,28 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
         }
         return {
           dispatcher: createLeasedWorkspaceAgentDispatcher(staticBinding, boundCtx, options?.request),
-          workspace: staticBinding.runtimeBundle.workspace
+          workspace: staticBinding.runtimeBundle.workspace,
+          bindPiSession: async (boundSessionId, requestedSessionCtx) => await ensureTrustedPiSessionBound(
+            staticBinding,
+            boundCtx,
+            boundSessionId,
+            options?.request,
+            requestedSessionCtx
+          )
         };
       }
       const binding = await getOrCreateRuntimeBinding(boundCtx.workspaceId, options?.request, { trustedCtx: boundCtx });
       bindingLifecycle.assertAdmission(boundCtx.workspaceId, options?.request);
       return {
         dispatcher: createLeasedWorkspaceAgentDispatcher(binding, boundCtx, options?.request),
-        workspace: binding.runtimeBundle.workspace
+        workspace: binding.runtimeBundle.workspace,
+        bindPiSession: async (boundSessionId, requestedSessionCtx) => await ensureTrustedPiSessionBound(
+          binding,
+          boundCtx,
+          boundSessionId,
+          options?.request,
+          requestedSessionCtx
+        )
       };
     }
   });

package/dist/{chunk-CJ2BW2W2.js → chunk-EOMY2HDT.js}

@@ -42,6 +42,7 @@ var AGENT_EFFECT_METHODS = {
 };
 function withAgentEffectAdmission(service, admit) {
   return {
+    ...service.ensurePiSessionBound ? { ensurePiSessionBound: (ctx, sessionId) => service.ensurePiSessionBound(ctx, sessionId) } : {},
     ...service.listSessions ? { listSessions: (ctx, options) => service.listSessions(ctx, options) } : {},
     async createSession(ctx, init) {
       await admit(ctx);

package/dist/core/index.d.ts

@@ -1,8 +1,8 @@
 import { A as AgentHarness, a as AgentReadiness, b as Agent } from '../harness-Cc48o6uS.js';
 export { c as AGENT_NOT_IMPLEMENTED_UNTIL_T1, d as AgentActor, e as AgentCoreHarness, f as AgentCoreHarnessFactory, g as AgentCorePromptInput, h as AgentCoreSessionAdapter, i as AgentCoreSessionSnapshot, j as AgentEvent, k as AgentMessageContent, l as AgentMessagePart, m as AgentNotImplementedError, n as AgentReadinessStatus, o as AgentResolveInputResponse, p as AgentSendInput, q as AgentStartReceipt, r as AgentStreamOptions } from '../harness-Cc48o6uS.js';
 import { S as SessionStore } from '../piChatEvent-BsMp3MSo.js';
-import { A as AgentCoreSessionService, a as AgentEffectAdmission } from '../piChatSessionService-BrPqKrpY.js';
-export { b as AGENT_EFFECT_METHODS, c as AgentEffectAdmissionError, P as PiChatEventStreamResult, d as PiChatEventStreamSubscription, e as PiChatEventSubscriber, f as PiChatReplayRangeError, g as PiChatSessionService, h as PiSessionCreateInit, i as PiSessionRequestContext, w as withAgentEffectAdmission } from '../piChatSessionService-BrPqKrpY.js';
+import { A as AgentCoreSessionService, a as AgentEffectAdmission } from '../piChatSessionService-C0KbcGw9.js';
+export { b as AGENT_EFFECT_METHODS, c as AgentEffectAdmissionError, P as PiChatEventStreamResult, d as PiChatEventStreamSubscription, e as PiChatEventSubscriber, f as PiChatReplayRangeError, g as PiChatSessionService, h as PiSessionCreateInit, i as PiSessionRequestContext, w as withAgentEffectAdmission } from '../piChatSessionService-C0KbcGw9.js';
 import '@mariozechner/pi-coding-agent';
 import 'zod';
 

package/dist/core/index.js

@@ -3,7 +3,7 @@ import {
   AgentEffectAdmissionError,
   createAgent,
   withAgentEffectAdmission
-} from "../chunk-CJ2BW2W2.js";
+} from "../chunk-EOMY2HDT.js";
 import {
   AGENT_NOT_IMPLEMENTED_UNTIL_T1,
   AgentNotImplementedError

package/dist/{errors-C38f6pol.d.ts → errors-G6T6S7PQ.d.ts}

@@ -101,6 +101,8 @@ interface AgentPromptCommand {
     readonly clientNonce: string;
     readonly content: string;
     readonly displayContent?: string;
+    /** Require an actually idle Pi session; busy is a retryable admission result. */
+    readonly requireIdle?: true;
     readonly model?: ChatModelSelection;
     readonly thinkingLevel?: ThinkingLevel;
     readonly attachments?: readonly ChatAttachmentPayload[];