@meistrari/remy-cli 1.20.0-rc.4 → 1.20.0

package/dist/remy.js

@@ -32092,55 +32092,74 @@ async function defaultSleep(milliseconds) {
 }
 
 // ../../packages/agents-protocol/src/agent-content.ts
-var textAgentInputBlockSchema = zod_default2.object({
+var textAgentInputBlockSchema = zod_default2.strictObject({
   type: zod_default2.literal("text"),
   text: zod_default2.string()
-}).strict();
-var urlAgentImageSourceSchema = zod_default2.object({
+});
+var urlAgentImageSourceSchema = zod_default2.strictObject({
   kind: zod_default2.literal("url"),
   url: zod_default2.url()
-}).strict();
-var base64AgentImageSourceSchema = zod_default2.object({
+});
+var base64AgentImageSourceSchema = zod_default2.strictObject({
   kind: zod_default2.literal("base64"),
   data: zod_default2.string().min(1),
   mimeType: zod_default2.string().min(1)
-}).strict();
+});
 var agentImageSourceSchema = zod_default2.discriminatedUnion("kind", [
   urlAgentImageSourceSchema,
   base64AgentImageSourceSchema
 ]);
-var imageAgentInputBlockSchema = zod_default2.object({
+var imageAgentInputBlockSchema = zod_default2.strictObject({
   type: zod_default2.literal("image"),
   source: agentImageSourceSchema
-}).strict();
-var textAgentFileSourceSchema = zod_default2.object({
+});
+var textAgentFileSourceSchema = zod_default2.strictObject({
   kind: zod_default2.literal("text"),
   name: zod_default2.string().min(1).optional(),
   text: zod_default2.string(),
   mimeType: zod_default2.string().min(1).optional()
-}).strict();
-var urlAgentFileSourceSchema = zod_default2.object({
+});
+var urlAgentFileSourceSchema = zod_default2.strictObject({
   kind: zod_default2.literal("url"),
   url: zod_default2.url(),
   name: zod_default2.string().min(1).optional(),
   mimeType: zod_default2.string().min(1).optional()
-}).strict();
+});
 var agentFileSourceSchema = zod_default2.discriminatedUnion("kind", [
   textAgentFileSourceSchema,
   urlAgentFileSourceSchema
 ]);
-var fileAgentInputBlockSchema = zod_default2.object({
+var fileAgentInputBlockSchema = zod_default2.strictObject({
   type: zod_default2.literal("file"),
   source: agentFileSourceSchema
-}).strict();
+});
 var agentInputBlockSchema = zod_default2.discriminatedUnion("type", [
   textAgentInputBlockSchema,
   imageAgentInputBlockSchema,
   fileAgentInputBlockSchema
 ]);
+var wireAgentImageSourceSchema = zod_default2.discriminatedUnion("kind", [
+  urlAgentImageSourceSchema.strip(),
+  base64AgentImageSourceSchema.strip()
+]);
+var wireAgentFileSourceSchema = zod_default2.discriminatedUnion("kind", [
+  textAgentFileSourceSchema.strip(),
+  urlAgentFileSourceSchema.strip()
+]);
+var wireAgentInputBlockSchema = zod_default2.discriminatedUnion("type", [
+  textAgentInputBlockSchema.strip(),
+  zod_default2.object({
+    type: zod_default2.literal("image"),
+    source: wireAgentImageSourceSchema
+  }),
+  zod_default2.object({
+    type: zod_default2.literal("file"),
+    source: wireAgentFileSourceSchema
+  })
+]);
 var agentPromptSchema = zod_default2.object({
-  blocks: zod_default2.array(agentInputBlockSchema).min(1)
-}).strict();
+  blocks: zod_default2.array(wireAgentInputBlockSchema).min(1)
+});
 
 // ../../packages/agents-protocol/src/agent-provider.ts
 var agentProviderIdSchema = zod_default2.enum(["codex", "claude"]);
@@ -32261,7 +32280,7 @@ var notificationTransportEnvelopeSchema = zod_default2.object({
   commandId: zod_default2.string().min(1),
   instruction: agentNotificationInstructionSchema.nullable(),
   notifications: agentNotificationsSchema
-}).strict();
+});
 function notificationTransportEnvelope(input) {
   return {
     type: notificationTransportEnvelopeType,
@@ -32297,27 +32316,33 @@ var agentUserInputOptionSchema = zod_default2.object({
   value: zod_default2.string().min(1),
   label: zod_default2.string().min(1),
   description: zod_default2.string().min(1).optional()
-}).strict();
+});
 var agentUserInputQuestionBaseSchema = zod_default2.object({
   id: zod_default2.string().min(1),
   label: zod_default2.string().min(1),
   description: zod_default2.string().min(1).optional(),
   required: zod_default2.boolean().optional()
-}).strict();
+});
 var agentUserInputTextQuestionSchema = agentUserInputQuestionBaseSchema.extend({
   type: zod_default2.literal("text"),
   placeholder: zod_default2.string().min(1).optional()
-}).strict();
+});
 var agentUserInputSingleSelectQuestionSchema = agentUserInputQuestionBaseSchema.extend({
   type: zod_default2.literal("single_select"),
   options: zod_default2.array(agentUserInputOptionSchema).min(1)
-}).strict();
+});
 var agentUserInputQuestionSchema = zod_default2.discriminatedUnion("type", [
   agentUserInputTextQuestionSchema,
   agentUserInputSingleSelectQuestionSchema
 ]);
 var agentUserInputAnswersSchema = zod_default2.record(zod_default2.string().min(1), jsonValueSchema);
 
+// ../../packages/agents-protocol/src/rejected-keys.ts
+function objectRejectingKeys(shape, rejectedKeys) {
+  const rejections = Object.fromEntries(rejectedKeys.map((key) => [key, zod_default2.never().optional()]));
+  return zod_default2.object({ ...shape, ...rejections });
+}
+
 // ../../packages/agents-protocol/src/agent-command.ts
 var agentReasoningEffortSchema = zod_default2.enum(["low", "medium", "high", "xhigh", "max"]);
 var agentPromptModeSchema = zod_default2.enum(["next", "steer"]);
@@ -32325,13 +32350,13 @@ var agentAuthorSchema = zod_default2.object({
   name: zod_default2.string().min(1),
   email: zod_default2.string().min(1).optional(),
   gitEmail: zod_default2.string().min(1).optional()
-}).strict();
+});
 var commandIdSchema = zod_default2.string().min(1);
-var runningCommandBaseSchema = zod_default2.object({
+var runningCommandBaseSchema = objectRejectingKeys({
   provider: agentProviderIdSchema,
   sessionId: zod_default2.string().min(1),
   providerSessionId: zod_default2.string().min(1)
-}).strict();
+}, ["providerTurnId"]);
 var sendPromptCommandSchema = runningCommandBaseSchema.extend({
   type: zod_default2.literal("agent.send-prompt"),
   mode: agentPromptModeSchema,
@@ -32339,13 +32364,13 @@ var sendPromptCommandSchema = runningCommandBaseSchema.extend({
   prompt: agentPromptSchema,
   commandId: commandIdSchema,
   author: agentAuthorSchema.optional()
-}).strict();
+});
 var agentNotifyCommandSchema = runningCommandBaseSchema.extend({
   type: zod_default2.literal("agent.notify"),
   commandId: commandIdSchema,
   instruction: agentNotificationInstructionSchema.nullable(),
   notifications: agentNotificationsSchema
-}).strict().superRefine((command, context) => {
+}).superRefine((command, context) => {
   if (isAgentNotificationToolOutputWithinSizeLimit({
     commandId: command.commandId,
     instruction: command.instruction,
@@ -32364,21 +32389,21 @@ var interruptAgentCommandSchema = runningCommandBaseSchema.extend({
   commandId: commandIdSchema,
   turnId: zod_default2.string().min(1).optional(),
   reason: zod_default2.string().min(1).optional()
-}).strict();
+});
 var compactContextAgentCommandSchema = runningCommandBaseSchema.extend({
   type: zod_default2.literal("agent.compact-context"),
   commandId: commandIdSchema
-}).strict();
+});
 var stopAgentCommandSchema = runningCommandBaseSchema.extend({
   type: zod_default2.literal("agent.stop"),
   reason: zod_default2.string().min(1).optional()
-}).strict();
+});
 var respondUserInputAgentCommandSchema = runningCommandBaseSchema.extend({
   type: zod_default2.literal("agent.respond-user-input"),
   commandId: commandIdSchema,
   requestId: zod_default2.string().min(1),
   answers: agentUserInputAnswersSchema
-}).strict();
+});
 var agentCommandSchema = zod_default2.union([
   sendPromptCommandSchema,
   agentNotifyCommandSchema,
@@ -32436,12 +32461,12 @@ var codexAgentRunMetadataSchema = zod_default2.object({
   provider: zod_default2.literal("codex"),
   ...metadataShape,
   model: codexModelIdSchema.optional()
-}).strict();
+});
 var claudeAgentRunMetadataSchema = zod_default2.object({
   provider: zod_default2.literal("claude"),
   ...metadataShape,
   model: claudeModelIdSchema.optional()
-}).strict();
+});
 var agentRunMetadataSchema = zod_default2.discriminatedUnion("provider", [
   codexAgentRunMetadataSchema,
   claudeAgentRunMetadataSchema
@@ -32452,21 +32477,22 @@ var agentToolDefinitionSchema = zod_default2.object({
   name: zod_default2.string().regex(/^[\w-]{1,128}$/),
   description: zod_default2.string().min(1),
   inputSchema: jsonObjectSchema
-}).strict();
-var agentToolTextContentSchema = zod_default2.object({
+});
+var privateMetadataKeys = ["_meta", "metadata"];
+var agentToolTextContentSchema = objectRejectingKeys({
   type: zod_default2.literal("text"),
   text: zod_default2.string()
-}).strict();
-var agentToolImageContentSchema = zod_default2.object({
+}, privateMetadataKeys);
+var agentToolImageContentSchema = objectRejectingKeys({
   type: zod_default2.literal("image"),
   data: zod_default2.string().min(1),
   mimeType: zod_default2.string().min(1)
-}).strict();
+}, ["uri", ...privateMetadataKeys]);
 var observedContentMetadata = {
   annotations: jsonObjectSchema.optional(),
   extras: jsonObjectSchema.optional()
 };
-var agentToolResourceLinkContentSchema = zod_default2.object({
+var agentToolResourceLinkContentSchema = objectRejectingKeys({
   type: zod_default2.literal("resource_link"),
   name: zod_default2.string(),
   uri: zod_default2.string(),
@@ -32475,45 +32501,45 @@ var agentToolResourceLinkContentSchema = zod_default2.object({
   title: zod_default2.string().optional(),
   size: zod_default2.number().nonnegative().optional(),
   ...observedContentMetadata
-}).strict();
+}, privateMetadataKeys);
 var resourceMetadata = {
   uri: zod_default2.string(),
   mimeType: zod_default2.string().optional(),
   extras: jsonObjectSchema.optional()
 };
-var agentToolResourceContentSchema = zod_default2.object({
+var agentToolResourceContentSchema = objectRejectingKeys({
   type: zod_default2.literal("resource"),
   resource: zod_default2.union([
-    zod_default2.object({ ...resourceMetadata, text: zod_default2.string() }).strict(),
-    zod_default2.object({ ...resourceMetadata, blob: zod_default2.string() }).strict()
+    objectRejectingKeys({ ...resourceMetadata, text: zod_default2.string() }, ["blob"]),
+    objectRejectingKeys({ ...resourceMetadata, blob: zod_default2.string() }, ["text"])
   ]),
   ...observedContentMetadata
-}).strict();
-var agentToolAudioContentSchema = zod_default2.object({
+}, privateMetadataKeys);
+var agentToolAudioContentSchema = objectRejectingKeys({
   type: zod_default2.literal("audio"),
   data: zod_default2.string().min(1),
   mimeType: zod_default2.string().min(1),
   ...observedContentMetadata
-}).strict();
-var agentToolJsonContentSchema = zod_default2.object({
+}, privateMetadataKeys);
+var agentToolJsonContentSchema = objectRejectingKeys({
   type: zod_default2.literal("json"),
   value: jsonValueSchema
-}).strict();
+}, privateMetadataKeys);
 var agentToolContentSchema = zod_default2.union([
-  agentToolTextContentSchema.extend(observedContentMetadata).strict(),
-  agentToolImageContentSchema.extend(observedContentMetadata).strict(),
-  zod_default2.object({ type: zod_default2.literal("image"), uri: zod_default2.string().min(1), ...observedContentMetadata }).strict(),
+  agentToolTextContentSchema.extend(observedContentMetadata),
+  agentToolImageContentSchema.extend(observedContentMetadata),
+  objectRejectingKeys({ type: zod_default2.literal("image"), uri: zod_default2.string().min(1), ...observedContentMetadata }, ["data", ...privateMetadataKeys]),
   agentToolAudioContentSchema,
   agentToolResourceContentSchema,
   agentToolResourceLinkContentSchema,
   agentToolJsonContentSchema
 ]);
-var agentToolResultSchema = zod_default2.object({
+var agentToolResultSchema = objectRejectingKeys({
   success: zod_default2.boolean(),
   content: zod_default2.array(agentToolContentSchema),
   structuredContent: jsonValueSchema.optional(),
   reportedSuccess: zod_default2.boolean().optional()
-}).strict();
+}, privateMetadataKeys);
 var agentToolCallStatusSchema = zod_default2.enum(["completed", "failed", "cancelled"]);
 
 // ../../packages/agents-protocol/src/agent-usage.ts
@@ -32525,19 +32551,19 @@ var agentUsageSchema = zod_default2.object({
   cacheWriteTokens: tokenCountSchema.optional(),
   reasoningOutputTokens: tokenCountSchema.optional(),
   totalTokens: tokenCountSchema.optional()
-}).strict();
+});
 
 // ../../packages/agents-protocol/src/agent-work.ts
 var agentWorkStatusSchema = zod_default2.enum(["pending", "in_progress", "completed"]);
-var agentWorkItemSchema = zod_default2.object({
+var agentWorkItemSchema = objectRejectingKeys({
   id: zod_default2.string().min(1),
   title: zod_default2.string().min(1),
   status: agentWorkStatusSchema
-}).strict();
-var agentWorkSnapshotObservationSchema = zod_default2.object({
+}, ["activeForm"]);
+var agentWorkSnapshotObservationSchema = objectRejectingKeys({
   kind: zod_default2.literal("snapshot"),
   items: zod_default2.array(agentWorkItemSchema)
-}).strict().superRefine(({ items }, context) => {
+}, ["explanation"]).superRefine(({ items }, context) => {
   const seenIds = new Set;
   for (const [index, item] of items.entries()) {
     if (seenIds.has(item.id)) {
@@ -32555,25 +32581,25 @@ var agentWorkObservationSchema = zod_default2.discriminatedUnion("kind", [
   zod_default2.object({
     kind: zod_default2.literal("item_observed"),
     item: agentWorkItemSchema
-  }).strict(),
+  }),
   zod_default2.object({
     kind: zod_default2.literal("item_renamed"),
     itemId: zod_default2.string().min(1),
     title: zod_default2.string().min(1)
-  }).strict(),
+  }),
   zod_default2.object({
     kind: zod_default2.literal("item_status_changed"),
     itemId: zod_default2.string().min(1),
     status: agentWorkStatusSchema
-  }).strict(),
+  }),
   zod_default2.object({
     kind: zod_default2.literal("item_removed"),
     itemId: zod_default2.string().min(1)
-  }).strict()
+  })
 ]);
-var agentWorkStateSchema = zod_default2.object({
+var agentWorkStateSchema = objectRejectingKeys({
   items: zod_default2.array(agentWorkItemSchema)
-}).strict();
+}, ["provider"]);
 function applyAgentWorkObservations(state, observations) {
   let items = state.items.map((item) => ({ ...item }));
   for (const observation of observations) {
@@ -32613,7 +32639,7 @@ var agentErrorSchema = zod_default2.object({
   name: zod_default2.string().min(1).optional(),
   stack: zod_default2.string().min(1).optional(),
   cause: zod_default2.lazy(() => agentErrorSchema).optional()
-}).strict();
+});
 var agentMessageRoleSchema = zod_default2.enum(["user", "assistant", "system"]);
 var agentSessionEndReasonSchema = zod_default2.enum(["completed", "stopped", "interrupted", "failed"]);
 var agentSessionStateSchema = zod_default2.enum(["ready", "running", "idle", "waiting_for_user_input", "stopping", "stopped", "failed"]);
@@ -32622,42 +32648,44 @@ var agentSubagentStatusSchema = zod_default2.enum(["completed", "failed", "cance
 var agentContextCompactionTriggerSchema = zod_default2.enum(["manual", "auto", "unknown"]);
 var agentContextCompactionStatusSchema = zod_default2.enum(["completed", "failed"]);
 var agentContextCompactionRequestResultSchema = zod_default2.discriminatedUnion("status", [
-  zod_default2.object({ status: zod_default2.literal("completed") }).strict(),
-  zod_default2.object({ status: zod_default2.literal("no_op"), reason: zod_default2.string() }).strict(),
-  zod_default2.object({ status: zod_default2.literal("failed"), error: agentErrorSchema }).strict(),
-  zod_default2.object({ status: zod_default2.literal("unknown") }).strict()
+  zod_default2.object({ status: zod_default2.literal("completed") }),
+  zod_default2.object({ status: zod_default2.literal("no_op"), reason: zod_default2.string() }),
+  zod_default2.object({ status: zod_default2.literal("failed"), error: agentErrorSchema }),
+  zod_default2.object({ status: zod_default2.literal("unknown") })
 ]);
 var agentErrorSourceSchema = zod_default2.enum(["provider", "runtime", "transport", "unknown"]);
 var agentSkillScopeSchema = zod_default2.enum(["user", "repository", "system", "admin"]);
-var agentSkillSchema = zod_default2.object({
+var agentSkillSchema = zod_default2.strictObject({
   id: zod_default2.string().min(1),
   name: zod_default2.string().min(1),
   description: zod_default2.string().min(1),
   scope: agentSkillScopeSchema
-}).strict();
-var agentEventBaseSchema = zod_default2.object({
+});
+var wireAgentSkillSchema = agentSkillSchema.strip();
+var agentEventBaseSchema = objectRejectingKeys({
   eventId: zod_default2.string().min(1),
   provider: agentProviderIdSchema,
   sessionId: zod_default2.string().min(1),
   providerSessionId: zod_default2.string().min(1),
   timestamp: zod_default2.string().datetime(),
   sequence: zod_default2.number().int().nonnegative()
-}).strict();
+}, ["providerTurnId"]);
+var agentSessionEventBaseSchema = objectRejectingKeys(agentEventBaseSchema.shape, ["turnId", "actor"]);
 var agentEventActorOriginSchema = zod_default2.discriminatedUnion("type", [
   zod_default2.object({
     type: zod_default2.literal("tool_call"),
     toolCallId: zod_default2.string().min(1)
-  }).strict(),
+  }),
   zod_default2.object({
     type: zod_default2.literal("provider_task"),
     taskId: zod_default2.string().min(1)
-  }).strict()
+  })
 ]);
 var agentEventActorSchema = zod_default2.discriminatedUnion("type", [
   zod_default2.object({
     type: zod_default2.literal("main"),
     actorId: zod_default2.literal("main")
-  }).strict(),
+  }),
   zod_default2.object({
     type: zod_default2.literal("subagent"),
     actorId: zod_default2.string().min(1),
@@ -32666,7 +32694,7 @@ var agentEventActorSchema = zod_default2.discriminatedUnion("type", [
     origin: agentEventActorOriginSchema,
     parentToolCallId: zod_default2.string().min(1).optional(),
     name: zod_default2.string().min(1).optional()
-  }).strict()
+  })
 ]);
 var subagentRefSchema = zod_default2.object({
   subagentId: zod_default2.string().min(1),
@@ -32675,16 +32703,16 @@ var subagentRefSchema = zod_default2.object({
   origin: agentEventActorOriginSchema,
   parentToolCallId: zod_default2.string().min(1).optional(),
   name: zod_default2.string().min(1).optional()
-}).strict();
+});
 var agentTurnEventBaseSchema = agentEventBaseSchema.extend({
   turnId: zod_default2.string().min(1),
   actor: agentEventActorSchema
-}).strict();
-var sessionStartedAgentEventSchema = agentEventBaseSchema.extend({
+});
+var sessionStartedAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("session.started"),
   payload: agentRunMetadataSchema
-}).strict();
-var sessionConfiguredAgentEventSchema = agentEventBaseSchema.extend({
+});
+var sessionConfiguredAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("session.configured"),
   payload: zod_default2.object({
     model: zod_default2.string().min(1),
@@ -32693,65 +32721,65 @@ var sessionConfiguredAgentEventSchema = agentEventBaseSchema.extend({
     tools: zod_default2.array(zod_default2.string().min(1)),
     reasoningEffort: zod_default2.string().min(1).optional(),
     environment: zod_default2.record(zod_default2.string().min(1), zod_default2.literal("[REDACTED]"))
-  }).strict()
-}).strict();
-var sessionSkillsUpdatedAgentEventSchema = agentEventBaseSchema.extend({
+  })
+});
+var sessionSkillsUpdatedAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("session.skills.updated"),
   payload: zod_default2.object({
-    skills: zod_default2.array(agentSkillSchema)
-  }).strict()
-}).strict();
-var sessionStateChangedAgentEventSchema = agentEventBaseSchema.extend({
+    skills: zod_default2.array(wireAgentSkillSchema)
+  })
+});
+var sessionStateChangedAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("session.state.changed"),
   payload: zod_default2.object({
     state: agentSessionStateSchema,
     error: agentErrorSchema.optional()
-  }).strict()
-}).strict();
-var sessionEndedAgentEventSchema = agentEventBaseSchema.extend({
+  })
+});
+var sessionEndedAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("session.ended"),
   payload: zod_default2.object({
     reason: agentSessionEndReasonSchema,
     exitCode: zod_default2.number().int().nullable().optional(),
     signal: zod_default2.string().min(1).nullable().optional(),
     error: agentErrorSchema.optional()
-  }).strict()
-}).strict();
+  })
+});
 var turnStartedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("turn.started"),
-  payload: zod_default2.object({}).strict()
-}).strict();
+  payload: zod_default2.object({})
+});
 var turnEndedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("turn.ended"),
-  payload: zod_default2.object({
+  payload: objectRejectingKeys({
     status: agentTurnEndStatusSchema,
     reason: zod_default2.string().min(1).optional(),
     error: agentErrorSchema.optional(),
     duration: zod_default2.number().int().nonnegative().optional()
-  }).strict()
-}).strict();
+  }, ["usage"])
+});
 var workObservedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("work.observed"),
   payload: zod_default2.object({
     observations: zod_default2.array(agentWorkObservationSchema).min(1)
-  }).strict()
-}).strict();
+  })
+});
 var messageStartedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("message.started"),
   payload: zod_default2.object({
     messageId: zod_default2.string().min(1),
     role: agentMessageRoleSchema,
     commandId: zod_default2.string().min(1).optional()
-  }).strict()
-}).strict();
+  })
+});
 var messageDeltaAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("message.delta"),
-  payload: zod_default2.object({
+  payload: objectRejectingKeys({
     messageId: zod_default2.string().min(1),
     role: agentMessageRoleSchema,
     delta: zod_default2.string()
-  }).strict()
-}).strict();
+  }, ["commandId"])
+});
 var messageEndedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("message.ended"),
   payload: zod_default2.object({
@@ -32759,50 +32787,50 @@ var messageEndedAgentEventSchema = agentTurnEventBaseSchema.extend({
     role: agentMessageRoleSchema,
     text: zod_default2.string().optional(),
     commandId: zod_default2.string().min(1).optional()
-  }).strict()
-}).strict();
+  })
+});
 var reasoningStartedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("reasoning.started"),
   payload: zod_default2.object({
     reasoningId: zod_default2.string().min(1)
-  }).strict()
-}).strict();
+  })
+});
 var reasoningSummaryDeltaAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("reasoning.summary.delta"),
   payload: zod_default2.object({
     reasoningId: zod_default2.string().min(1),
     text: zod_default2.string()
-  }).strict()
-}).strict();
+  })
+});
 var reasoningEndedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("reasoning.ended"),
   payload: zod_default2.object({
     reasoningId: zod_default2.string().min(1),
     summary: zod_default2.string().optional()
-  }).strict()
-}).strict();
+  })
+});
 var toolCallStartedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("tool.call.started"),
   payload: zod_default2.object({
     toolCallId: zod_default2.string().min(1),
     toolName: zod_default2.string().min(1),
     input: jsonValueSchema.optional()
-  }).strict()
-}).strict();
+  })
+});
 var toolOutputDeltaAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("tool.output.delta"),
   payload: zod_default2.object({
     toolCallId: zod_default2.string().min(1),
     delta: zod_default2.string()
-  }).strict()
-}).strict();
+  })
+});
 var toolOutputUpdatedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("tool.output.updated"),
   payload: zod_default2.object({
     toolCallId: zod_default2.string().min(1),
     output: agentToolResultSchema
-  }).strict()
-}).strict();
+  })
+});
 var toolCallCompletedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("tool.call.completed"),
   payload: zod_default2.object({
@@ -32811,22 +32839,22 @@ var toolCallCompletedAgentEventSchema = agentTurnEventBaseSchema.extend({
     status: agentToolCallStatusSchema,
     output: agentToolResultSchema.optional(),
     error: agentErrorSchema.optional()
-  }).strict()
-}).strict();
+  })
+});
 var subagentStartedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("subagent.started"),
   payload: subagentRefSchema.extend({
     description: zod_default2.string().min(1).optional()
-  }).strict()
-}).strict();
+  })
+});
 var subagentProgressAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("subagent.progress"),
   payload: subagentRefSchema.extend({
     summary: zod_default2.string().min(1).optional(),
     lastToolName: zod_default2.string().min(1).optional(),
     usage: agentUsageSchema.optional()
-  }).strict()
-}).strict();
+  })
+});
 var subagentEndedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("subagent.ended"),
   payload: subagentRefSchema.extend({
@@ -32834,47 +32862,66 @@ var subagentEndedAgentEventSchema = agentTurnEventBaseSchema.extend({
     summary: zod_default2.string().optional(),
     usage: agentUsageSchema.optional(),
     error: agentErrorSchema.optional()
-  }).strict()
-}).strict();
+  })
+});
 var usageAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("usage"),
   payload: zod_default2.object({
     usage: agentUsageSchema
-  }).strict()
-}).strict();
+  })
+});
+var knownAgentContextWindowShape = {
+  status: zod_default2.literal("known"),
+  capacityTokens: zod_default2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  remainingPercent: zod_default2.number().int().min(0).max(100)
+};
 var agentContextWindowSchema = zod_default2.discriminatedUnion("status", [
+  zod_default2.strictObject({ status: zod_default2.literal("unknown") }),
+  zod_default2.strictObject(knownAgentContextWindowShape)
+]);
+var wireAgentContextWindowSchema = zod_default2.discriminatedUnion("status", [
   zod_default2.object({
-    status: zod_default2.literal("unknown")
-  }).strict(),
-  zod_default2.object({
-    status: zod_default2.literal("known"),
-    capacityTokens: zod_default2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    remainingPercent: zod_default2.number().int().min(0).max(100)
-  }).strict()
+    status: zod_default2.literal("unknown"),
+    capacityTokens: zod_default2.never().optional(),
+    remainingPercent: zod_default2.never().optional()
+  }),
+  zod_default2.object(knownAgentContextWindowShape)
 ]);
 var agentContextSnapshotSchema = zod_default2.discriminatedUnion("status", [
+  zod_default2.strictObject({ status: zod_default2.literal("unknown") }),
+  zod_default2.strictObject({
+    status: zod_default2.literal("observed"),
+    usedTokens: zod_default2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    window: agentContextWindowSchema
+  })
+]);
+var wireAgentContextSnapshotSchema = zod_default2.discriminatedUnion("status", [
   zod_default2.object({
-    status: zod_default2.literal("unknown")
-  }).strict(),
+    status: zod_default2.literal("unknown"),
+    usedTokens: zod_default2.never().optional(),
+    window: zod_default2.never().optional(),
+    providerModel: zod_default2.never().optional()
+  }),
   zod_default2.object({
     status: zod_default2.literal("observed"),
     usedTokens: zod_default2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-    window: agentContextWindowSchema
-  }).strict()
+    window: wireAgentContextWindowSchema,
+    providerModel: zod_default2.never().optional()
+  })
 ]);
 var contextUpdatedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("context.updated"),
   payload: zod_default2.object({
-    snapshot: agentContextSnapshotSchema
-  }).strict()
-}).strict();
+    snapshot: wireAgentContextSnapshotSchema
+  })
+});
 var contextCompactionStartedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("context.compaction.started"),
   payload: zod_default2.object({
     compactionId: zod_default2.string().min(1),
     trigger: agentContextCompactionTriggerSchema
-  }).strict()
-}).strict();
+  })
+});
 var contextCompactionCompletedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("context.compaction.completed"),
   payload: zod_default2.object({
@@ -32885,15 +32932,15 @@ var contextCompactionCompletedAgentEventSchema = agentTurnEventBaseSchema.extend
     inputTokensBefore: zod_default2.number().int().nonnegative().optional(),
     inputTokensAfter: zod_default2.number().int().nonnegative().optional(),
     error: agentErrorSchema.optional()
-  }).strict()
-}).strict();
-var contextCompactionRequestCompletedAgentEventSchema = agentEventBaseSchema.extend({
+  })
+});
+var contextCompactionRequestCompletedAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("context.compaction.request.completed"),
   payload: zod_default2.object({
     commandId: zod_default2.string().min(1),
     result: agentContextCompactionRequestResultSchema
-  }).strict()
-}).strict();
+  })
+});
 var userInputRequestedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("user-input.requested"),
   payload: zod_default2.object({
@@ -32901,26 +32948,26 @@ var userInputRequestedAgentEventSchema = agentTurnEventBaseSchema.extend({
     toolCallId: zod_default2.string().min(1),
     prompt: zod_default2.string().min(1),
     questions: zod_default2.array(agentUserInputQuestionSchema).min(1)
-  }).strict()
-}).strict();
-var userInputResolvedAgentEventSchema = agentEventBaseSchema.extend({
+  })
+});
+var userInputResolvedAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("user-input.resolved"),
   payload: zod_default2.object({
     requestId: zod_default2.string().min(1),
     requestedTurnId: zod_default2.string().min(1),
     toolCallId: zod_default2.string().min(1),
     answers: agentUserInputAnswersSchema
-  }).strict()
-}).strict();
-var errorAgentEventSchema = agentEventBaseSchema.extend({
+  })
+});
+var errorAgentEventSchema = agentSessionEventBaseSchema.extend({
   type: zod_default2.literal("error"),
   payload: zod_default2.object({
     message: zod_default2.string().min(1),
     fatal: zod_default2.boolean(),
     source: agentErrorSourceSchema.optional(),
     error: agentErrorSchema.optional()
-  }).strict()
-}).strict();
+  })
+});
 var agentEventSchema = zod_default2.discriminatedUnion("type", [
   sessionStartedAgentEventSchema,
   sessionConfiguredAgentEventSchema,
@@ -32952,6 +32999,7 @@ var agentEventSchema = zod_default2.discriminatedUnion("type", [
   userInputResolvedAgentEventSchema,
   errorAgentEventSchema
 ]);
+var agentEventTypes = agentEventSchema.options.map((schema) => schema.shape.type.value);
 // ../../packages/agents-protocol/src/agent-presentation.ts
 var CODEX_CONTEXT_WINDOW = 272000;
 var codexModelPresentation = {
@@ -34209,91 +34257,91 @@ import { dirname as dirname4, join as join3 } from "path";
 // ../../packages/supervisor-protocol/src/agent-event-wrapper.ts
 var wrappedSessionStartedAgentEventSchema = sessionStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.session.started")
-}).strict();
+});
 var wrappedSessionConfiguredAgentEventSchema = sessionConfiguredAgentEventSchema.extend({
   type: zod_default2.literal("agent.session.configured")
-}).strict();
+});
 var wrappedSessionSkillsUpdatedAgentEventSchema = sessionSkillsUpdatedAgentEventSchema.extend({
   type: zod_default2.literal("agent.session.skills.updated")
-}).strict();
+});
 var wrappedSessionStateChangedAgentEventSchema = sessionStateChangedAgentEventSchema.extend({
   type: zod_default2.literal("agent.session.state.changed")
-}).strict();
+});
 var wrappedSessionEndedAgentEventSchema = sessionEndedAgentEventSchema.extend({
   type: zod_default2.literal("agent.session.ended")
-}).strict();
+});
 var wrappedTurnStartedAgentEventSchema = turnStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.turn.started")
-}).strict();
+});
 var wrappedTurnEndedAgentEventSchema = turnEndedAgentEventSchema.extend({
   type: zod_default2.literal("agent.turn.ended")
-}).strict();
+});
 var wrappedWorkObservedAgentEventSchema = workObservedAgentEventSchema.extend({
   type: zod_default2.literal("agent.work.observed")
-}).strict();
+});
 var wrappedMessageStartedAgentEventSchema = messageStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.message.started")
-}).strict();
+});
 var wrappedMessageDeltaAgentEventSchema = messageDeltaAgentEventSchema.extend({
   type: zod_default2.literal("agent.message.delta")
-}).strict();
+});
 var wrappedMessageEndedAgentEventSchema = messageEndedAgentEventSchema.extend({
   type: zod_default2.literal("agent.message.ended")
-}).strict();
+});
 var wrappedReasoningStartedAgentEventSchema = reasoningStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.reasoning.started")
-}).strict();
+});
 var wrappedReasoningSummaryDeltaAgentEventSchema = reasoningSummaryDeltaAgentEventSchema.extend({
   type: zod_default2.literal("agent.reasoning.summary.delta")
-}).strict();
+});
 var wrappedReasoningEndedAgentEventSchema = reasoningEndedAgentEventSchema.extend({
   type: zod_default2.literal("agent.reasoning.ended")
-}).strict();
+});
 var wrappedToolCallStartedAgentEventSchema = toolCallStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.tool.call.started")
-}).strict();
+});
 var wrappedToolOutputDeltaAgentEventSchema = toolOutputDeltaAgentEventSchema.extend({
   type: zod_default2.literal("agent.tool.output.delta")
-}).strict();
+});
 var wrappedToolOutputUpdatedAgentEventSchema = toolOutputUpdatedAgentEventSchema.extend({
   type: zod_default2.literal("agent.tool.output.updated")
-}).strict();
+});
 var wrappedToolCallCompletedAgentEventSchema = toolCallCompletedAgentEventSchema.extend({
   type: zod_default2.literal("agent.tool.call.completed")
-}).strict();
+});
 var wrappedSubagentStartedAgentEventSchema = subagentStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.subagent.started")
-}).strict();
+});
 var wrappedSubagentProgressAgentEventSchema = subagentProgressAgentEventSchema.extend({
   type: zod_default2.literal("agent.subagent.progress")
-}).strict();
+});
 var wrappedSubagentEndedAgentEventSchema = subagentEndedAgentEventSchema.extend({
   type: zod_default2.literal("agent.subagent.ended")
-}).strict();
+});
 var wrappedUsageAgentEventSchema = usageAgentEventSchema.extend({
   type: zod_default2.literal("agent.usage")
-}).strict();
+});
 var wrappedContextUpdatedAgentEventSchema = contextUpdatedAgentEventSchema.extend({
   type: zod_default2.literal("agent.context.updated")
-}).strict();
+});
 var wrappedContextCompactionStartedAgentEventSchema = contextCompactionStartedAgentEventSchema.extend({
   type: zod_default2.literal("agent.context.compaction.started")
-}).strict();
+});
 var wrappedContextCompactionCompletedAgentEventSchema = contextCompactionCompletedAgentEventSchema.extend({
   type: zod_default2.literal("agent.context.compaction.completed")
-}).strict();
+});
 var wrappedContextCompactionRequestCompletedAgentEventSchema = contextCompactionRequestCompletedAgentEventSchema.extend({
   type: zod_default2.literal("agent.context.compaction.request.completed")
-}).strict();
+});
 var wrappedUserInputRequestedAgentEventSchema = userInputRequestedAgentEventSchema.extend({
   type: zod_default2.literal("agent.user-input.requested")
-}).strict();
+});
 var wrappedUserInputResolvedAgentEventSchema = userInputResolvedAgentEventSchema.extend({
   type: zod_default2.literal("agent.user-input.resolved")
-}).strict();
+});
 var wrappedErrorAgentEventSchema = errorAgentEventSchema.extend({
   type: zod_default2.literal("agent.error")
-}).strict();
+});
 var wrappedAgentEventSchema = zod_default2.discriminatedUnion("type", [
   wrappedSessionStartedAgentEventSchema,
   wrappedSessionConfiguredAgentEventSchema,
@@ -34325,6 +34373,10 @@ var wrappedAgentEventSchema = zod_default2.discriminatedUnion("type", [
   wrappedUserInputResolvedAgentEventSchema,
   wrappedErrorAgentEventSchema
 ]);
+var wrappedAgentEventTypes = agentEventTypes.map(wrapAgentEventType);
+function wrapAgentEventType(type) {
+  return `agent.${type}`;
+}
 
 // ../../packages/agents-protocol/src/agent-identity.ts
 function normalizeAgentSubagentIdentity(identity) {
@@ -40740,7 +40792,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.20.0-rc.4";
+var remyCliVersion = "1.20.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meistrari/remy-cli",
-    "version": "1.20.0-rc.4",
+    "version": "1.20.0",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {