effect(core-messages-session): session/lease zod→Schema

Add Effect Schema definitions for every session.* payload
(hello/welcome/error/bye/ping/pong/ack/list_jobs/jobs) and lease/
lease-constraints alongside the existing zod schemas. Zod schemas are
renamed to *ZodSchema and continue to drive messageEnvelope() because
envelope.ts itself stays zod-typed until slice #50. events.ts now
consumes the native Effect LeaseConstraintsSchema; LeaseSchema stays
on the zod-twin bridge to preserve the mutable Lease shape consumers
depend on.

Closes #37

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Nick Ficano

packages/core/src/messages/events.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { ERROR_CODES } from "../errors.js";
 
 import { ArtifactRefSchema } from "./artifacts.js";
-import { LeaseConstraintsSchema, LeaseSchema } from "./lease-schema.js";
+import { LeaseConstraintsSchema, LeaseZodSchema } from "./lease-schema.js";
 import { LogPayloadSchema, MetricPayloadSchema } from "./telemetry.js";
 import { fromZod } from "./zod-adapter.js";
 
@@ -93,20 +93,22 @@ export const StatusBodySchema = Schema.Struct({
 });
 export type StatusBody = Schema.Schema.Type<typeof StatusBodySchema>;
 
-// `lease_request` / `lease_constraints` still live as zod (slice-boundary;
-// `lease-schema.ts` migration is its own future slice). Bridge through
-// `fromZod` so the surrounding Effect `Schema.Struct` can compose them.
-const LeaseEffectSchema = fromZod(LeaseSchema);
-const LeaseConstraintsEffectSchema = fromZod(LeaseConstraintsSchema);
+// `LeaseSchema` infers `Record<string, ReadonlyArray<string>>`; the rest of
+// the runtime (lease.ts, job-runner.ts) treats `Lease` as the mutable
+// `Record<string, string[]>` shape from the zod twin. Bridge through
+// `fromZod` so the inferred `DelegateBody.lease_request` stays
+// assignment-compatible with the zod-derived `Lease` alias until slice #50
+// migrates the `Lease` consumers to readonly arrays.
+const LeaseMutableEffectSchema = fromZod(LeaseZodSchema);
 
 /** §8.2 `delegate` event-kind body. */
 export const DelegateBodySchema = Schema.Struct({
   delegate_id: Schema.String.pipe(Schema.nonEmptyString()),
   agent: Schema.String.pipe(Schema.nonEmptyString()),
   input: Schema.Unknown,
-  lease_request: Schema.optional(LeaseEffectSchema),
+  lease_request: Schema.optional(LeaseMutableEffectSchema),
   /** v1.1 §9.4/§9.5 — child lease bound; MUST NOT exceed parent's. */
-  lease_constraints: Schema.optional(LeaseConstraintsEffectSchema),
+  lease_constraints: Schema.optional(LeaseConstraintsSchema),
 });
 export type DelegateBody = Schema.Schema.Type<typeof DelegateBodySchema>;
 

packages/core/src/messages/execution.ts

@@ -11,8 +11,8 @@ import {
 
 import { JobEventPayloadZodSchema } from "./events.js";
 import {
-  LeaseConstraintsSchema,
-  LeaseSchema,
+  LeaseConstraintsZodSchema,
+  LeaseZodSchema,
 } from "./lease-schema.js";
 
 // ARCP v1.0 §7-§8 job-related envelopes.
@@ -22,8 +22,10 @@ export {
   isValidCapabilityName,
   type Lease,
   LeaseConstraintsSchema,
+  LeaseConstraintsZodSchema,
   type LeaseConstraints,
   LeaseSchema,
+  LeaseZodSchema,
   RESERVED_CAPABILITY_NAMES,
   type ReservedCapabilityName,
 } from "./lease-schema.js";
@@ -159,8 +161,8 @@ export const JobSubmitPayloadSchema = Schema.Struct({
 export const JobSubmitPayloadZodSchema = z.object({
   agent: z.string().min(1),
   input: z.unknown(),
-  lease_request: LeaseSchema.optional(),
-  lease_constraints: LeaseConstraintsSchema.optional(),
+  lease_request: LeaseZodSchema.optional(),
+  lease_constraints: LeaseConstraintsZodSchema.optional(),
   idempotency_key: z.string().min(1).optional(),
   max_runtime_sec: z.number().int().positive().optional(),
 });
@@ -187,9 +189,9 @@ export const JobAcceptedPayloadZodSchema = z.object({
   job_id: z.string().min(1).brand<"JobId">(),
   /** Resolved `name@version` when v1.1 agent_versions is in use; bare name otherwise. */
   agent: z.string().min(1).optional(),
-  lease: LeaseSchema,
+  lease: LeaseZodSchema,
   /** v1.1 §9.5 — echoed lease constraints. */
-  lease_constraints: LeaseConstraintsSchema.optional(),
+  lease_constraints: LeaseConstraintsZodSchema.optional(),
   /** v1.1 §9.6 — initial budget counters, when `cost.budget` is in the lease. */
   budget: JobBudgetZodSchema.optional(),
   accepted_at: z.string().min(1),
@@ -358,8 +360,8 @@ export const JobSubscribedPayloadZodSchema = z.object({
   job_id: z.string().min(1).brand<"JobId">(),
   current_status: JobStateZodSchema,
   agent: z.string().min(1),
-  lease: LeaseSchema,
-  lease_constraints: LeaseConstraintsSchema.optional(),
+  lease: LeaseZodSchema,
+  lease_constraints: LeaseConstraintsZodSchema.optional(),
   budget: JobBudgetZodSchema.optional(),
   parent_job_id: z.string().brand<"JobId">().nullable().optional(),
   trace_id: z.string().brand<"TraceId">().optional(),

packages/core/src/messages/lease-schema.ts

@@ -1,3 +1,4 @@
+import { Schema } from "effect";
 import { z } from "zod";
 
 /**
@@ -31,21 +32,49 @@ export function isValidCapabilityName(name: string): boolean {
   return /^x-vendor(\.[a-z0-9_-]+){2,}$/.test(name);
 }
 
-/** §9.1 lease: capability → list of glob patterns. */
-export const LeaseSchema = z.record(
+/**
+ * §9.1 lease (Effect Schema): capability → list of glob patterns.
+ *
+ * Native Effect surface for in-process consumers. The zod twin
+ * {@link LeaseZodSchema} still feeds `messageEnvelope()` (slice #50).
+ *
+ * Effect's `Schema.Record` silently drops keys that fail the key schema, so
+ * `{ "": [...] }` decodes to `{}`. The zod twin rejects empty keys at the
+ * wire layer where it counts.
+ */
+export const LeaseSchema = Schema.Record({
+  key: Schema.String.pipe(Schema.nonEmptyString()),
+  value: Schema.Array(Schema.String.pipe(Schema.nonEmptyString())),
+});
+
+/** §9.1 lease (zod twin) — drives the zod-typed envelope wrappers. */
+export const LeaseZodSchema = z.record(
   z.string().min(1),
   z.array(z.string().min(1)),
 );
-export type Lease = z.infer<typeof LeaseSchema>;
+/**
+ * `Lease` is the zod-inferred type so it stays structurally equivalent to
+ * `Record<string, string[]>` for the many in-process consumers
+ * (`runtime/lease.ts`, `client-handle.ts`, etc.). The Effect schema infers a
+ * `ReadonlyArray<string>` value which would be a non-trivial breaking change
+ * to callers — defer that to slice #50.
+ */
+export type Lease = z.infer<typeof LeaseZodSchema>;
 
 /**
- * v1.1 §9.5 lease constraints. Currently carries only `expires_at` (ISO 8601
- * UTC with `Z` suffix), which sets a hard upper bound on the lease's lifetime.
+ * v1.1 §9.5 lease constraints (Effect Schema). Currently carries only
+ * `expires_at` (ISO 8601 UTC with `Z` suffix), which sets a hard upper bound
+ * on the lease's lifetime.
  *
  * The schema validates `expires_at` is a non-empty string. Stricter checks
  * (UTC, future-dated) are enforced at submit time by the runtime.
  */
-export const LeaseConstraintsSchema = z.object({
+export const LeaseConstraintsSchema = Schema.Struct({
+  expires_at: Schema.optional(Schema.String.pipe(Schema.nonEmptyString())),
+});
+
+/** v1.1 §9.5 lease constraints (zod twin). */
+export const LeaseConstraintsZodSchema = z.object({
   expires_at: z.string().min(1).optional(),
 });
-export type LeaseConstraints = z.infer<typeof LeaseConstraintsSchema>;
+export type LeaseConstraints = z.infer<typeof LeaseConstraintsZodSchema>;