appostle-installer 0.0.20 → 0.0.21

package/dist/worker.js

@@ -4239,6 +4239,7 @@ var GoogleFontsDownloadResponseSchema = z10.object({
 });
 
 // ../server/src/shared/messages.ts
+var InitialAgentSnapshotPageLimit = 200;
 var MutableDaemonConfigSchema = z11.object({
   mcp: z11.object({
     injectIntoAgents: z11.boolean()
@@ -6731,6 +6732,17 @@ var FetchAgentsResponseMessageSchema = z11.object({
     })
   })
 });
+var InitialAgentSnapshotMessageSchema = z11.object({
+  type: z11.literal("initial_agent_snapshot"),
+  payload: z11.object({
+    entries: z11.array(
+      z11.object({
+        agent: AgentSnapshotPayloadSchema,
+        project: ProjectPlacementPayloadSchema
+      })
+    )
+  })
+});
 var FetchWorkspacesResponseMessageSchema = z11.object({
   type: z11.literal("fetch_workspaces_response"),
   payload: z11.object({
@@ -7772,6 +7784,7 @@ var SessionOutboundMessageSchema = z11.discriminatedUnion("type", [
   AgentStreamMessageSchema,
   AgentStatusMessageSchema,
   FetchAgentsResponseMessageSchema,
+  InitialAgentSnapshotMessageSchema,
   FetchWorkspacesResponseMessageSchema,
   OpenProjectResponseMessageSchema,
   StartWorkspaceScriptResponseMessageSchema,
@@ -33602,7 +33615,7 @@ function serializeFrontmatter(input) {
 
 // ../server/src/server/agent/handoff-mcp.ts
 function buildHandoffMcpServer(callerAgentId, options) {
-  const { agentManager, appostleHome, logger } = options;
+  const { agentManager, appostleHome, logger, agentStorage } = options;
   const log = logger.child({ module: "handoff-mcp", callerAgentId });
   const handoffTool = tool2(
     "handoff",
@@ -33681,6 +33694,22 @@ function buildHandoffMcpServer(callerAgentId, options) {
       } catch (err) {
         log.error({ err, agentId: snapshot.id }, "handoff: failed to start run");
       }
+      if (agentStorage) {
+        try {
+          setupFinishNotification({
+            agentManager,
+            agentStorage,
+            childAgentId: snapshot.id,
+            callerAgentId,
+            logger: log
+          });
+        } catch (err) {
+          log.error(
+            { err, agentId: snapshot.id },
+            "handoff: failed to wire auto-return notification"
+          );
+        }
+      }
       return {
         content: [
           {
@@ -33691,11 +33720,97 @@ function buildHandoffMcpServer(callerAgentId, options) {
       };
     }
   );
+  const reportTool = tool2(
+    "report",
+    [
+      "Send a curated message from this handoff child session back to its parent.",
+      "Use this when the user types `>report` \u2014 they want to deliver a specific update",
+      "to the parent right now, in their own words.",
+      "",
+      "Independent of the automatic on-finish notification: the parent still receives",
+      "the auto-return when this child eventually finishes. You can call this tool any",
+      "number of times over the lifetime of the handoff \u2014 each call is a separate",
+      "update.",
+      "",
+      "Only works in sessions that were spawned via `handoff`. Errors otherwise."
+    ].join("\n"),
+    {
+      message: z33.string().min(1).describe(
+        "The curated report to deliver to the parent session. Self-contained: the parent does not see this conversation's timeline."
+      )
+    },
+    async (args) => {
+      const childAgent = agentManager.getAgent(callerAgentId);
+      if (!childAgent) {
+        return {
+          isError: true,
+          content: [
+            { type: "text", text: `Caller agent ${callerAgentId} not found in agent manager` }
+          ]
+        };
+      }
+      const parentAgentId = childAgent.labels?.["appostle.parent-agent-id"];
+      if (!parentAgentId) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: "This session was not spawned via `handoff`, so there is no parent to report to."
+            }
+          ]
+        };
+      }
+      const parentAgent = agentManager.getAgent(parentAgentId);
+      if (!parentAgent) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Parent agent ${parentAgentId} is no longer available.`
+            }
+          ]
+        };
+      }
+      const childTitle = childAgent.config?.title ?? callerAgentId;
+      const trimmedMessage = args.message.trim();
+      const prompt = `<appostle-system>
+Agent ${callerAgentId} (${childTitle}) reported back:
+
+${trimmedMessage}
+</appostle-system>`;
+      try {
+        startAgentRun(agentManager, parentAgentId, prompt, log, {
+          replaceRunning: true
+        });
+      } catch (err) {
+        log.error({ err, parentAgentId }, "report: failed to inject prompt into parent");
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `report failed: could not wake parent \u2014 ${err instanceof Error ? err.message : String(err)}`
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Reported to parent ${parentAgentId}.`
+          }
+        ]
+      };
+    }
+  );
   const writePlanTool = buildWritePlanTool(callerAgentId, { agentManager, logger });
   const sdkInstance = createSdkMcpServer({
     name: "appostle",
     version: "0.1.0",
-    tools: [handoffTool, writePlanTool],
+    tools: [handoffTool, reportTool, writePlanTool],
     alwaysLoad: true
   });
   return {
@@ -34256,7 +34371,8 @@ var AgentManager = class {
       mcpServers.appostle = buildHandoffMcpServer(agentId, {
         agentManager: this,
         appostleHome: this.appostleHome,
-        logger: this.logger
+        logger: this.logger,
+        agentStorage: this.registry
       });
     }
     return { ...config, mcpServers };
@@ -42563,9 +42679,35 @@ var Session = class _Session {
     this.emit(message);
   }
   /**
-   * Send initial state to client after connection
+   * Push the first page of the agent directory unsolicited right after
+   * `server_info` so the client can paint attention state before its own
+   * paginated `fetch_agents_request` round-trip lands. The regular fetch
+   * still runs in parallel — it establishes the live-update subscription
+   * and paginates beyond the first page. This push exists purely to shave
+   * one relay round-trip from time-to-first-paint.
+   *
+   * Errors are swallowed: a failed push degrades to "wait for the client
+   * to ask," which is still correct.
    */
   async sendInitialState() {
+    try {
+      const synthetic = {
+        type: "fetch_agents_request",
+        requestId: "internal:initial-snapshot",
+        filter: { includeArchived: true },
+        page: { limit: InitialAgentSnapshotPageLimit }
+      };
+      const { entries } = await this.listFetchAgentsEntries(synthetic);
+      this.emit({
+        type: "initial_agent_snapshot",
+        payload: { entries }
+      });
+    } catch (error) {
+      this.sessionLogger.warn(
+        { err: error },
+        "Failed to push initial agent snapshot \u2014 client will fall back to fetch_agents_request"
+      );
+    }
   }
   /**
    * Normalize a user prompt (with optional image metadata) for AgentManager
@@ -52961,6 +53103,7 @@ var VoiceAssistantWebSocketServer = class {
     this.sessions.set(ws, connection);
     this.externalSessionsByKey.set(clientId, connection);
     this.sendToClient(ws, this.createServerInfoMessage());
+    void connection.session.sendInitialState();
     connection.connectionLogger.trace(
       {
         clientId,