mulmoclaude 0.6.2 → 0.6.4

package/src/types/encore-dsl/cadence.ts

@@ -0,0 +1,289 @@
+// Encore cadence math. Pure functions — no fs, no clock injection
+// here (the caller passes `now` explicitly). Per the DSL spec each
+// cadence shape determines:
+//
+//   - which slot "now" falls into (currentCycleSlot)
+//   - the cycle's start date (cycleStart)
+//   - the cycle's deadline date (cycleDeadline)
+//   - the on-disk cycle id string (formatCycleId), used to name the
+//     per-cycle file under obligations/<id>/<cycleId>.md
+//
+// The five v1 cadences are: annual, biannual, monthly, weekly, daily.
+// Quarterly / one-shot / custom-cron are out of scope. Days are
+// capped at 28 in validators to avoid February edge cases; the math
+// here trusts validated input. ISO dates everywhere (YYYY-MM-DD).
+
+import { z } from "zod";
+
+// ── ISO date helpers ────────────────────────────────────────────
+
+/** Format a Date as `YYYY-MM-DD` in the server's LOCAL timezone.
+ *  Encore obligations are wall-clock obligations ("pay rent on the
+ *  1st" means the 1st in the user's calendar, not the 1st in UTC),
+ *  so cycle boundaries must follow the host's wall clock. Matches
+ *  the journal subsystem's `toLocalIsoDate` convention in
+ *  `server/utils/date.ts`. */
+export function isoDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function localDate(year: number, monthZero: number, day: number): Date {
+  return new Date(year, monthZero, day);
+}
+
+/** Parse a YYYY-MM-DD string to a local-midnight Date. */
+function parseLocalIsoDate(iso: string): Date {
+  const [year, month, day] = iso.split("-").map(Number);
+  return new Date(year, month - 1, day);
+}
+
+/** Add N calendar days to an ISO date (returns ISO). */
+export function addDays(iso: string, days: number): string {
+  const [year, month, day] = iso.split("-").map(Number);
+  return isoDate(localDate(year, month - 1, day + days));
+}
+
+/** Lexicographic ISO compare. -1 / 0 / 1. */
+export function compareIsoDates(lhs: string, rhs: string): number {
+  if (lhs < rhs) return -1;
+  if (lhs > rhs) return 1;
+  return 0;
+}
+
+// ── ISO week helpers (used by weekly cadence) ───────────────────
+
+const MS_PER_WEEK = 7 * 24 * 60 * 60 * 1000;
+
+/** ISO 8601 week number for a date. The ISO week year matches the
+ *  Thursday of the week — handy for the early-Jan / late-Dec edge
+ *  cases where a date's calendar year and ISO-week year differ. */
+function isoWeekYearAndNumber(date: Date): { year: number; week: number } {
+  // Copy to avoid mutating caller.
+  const thursdayOfWeek = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const dayNum = (thursdayOfWeek.getDay() + 6) % 7; // Mon=0 … Sun=6
+  thursdayOfWeek.setDate(thursdayOfWeek.getDate() - dayNum + 3);
+  const firstThursday = new Date(thursdayOfWeek.getFullYear(), 0, 4);
+  const firstThursdayDayNum = (firstThursday.getDay() + 6) % 7;
+  const firstThursdayWeekStart = new Date(firstThursday);
+  firstThursdayWeekStart.setDate(firstThursday.getDate() - firstThursdayDayNum);
+  const diffMs = thursdayOfWeek.getTime() - firstThursdayWeekStart.getTime();
+  const week = 1 + Math.round(diffMs / MS_PER_WEEK);
+  return { year: thursdayOfWeek.getFullYear(), week };
+}
+
+/** Monday of the given ISO week (returns ISO date). */
+function isoWeekMonday(year: number, week: number): string {
+  // Jan 4 is always in week 1.
+  const jan4 = new Date(year, 0, 4);
+  const jan4DayNum = (jan4.getDay() + 6) % 7;
+  const mondayOfWeek1 = new Date(jan4);
+  mondayOfWeek1.setDate(jan4.getDate() - jan4DayNum);
+  const target = new Date(mondayOfWeek1);
+  target.setDate(mondayOfWeek1.getDate() + (week - 1) * 7);
+  return isoDate(target);
+}
+
+// ── Cadence Zod schema ──────────────────────────────────────────
+
+const dayInMonth = z.number().int().min(1).max(28);
+const monthOfYear = z.number().int().min(1).max(12);
+
+const cycleEntry = z.object({ month: monthOfYear, day: dayInMonth });
+
+const annual = z.object({
+  type: z.literal("annual"),
+  cycles: z.tuple([cycleEntry]),
+});
+
+const biannual = z.object({
+  type: z.literal("biannual"),
+  cycles: z.tuple([cycleEntry, cycleEntry]),
+});
+
+const monthly = z.object({
+  type: z.literal("monthly"),
+  day: dayInMonth,
+});
+
+const DAY_OF_WEEK = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] as const;
+export type DayOfWeek = (typeof DAY_OF_WEEK)[number];
+
+const weekly = z.object({
+  type: z.literal("weekly"),
+  dayOfWeek: z.enum(DAY_OF_WEEK),
+});
+
+const daily = z.object({
+  type: z.literal("daily"),
+});
+
+export const CadenceSchema = z.discriminatedUnion("type", [annual, biannual, monthly, weekly, daily]).superRefine((cadence, ctx) => {
+  if (cadence.type === "biannual") {
+    const [first, second] = cadence.cycles;
+    if (first.month > second.month || (first.month === second.month && first.day >= second.day)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "biannual cycles must be in calendar order (first cycle before second)",
+        path: ["cycles"],
+      });
+    }
+  }
+});
+
+export type Cadence = z.infer<typeof CadenceSchema>;
+
+// ── Slot identification ─────────────────────────────────────────
+
+export type CycleSlot =
+  | { kind: "annual"; year: number }
+  | { kind: "biannual"; year: number; half: 1 | 2 }
+  | { kind: "monthly"; year: number; month: number }
+  | { kind: "weekly"; year: number; week: number }
+  | { kind: "daily"; iso: string };
+
+/** Find the cycle slot a given date falls into for this cadence.
+ *  "Falls into" = the slot whose [start, deadline] range contains
+ *  `now`; for annual / biannual we pick the slot whose deadline is
+ *  the next upcoming one (so the cycle is "active" until its
+ *  deadline passes; the day AFTER the deadline rolls into the next
+ *  cycle, matching the spec's cycle-start = day-after-prev-deadline
+ *  rule). */
+export function currentCycleSlot(cadence: Cadence, now: Date): CycleSlot {
+  // Compare as ISO date strings — the deadline is date-only, and
+  // comparing `now` (a full timestamp) against a midnight Date
+  // would roll over one day early on the deadline day. ISO-string
+  // lexical compare is calendar-correct for YYYY-MM-DD.
+  const todayIso = isoDate(now);
+  const year = now.getFullYear();
+  if (cadence.type === "annual") {
+    const [{ month, day }] = cadence.cycles;
+    const thisYearDeadlineIso = isoDate(localDate(year, month - 1, day));
+    return { kind: "annual", year: todayIso <= thisYearDeadlineIso ? year : year + 1 };
+  }
+  if (cadence.type === "biannual") {
+    const [first, second] = cadence.cycles;
+    const firstDeadlineIso = isoDate(localDate(year, first.month - 1, first.day));
+    const secondDeadlineIso = isoDate(localDate(year, second.month - 1, second.day));
+    if (todayIso <= firstDeadlineIso) return { kind: "biannual", year, half: 1 };
+    if (todayIso <= secondDeadlineIso) return { kind: "biannual", year, half: 2 };
+    return { kind: "biannual", year: year + 1, half: 1 };
+  }
+  if (cadence.type === "monthly") {
+    const monthZero = now.getMonth();
+    const deadlineThisMonthIso = isoDate(localDate(year, monthZero, cadence.day));
+    if (todayIso <= deadlineThisMonthIso) {
+      return { kind: "monthly", year, month: monthZero + 1 };
+    }
+    const next = localDate(year, monthZero + 1, 1);
+    return { kind: "monthly", year: next.getFullYear(), month: next.getMonth() + 1 };
+  }
+  if (cadence.type === "weekly") {
+    const targetIdx = DAY_OF_WEEK.indexOf(cadence.dayOfWeek);
+    const { year: isoYear, week } = isoWeekYearAndNumber(now);
+    const monday = isoWeekMonday(isoYear, week);
+    const deadlineThisWeek = addDays(monday, targetIdx);
+    if (isoDate(now) <= deadlineThisWeek) {
+      return { kind: "weekly", year: isoYear, week };
+    }
+    const nextMondayIso = addDays(monday, 7);
+    const next = isoWeekYearAndNumber(parseLocalIsoDate(nextMondayIso));
+    return { kind: "weekly", year: next.year, week: next.week };
+  }
+  // daily
+  return { kind: "daily", iso: isoDate(now) };
+}
+
+/** ISO date of the cycle's deadline. */
+export function cycleDeadline(cadence: Cadence, slot: CycleSlot): string {
+  if (cadence.type === "annual" && slot.kind === "annual") {
+    const [{ month, day }] = cadence.cycles;
+    return isoDate(localDate(slot.year, month - 1, day));
+  }
+  if (cadence.type === "biannual" && slot.kind === "biannual") {
+    const entry = cadence.cycles[slot.half - 1];
+    return isoDate(localDate(slot.year, entry.month - 1, entry.day));
+  }
+  if (cadence.type === "monthly" && slot.kind === "monthly") {
+    return isoDate(localDate(slot.year, slot.month - 1, cadence.day));
+  }
+  if (cadence.type === "weekly" && slot.kind === "weekly") {
+    const monday = isoWeekMonday(slot.year, slot.week);
+    const targetIdx = DAY_OF_WEEK.indexOf(cadence.dayOfWeek);
+    return addDays(monday, targetIdx);
+  }
+  if (cadence.type === "daily" && slot.kind === "daily") {
+    return slot.iso;
+  }
+  throw new Error(`cadence/slot mismatch: cadence.type=${cadence.type} slot.kind=${slot.kind}`);
+}
+
+/** ISO date of the cycle's start. For annual/biannual that's the
+ *  day after the previous slot's deadline; for monthly the 1st of
+ *  the month; weekly the Monday of the ISO week; daily same as
+ *  deadline. */
+export function cycleStart(cadence: Cadence, slot: CycleSlot): string {
+  if (cadence.type === "annual" && slot.kind === "annual") {
+    const [{ month, day }] = cadence.cycles;
+    const prevDeadline = isoDate(localDate(slot.year - 1, month - 1, day));
+    return addDays(prevDeadline, 1);
+  }
+  if (cadence.type === "biannual" && slot.kind === "biannual") {
+    if (slot.half === 1) {
+      const [, second] = cadence.cycles;
+      const prevDeadline = isoDate(localDate(slot.year - 1, second.month - 1, second.day));
+      return addDays(prevDeadline, 1);
+    }
+    const [first] = cadence.cycles;
+    const prevDeadline = isoDate(localDate(slot.year, first.month - 1, first.day));
+    return addDays(prevDeadline, 1);
+  }
+  if (cadence.type === "monthly" && slot.kind === "monthly") {
+    return isoDate(localDate(slot.year, slot.month - 1, 1));
+  }
+  if (cadence.type === "weekly" && slot.kind === "weekly") {
+    return isoWeekMonday(slot.year, slot.week);
+  }
+  if (cadence.type === "daily" && slot.kind === "daily") {
+    return slot.iso;
+  }
+  throw new Error(`cadence/slot mismatch: cadence.type=${cadence.type} slot.kind=${slot.kind}`);
+}
+
+/** On-disk cycle id string. Stable / deterministic — used as the
+ *  per-cycle markdown file name under obligations/<id>/<cycleId>.md. */
+export function formatCycleId(slot: CycleSlot): string {
+  if (slot.kind === "annual") return `${slot.year}`;
+  if (slot.kind === "biannual") return `${slot.year}-h${slot.half}`;
+  if (slot.kind === "monthly") return `${slot.year}-${String(slot.month).padStart(2, "0")}`;
+  if (slot.kind === "weekly") return `${slot.year}-W${String(slot.week).padStart(2, "0")}`;
+  return slot.iso;
+}
+
+/** Advance to the next slot after `current` for this cadence. Used
+ *  by next-cycle provisioning when a cycle closes. */
+export function nextSlot(cadence: Cadence, current: CycleSlot): CycleSlot {
+  if (cadence.type === "annual" && current.kind === "annual") {
+    return { kind: "annual", year: current.year + 1 };
+  }
+  if (cadence.type === "biannual" && current.kind === "biannual") {
+    if (current.half === 1) return { kind: "biannual", year: current.year, half: 2 };
+    return { kind: "biannual", year: current.year + 1, half: 1 };
+  }
+  if (cadence.type === "monthly" && current.kind === "monthly") {
+    const next = localDate(current.year, current.month, 1);
+    return { kind: "monthly", year: next.getFullYear(), month: next.getMonth() + 1 };
+  }
+  if (cadence.type === "weekly" && current.kind === "weekly") {
+    const monday = isoWeekMonday(current.year, current.week);
+    const nextMondayIso = addDays(monday, 7);
+    const { year, week } = isoWeekYearAndNumber(parseLocalIsoDate(nextMondayIso));
+    return { kind: "weekly", year, week };
+  }
+  if (cadence.type === "daily" && current.kind === "daily") {
+    return { kind: "daily", iso: addDays(current.iso, 1) };
+  }
+  throw new Error(`cadence/slot mismatch: cadence.type=${cadence.type} current.kind=${current.kind}`);
+}

package/src/types/encore-dsl/schema.ts

@@ -0,0 +1,288 @@
+// Encore DSL Zod schema.
+//
+// One obligation = one DSL document, validated end-to-end on every
+// setup / amendDefinition call. The discriminated union on `type`
+// (payment | service) enforces `currency` required iff payment. The
+// cross-field rules (cadence cycle-count, step-field ownership, at-
+// expression validity, etc.) live in superRefine blocks at the leaf
+// or document level.
+//
+// Naming convention (a deliberate distinction):
+//   - KEBAB regex (slug ids): obligation id, target id, step id —
+//     these become file/folder names and routes, so case-sensitive
+//     paths matter.
+//   - IDENTIFIER regex (field names): camelCase or kebab — Claude
+//     composes "invoiceReceivedOn" / "paidOn" naturally and the
+//     surrounding codebase uses camelCase identifiers everywhere.
+//
+// See plans/feat-encore-plugin.md §The Encore DSL for the full
+// natural-language spec; this file is its executable form.
+
+import { z } from "zod";
+import { CadenceSchema } from "./cadence.js";
+import { atExprSchema, parseAtExpression } from "./at-expression.js";
+import { resolveAtExpression } from "./at-resolver.js";
+
+const KEBAB = /^[a-z][a-z0-9-]*$/;
+const IDENTIFIER = /^[a-z][a-zA-Z0-9_-]*$/;
+const ISO_4217 = /^[A-Z]{3}$/;
+
+const kebabId = z.string().regex(KEBAB, "must be kebab-case (lowercase letters, digits, hyphens; starts with a letter)");
+const fieldName = z.string().regex(IDENTIFIER, "must be a valid identifier (lowercase start; letters / digits / _ / -)");
+
+// ── formSchema field ────────────────────────────────────────────
+
+const FIELD_TYPES = ["string", "text", "url", "email", "date", "number", "boolean", "enum"] as const;
+export type FormFieldType = (typeof FIELD_TYPES)[number];
+
+const FormField = z
+  .object({
+    name: fieldName,
+    type: z.enum(FIELD_TYPES),
+    label: z.string().min(1),
+    required: z.boolean().optional(),
+    placeholder: z.string().optional(),
+    options: z.array(z.string().min(1)).optional(),
+  })
+  .superRefine((field, ctx) => {
+    if (field.type === "enum") {
+      if (!field.options || field.options.length === 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "type=enum requires non-empty options[]",
+          path: ["options"],
+        });
+      }
+    } else if (field.options && field.options.length > 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `options[] is only meaningful for type=enum; got type=${field.type}`,
+        path: ["options"],
+      });
+    }
+  });
+
+export type FormFieldDef = z.infer<typeof FormField>;
+
+const FormSchema = z.object({
+  fields: z.array(FormField).min(1),
+});
+
+// ── target / step ───────────────────────────────────────────────
+
+const Target = z.object({
+  id: kebabId,
+  displayName: z.string().min(1),
+  /** Pre-fill map — field-name → default value. The LLM treats
+   *  presence of a default as "don't ask; auto-record". Validated
+   *  against formSchema in the doc-level superRefine. */
+  defaults: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type TargetDef = z.infer<typeof Target>;
+
+const Severity = z.enum(["info", "warning", "urgent"]);
+export type Severity = z.infer<typeof Severity>;
+
+const FiringPhase = z.object({
+  at: atExprSchema({ allowStepDeadline: true }),
+  severity: Severity,
+});
+
+const Step = z.object({
+  id: kebabId,
+  displayName: z.string().min(1),
+  /** When this step's deadline falls. Resolved against
+   *  cycleStart / cycleDeadline — step-deadline anchor not allowed
+   *  here (it would be self-referential). */
+  deadline: atExprSchema({ allowStepDeadline: false }),
+  firingPlan: z.array(FiringPhase).min(1),
+  /** Field names this step is responsible for. Must reference
+   *  existing formSchema field names; checked at document level. */
+  fields: z.array(fieldName),
+});
+
+export type StepDef = z.infer<typeof Step>;
+
+// ── carryForward ────────────────────────────────────────────────
+
+const CarryForward = z.object({
+  body: z.enum(["empty", "copy"]).default("empty"),
+});
+
+// ── top-level DSL (discriminated union on type) ─────────────────
+
+const STATUS = ["active", "paused", "retired"] as const;
+
+const sharedFields = {
+  version: z.literal(1),
+  /** Generated server-side from displayName at setup; the DSL Claude
+   *  composes omits it. We keep the field optional in the input
+   *  schema so amend operations work; setup explicitly strips. */
+  id: kebabId.optional(),
+  displayName: z.string().min(1),
+  status: z.enum(STATUS).default("active"),
+  /** Generated server-side at setup. */
+  createdAt: z.string().optional(),
+
+  cadence: CadenceSchema,
+  targets: z.array(Target).min(1),
+  steps: z.array(Step).min(1),
+  formSchema: FormSchema,
+  carryForward: CarryForward.optional(),
+};
+
+const PaymentDsl = z.object({
+  ...sharedFields,
+  type: z.literal("payment"),
+  currency: z.string().regex(ISO_4217, "currency must be a 3-letter uppercase ISO 4217 code (e.g. JPY, USD, EUR)"),
+});
+
+const ServiceDsl = z.object({
+  ...sharedFields,
+  type: z.literal("service"),
+});
+
+// ── cross-field validators (split out so the per-document
+// superRefine stays under the cognitive-complexity threshold) ─────
+
+interface Doc {
+  targets: TargetDef[];
+  steps: StepDef[];
+  formSchema: { fields: FormFieldDef[] };
+}
+type Ctx = z.RefinementCtx;
+
+function validateUniqueIds(doc: Doc, ctx: Ctx): { fieldNames: Set<string> } {
+  const targetIds = new Set<string>();
+  for (const target of doc.targets) {
+    if (targetIds.has(target.id)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate target id ${JSON.stringify(target.id)}`, path: ["targets"] });
+    }
+    targetIds.add(target.id);
+  }
+  const stepIds = new Set<string>();
+  for (const step of doc.steps) {
+    if (stepIds.has(step.id)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate step id ${JSON.stringify(step.id)}`, path: ["steps"] });
+    }
+    stepIds.add(step.id);
+  }
+  const fieldNames = new Set<string>();
+  for (const field of doc.formSchema.fields) {
+    if (fieldNames.has(field.name)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate formSchema field name ${JSON.stringify(field.name)}`, path: ["formSchema", "fields"] });
+    }
+    fieldNames.add(field.name);
+  }
+  return { fieldNames };
+}
+
+function validateFieldOwnership(doc: Doc, fieldNames: Set<string>, ctx: Ctx): void {
+  const claims = new Map<string, string[]>();
+  for (const step of doc.steps) {
+    for (const fname of step.fields) {
+      if (!fieldNames.has(fname)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `step ${JSON.stringify(step.id)} references unknown formSchema field ${JSON.stringify(fname)}`,
+          path: ["steps"],
+        });
+        continue;
+      }
+      const list = claims.get(fname) ?? [];
+      list.push(step.id);
+      claims.set(fname, list);
+    }
+  }
+  for (const fname of fieldNames) {
+    const list = claims.get(fname) ?? [];
+    if (list.length === 0) {
+      // The LLM gets stuck here in a known loop: error #1 says "field not
+      // claimed", LLM removes the field, then `formSchema.fields.min(1)`
+      // fires and the LLM has no path forward (formSchema is non-optional
+      // and must have ≥1 field). Tell it the resolution explicitly: claim
+      // the field from a step. Reference the no-data pattern in the docs
+      // so the LLM can also pick the inverse (placeholder field claimed
+      // by the single step) when that fits the obligation better.
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          `formSchema field ${JSON.stringify(fname)} is not claimed by any step.fields[]. ` +
+          `Add ${JSON.stringify(fname)} to exactly one of the entries in steps[].fields[] ` +
+          `(every formSchema field must be claimed by one step). ` +
+          `If the obligation has nothing to record, see the "obligation with nothing to record" example in config/helps/encore-dsl.md ` +
+          `— you still need one placeholder field claimed by the step.`,
+        path: ["formSchema", "fields"],
+      });
+    } else if (list.length > 1) {
+      const owners = list.map((stepId) => JSON.stringify(stepId)).join(", ");
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `formSchema field ${JSON.stringify(fname)} is claimed by multiple steps: ${owners}`,
+        path: ["formSchema", "fields"],
+      });
+    }
+  }
+}
+
+function validateDefaultKeys(doc: Doc, fieldNames: Set<string>, ctx: Ctx): void {
+  for (const target of doc.targets) {
+    if (!target.defaults) continue;
+    for (const key of Object.keys(target.defaults)) {
+      if (!fieldNames.has(key)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `target ${JSON.stringify(target.id)} default for ${JSON.stringify(key)} references unknown formSchema field`,
+          path: ["targets"],
+        });
+      }
+    }
+  }
+}
+
+function validateFiringPlanOrder(doc: Doc, ctx: Ctx): void {
+  // Use a representative cycle (the actual date doesn't matter, only
+  // the relative ordering of phases against it).
+  const anchorsBase = { cycleStart: "2026-01-01", cycleDeadline: "2026-12-31" };
+  for (const step of doc.steps) {
+    let stepDeadlineIso: string | undefined;
+    try {
+      const expr = parseAtExpression(step.deadline, { allowStepDeadline: false });
+      stepDeadlineIso = resolveAtExpression(expr, anchorsBase);
+    } catch {
+      continue;
+    }
+    const anchors = { ...anchorsBase, stepDeadline: stepDeadlineIso };
+    let prev: string | null = null;
+    for (let i = 0; i < step.firingPlan.length; i++) {
+      const phase = step.firingPlan[i];
+      let resolved: string;
+      try {
+        const expr = parseAtExpression(phase.at, { allowStepDeadline: true });
+        resolved = resolveAtExpression(expr, anchors);
+      } catch {
+        continue;
+      }
+      if (prev !== null && resolved < prev) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `step ${JSON.stringify(step.id)}: firingPlan[${i}].at ${JSON.stringify(phase.at)} resolves before the previous phase — phases must be chronologically ordered`,
+          path: ["steps"],
+        });
+      }
+      prev = resolved;
+    }
+  }
+}
+
+/** Top-level DSL union. Input shape — the post-superRefine resolved
+ *  shape lives in `EncoreDsl` below. */
+export const EncoreDslInput = z.discriminatedUnion("type", [PaymentDsl, ServiceDsl]).superRefine((doc, ctx) => {
+  const { fieldNames } = validateUniqueIds(doc, ctx);
+  validateFieldOwnership(doc, fieldNames, ctx);
+  validateDefaultKeys(doc, fieldNames, ctx);
+  validateFiringPlanOrder(doc, ctx);
+});
+
+export type EncoreDsl = z.infer<typeof EncoreDslInput>;

package/src/types/notification.ts

@@ -69,7 +69,7 @@ export type NotificationPriority = (typeof NOTIFICATION_PRIORITIES)[keyof typeof
 // router / page component needs to jump to a specific item. Omitting
 // the identifier lands on the feature's index view.
 export type NotificationTarget =
-  | { view: typeof NOTIFICATION_VIEWS.chat; sessionId: string; resultUuid?: string }
+  | { view: typeof NOTIFICATION_VIEWS.chat; sessionId: string }
   | { view: typeof NOTIFICATION_VIEWS.todos; itemId?: string }
   | { view: typeof NOTIFICATION_VIEWS.calendar }
   | { view: typeof NOTIFICATION_VIEWS.automations; taskId?: string }
@@ -96,6 +96,7 @@ export type NotificationAction =
  *  client is on. Other notification kinds may opt in later. */
 export interface NotificationI18n {
   titleKey: string;
+  titleParams?: Readonly<Record<string, string | number | readonly string[]>>;
   bodyKey?: string;
   bodyParams?: Readonly<Record<string, string | number | readonly string[]>>;
 }

package/src/types/session.ts

@@ -63,7 +63,13 @@ export interface SessionSummary {
   isBookmarked?: boolean;
   // Live state from the server session store (present when the
   // session has an active in-memory entry on the server).
+  //
+  // `isRunning` — broad: agent turn live OR background generation
+  // pending. Drives the sidebar busy indicator.
+  // `liveIsRunning` — narrow: mirrors the DELETE 409 gate exactly
+  // (#1195). `false` ⇒ a DELETE on this session will be accepted.
   isRunning?: boolean;
+  liveIsRunning?: boolean;
   hasUnread?: boolean;
   statusMessage?: string;
 }

package/src/types/sse.ts

@@ -17,6 +17,11 @@ export interface SseToolCallResult {
   type: typeof EVENT_TYPES.toolCallResult;
   toolUseId: string;
   content: string;
+  /** Set when the tool-result block carried `is_error: true` —
+   *  forwarded from `AgentEvent.toolCallResult.isError` so the
+   *  frontend can render the chip distinctly. Drives the MCP
+   *  failure monitor (#1353). */
+  isError?: boolean;
 }
 
 export interface SseStatus {

package/src/types/toolCallHistory.ts

@@ -3,6 +3,8 @@
 // session domain types, the pending-calls helper, etc.) can refer
 // to it without depending on a Vue file.
 
+import type { McpHint } from "../utils/agent/mcpHint";
+
 export interface ToolCallHistoryItem {
   toolUseId: string;
   toolName: string;
@@ -10,4 +12,9 @@ export interface ToolCallHistoryItem {
   timestamp: number;
   result?: string;
   error?: string;
+  /** Structured hint surfaced next to `error` when the failing tool
+   *  belongs to a catalogued MCP server. Lets the right-sidebar
+   *  render setup-guide links / required-key reminders without the
+   *  caller re-parsing the tool name. (#1354) */
+  mcpHint?: McpHint;
 }