mockpit 2.0.0 → 3.1.0

package/dist/server/mcpSpec.d.ts

@@ -8,14 +8,14 @@ export declare const MCP_INSTRUCTIONS: string;
 export declare const mcpSurfaceSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     kind: z.ZodOptional<z.ZodEnum<{
-        html: "html";
+        code: "code";
         diff: "diff";
+        html: "html";
         image: "image";
+        json: "json";
         markdown: "markdown";
-        terminal: "terminal";
         mermaid: "mermaid";
-        json: "json";
-        code: "code";
+        terminal: "terminal";
     }>>;
     html: z.ZodOptional<z.ZodString>;
     kits: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -30,8 +30,8 @@ export declare const mcpSurfaceSchema: z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     layout: z.ZodOptional<z.ZodEnum<{
-        unified: "unified";
         split: "split";
+        unified: "unified";
     }>>;
     assetId: z.ZodOptional<z.ZodString>;
     alt: z.ZodOptional<z.ZodString>;
@@ -54,7 +54,7 @@ type Param = {
     d?: string;
     req?: boolean;
 } | {
-    t: "surfaces" | "asks" | "object" | "integers" | "strings";
+    t: "surfaces" | "asks" | "object" | "objects" | "named" | "pairs" | "json" | "integers" | "strings";
     d?: string;
     req?: boolean;
 };
@@ -72,115 +72,115 @@ export declare const HTTP_MCP_TOOLS: ({
     _meta: {
         "anthropic/alwaysLoad": boolean;
     };
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 } | {
     _meta?: undefined;
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 })[];
 export declare const STDIO_MCP_CATALOG: ({
     _meta: {
         "anthropic/alwaysLoad": boolean;
     };
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 } | {
     _meta?: undefined;
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 })[];
 export declare const HTTP_RUN_TOOLS: ({
     _meta: {
         "anthropic/alwaysLoad": boolean;
     };
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 } | {
     _meta?: undefined;
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 })[];
 export declare const STDIO_RUN_CATALOG: ({
     _meta: {
         "anthropic/alwaysLoad": boolean;
     };
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 } | {
     _meta?: undefined;
-    outputSchema?: Json | undefined;
     name: string;
     description: string;
     inputSchema: Json;
+    outputSchema?: Json | undefined;
 })[];
 export declare const STDIO_MCP_TOOLS: ({
     _meta: {
         "anthropic/alwaysLoad": boolean;
     };
-    outputSchema?: z.ZodObject<{
-        [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    }, z.core.$loose> | undefined;
     name: string;
     description: string;
     inputSchema: Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }>;
-} | {
-    _meta?: undefined;
     outputSchema?: z.ZodObject<{
         [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }, z.core.$loose> | undefined;
+} | {
+    _meta?: undefined;
     name: string;
     description: string;
     inputSchema: Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }>;
+    outputSchema?: z.ZodObject<{
+        [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose> | undefined;
 })[];
 export declare const STDIO_RUN_TOOLS: ({
     _meta: {
         "anthropic/alwaysLoad": boolean;
     };
-    outputSchema?: z.ZodObject<{
-        [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    }, z.core.$loose> | undefined;
     name: string;
     description: string;
     inputSchema: Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }>;
-} | {
-    _meta?: undefined;
     outputSchema?: z.ZodObject<{
         [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }, z.core.$loose> | undefined;
+} | {
+    _meta?: undefined;
     name: string;
     description: string;
     inputSchema: Readonly<{
         [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     }>;
+    outputSchema?: z.ZodObject<{
+        [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose> | undefined;
 })[];
 export declare const MCP_TOOL_NAMES: string[];
 export declare function toolResult(name: string, value: unknown): {
-    structuredContent?: Record<string, unknown> | undefined;
     content: {
         type: "text";
         text: string;
     }[];
+    structuredContent?: Record<string, unknown> | undefined;
 };
 export declare const MAX_RESULT_IMAGES = 8;
 export declare function withFeedbackImages<T extends {
@@ -190,11 +190,11 @@ export declare function withFeedbackImages<T extends {
     mimeType: string;
 } | null>): Promise<T>;
 export declare function runToolResult(envelope: unknown): {
-    isError?: boolean | undefined;
-    structuredContent?: Record<string, unknown> | undefined;
     content: {
         type: "text";
         text: string;
     }[];
+    structuredContent?: Record<string, unknown> | undefined;
+    isError?: boolean | undefined;
 };
 export {};

package/dist/server/mcpSpec.js

@@ -4,24 +4,23 @@ import { GUIDE_TOPICS } from "./designGuide.js";
 import { feedbackImages } from "./feedbackBatch.js";
 import { KIT_IDS } from "./kits.js";
 import { RUN_DESCRIPTION } from "./runApi.js";
-import { SURFACE_KINDS } from "./types.js";
+import { MAX_NOTES, SURFACE_KINDS } from "./types.js";
 export const MCP_SERVER_INFO = { name: "mockpit", version: "0.2.0" };
 // The `kind` enum both MCP transports advertise — derived from the one canonical
 // list (types.ts) so the MCP tier can never fall behind what REST/CLI accept.
 const SURFACE_KIND_ENUM = [...SURFACE_KINDS];
-export const MCP_INSTRUCTIONS = "Mockpit shows design work to the user: project > mock > state > variant > version. publish " +
+export const MCP_INSTRUCTIONS = "Mockpit shows design work to the user: project > design > state > variant > version. publish " +
     "each variant (name states in the user's words; declare parts with data-part); publish again to " +
     "revise. A choice is several variants plus one question that binds them (ask). One render plus a " +
     "control: declare a knob. Say where to look, then end your turn; nothing waits. When the " +
     "user says they answered, call feedback. Writes return feedback too; it is delivered once. " +
     "Fetch guide before html.";
 const field = {
-    mock: "Mock slug or id",
+    design: "Design slug, title or id",
     state: "State label; omit if single-state",
-    situation: 'Another render of this state ("Couldn\'t save", "Loading"); publish the state itself first',
     variant: 'Variant label; default "default"',
     project: "Default: the session's project",
-    title: "Mock title",
+    title: "Design title",
     session: "Session id from an earlier publish",
     sessionTitle: "Task name; used only when creating the session",
     agent: "Agent name for a new session",
@@ -29,11 +28,13 @@ const field = {
     knobs: 'Global knobs (tunekit usePane shape) keyed by path: [default,min,max,step], boolean, {type:"select",options}, "#hex"',
     variantKnobs: "Knobs this variant alone has",
     from: "Branch from this version",
+    amend: "Replace the latest version in place: a fix before the user acts on it",
+    withdraw: "Take the latest version back, before the user acts on it",
     fork: 'Start this new variant from a sibling: "variant" or "variant@N"; alone it copies it, with parts/fills it edits the copy',
     prompt: "What prompted this version; usually omit",
-    note: "What this variant is; shown beside it, never in the html",
+    description: "What this variant is; shown beside it, never in the html",
     widths: "Widths it ships at, side by side: [390,1280]",
-    kind: "Only when building the product's screens: page (a screen), component (a piece pages embed). Omit for sketches, diagrams and reviews",
+    kind: "Only when building the product's screens: screen, component (a reusable design screens embed). With no html it plans one, drawn by a later publish. Omit for ideas, diagrams and reviews",
     area: 'Product area in the project\'s words; Home groups by it. "" clears',
     source: 'Code path implementing it. "" clears',
     flow: "Flow this state is a step of; alone, only places it",
@@ -82,8 +83,12 @@ export const mcpSurfaceSchema = z
 const askSchema = z.object({
     id: z.string().optional().describe("Stable id; reusing one replaces that question"),
     text: z.string().describe("The question, one sentence"),
-    scope: z.enum(["mock", "state", "part"]).optional(),
+    scope: z.enum(["design", "state", "part"]).optional(),
     state: z.string().optional(),
+    states: z
+        .array(z.string())
+        .optional()
+        .describe("Design-wide question: the states its answers can be seen on, best first"),
     part: z.string().optional().describe("data-part name, for scope part"),
     multi: z.boolean().optional(),
     after: z
@@ -96,6 +101,13 @@ const askSchema = z.object({
         variant: z.string().optional().describe("Bind to a published variant"),
         version: z.number().int().optional().describe("And one version of it"),
         set: z.record(z.string(), z.unknown()).optional().describe("Or to knob values {path: value}"),
+        style: z.string().optional().describe("With a set of a new value: its CSS"),
+        fill: z.string().optional().describe("With a set of {part: new fill}: its html"),
+        palette: z
+            .string()
+            .optional()
+            .describe("Or a palette id of the project's system; the answer makes it the default"),
+        html: z.string().optional().describe("Or a whole page"),
         recommended: z.boolean().optional().describe("The one you would pick; one per ask"),
     })),
 });
@@ -114,6 +126,23 @@ function zodParam(p) {
         case "object":
             s = z.record(z.string(), z.unknown());
             break;
+        case "objects":
+            s = z.array(z.record(z.string(), z.unknown()));
+            break;
+        // A list of objects where a bare name stands for {name}.
+        case "named":
+            s = z.array(z.union([z.string(), z.record(z.string(), z.unknown())]));
+            break;
+        // [foreground, background, minimum?]
+        case "pairs":
+            s = z.array(z
+                .array(z.union([z.string(), z.number()]))
+                .min(2)
+                .max(3));
+            break;
+        case "json":
+            s = z.unknown();
+            break;
         case "integer":
             s = z.number().int();
             break;
@@ -131,22 +160,21 @@ function zodParam(p) {
     return p.req ? s : s.optional();
 }
 const P = {
-    mock: { t: "string", d: field.mock, req: true },
+    design: { t: "string", d: field.design, req: true },
     state: { t: "string", d: field.state },
     variant: { t: "string", d: field.variant },
     project: { t: "string", d: field.project },
     session: { t: "string", d: field.session },
 };
-const VARIANT_REF = { mock: P.mock, state: P.state, variant: P.variant, project: P.project };
+const VARIANT_REF = { design: P.design, state: P.state, variant: P.variant, project: P.project };
 export const MCP_TOOL_DEFS = [
     {
         name: "publish",
-        description: "Create or version one variant of one state of a mock. One of html, surfaces (the full ordered list), parts or fills (splice the latest version). Returns parts per state, nudges, feedback.",
+        description: "Create or version one variant of one state of a design. One of html, surfaces (the full ordered list), parts or fills (splice the latest version); or kind screen or component and none of them, to plan it. Returns parts per state, nudges, feedback.",
         params: {
             ...VARIANT_REF,
-            situation: { t: "string", d: field.situation },
             title: { t: "string", d: field.title },
-            kind: { t: "enum", values: ["page", "component", "sketch"], d: field.kind },
+            kind: { t: "enum", values: ["screen", "component", "idea"], d: field.kind },
             area: { t: "string", d: field.area },
             source: { t: "string", d: field.source },
             html: { t: "string", d: field.html },
@@ -164,8 +192,10 @@ export const MCP_TOOL_DEFS = [
             variantKnobs: { t: "object", d: field.variantKnobs },
             from: { t: "integer", d: field.from },
             fork: { t: "string", d: field.fork },
+            amend: { t: "boolean", d: field.amend },
+            withdraw: { t: "boolean", d: field.withdraw },
             prompt: { t: "string", d: field.prompt },
-            note: { t: "string", d: field.note },
+            description: { t: "string", d: field.description },
             widths: { t: "integers", d: field.widths },
             flow: { t: "string", d: field.flow },
             step: { t: "integer", d: field.step },
@@ -177,9 +207,9 @@ export const MCP_TOOL_DEFS = [
     },
     {
         name: "ask",
-        description: "Ask structured questions on a mock. A choice is several variants plus one question that binds them; options may also set knob values. Reusing a question id replaces it.",
+        description: "Ask structured questions on a design. A choice is several variants plus one question that binds them; options may also set knob values. Reusing a question id replaces it.",
         params: {
-            mock: P.mock,
+            design: P.design,
             project: P.project,
             asks: { t: "asks", d: "Questions with options", req: true },
             session: P.session,
@@ -188,21 +218,25 @@ export const MCP_TOOL_DEFS = [
     },
     {
         name: "read",
-        description: "Without mock: every mock (slug, states, variants, open questions), flows, plus pending. With mock: its states, variants, questions with answers, parts, knobs and settled values (every answer's set and tuning sent so far), plus pending. Never consumes feedback.",
+        description: "Read this first. Both forms carry decisionList: what the user already settled in this project; it stands unless they say otherwise. Without design: every design (slug, states, variants, open questions), flows, plus pending. With design: its notes (a spec; the user's edits stand), states, variants, questions with answers, parts, knobs and settled values (every answer's set and tuning sent so far), plus pending. Never consumes feedback.",
         params: {
-            mock: { t: "string", d: field.mock },
+            design: { t: "string", d: field.design },
             project: P.project,
             body: { t: "boolean", d: "Include each variant's surfaces" },
             history: { t: "boolean", d: "Include version rows" },
             tree: {
                 t: "boolean",
-                d: "Without mock: the project as a tree (each mock's variants with status and forkedFrom, the mocks it embeds and is embedded in)",
+                d: "Without design: the project as a tree (each design's variants with status and forkedFrom, the designs it embeds and is embedded in)",
+            },
+            decisions: {
+                t: "boolean",
+                d: "Only the whole decision list, when decisionList says it was cut",
             },
         },
     },
     {
         name: "feedback",
-        description: "Returns at once: what the user sent since you last heard (one batch per mock: reply answers, borrowed parts, tuned knobs, part comments, verdict; thread messages; inUse/archived; or closed with the questions it dismissed), delivered once, plus pending (viewer open, draft progress).",
+        description: "Returns at once: what the user sent since you last heard (one batch per design: reply answers, borrowed parts, tuned knobs, part comments, verdict; thread messages; inUse/archived), delivered once, plus pending (viewer open, draft progress).",
         params: {
             project: P.project,
             session: { t: "string", d: "Session id returned by publish", req: true },
@@ -211,7 +245,7 @@ export const MCP_TOOL_DEFS = [
     },
     {
         name: "say",
-        description: "Post a short plain-text message in a mock's thread. Returns feedback.",
+        description: "Post a short plain-text message in a design's thread. Returns feedback.",
         params: {
             ...VARIANT_REF,
             message: { t: "string", d: "Plain text", req: true },
@@ -219,24 +253,47 @@ export const MCP_TOOL_DEFS = [
         },
         httpOnly: ["session"],
     },
+    {
+        name: "move",
+        description: "Tidy up variants: to or toState moves them there and out of here; archive takes them out of view; restore brings them back; a group goes along; one in use stays. Only when the user asks: hideOlder hides each variant's older versions (variants optional: all of them), and deleteOlder deletes them for good, skipping any that a reply, comment, question, embed, copy or fork still points at, or that is in use. Confirm a delete first: it can't be undone. Returns feedback.",
+        params: {
+            design: P.design,
+            state: P.state,
+            variants: { t: "strings", d: "Variant names; required except with hideOlder or deleteOlder" },
+            to: { t: "string", d: "Target design; default this one" },
+            toState: { t: "string", d: "Target state; created if new" },
+            archive: { t: "boolean" },
+            restore: { t: "boolean" },
+            hideOlder: { t: "boolean", d: "Hide all but each variant's newest visible version" },
+            deleteOlder: { t: "boolean", d: "Delete them instead; permanent, skips what's referenced" },
+            project: P.project,
+            session: P.session,
+        },
+        httpOnly: ["session"],
+    },
     {
         name: "export",
-        description: "The html in use (else current) per state, version history, screenshot URL, knobs, the settled values and the last reply.",
-        params: VARIANT_REF,
+        description: "The html in use (else current) per state, version history, screenshot URL, knobs, the settled values and the last reply. Without design: the project's system for code (sheet, tokens as CSS and JSON, settled project knobs, components' sources).",
+        params: { ...VARIANT_REF, design: { t: "string", d: field.design } },
     },
     {
         name: "edit",
-        description: "Change a mock without a new version; a new slug rewrites every reference to the old one. Without mock, rename renames the project and areaOrder orders its areas. Returns feedback.",
+        description: "Change a design without a new version; a new slug rewrites every reference to the old one. Without design, rename renames the project and areaOrder orders its areas. Returns feedback.",
         params: {
-            mock: { t: "string", d: field.mock },
+            design: { t: "string", d: field.design },
             project: P.project,
             slug: { t: "string" },
             title: { t: "string" },
-            kind: { t: "enum", values: ["page", "component", "sketch"] },
+            kind: { t: "enum", values: ["screen", "component", "idea"] },
             area: { t: "string" },
             source: { t: "string" },
+            firstState: { t: "string", d: "Names a design's one unnamed state, so it can have more" },
+            notes: {
+                t: "string",
+                d: `A short plain-text spec, at most ${MAX_NOTES} characters; "" clears. Not applied over the user's own edit, and the result says so`,
+            },
             rename: { t: "string", d: "New project name" },
-            areaOrder: { t: "strings", d: "Without mock: Home's area order" },
+            areaOrder: { t: "strings", d: "Without design: Home's area order" },
             session: P.session,
         },
         httpOnly: ["session"],
@@ -254,10 +311,34 @@ export const MCP_TOOL_DEFS = [
         httpOnly: ["session"],
         stdioExtra: { path: { t: "string", d: "Local file path; use instead of data" } },
     },
+    {
+        name: "system",
+        description: "Read or change the project's system (sheet, tokens, scales, palettes, project knobs), which every render wears at once. No arguments reads it; each argument replaces its part, tokens, scales and palettes upsert. Shapes: topic system.",
+        params: {
+            project: P.project,
+            sheet: { t: "string", d: "CSS; no @import" },
+            classes: { t: "named", d: "[{name, note}] or names" },
+            fonts: { t: "objects", d: "[{family, href?}]" },
+            tokens: { t: "objects", d: "[{name, type, value, note?}]" },
+            scales: {
+                t: "objects",
+                d: "[{id, family: type|space, prefix, steps, zero, base, ratio, fluid?}]",
+            },
+            roles: { t: "named", d: "[{name, note}] or names" },
+            palettes: { t: "objects", d: "[{id, label, note, light, dark}]" },
+            pairs: { t: "pairs", d: "[[fg, bg, min?]]" },
+            as: { t: "object" },
+            knobs: { t: "object", d: "Project knobs" },
+            remove: { t: "object", d: "{tokens?, palettes?, scales?}" },
+            restore: { t: "integer", d: "A revision, alone" },
+            session: P.session,
+        },
+        httpOnly: ["session"],
+    },
     {
         name: "guide",
         description: "Fetch the brief: the loop, parts, asks and knobs, feedback, the html contract, and this " +
-            "project's palette, kit and icons. Read it before the first publish. Pass topic for one " +
+            "project's system, kit and icons. Read it before the first publish. Pass topic for one " +
             `reference section (${GUIDE_TOPICS.join(", ")}).`,
         params: {
             project: P.project,
@@ -294,14 +375,14 @@ const bag = z.record(z.string(), z.unknown());
 const variantRef = o({ state: nullStr, variant: str });
 const inUseRef = o({ state: nullStr, variant: str, version: num });
 const partsByState = z.array(o({ state: nullStr, parts: z.array(o({ name: str })) }));
-const flowSchema = o({ name: str, steps: z.array(o({ mock: str, state: nullStr })) });
+const flowSchema = o({ name: str, steps: z.array(o({ design: str, state: nullStr })) });
 const feedbackSchema = o({
-    mock: nullStr,
+    design: nullStr,
     reply: o({
         asks: z.array(o({
             ask: str,
             chosen: z.array(o({ label: str, other: z.literal(true).optional() })),
-            note: str.optional(),
+            description: str.optional(),
         })),
         borrowed: bag.describe("Part → the variant to take it from"),
         tuned: bag,
@@ -309,39 +390,47 @@ const feedbackSchema = o({
         reactions: strs.optional().describe('One-tap reactions, e.g. 👍 part "hero" (variant B)'),
         verdict: o({ kind: z.enum(["use", "revise"]), state: nullStr, variant: str })
             .optional()
-            .describe("Use this or Revise on one variant"),
+            .describe("Use this or New version on one variant"),
+        more: o({
+            ask: str,
+            text: str,
+            existing: strs,
+            note: str.optional(),
+            answered: z.array(o({ ask: str, text: str, chosen: strs, comment: str.optional() })),
+        })
+            .optional()
+            .describe("The user wants more answers to this question: ask it again, same id, with them"),
     })
         .nullable()
         .describe("The user's Send; null if only messages"),
     messages: z.array(o({ seq: num, text: str })).describe("What the user wrote in the thread"),
     inUse: z.array(inUseRef).describe("In use, each at the version the user put in use"),
     archived: z.array(variantRef),
-    closed: z
-        .literal(true)
-        .optional()
-        .describe("The user closed the mock: its open questions were closed unanswered"),
-    dismissed: z
-        .array(o({ ask: str, text: str }))
-        .optional()
-        .describe("The questions the close dismissed; don't ask them again"),
-    edited: o({ kind: str.optional(), area: nullStr.optional() })
+    edited: o({
+        kind: str.optional(),
+        area: nullStr.optional(),
+        notes: nullStr.optional(),
+    })
         .optional()
-        .describe("The user moved the mock from Home: its kind or area now"),
+        .describe("The user moved the design from Home (its kind or area now) or edited its notes"),
 }).meta({ id: "Feedback" });
 // Typed once, on feedback: repeating it on every write would cost more than
 // the rest of the write's output schema.
 const feedbackRide = z.array(bag).describe("Feedback batches as the feedback tool returns");
 const pendingSchema = o({
-    mock: str,
-    closed: z.literal(true).optional(),
+    design: str,
+    archived: z.literal(true).optional(),
     viewerOpen: z.boolean(),
     draft: o({ answered: num, of: num, comments: num, touchedAt: str }).nullable(),
 }).meta({ id: "Pending" });
 const writeOutput = {
-    post: o({ state: nullStr, variant: str, version: num }),
+    post: o({ state: nullStr, variant: str, version: num })
+        .optional()
+        .describe("Absent when planned: nothing is drawn yet"),
+    planned: z.boolean().optional(),
     sessionId: str,
     url: str.describe("Viewer link for the user"),
-    parts: partsByState,
+    parts: partsByState.optional(),
     partChanges: o({ vanished: strs, renamed: z.array(o({ from: str, to: str })) }).optional(),
     nudges: strs.optional(),
     suggestedAsk: bag.optional().describe("Send with ask when a nudge names it"),
@@ -378,10 +467,33 @@ const OUTPUT_SCHEMAS = {
         feedback: feedbackRide,
     },
     feedback: {
-        feedback: z.array(feedbackSchema).describe("One batch per mock; empty when nothing is new"),
+        feedback: z.array(feedbackSchema).describe("One batch per design; empty when nothing is new"),
         pending: z.array(pendingSchema),
     },
     say: { feedback: feedbackRide },
+    move: {
+        variants: z.array(o({ state: str.nullable(), variant: str, status: str })),
+        versions: z
+            .array(o({ state: str.nullable(), variant: str, version: num }))
+            .optional()
+            .describe("With hideOlder or deleteOlder: what was hidden or deleted"),
+        skipped: z.array(o({ state: str.nullable().optional(), variant: str, version: num.optional(), why: str })),
+        to: o({ design: str, title: str, state: str.nullable() }).optional(),
+        saved: z
+            .array(o({ state: str.nullable(), variant: str, already: z.boolean() }))
+            .optional()
+            .describe("What each is called there"),
+        url: str,
+        feedback: feedbackRide,
+    },
+    system: {
+        rev: num,
+        changed: strs.optional().describe("What this write changed, as the Thread says it"),
+        checks: strs,
+        nudges: strs.optional(),
+        url: str,
+        feedback: feedbackRide.optional(),
+    },
     edit: {
         renamed: o({ from: str, to: str }).optional(),
         areaOrder: strs.optional(),
@@ -390,7 +502,7 @@ const OUTPUT_SCHEMAS = {
         feedback: feedbackRide,
     },
     read: {
-        mocks: z.array(o({ slug: str, states: strs, variants: num, open: num })).optional(),
+        designs: z.array(o({ slug: str, states: strs, variants: num, open: num })).optional(),
         states: strs.optional(),
         asks: z.array(o({ id: str, text: str })).optional(),
         variants: z
@@ -411,13 +523,31 @@ const OUTPUT_SCHEMAS = {
             .optional()
             .describe("Per state, the version the user put in use; export and embeds resolve to it"),
         knobs: bag.optional(),
+        system: str
+            .optional()
+            .describe("Without design: what the project's renders wear (rev, palettes, counts, failing checks)"),
         settled: bag.optional().describe("Every knob value the user has sent, later replies winning"),
         tree: z.array(bag).optional(),
         flows: z.array(flowSchema).optional(),
-        pending: z.union([z.array(pendingSchema), pendingSchema]),
+        decisionList: o({
+            total: num,
+            lines: z.array(o({
+                design: str,
+                text: str,
+                here: z.boolean().optional().describe("From the design read"),
+                system: z.boolean().optional().describe("The project's own, on every design"),
+                edited: z.boolean().optional(),
+                archived: z.boolean().optional(),
+            })),
+            more: str.optional(),
+        }).optional(),
+        total: num.optional(),
+        lines: z.array(bag).optional(),
+        pending: z.union([z.array(pendingSchema), pendingSchema]).optional(),
     },
     export: {
-        states: z.array(o({
+        states: z
+            .array(o({
             state: nullStr,
             variant: str,
             version: num,
@@ -425,9 +555,17 @@ const OUTPUT_SCHEMAS = {
             html: str.describe("With fills: only the chosen ones"),
             allFills: str.optional().describe("With fills: the html with every fill"),
             markdown: str,
-        })),
-        settled: bag,
-        reply: bag.nullable(),
+        }))
+            .optional(),
+        settled: bag.optional(),
+        reply: bag.nullable().optional(),
+        sheet: str.optional().describe("Without design: the project's sheet"),
+        css: str
+            .optional()
+            .describe("Without design: tokens as CSS, the default palette on :root, kept ones by [data-palette]"),
+        tokens: bag.optional().describe("Without design: the same as data"),
+        knobs: bag.optional().describe("Without design: the project knobs' values"),
+        components: z.array(bag).optional(),
     },
 };
 // The core loop, loaded up front by harnesses that defer the rest of the
@@ -443,9 +581,11 @@ function shapeFor(tool, transport) {
         shape[key] =
             transport === "stdio" && key === "html" && tool.name === "publish"
                 ? z.string().optional().describe(`${field.html}; or a file path`)
-                : transport === "stdio" && key === "poster" && tool.name === "publish"
-                    ? z.string().optional().describe(`${p.d}; or an image file path`)
-                    : zodParam(p);
+                : transport === "stdio" && key === "sheet" && tool.name === "system"
+                    ? z.string().optional().describe(`${p.d}; or a file path`)
+                    : transport === "stdio" && key === "poster" && tool.name === "publish"
+                        ? z.string().optional().describe(`${p.d}; or an image file path`)
+                        : zodParam(p);
     }
     return shape;
 }