@moxxy/sdk 0.44.0 → 0.45.0

package/dist/workflow-approval.d.ts

@@ -19,7 +19,7 @@ export interface WorkflowApprovalsView {
     revoke(id: string): Promise<void>;
     cancel(id: string): Promise<void>;
 }
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export declare const workflowApprovalItemSchema: z.ZodEffects<z.ZodObject<{
     id: z.ZodString;
     workflowId: z.ZodString;
@@ -34,7 +34,7 @@ export declare const workflowApprovalItemSchema: z.ZodEffects<z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -45,7 +45,7 @@ export declare const workflowApprovalItemSchema: z.ZodEffects<z.ZodObject<{
 }, {
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -57,7 +57,7 @@ export declare const workflowApprovalItemSchema: z.ZodEffects<z.ZodObject<{
     input: unknown;
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -67,7 +67,7 @@ export declare const workflowApprovalItemSchema: z.ZodEffects<z.ZodObject<{
 }, {
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -90,7 +90,7 @@ export declare const workflowApprovalItemsSchema: z.ZodArray<z.ZodEffects<z.ZodO
 }, "strict", z.ZodTypeAny, {
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -101,7 +101,7 @@ export declare const workflowApprovalItemsSchema: z.ZodArray<z.ZodEffects<z.ZodO
 }, {
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -113,7 +113,7 @@ export declare const workflowApprovalItemsSchema: z.ZodArray<z.ZodEffects<z.ZodO
     input: unknown;
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;
@@ -123,7 +123,7 @@ export declare const workflowApprovalItemsSchema: z.ZodArray<z.ZodEffects<z.ZodO
 }, {
     tool: string;
     id: string;
-    status: "denied" | "pending" | "allowed" | "cancelled" | "interrupted" | "revoked";
+    status: "denied" | "pending" | "cancelled" | "allowed" | "interrupted" | "revoked";
     workflowId: string;
     workflowName: string;
     revision: string;

package/dist/workflow-approval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-approval.d.ts","sourceRoot":"","sources":["../src/workflow-approval.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,sBAAsB,GAAG,YAAY,GAAG,cAAc,GAAG,MAAM,CAAC;AAC5E,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;IAC5F,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAAC;IACrD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AACD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAciB,CAAC;AACzD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAsC,CAAC"}
+{"version":3,"file":"workflow-approval.d.ts","sourceRoot":"","sources":["../src/workflow-approval.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,sBAAsB,GAAG,YAAY,GAAG,cAAc,GAAG,MAAM,CAAC;AAC5E,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;IAC5F,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAAC;IACrD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AACD,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAciB,CAAC;AACzD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAsC,CAAC"}

package/dist/workflow-approval.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v3';
 export const workflowApprovalItemSchema = z
     .object({
     id: z.string().uuid(),

package/dist/workflow-approval.js.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-approval.js","sourceRoot":"","sources":["../src/workflow-approval.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE;IACrB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACzC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;IACvF,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;CAClE,CAAC;KACD,MAAM,EAAE;KACR,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACzD,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC"}
+{"version":3,"file":"workflow-approval.js","sourceRoot":"","sources":["../src/workflow-approval.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE;IACrB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACzC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;IACvF,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;CAClE,CAAC;KACD,MAAM,EAAE;KACR,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AACzD,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxxy/sdk",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Typed public surface for the moxxy framework: event types, define* factories, lifecycle hook signatures.",
   "keywords": [
     "moxxy",
@@ -53,6 +53,30 @@
       "types": "./dist/tool-display.d.ts",
       "import": "./dist/tool-display.js"
     },
+    "./agent-account-limit": {
+      "types": "./dist/agent-account-limit.d.ts",
+      "import": "./dist/agent-account-limit.js"
+    },
+    "./agent-no-reply": {
+      "types": "./dist/agent-no-reply.d.ts",
+      "import": "./dist/agent-no-reply.js"
+    },
+    "./starting-model": {
+      "types": "./dist/starting-model.d.ts",
+      "import": "./dist/starting-model.js"
+    },
+    "./agent-work": {
+      "types": "./dist/agent-work.d.ts",
+      "import": "./dist/agent-work.js"
+    },
+    "./cron": {
+      "types": "./dist/cron.d.ts",
+      "import": "./dist/cron.js"
+    },
+    "./agent-computer-use": {
+      "types": "./dist/agent-computer-use.d.ts",
+      "import": "./dist/agent-computer-use.js"
+    },
     "./attachment-payload": {
       "types": "./dist/attachment-payload.d.ts",
       "import": "./dist/attachment-payload.js"
@@ -68,6 +92,10 @@
     "./transcriber": {
       "types": "./dist/transcriber.d.ts",
       "import": "./dist/transcriber.js"
+    },
+    "./questions": {
+      "types": "./dist/questions.d.ts",
+      "import": "./dist/questions.js"
     }
   },
   "files": [
@@ -79,14 +107,14 @@
     "access": "public"
   },
   "peerDependencies": {
-    "zod": "^3.25.76",
-    "undici": "^8.11.2"
+    "zod": "^4.6.6",
+    "undici": "^8.12.2"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "undici": "^8.11.2",
+    "undici": "^8.12.2",
     "vitest": "^5.0.3",
-    "zod": "^3.25.76",
+    "zod": "^4.6.6",
     "@moxxy/tsconfig": "0.0.0",
     "@moxxy/vitest-preset": "0.0.0"
   },

package/src/agent-account-limit.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import {
+  AGENT_ACCOUNT_LIMIT_SUBTYPE,
+  accountLimitInForce,
+  accountLimitOfEvent,
+  recordedAccountLimit,
+  sameAccountLimit,
+  withKnownReset,
+  type AgentAccountLimit,
+} from './agent-account-limit.js';
+import { AGENT_CONNECTION_PLUGIN_ID } from './agent-step.js';
+import type { MoxxyEvent } from './events.js';
+
+function recorded(provider: string, limit: AgentAccountLimit, agent?: string): MoxxyEvent {
+  return {
+    type: 'plugin_event',
+    pluginId: AGENT_CONNECTION_PLUGIN_ID,
+    subtype: AGENT_ACCOUNT_LIMIT_SUBTYPE,
+    payload: { provider, ...(agent ? { agent } : {}), limit },
+  } as unknown as MoxxyEvent;
+}
+
+const HOUR = 3_600_000;
+
+describe('recordedAccountLimit', () => {
+  it('reads the last limit recorded for the provider', () => {
+    const events = [
+      recorded('claude-agent', { state: 'near', usedPercent: 80 }),
+      recorded('codex-agent', { state: 'ok', usedPercent: 10 }),
+      recorded('claude-agent', { state: 'reached', resetsAt: 5 * HOUR }),
+    ];
+    expect(recordedAccountLimit(events, 'claude-agent')).toEqual({ provider: 'claude-agent', limit: { state: 'reached', resetsAt: 5 * HOUR } });
+    expect(recordedAccountLimit(events, 'codex-agent')).toEqual({ provider: 'codex-agent', limit: { state: 'ok', usedPercent: 10 } });
+    expect(recordedAccountLimit(events, 'opencode')).toBeUndefined();
+  });
+});
+
+describe('accountLimitOfEvent', () => {
+  it('reads the limit and whose it is from the event that records it, and nothing from any other', () => {
+    expect(accountLimitOfEvent(recorded('claude-agent', { state: 'reached' }, 'Claude'))).toEqual({
+      provider: 'claude-agent',
+      agent: 'Claude',
+      limit: { state: 'reached' },
+    });
+    expect(accountLimitOfEvent({ type: 'plugin_event', pluginId: AGENT_CONNECTION_PLUGIN_ID, subtype: 'goal_status', payload: {} } as unknown as MoxxyEvent)).toBeUndefined();
+  });
+});
+
+describe('accountLimitInForce', () => {
+  it('holds a reached or near limit until its window resets', () => {
+    const reached = { provider: 'claude-agent', limit: { state: 'reached', resetsAt: 5 * HOUR } } as const;
+    expect(accountLimitInForce(reached, 4 * HOUR)).toBe(reached);
+    expect(accountLimitInForce(reached, 5 * HOUR)).toBeUndefined();
+    const near = { provider: 'claude-agent', limit: { state: 'near', usedPercent: 92 } } as const;
+    expect(accountLimitInForce(near, 4 * HOUR)).toBe(near);
+  });
+
+  it('says nothing about a limit with room left', () => {
+    expect(accountLimitInForce({ provider: 'codex-agent', limit: { state: 'ok', usedPercent: 10 } }, 0)).toBeUndefined();
+    expect(accountLimitInForce(undefined, 0)).toBeUndefined();
+  });
+});
+
+describe('sameAccountLimit', () => {
+  it('ignores what a person would not see change: a fraction of a percent, seconds of the reset', () => {
+    const limit: AgentAccountLimit = { state: 'near', usedPercent: 91.2, resetsAt: 5 * HOUR, windowMinutes: 10080 };
+    expect(sameAccountLimit(limit, { ...limit, usedPercent: 91.4, resetsAt: 5 * HOUR + 20_000 })).toBe(true);
+    expect(sameAccountLimit(limit, { ...limit, usedPercent: 92 })).toBe(false);
+    expect(sameAccountLimit(limit, { ...limit, state: 'reached' })).toBe(false);
+    expect(sameAccountLimit(undefined, limit)).toBe(false);
+  });
+});
+
+describe('a used-up limit reported without its reset', () => {
+  const now = 1_000_000;
+  const weekly = { state: 'reached', windowMinutes: 10080, resetsAt: now + 60_000 } as const;
+
+  it('keeps the reset known before while it lies ahead', () => {
+    expect(withKnownReset({ state: 'reached' }, weekly, now)).toEqual(weekly);
+  });
+
+  it('stays as the agent said once that reset has passed, or when the agent gave its own', () => {
+    expect(withKnownReset({ state: 'reached' }, weekly, now + 120_000)).toEqual({ state: 'reached' });
+    expect(withKnownReset({ state: 'reached', resetsAt: now + 5 }, weekly, now)).toEqual({ state: 'reached', resetsAt: now + 5 });
+    expect(withKnownReset({ state: 'near', usedPercent: 80 }, weekly, now)).toEqual({ state: 'near', usedPercent: 80 });
+  });
+});

package/src/agent-account-limit.ts

@@ -0,0 +1,89 @@
+import { AGENT_CONNECTION_PLUGIN_ID } from './agent-step.js';
+import type { MoxxyEvent } from './events.js';
+
+/**
+ * How much of the person's account an agent connection's agent may still use, as the agent
+ * reports it (Claude's plan limits, Codex's rate limits). Recorded in the log, so every surface
+ * reads the same state.
+ */
+export interface AgentAccountLimit {
+  /** `reached`: the agent does no work until `resetsAt`; `near`: most of the window is used. */
+  readonly state: 'ok' | 'near' | 'reached';
+  /** When the window resets, in epoch ms, when the agent says. */
+  readonly resetsAt?: number;
+  /** The window's length in minutes: 300 for five hours, 10080 for a week. */
+  readonly windowMinutes?: number;
+  /** How much of the window is used, 0–100. */
+  readonly usedPercent?: number;
+}
+
+/** From how much of a window a limit counts as near, for an agent that does not say so itself (Claude warns from 75%). */
+export const ACCOUNT_LIMIT_NEAR_PERCENT = 75;
+
+/** Where an agent connection records its agent's account limit, under `AGENT_CONNECTION_PLUGIN_ID`. */
+export const AGENT_ACCOUNT_LIMIT_SUBTYPE = 'account_limit';
+
+export interface RecordedAccountLimit {
+  readonly provider: string;
+  /** The agent's name ("Claude", "Codex"), for the surfaces to say whose limit it is. */
+  readonly agent?: string;
+  readonly limit: AgentAccountLimit;
+}
+
+/** The last account limit recorded for the provider. */
+export function recordedAccountLimit(events: ReadonlyArray<MoxxyEvent>, provider: string): RecordedAccountLimit | undefined {
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const event = events[i];
+    if (!event || event.type !== 'plugin_event') continue;
+    if (event.pluginId !== AGENT_CONNECTION_PLUGIN_ID || event.subtype !== AGENT_ACCOUNT_LIMIT_SUBTYPE) continue;
+    const payload = event.payload as Partial<RecordedAccountLimit> | null;
+    if (payload && payload.provider === provider && payload.limit) return accountLimitPayload(payload);
+  }
+  return undefined;
+}
+
+/** The limit a plugin event records, or undefined when it records something else. */
+export function accountLimitOfEvent(event: MoxxyEvent): RecordedAccountLimit | undefined {
+  if (event.type !== 'plugin_event' || event.pluginId !== AGENT_CONNECTION_PLUGIN_ID || event.subtype !== AGENT_ACCOUNT_LIMIT_SUBTYPE) return undefined;
+  const payload = event.payload as Partial<RecordedAccountLimit> | null;
+  return payload && typeof payload.provider === 'string' && payload.limit ? accountLimitPayload(payload) : undefined;
+}
+
+function accountLimitPayload(payload: Partial<RecordedAccountLimit>): RecordedAccountLimit {
+  return {
+    provider: String(payload.provider),
+    ...(typeof payload.agent === 'string' ? { agent: payload.agent } : {}),
+    limit: payload.limit as AgentAccountLimit,
+  };
+}
+
+/** A near or reached limit, until its window resets; a limit with room left says nothing. */
+export function accountLimitInForce(recorded: RecordedAccountLimit | undefined, nowMs: number): RecordedAccountLimit | undefined {
+  if (!recorded || recorded.limit.state === 'ok') return undefined;
+  const { resetsAt } = recorded.limit;
+  return resetsAt !== undefined && resetsAt <= nowMs ? undefined : recorded;
+}
+
+/** Whether two reports would read the same to the person: whole percents, the reset to the minute. */
+export function sameAccountLimit(a: AgentAccountLimit | undefined, b: AgentAccountLimit): boolean {
+  if (!a) return false;
+  const minute = (ms: number | undefined) => (ms === undefined ? undefined : Math.round(ms / 60_000));
+  const percent = (p: number | undefined) => (p === undefined ? undefined : Math.floor(p));
+  return (
+    a.state === b.state &&
+    a.windowMinutes === b.windowMinutes &&
+    minute(a.resetsAt) === minute(b.resetsAt) &&
+    percent(a.usedPercent) === percent(b.usedPercent)
+  );
+}
+
+/**
+ * A used-up limit the agent reports without its reset (Claude Code's own
+ * "You've hit your limit" when its process already said when it resets) keeps
+ * the reset known before, while that still lies ahead.
+ */
+export function withKnownReset(reading: AgentAccountLimit, known: AgentAccountLimit | undefined, nowMs: number): AgentAccountLimit {
+  if (reading.state !== 'reached' || reading.resetsAt !== undefined) return reading;
+  if (!known || known.resetsAt === undefined || known.resetsAt <= nowMs) return reading;
+  return { ...reading, resetsAt: known.resetsAt, ...(known.windowMinutes !== undefined && reading.windowMinutes === undefined ? { windowMinutes: known.windowMinutes } : {}) };
+}

package/src/agent-computer-use.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { agentComputerUseOf } from './agent-computer-use.js';
+
+describe("an agent's own tool call that controls the computer", () => {
+  it('is a call to a computer-use MCP server, with the app it names', () => {
+    expect(agentComputerUseOf('mcp__computer-use__click', { app: 'Arc', element_index: '185' })).toEqual({ app: 'Arc' });
+    expect(agentComputerUseOf('mcp__computer-use__list_apps', {})).toEqual({ app: null });
+    expect(agentComputerUseOf('mcp__computer_use__screenshot', { app: 'Safari' })).toEqual({ app: 'Safari' });
+    expect(agentComputerUseOf('computer-use_click', { app: 'Notes' })).toEqual({ app: 'Notes' });
+  });
+
+  it("is Codex's computer JavaScript, with the app the code opens", () => {
+    expect(agentComputerUseOf('mcp__cua_repl__js', { code: "const app = await cua.getApp('Electron'); await app.getAXState();" })).toEqual({ app: 'Electron' });
+    expect(agentComputerUseOf('mcp__cua_repl__js', { code: 'await cua.getState();' })).toEqual({ app: null });
+  });
+
+  it("is not Codex's own browser, which does not touch the person's apps", () => {
+    expect(agentComputerUseOf('mcp__cua_repl__js', { code: "const tab = await cua.createBrowserTab('https://example.com');" })).toBeUndefined();
+  });
+
+  it('is not any other tool', () => {
+    expect(agentComputerUseOf('Bash', { command: 'open -a Safari' })).toBeUndefined();
+    expect(agentComputerUseOf('mcp__docs__search', { app: 'Arc' })).toBeUndefined();
+    expect(agentComputerUseOf('computer_click', { app: 'Arc' })).toBeUndefined();
+  });
+});

package/src/agent-computer-use.ts

@@ -0,0 +1,29 @@
+/**
+ * Whether a tool call an agent connection ran itself operates the person's computer, recognised
+ * by the tool's name, so every surface can say the agent is using the computer and offer Stop.
+ */
+
+export interface AgentComputerUse {
+  /** The app the call names, `null` when it names none (listing apps, a screenshot of the screen). */
+  readonly app: string | null;
+}
+
+/**
+ * A computer-use MCP server's tools, which drive the person's apps: `mcp__computer-use__click` from
+ * Claude Code and Codex, `computer-use_click` from OpenCode (which names MCP tools `server_tool`).
+ */
+const COMPUTER_SERVERS = /^(?:mcp__)?computer[-_]use_/;
+/** Codex's computer use as JavaScript against its `cua` API; the same API also drives Codex's own browser. */
+const CUA_JS = 'mcp__cua_repl__js';
+const CUA_APPS = /\bcua\.(getApp|getState|listApps|listWindows)\s*\(/;
+const CUA_APP_NAME = /\bcua\.getApp\(\s*['"`]([^'"`]+)['"`]/;
+
+export function agentComputerUseOf(name: string, input: unknown): AgentComputerUse | undefined {
+  const fields = typeof input === 'object' && input !== null ? (input as Record<string, unknown>) : {};
+  if (COMPUTER_SERVERS.test(name)) {
+    return { app: typeof fields.app === 'string' && fields.app.length > 0 ? fields.app : null };
+  }
+  if (name !== CUA_JS || typeof fields.code !== 'string' || !CUA_APPS.test(fields.code)) return undefined;
+  const named = CUA_APP_NAME.exec(fields.code);
+  return { app: named && named[1] ? named[1] : null };
+}

package/src/agent-context-window.ts

@@ -0,0 +1,51 @@
+import { AGENT_CONNECTION_PLUGIN_ID } from './agent-step.js';
+import type { MoxxyEvent } from './events.js';
+import type { ModelDescriptor } from './provider.js';
+
+/**
+ * Where an agent connection records the context window its agent reports for a model
+ * (Codex's `modelContextWindow`, Claude's `modelUsage.contextWindow`), under
+ * `AGENT_CONNECTION_PLUGIN_ID`. It replaces the starting window from the model list,
+ * so every surface shows the window the agent really runs with.
+ */
+export const AGENT_CONTEXT_WINDOW_SUBTYPE = 'context_window';
+
+export interface RecordedContextWindow {
+  readonly provider: string;
+  readonly model: string;
+  readonly tokens: number;
+}
+
+export function isContextWindowSize(tokens: unknown): tokens is number {
+  return typeof tokens === 'number' && Number.isSafeInteger(tokens) && tokens > 0;
+}
+
+/** The window an event records, or undefined when it records something else. */
+export function contextWindowOfEvent(event: MoxxyEvent): RecordedContextWindow | undefined {
+  if (event.type !== 'plugin_event' || event.pluginId !== AGENT_CONNECTION_PLUGIN_ID || event.subtype !== AGENT_CONTEXT_WINDOW_SUBTYPE) return undefined;
+  const payload = event.payload as Partial<RecordedContextWindow> | null;
+  if (!payload || typeof payload.provider !== 'string' || typeof payload.model !== 'string' || !isContextWindowSize(payload.tokens)) return undefined;
+  return { provider: payload.provider, model: payload.model, tokens: payload.tokens };
+}
+
+/** The last window recorded for each model of the provider. */
+export function recordedContextWindows(events: ReadonlyArray<MoxxyEvent>, provider: string): ReadonlyMap<string, number> {
+  const windows = new Map<string, number>();
+  for (const event of events) {
+    const recorded = contextWindowOfEvent(event);
+    if (recorded && recorded.provider === provider) windows.set(recorded.model, recorded.tokens);
+  }
+  return windows;
+}
+
+/** The models with the windows the agent reported in place of their starting ones. */
+export function withRecordedContextWindows(
+  models: ReadonlyArray<ModelDescriptor>,
+  windows: ReadonlyMap<string, number>,
+): ReadonlyArray<ModelDescriptor> {
+  if (windows.size === 0) return models;
+  return models.map((model) => {
+    const tokens = windows.get(model.id);
+    return tokens === undefined || tokens === model.contextWindow ? model : { ...model, contextWindow: tokens };
+  });
+}

package/src/agent-no-reply.ts

@@ -0,0 +1,16 @@
+import { AGENT_CONNECTION_PLUGIN_ID } from './agent-step.js';
+import type { MoxxyEvent } from './events.js';
+
+/**
+ * Recorded under `AGENT_CONNECTION_PLUGIN_ID` at the end of a turn the agent took up by
+ * itself ("Agent continued") in which it said nothing and ran nothing, so every surface
+ * says so instead of leaving the turn's marker alone in the chat.
+ */
+export const AGENT_NO_REPLY_SUBTYPE = 'no_reply';
+
+/** How every surface words the note. */
+export const AGENT_NO_REPLY_TEXT = 'The agent finished without replying.';
+
+export function isAgentNoReplyEvent(event: MoxxyEvent): boolean {
+  return event.type === 'plugin_event' && event.pluginId === AGENT_CONNECTION_PLUGIN_ID && event.subtype === AGENT_NO_REPLY_SUBTYPE;
+}

package/src/agent-step.ts

@@ -0,0 +1,26 @@
+import type { MoxxyEvent } from './events.js';
+import { asPluginId } from './ids.js';
+
+/**
+ * Where an agent connection keeps the vendor agent's session in the log. The
+ * `agentStep` contract itself is part of the provider types (`provider.ts`).
+ */
+
+export const AGENT_CONNECTION_PLUGIN_ID = asPluginId('@moxxy/agent-connection');
+export const AGENT_SESSION_SUBTYPE = 'agent_session';
+/** The state of the agent's own goal (Claude `/goal`, Codex `thread/goal`), recorded after its turn. */
+export const AGENT_GOAL_SUBTYPE = 'goal_status';
+/** Where subagents are recorded, the agent's own as well as Moxxy's (`@moxxy/core` writes the same envelope). */
+export const SUBAGENTS_PLUGIN_ID = asPluginId('@moxxy/subagents');
+
+/** The agent session to resume for this provider: the last one recorded, if any. */
+export function agentSessionFromEvents(events: ReadonlyArray<MoxxyEvent>, provider: string): string | undefined {
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const event = events[i];
+    if (!event || event.type !== 'plugin_event') continue;
+    if (event.pluginId !== AGENT_CONNECTION_PLUGIN_ID || event.subtype !== AGENT_SESSION_SUBTYPE) continue;
+    const payload = event.payload as { provider?: unknown; sessionId?: unknown } | null;
+    if (payload && payload.provider === provider && typeof payload.sessionId === 'string') return payload.sessionId;
+  }
+  return undefined;
+}

package/src/agent-work.ts

@@ -0,0 +1,102 @@
+import { AGENT_CONNECTION_PLUGIN_ID, SUBAGENTS_PLUGIN_ID } from './agent-step.js';
+import type { PluginId } from './ids.js';
+import type { MoxxyEvent } from './events.js';
+import type { AgentStepEvent } from './provider.js';
+
+/** Everything the agent runs in the background now (`AGENT_CONNECTION_PLUGIN_ID`); each record replaces the one before. */
+export const AGENT_BACKGROUND_WORK_SUBTYPE = 'background_work';
+/** One background work ended (`AGENT_CONNECTION_PLUGIN_ID`), with what it printed last. */
+export const AGENT_BACKGROUND_WORK_ENDED_SUBTYPE = 'background_work_ended';
+/** What a subagent said as it worked (`SUBAGENTS_PLUGIN_ID`). */
+export const SUBAGENT_MESSAGE_SUBTYPE = 'subagent_message';
+/** How much of a command's output a `background_work_ended` keeps: its end, which says how it went. */
+export const AGENT_WORK_OUTPUT_LIMIT = 4096;
+
+/** A record of the agent's background work (its list, an end): read by the Agents pane, never drawn in the chat. */
+export function isAgentWorkEvent(event: MoxxyEvent): boolean {
+  return (
+    event.type === 'plugin_event' &&
+    event.pluginId === AGENT_CONNECTION_PLUGIN_ID &&
+    (event.subtype === AGENT_BACKGROUND_WORK_SUBTYPE || event.subtype === AGENT_BACKGROUND_WORK_ENDED_SUBTYPE)
+  );
+}
+
+/** A record of a helper agent (its start, steps, words, end), from Moxxy's own subagents or an agent connection's. */
+export function isSubagentEvent(event: MoxxyEvent): boolean {
+  return event.type === 'plugin_event' && event.pluginId === SUBAGENTS_PLUGIN_ID;
+}
+
+/** A `plugin_event` without its envelope (session, turn, id, time). */
+export interface AgentActivityRecord {
+  readonly source: 'plugin' | 'system';
+  readonly pluginId: PluginId;
+  readonly subtype: string;
+  readonly payload: Record<string, unknown>;
+}
+
+/** The helpers of a conversation by id, kept to name them in the records of their later events. */
+export type SubagentNames = Map<string, { readonly label: string; readonly agentType: string }>;
+
+/**
+ * How an agent's helpers and background work are recorded in the log, the
+ * same whether they come in a turn or between turns; `undefined` for any
+ * other event.
+ */
+export function agentActivityRecord(event: AgentStepEvent, provider: string, names: SubagentNames): AgentActivityRecord | undefined {
+  switch (event.type) {
+    case 'subagent_started':
+      names.set(event.id, { label: event.label, agentType: event.agentType });
+      return subagentRecord('subagent_started', {
+        childSessionId: event.id,
+        label: event.label,
+        agentType: event.agentType,
+        ...(event.prompt ? { prompt: event.prompt } : {}),
+        ...(event.toolsUnseen ? { toolsUnseen: true } : {}),
+      });
+    case 'subagent_tool_call': {
+      const named = names.get(event.id);
+      return subagentRecord('subagent_tool_call', { childSessionId: event.id, ...(named ? { label: named.label } : {}), name: event.name, input: event.input });
+    }
+    case 'subagent_message': {
+      const named = names.get(event.id);
+      return subagentRecord(SUBAGENT_MESSAGE_SUBTYPE, { childSessionId: event.id, ...(named ? { label: named.label } : {}), text: event.text });
+    }
+    case 'subagent_completed': {
+      const named = names.get(event.id);
+      return subagentRecord('subagent_completed', {
+        childSessionId: event.id,
+        ...(named ? { label: named.label, agentType: named.agentType } : {}),
+        text: event.text,
+        stopReason: event.stopped ? 'stopped' : event.error ? 'error' : 'end_turn',
+        ...(event.tokensUsed !== undefined ? { tokensUsed: event.tokensUsed } : {}),
+        ...(event.error ? { error: event.error } : {}),
+      });
+    }
+    case 'background_work':
+      return workRecord(AGENT_BACKGROUND_WORK_SUBTYPE, { provider, work: event.work.map(({ id, kind, label }) => ({ id, kind, label })) });
+    case 'background_work_ended':
+      return workRecord(AGENT_BACKGROUND_WORK_ENDED_SUBTYPE, {
+        provider,
+        id: event.id,
+        kind: event.kind,
+        label: event.label,
+        status: event.status,
+        ...(event.summary ? { summary: event.summary } : {}),
+        ...(event.output ? { output: outputEnd(event.output) } : {}),
+      });
+    default:
+      return undefined;
+  }
+}
+
+function subagentRecord(subtype: string, payload: Record<string, unknown>): AgentActivityRecord {
+  return { source: 'plugin', pluginId: SUBAGENTS_PLUGIN_ID, subtype, payload };
+}
+
+function workRecord(subtype: string, payload: Record<string, unknown>): AgentActivityRecord {
+  return { source: 'system', pluginId: AGENT_CONNECTION_PLUGIN_ID, subtype, payload };
+}
+
+function outputEnd(output: string): string {
+  return output.length <= AGENT_WORK_OUTPUT_LIMIT ? output : output.slice(-AGENT_WORK_OUTPUT_LIMIT);
+}

package/src/attachment-payload.ts

@@ -2,7 +2,7 @@ import type { MoxxyEvent, UserPromptAttachment } from './events.js';
 
 /**
  * Attachment bytes travel two very different roads. The model needs them in
- * full; a client that only DRAWS the conversation (desktop, mobile, a channel
+ * full; a client that only DRAWS the conversation (desktop, a channel
  * bot) does not, and pushing a scanned 30 MB PDF through the client link on
  * every reconnect is what once wedged a chat in a reconnect loop. So the runner
  * sends clients {@link eventForClient} — large payloads swapped for their size —

package/src/auto-approve.test.ts

@@ -1,11 +1,12 @@
 import { describe, expect, it } from 'vitest';
-import { AUTO_APPROVE_PLUGIN_ID, AUTO_APPROVE_SUBTYPE, autoApproveFromEvents, autoApproveSwitch } from './auto-approve.js';
+import { AUTO_APPROVE_PLUGIN_ID, AUTO_APPROVE_SUBTYPE, autoApproveFromAgent, autoApproveFromEvents, autoApproveRecorded, autoApproveSwitch } from './auto-approve.js';
 import type { MoxxyEvent } from './events.js';
 
 let seq = 0;
 const base = () => ({ id: `e${seq}`, seq: seq++, ts: 0, sessionId: 's', turnId: 't' }) as const;
 const switched = (enabled: unknown): MoxxyEvent =>
   ({ ...base(), type: 'plugin_event', source: 'user', pluginId: AUTO_APPROVE_PLUGIN_ID, subtype: AUTO_APPROVE_SUBTYPE, payload: { enabled } }) as unknown as MoxxyEvent;
+const fromSystem = (enabled: boolean): MoxxyEvent => ({ ...switched(enabled), source: 'system' }) as MoxxyEvent;
 const prompt = (): MoxxyEvent => ({ ...base(), type: 'user_prompt', source: 'user', text: 'hi' }) as unknown as MoxxyEvent;
 const otherPlugin = (): MoxxyEvent =>
   ({ ...base(), type: 'plugin_event', source: 'plugin', pluginId: 'x', subtype: AUTO_APPROVE_SUBTYPE, payload: { enabled: true } }) as unknown as MoxxyEvent;
@@ -26,4 +27,15 @@ describe('auto-approve fold', () => {
     expect(autoApproveSwitch(otherPlugin())).toBeNull();
     expect(autoApproveSwitch(switched('yes'))).toBeNull();
   });
+
+  it('says whether the conversation recorded a switch at all, even one back to off', () => {
+    expect(autoApproveRecorded([prompt(), otherPlugin()])).toBe(false);
+    expect(autoApproveRecorded([switched(true), prompt(), switched(false)])).toBe(true);
+  });
+
+  it("says whether the switch in force is the agent's own setup Moxxy took on, not the person's choice", () => {
+    expect(autoApproveFromAgent([prompt()])).toBe(false);
+    expect(autoApproveFromAgent([fromSystem(true), prompt()])).toBe(true);
+    expect(autoApproveFromAgent([fromSystem(true), switched(false), switched(true)])).toBe(false);
+  });
 });