agent-tempo 1.4.1 → 1.4.2

package/dashboard/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-tempo-dashboard",
   "private": true,
-  "version": "1.4.1",
+  "version": "1.4.2",
   "type": "module",
   "description": "Web dashboard for agent-tempo. Bundled into the npm package; served by the daemon at /dashboard/*.",
   "scripts": {

package/dist/client/core.js

@@ -741,6 +741,24 @@ function createTempoClientCore(client, opts = {}) {
                 entryId,
             };
         },
+        async reset(ensemble, playerId, reason) {
+            // H5b: HTTP-route counterpart to the `reset` MCP tool (D14). Enqueues the
+            // SAME `'reset'` outbox entry on the maestro outbox — no new wire. D14:
+            // reset is clean-wipe only (always `fresh: true`); `invokerPlayerId:
+            // 'maestro'` is the operator identity, surfaced to the wiped session as
+            // `requestedBy`. The caller (HTTP handler) ensures the maestro exists.
+            const maestroId = (0, config_1.sessionWorkflowId)(ensemble, 'maestro');
+            const h = handle(maestroId);
+            const entry = {
+                type: 'reset',
+                targetPlayerId: playerId,
+                invokerPlayerId: 'maestro',
+                fresh: true,
+                ...(reason !== undefined ? { reason } : {}),
+            };
+            const entryId = await h.executeUpdate(signals_1.submitOutboxUpdate, { args: [entry] });
+            return { playerId, entryId };
+        },
         async detach(ensemble, playerId, deadlineMs = 5_000) {
             const maestroId = (0, config_1.sessionWorkflowId)(ensemble, 'maestro');
             const h = handle(maestroId);

package/dist/client/interface.d.ts

@@ -97,6 +97,12 @@ export interface RestartClientResult {
     /** Outbox entry id; callers can poll `submitOutbox` history or `outboxQuery` for status. */
     entryId: string;
 }
+export interface ResetClientResult {
+    /** Player the reset (clean-wipe) was queued for. */
+    playerId: string;
+    /** Outbox entry id; callers can poll `submitOutbox` history or `outboxQuery` for status. */
+    entryId: string;
+}
 /** Per-target outcome returned by `shutdown`. */
 export interface EnsembleShutdownDetail {
     playerId: string;
@@ -294,6 +300,15 @@ export interface TempoClientCore {
     release(ensemble: string, playerId?: string): Promise<ReleaseClientResult>;
     /** PR-D: Restart a player — §8.2 algorithm. Works on any non-`gone` phase. */
     restart(ensemble: string, playerId: string, opts?: RestartClientOpts): Promise<RestartClientResult>;
+    /**
+     * H5b: Clean-wipe a player's conversation context (D14 reset) via the maestro
+     * outbox — the HTTP-route counterpart to the `reset` MCP tool. Always
+     * `fresh: true`; the operator identity (`invokerPlayerId: 'maestro'`) is
+     * surfaced to the wiped session. Reuses the existing reset machinery — no new
+     * wire. The caller must ensure the maestro session exists first (the daemon
+     * HTTP handler does, mirroring `cue`).
+     */
+    reset(ensemble: string, playerId: string, reason?: string): Promise<ResetClientResult>;
     /** PR-D: Gracefully detach a player's adapter. Workflow survives in `detached`. */
     detach(ensemble: string, playerId: string, deadlineMs?: number): Promise<void>;
     /**

package/dist/http/writes.d.ts

@@ -42,7 +42,7 @@ export { WRITE_BODY_MAX };
  *   mutations. Bodies are uniform `{ playerId, reason? }` (plus per-action
  *   extras); the ensemble lives in the URL.
  */
-export declare const WRITE_ACTIONS: readonly ["cue", "pause", "play", "release", "recruit", "restart", "destroy", "detach", "recall"];
+export declare const WRITE_ACTIONS: readonly ["cue", "pause", "play", "release", "recruit", "restart", "reset", "destroy", "detach", "recall"];
 export type WriteAction = (typeof WRITE_ACTIONS)[number];
 /** Type guard — narrows an arbitrary string to a known `WriteAction`. */
 export declare function isWriteAction(s: string): s is WriteAction;

package/dist/http/writes.js

@@ -26,6 +26,7 @@ exports.WRITE_ACTIONS = [
     'release',
     'recruit',
     'restart',
+    'reset',
     'destroy',
     'detach',
     'recall',
@@ -62,6 +63,7 @@ async function handleWriteRoute(req, res, client, ensemble, action) {
             case 'release': return await handleRelease(res, client, ensemble, body);
             case 'recruit': return await handleRecruit(res, client, ensemble, body);
             case 'restart': return await handleRestart(res, client, ensemble, body);
+            case 'reset': return await handleReset(res, client, ensemble, body);
             case 'destroy': return await handleDestroy(res, client, ensemble, body);
             case 'detach': return await handleDetach(res, client, ensemble, body);
             case 'recall': return await handleRecall(res, client, ensemble, body);
@@ -169,6 +171,18 @@ async function handleRestart(res, client, ensemble, body) {
     const result = await client.restart(ensemble, playerId);
     (0, responses_1.jsonResponse)(res, 202, result);
 }
+async function handleReset(res, client, ensemble, body) {
+    const playerId = (0, body_1.requirePlayerId)(res, body);
+    if (!playerId)
+        return;
+    const reason = (0, body_1.stringField)(body, 'reason');
+    // Reset (D14 clean-wipe) enqueues on the maestro outbox — ensure the maestro
+    // exists first (like `cue`) so a reset before it's up doesn't 500. Idempotent
+    // (USE_EXISTING). 202 + the queued entry id, mirroring `restart`.
+    await client.ensureMaestroSession(ensemble);
+    const result = await client.reset(ensemble, playerId, reason);
+    (0, responses_1.jsonResponse)(res, 202, result);
+}
 async function handleDestroy(res, client, ensemble, body) {
     const playerId = (0, body_1.requirePlayerId)(res, body);
     if (!playerId)

package/dist/pi/mission-control/actions.d.ts

@@ -42,6 +42,7 @@ export declare class MissionControlActions {
     play(release?: boolean): Promise<ActionResult>;
     restart(playerId: string, reason?: string): Promise<ActionResult>;
     destroy(playerId: string, reason?: string): Promise<ActionResult>;
+    reset(playerId: string, reason?: string): Promise<ActionResult>;
     gateArm(playerId: string): Promise<ActionResult>;
     gateDisarm(playerId: string): Promise<ActionResult>;
     gateDecide(playerId: string, requestId: string, decision: 'allow' | 'deny'): Promise<ActionResult>;

package/dist/pi/mission-control/actions.js

@@ -84,6 +84,9 @@ class MissionControlActions {
     destroy(playerId, reason) {
         return this.post(`/v1/ensembles/${this.ens()}/destroy`, { playerId, ...(reason ? { reason } : {}) });
     }
+    reset(playerId, reason) {
+        return this.post(`/v1/ensembles/${this.ens()}/reset`, { playerId, ...(reason ? { reason } : {}) });
+    }
     // ── Operator gate plane (T3) ──
     gateArm(playerId) {
         return this.post(`/v1/players/${this.player(playerId)}/gate-arm`, {});

package/dist/pi/mission-control/extension.js

@@ -161,15 +161,13 @@ class Controller {
         this.report(ctx, `destroy ${p}`, await this.actions.destroy(p, reason || undefined));
     }
     async cmdReset(args, ctx) {
-        const p = args.trim();
+        // H5b: real POST /v1/ensembles/:e/reset (D14 clean-wipe) — mirrors cmdRestart.
+        const [p, reason] = Controller.splitFirst(args);
         if (!p) {
-            this.notify(ctx, 'Usage: /reset <player>');
+            this.notify(ctx, 'Usage: /reset <player> [reason]');
             return;
         }
-        // D14 reset has NO daemon HTTP route yet (MCP/outbox only). Surface clearly
-        // rather than silently fail. Wiring a POST /v1/ensembles/:e/reset is a daemon
-        // follow-up (flagged to the conductor).
-        this.notify(ctx, `reset ${p}: not available over the daemon HTTP surface yet (MCP/outbox only). Flagged for a daemon route.`);
+        this.report(ctx, `reset ${p}`, await this.actions.reset(p, reason || undefined));
     }
     async cmdArm(args, ctx) {
         const [p, mode] = Controller.splitFirst(args);
@@ -320,7 +318,7 @@ function createMissionControlExtension(deps = {}) {
         pi.registerCommand('play', { description: 'Resume the ensemble (/play [release])', handler: (a, ctx) => ctrl.cmdPlay(a, ctx) });
         pi.registerCommand('restart', { description: 'Restart a player (/restart <player> [reason])', handler: (a, ctx) => ctrl.cmdRestart(a, ctx) });
         pi.registerCommand('destroy', { description: 'Destroy a player (/destroy <player> [reason])', handler: (a, ctx) => ctrl.cmdDestroy(a, ctx) });
-        pi.registerCommand('reset', { description: 'Clean-wipe a player (/reset <player>)', handler: (a, ctx) => ctrl.cmdReset(a, ctx) });
+        pi.registerCommand('reset', { description: 'Clean-wipe a player (/reset <player> [reason])', handler: (a, ctx) => ctrl.cmdReset(a, ctx) });
         pi.registerCommand('arm', { description: 'Arm/disarm the operator gate for a player (/arm <player> [off])', handler: (a, ctx) => ctrl.cmdArm(a, ctx) });
         pi.registerCommand('gate', { description: 'Decide a gate request for the tailed player (/gate <reqId> allow|deny)', handler: (a, ctx) => ctrl.cmdGate(a, ctx) });
     };

package/dist/pi/pi-types.d.ts

@@ -179,14 +179,25 @@ export interface PiToolCallResult {
     reason?: string;
 }
 /**
- * Pi tool result (`AgentToolResult`). The exact streaming shape is UNCONFIRMED
- * (spike gap D12b) — Phase 0 uses the minimal `{ output, isError }` form, which
- * is sufficient for a non-streaming tool like `report`.
+ * Pi tool result — a Pi-free structural mirror of the real `AgentToolResult`
+ * (#653, 1.4.2). The Phase-0 `{ output, isError }` guess was WRONG: Pi's real
+ * `AgentToolResult` is `{ content: (TextContent|ImageContent)[]; details; terminate? }`
+ * (pi-agent-core types.d.ts:305), so `{ output, isError }` made every native
+ * agent-tempo tool result malformed for a Pi model (no `content[]` — the
+ * RESULT-shape mirror of #651's INPUT-shape bug).
+ *
+ * We only ever emit TEXT content. Errors are NOT content-encoded — they are
+ * THROWN from `execute` (Pi's sanctioned error path; the loop catches → sets
+ * isError + folds the message into content). So this success-shape carries no
+ * error flag. See `toPiResult` / `renderToPi` in render-tools.ts.
  */
 export interface PiToolResult {
-    output?: string;
-    isError?: boolean;
-    [key: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    details: Record<string, unknown>;
+    terminate?: boolean;
 }
 /**
  * Pi native tool definition. `parameters` is a TypeBox schema (NOT zod) — see

package/dist/pi/render-tools.d.ts

@@ -1,11 +1,11 @@
 import type { TempoToolDescriptor, TempoToolResult } from '../tools/descriptor';
 import type { ExtensionAPI, PiToolResult } from './pi-types';
 /**
- * Map a neutral {@link TempoToolResult} onto Pi's `AgentToolResult` shape.
- *
- * Phase 0 confirmed Pi's result is `{ output, isError }` for a non-streaming
- * tool (D12). The neutral `{ text, isError? }` maps directly: `text → output`,
- * `isError` passes through.
+ * Map a SUCCESSFUL neutral {@link TempoToolResult} onto Pi's `AgentToolResult`
+ * shape (#653, 1.4.2): the text becomes a single text-content block. ERRORS are
+ * NOT mapped here — they are thrown from `execute` (Pi's sanctioned error path),
+ * so callers must check `r.isError` BEFORE calling this. `details` is an empty
+ * object (we surface no structured details); `terminate` is left unset.
  */
 export declare function toPiResult(r: TempoToolResult): PiToolResult;
 /**

package/dist/pi/render-tools.js

@@ -24,14 +24,14 @@ exports.renderToPi = renderToPi;
  */
 const zod_to_typebox_1 = require("./zod-to-typebox");
 /**
- * Map a neutral {@link TempoToolResult} onto Pi's `AgentToolResult` shape.
- *
- * Phase 0 confirmed Pi's result is `{ output, isError }` for a non-streaming
- * tool (D12). The neutral `{ text, isError? }` maps directly: `text → output`,
- * `isError` passes through.
+ * Map a SUCCESSFUL neutral {@link TempoToolResult} onto Pi's `AgentToolResult`
+ * shape (#653, 1.4.2): the text becomes a single text-content block. ERRORS are
+ * NOT mapped here — they are thrown from `execute` (Pi's sanctioned error path),
+ * so callers must check `r.isError` BEFORE calling this. `details` is an empty
+ * object (we surface no structured details); `terminate` is left unset.
  */
 function toPiResult(r) {
-    return r.isError ? { output: r.text, isError: true } : { output: r.text };
+    return { content: [{ type: 'text', text: r.text }], details: {} };
 }
 /**
  * Register every descriptor onto the Pi extension API. The TypeBox schema is
@@ -50,7 +50,16 @@ function renderToPi(pi, descriptors) {
             // toolCallId string (1st) and hand `params` to the descriptor handler.
             // (Passing the 1st positional was the v1.4.0 arg-order bug: handlers got the
             // toolCallId string instead of params.) See PiToolDefinition.execute.
-            execute: async (_toolCallId, params) => toPiResult(await d.handler(params)),
+            execute: async (_toolCallId, params) => {
+                const r = await d.handler(params);
+                // Pi's sanctioned error path (#653): THROW on failure — the agent loop
+                // catches it → createErrorToolResult (message → content) + isError:true.
+                // Content-encoding an error WITHOUT throwing would make the model think
+                // the tool SUCCEEDED (Pi types.d.ts:327). So errors never reach toPiResult.
+                if (r.isError)
+                    throw new Error(r.text);
+                return toPiResult(r);
+            },
         });
     }
 }

package/dist/tui/index.js

@@ -118,6 +118,7 @@ function createDummyClient() {
         recruit: fail,
         release: fail,
         restart: fail,
+        reset: fail,
         detach: fail,
         destroy: fail,
         migrate: fail,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-tempo",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Many agents, one tempo. Durable coordination for multi-agent work via Temporal.",
   "keywords": [
     "mcp",