@jokerized/decksmith 0.9.6 → 0.9.8

package/dist/cli.js

@@ -23530,9 +23530,9 @@ function literalFindings(storyboard, source, opts = {}) {
     prevKey = { id: beat2.id, key };
   });
   const tables = beats.filter((b) => b.literal?.kind === "table");
-  if (tables.length > 1)
+  for (const t2 of tables.slice(1))
     out.push(
-      `The plan draws ${tables.length} tables (${tables.map((b) => b.id).join(", ")}). A table reads like a report: keep at most one, and draw the others as what they list \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
+      `${t2.id} draws a table, and so does ${tables[0]?.id}. A table reads like a report: keep at most one, and draw this one as what it lists \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
     );
   const byVectors = /* @__PURE__ */ new Map();
   for (const b of beats) {
@@ -23541,20 +23541,20 @@ function literalFindings(storyboard, source, opts = {}) {
     const key = JSON.stringify(l.vectors.map((v) => v.values));
     byVectors.set(key, [...byVectors.get(key) ?? [], b.id]);
   }
-  for (const ids of byVectors.values())
-    if (ids.length > 1)
+  for (const [first, ...rest] of byVectors.values())
+    for (const id2 of rest)
       out.push(
-        `${ids.join(" and ")} run operate on the same vectors, so the deck shows one chart twice. Give the second beat's chain to the first (one longer chain), or draw the second another way.`
+        `${id2} runs operate on the same vectors as ${first}, so the deck shows one chart twice. Give its chain to ${first} (one longer chain), or draw ${id2} another way.`
       );
   const forms = /* @__PURE__ */ new Map();
   for (const b of beats) {
     const f = b.literal && wordForm(b.literal);
     if (f) forms.set(f, [...forms.get(f) ?? [], b.id]);
   }
-  for (const [f, ids] of forms)
-    if (ids.length > 1)
+  for (const [f, [first, ...rest]] of forms)
+    for (const id2 of rest)
       out.push(
-        `The plan draws \`${f}\` ${ids.length} times (${ids.join(", ")}). It draws no picture, so a second one is the same slide again: keep it on one beat, and draw the others another way or with \`literal\` null.`
+        `${id2} draws \`${f}\`, as ${first} already does. It draws no picture, so a second one is the same slide again: draw ${id2} another way, or with \`literal\` null.`
       );
   return out;
 }
@@ -23630,15 +23630,26 @@ function isScene(beat2, design2) {
       return pictured(p.backdrop);
   }
 }
+function shapesFor(storyboard, i, offered, images) {
+  const beats = storyboard.beats;
+  const others = beats.filter((_, k) => k !== i);
+  const kinetic2 = others.filter((b) => b.archetype === "kinetic").length;
+  const panels = others.filter((b) => PANEL_ARCHETYPES.has(b.archetype)).length;
+  const panelCap = panelsAllowed(beats.length, images);
+  return offered.filter(
+    (a) => a !== beats[i - 1]?.archetype && a !== beats[i + 1]?.archetype && (a !== "title" || i === 0) && (a !== "kinetic" || kinetic2 < KINETIC_MAX) && (!PANEL_ARCHETYPES.has(a) || panels < panelCap)
+  );
+}
 function varietyFindings(storyboard, images, design2) {
   const beats = storyboard.beats;
   const out = [];
+  const avoid = (beat2, other) => [beat2.archetype, other?.archetype].filter((x, k, xs) => x !== void 0 && xs.indexOf(x) === k).map((x) => `\`${x}\``).join(" or ");
   for (let i = 1; i < beats.length; i++) {
     const a = beats[i - 1];
     const b = beats[i];
     if (a.archetype === b.archetype) {
       out.push(
-        `${a.id} and ${b.id} are both \`${a.archetype}\`, next to each other. Draw one of them as a different shape.`
+        `${a.id} and ${b.id} are both \`${a.archetype}\`, next to each other. Redraw ${a.id} as anything but ${avoid(a, beats[i - 2])}, or ${b.id} as anything but ${avoid(b, beats[i + 1])}.`
       );
     }
   }
@@ -24997,13 +25008,39 @@ function operateVariants(v) {
   return [only(OPERATE_CHAIN, OPERATE_TERMS), only(OPERATE_TERMS)];
 }
 function schemaFor(prefs, source) {
-  return splitOperate(
-    hideFromPlanner(
-      forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
-      plannerInvisible(prefs, source)
+  return shareLiteral(
+    splitOperate(
+      hideFromPlanner(
+        forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
+        plannerInvisible(prefs, source)
+      )
     )
   );
 }
+function shareLiteral(schema) {
+  const root = schema;
+  const variants = root.properties.beats.items.anyOf;
+  const literal = variants[0]?.properties.literal;
+  if (!literal) return schema;
+  const one2 = JSON.stringify(literal);
+  if (!variants.every((v) => JSON.stringify(v.properties.literal) === one2))
+    throw new Error("schemaFor: the beat variants carry different `literal` schemas.");
+  const ref = { $ref: "#/$defs/literal" };
+  return {
+    ...root,
+    $defs: { literal },
+    properties: {
+      ...root.properties,
+      beats: {
+        ...root.properties.beats,
+        items: {
+          ...root.properties.beats.items,
+          anyOf: variants.map((v) => ({ ...v, properties: { ...v.properties, literal: ref } }))
+        }
+      }
+    }
+  };
+}
 var SCHEMA = schemaFor(prefsSchema.parse({}));
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});
@@ -25011,7 +25048,8 @@ async function codexPlanner(source, opts = {}) {
   try {
     const schemaPath = join9(dir, "storyboard.schema.json");
     const outPath = join9(dir, "storyboard.json");
-    await writeFile7(schemaPath, JSON.stringify(schemaFor(prefs, source)));
+    const schema = schemaFor(prefs, source);
+    await writeFile7(schemaPath, JSON.stringify(schema));
     const ask = async (prompt2) => {
       await rm3(outPath, { force: true });
       await (opts.run ?? runCodex)({
@@ -25155,6 +25193,46 @@ ${left.map((m) => `  ${m}`).join("\n")}`
         );
       return plan;
     };
+    const beatSchemaPath = join9(dir, "beat.schema.json");
+    const offered = beatVariants(schema).map((v) => v.properties.archetype.const);
+    const reshape2 = async (deck, i) => {
+      const beat2 = deck.beats[i];
+      const shapes = shapesFor(deck, i, offered, prefs.images);
+      if (!shapes.length) return deck;
+      await writeFile7(beatSchemaPath, JSON.stringify(beatSchemaFor(schema, shapes)));
+      let problems = [];
+      for (let t2 = 1; t2 <= SCENE_REPAIRS; t2++) {
+        opts.onReshape?.(beat2.id, shapes);
+        const out = join9(dir, `beat-${beat2.id}-${t2}.json`);
+        try {
+          await (opts.run ?? runCodex)({
+            prompt: beatPrompt(prompt, deck, beat2, shapes, problems),
+            schemaPath: beatSchemaPath,
+            outPath: out,
+            ...opts.model === void 0 ? {} : { model: opts.model },
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS
+          });
+          const got = stripNulls(JSON.parse(await readFile8(out, "utf8")))?.beat;
+          const redrawn = {
+            ...got,
+            id: beat2.id,
+            ...beat2.literal ? { literal: beat2.literal } : {}
+          };
+          const beats = deck.beats.map((b, k) => k === i ? redrawn : b);
+          return withStockLabels(checkPlan({ ...deck, beats }, source, prefs), source);
+        } catch (err) {
+          problems = err instanceof PlanRejected ? err.problems : [`the ask failed: ${err instanceof Error ? err.message : err}`];
+        }
+      }
+      return deck;
+    };
+    const neighbours = async (planned) => {
+      let plan = planned;
+      for (let i = 1; i < plan.beats.length; i++)
+        if (plan.beats[i]?.archetype === plan.beats[i - 1]?.archetype)
+          plan = await reshape2(plan, i);
+      return plan;
+    };
     let answer = await attempt2(prompt);
     if (answer.plan && listOf(answer.broken).length === 0) return await scenes(answer.plan);
     const firstBeats = beatCount(answer.json);
@@ -25174,7 +25252,13 @@ ${left.map((m) => `  ${m}`).join("\n")}`
         advice: []
       };
       if (next.plan && listOf(still).length === 0) return await scenes(next.plan);
-      if (round8 === REPAIRS) throw unrepaired(next, still, round8);
+      if (round8 === REPAIRS) {
+        if (!next.plan || !listOf(still).every(isNeighbour)) throw unrepaired(next, still, round8);
+        const plan = await neighbours(next.plan);
+        const left = { ...findings(plan), advice: [] };
+        if (listOf(left).length) throw unrepaired(next, left, round8);
+        return await scenes(plan);
+      }
       merging ||= still.size.length > 0;
       answer = { ...next, broken: still };
     }
@@ -25229,6 +25313,37 @@ ${list2}
 
 Return {"literal": ...}: beat ${id2}'s scene, redrawn so none of these hold \u2014 every number, word and figure one the source states, every slot its verb needs filled. Keep its verb unless a finding names another. Return a scene: this ask has no way to leave it out. No other beat is yours to change.
 
+THE STORYBOARD:
+${JSON.stringify(plan, null, 2)}`;
+}
+function isNeighbour(finding2) {
+  return /^\S+ and \S+ are both `[^`]+`, next to each other\./.test(finding2);
+}
+function beatVariants(schema) {
+  return schema.properties.beats.items.anyOf;
+}
+function beatSchemaFor(schema, shapes) {
+  const anyOf = beatVariants(schema).filter((v) => shapes.includes(v.properties.archetype.const)).map((v) => hideFromPlanner(v, /* @__PURE__ */ new Set(["literal"])));
+  return {
+    type: "object",
+    properties: { beat: { anyOf } },
+    required: ["beat"],
+    additionalProperties: false
+  };
+}
+function beatPrompt(prompt, plan, beat2, shapes, problems) {
+  const refused = problems.length ? `
+Your last answer was refused for:
+${problems.map((m) => `  - ${m}`).join("\n")}
+` : "";
+  return `${prompt}
+
+THE DECK IS PLANNED. ONE BEAT'S SHAPE IS LEFT.
+
+The storyboard below is settled, but beat ${beat2.id} is \`${beat2.archetype}\` beside a beat of the same shape, and no two beats in a row may share an archetype.
+${refused}
+Return {"beat": ...}: beat ${beat2.id} redrawn as one of ${shapes.map((s) => `\`${s}\``).join(", ")} \u2014 whichever shows its point best \u2014 with the params that shape needs, every number, word and figure one the source states. Keep its id, its point, its evidence, its narration and its part. No other beat is yours to change.
+
 THE STORYBOARD:
 ${JSON.stringify(plan, null, 2)}`;
 }
@@ -25326,7 +25441,9 @@ async function readPlan(outPath, source, prefs) {
 ${raw2.slice(0, 200)}`
     );
   }
-  const plan = stripNulls(parsed);
+  return checkPlan(stripNulls(parsed), source, prefs);
+}
+function checkPlan(plan, source, prefs) {
   const result = storyboardSchema.safeParse(plan);
   if (!result.success) {
     const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);
@@ -38201,6 +38318,7 @@ imageFlags(
       step(`plan: redrawing ${beat2}'s scene on its own \u2014`);
       for (const m of broken) step(`plan:   ${m}`);
     },
+    onReshape: (beat2, shapes) => step(`plan: redrawing ${beat2} on its own, as one of: ${shapes.join(", ")}`),
     onDropScenes: (beats, why3) => {
       step(
         `plan: WARNING: ${beats.join(", ")} drawn by their archetype instead; their scenes stay broken \u2014`

package/dist/index.js

@@ -25877,9 +25877,9 @@ function literalFindings(storyboard, source, opts = {}) {
     prevKey = { id: beat2.id, key };
   });
   const tables = beats.filter((b) => b.literal?.kind === "table");
-  if (tables.length > 1)
+  for (const t2 of tables.slice(1))
     out.push(
-      `The plan draws ${tables.length} tables (${tables.map((b) => b.id).join(", ")}). A table reads like a report: keep at most one, and draw the others as what they list \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
+      `${t2.id} draws a table, and so does ${tables[0]?.id}. A table reads like a report: keep at most one, and draw this one as what it lists \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
     );
   const byVectors = /* @__PURE__ */ new Map();
   for (const b of beats) {
@@ -25888,20 +25888,20 @@ function literalFindings(storyboard, source, opts = {}) {
     const key = JSON.stringify(l.vectors.map((v) => v.values));
     byVectors.set(key, [...byVectors.get(key) ?? [], b.id]);
   }
-  for (const ids of byVectors.values())
-    if (ids.length > 1)
+  for (const [first, ...rest] of byVectors.values())
+    for (const id2 of rest)
       out.push(
-        `${ids.join(" and ")} run operate on the same vectors, so the deck shows one chart twice. Give the second beat's chain to the first (one longer chain), or draw the second another way.`
+        `${id2} runs operate on the same vectors as ${first}, so the deck shows one chart twice. Give its chain to ${first} (one longer chain), or draw ${id2} another way.`
       );
   const forms = /* @__PURE__ */ new Map();
   for (const b of beats) {
     const f = b.literal && wordForm(b.literal);
     if (f) forms.set(f, [...forms.get(f) ?? [], b.id]);
   }
-  for (const [f, ids] of forms)
-    if (ids.length > 1)
+  for (const [f, [first, ...rest]] of forms)
+    for (const id2 of rest)
       out.push(
-        `The plan draws \`${f}\` ${ids.length} times (${ids.join(", ")}). It draws no picture, so a second one is the same slide again: keep it on one beat, and draw the others another way or with \`literal\` null.`
+        `${id2} draws \`${f}\`, as ${first} already does. It draws no picture, so a second one is the same slide again: draw ${id2} another way, or with \`literal\` null.`
       );
   return out;
 }
@@ -25977,15 +25977,26 @@ function isScene(beat2, design2) {
       return pictured(p.backdrop);
   }
 }
+function shapesFor(storyboard, i, offered, images) {
+  const beats = storyboard.beats;
+  const others = beats.filter((_, k) => k !== i);
+  const kinetic2 = others.filter((b) => b.archetype === "kinetic").length;
+  const panels = others.filter((b) => PANEL_ARCHETYPES.has(b.archetype)).length;
+  const panelCap = panelsAllowed(beats.length, images);
+  return offered.filter(
+    (a) => a !== beats[i - 1]?.archetype && a !== beats[i + 1]?.archetype && (a !== "title" || i === 0) && (a !== "kinetic" || kinetic2 < KINETIC_MAX) && (!PANEL_ARCHETYPES.has(a) || panels < panelCap)
+  );
+}
 function varietyFindings(storyboard, images, design2) {
   const beats = storyboard.beats;
   const out = [];
+  const avoid = (beat2, other) => [beat2.archetype, other?.archetype].filter((x, k, xs) => x !== void 0 && xs.indexOf(x) === k).map((x) => `\`${x}\``).join(" or ");
   for (let i = 1; i < beats.length; i++) {
     const a = beats[i - 1];
     const b = beats[i];
     if (a.archetype === b.archetype) {
       out.push(
-        `${a.id} and ${b.id} are both \`${a.archetype}\`, next to each other. Draw one of them as a different shape.`
+        `${a.id} and ${b.id} are both \`${a.archetype}\`, next to each other. Redraw ${a.id} as anything but ${avoid(a, beats[i - 2])}, or ${b.id} as anything but ${avoid(b, beats[i + 1])}.`
       );
     }
   }
@@ -27344,13 +27355,39 @@ function operateVariants(v) {
   return [only(OPERATE_CHAIN, OPERATE_TERMS), only(OPERATE_TERMS)];
 }
 function schemaFor(prefs, source) {
-  return splitOperate(
-    hideFromPlanner(
-      forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
-      plannerInvisible(prefs, source)
+  return shareLiteral(
+    splitOperate(
+      hideFromPlanner(
+        forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
+        plannerInvisible(prefs, source)
+      )
     )
   );
 }
+function shareLiteral(schema) {
+  const root = schema;
+  const variants = root.properties.beats.items.anyOf;
+  const literal = variants[0]?.properties.literal;
+  if (!literal) return schema;
+  const one2 = JSON.stringify(literal);
+  if (!variants.every((v) => JSON.stringify(v.properties.literal) === one2))
+    throw new Error("schemaFor: the beat variants carry different `literal` schemas.");
+  const ref = { $ref: "#/$defs/literal" };
+  return {
+    ...root,
+    $defs: { literal },
+    properties: {
+      ...root.properties,
+      beats: {
+        ...root.properties.beats,
+        items: {
+          ...root.properties.beats.items,
+          anyOf: variants.map((v) => ({ ...v, properties: { ...v.properties, literal: ref } }))
+        }
+      }
+    }
+  };
+}
 var SCHEMA = schemaFor(prefsSchema.parse({}));
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});
@@ -27358,7 +27395,8 @@ async function codexPlanner(source, opts = {}) {
   try {
     const schemaPath = join12(dir, "storyboard.schema.json");
     const outPath = join12(dir, "storyboard.json");
-    await writeFile10(schemaPath, JSON.stringify(schemaFor(prefs, source)));
+    const schema = schemaFor(prefs, source);
+    await writeFile10(schemaPath, JSON.stringify(schema));
     const ask = async (prompt2) => {
       await rm5(outPath, { force: true });
       await (opts.run ?? runCodex)({
@@ -27502,6 +27540,46 @@ ${left.map((m) => `  ${m}`).join("\n")}`
         );
       return plan;
     };
+    const beatSchemaPath = join12(dir, "beat.schema.json");
+    const offered = beatVariants(schema).map((v) => v.properties.archetype.const);
+    const reshape2 = async (deck, i) => {
+      const beat2 = deck.beats[i];
+      const shapes = shapesFor(deck, i, offered, prefs.images);
+      if (!shapes.length) return deck;
+      await writeFile10(beatSchemaPath, JSON.stringify(beatSchemaFor(schema, shapes)));
+      let problems = [];
+      for (let t2 = 1; t2 <= SCENE_REPAIRS; t2++) {
+        opts.onReshape?.(beat2.id, shapes);
+        const out = join12(dir, `beat-${beat2.id}-${t2}.json`);
+        try {
+          await (opts.run ?? runCodex)({
+            prompt: beatPrompt(prompt, deck, beat2, shapes, problems),
+            schemaPath: beatSchemaPath,
+            outPath: out,
+            ...opts.model === void 0 ? {} : { model: opts.model },
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
+          });
+          const got = stripNulls(JSON.parse(await readFile12(out, "utf8")))?.beat;
+          const redrawn = {
+            ...got,
+            id: beat2.id,
+            ...beat2.literal ? { literal: beat2.literal } : {}
+          };
+          const beats = deck.beats.map((b, k) => k === i ? redrawn : b);
+          return withStockLabels(checkPlan({ ...deck, beats }, source, prefs), source);
+        } catch (err) {
+          problems = err instanceof PlanRejected ? err.problems : [`the ask failed: ${err instanceof Error ? err.message : err}`];
+        }
+      }
+      return deck;
+    };
+    const neighbours = async (planned) => {
+      let plan = planned;
+      for (let i = 1; i < plan.beats.length; i++)
+        if (plan.beats[i]?.archetype === plan.beats[i - 1]?.archetype)
+          plan = await reshape2(plan, i);
+      return plan;
+    };
     let answer = await attempt2(prompt);
     if (answer.plan && listOf(answer.broken).length === 0) return await scenes(answer.plan);
     const firstBeats = beatCount(answer.json);
@@ -27521,7 +27599,13 @@ ${left.map((m) => `  ${m}`).join("\n")}`
         advice: []
       };
       if (next.plan && listOf(still).length === 0) return await scenes(next.plan);
-      if (round8 === REPAIRS) throw unrepaired(next, still, round8);
+      if (round8 === REPAIRS) {
+        if (!next.plan || !listOf(still).every(isNeighbour)) throw unrepaired(next, still, round8);
+        const plan = await neighbours(next.plan);
+        const left = { ...findings(plan), advice: [] };
+        if (listOf(left).length) throw unrepaired(next, left, round8);
+        return await scenes(plan);
+      }
       merging ||= still.size.length > 0;
       answer = { ...next, broken: still };
     }
@@ -27576,6 +27660,37 @@ ${list2}
 
 Return {"literal": ...}: beat ${id2}'s scene, redrawn so none of these hold \u2014 every number, word and figure one the source states, every slot its verb needs filled. Keep its verb unless a finding names another. Return a scene: this ask has no way to leave it out. No other beat is yours to change.
 
+THE STORYBOARD:
+${JSON.stringify(plan, null, 2)}`;
+}
+function isNeighbour(finding2) {
+  return /^\S+ and \S+ are both `[^`]+`, next to each other\./.test(finding2);
+}
+function beatVariants(schema) {
+  return schema.properties.beats.items.anyOf;
+}
+function beatSchemaFor(schema, shapes) {
+  const anyOf = beatVariants(schema).filter((v) => shapes.includes(v.properties.archetype.const)).map((v) => hideFromPlanner(v, /* @__PURE__ */ new Set(["literal"])));
+  return {
+    type: "object",
+    properties: { beat: { anyOf } },
+    required: ["beat"],
+    additionalProperties: false
+  };
+}
+function beatPrompt(prompt, plan, beat2, shapes, problems) {
+  const refused = problems.length ? `
+Your last answer was refused for:
+${problems.map((m) => `  - ${m}`).join("\n")}
+` : "";
+  return `${prompt}
+
+THE DECK IS PLANNED. ONE BEAT'S SHAPE IS LEFT.
+
+The storyboard below is settled, but beat ${beat2.id} is \`${beat2.archetype}\` beside a beat of the same shape, and no two beats in a row may share an archetype.
+${refused}
+Return {"beat": ...}: beat ${beat2.id} redrawn as one of ${shapes.map((s) => `\`${s}\``).join(", ")} \u2014 whichever shows its point best \u2014 with the params that shape needs, every number, word and figure one the source states. Keep its id, its point, its evidence, its narration and its part. No other beat is yours to change.
+
 THE STORYBOARD:
 ${JSON.stringify(plan, null, 2)}`;
 }
@@ -27673,7 +27788,9 @@ async function readPlan(outPath, source, prefs) {
 ${raw2.slice(0, 200)}`
     );
   }
-  const plan = stripNulls(parsed);
+  return checkPlan(stripNulls(parsed), source, prefs);
+}
+function checkPlan(plan, source, prefs) {
   const result = storyboardSchema.safeParse(plan);
   if (!result.success) {
     const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);

package/dist/mcp.js

@@ -24389,9 +24389,9 @@ function literalFindings(storyboard, source, opts = {}) {
     prevKey = { id: beat.id, key };
   });
   const tables = beats.filter((b) => b.literal?.kind === "table");
-  if (tables.length > 1)
+  for (const t2 of tables.slice(1))
     out.push(
-      `The plan draws ${tables.length} tables (${tables.map((b) => b.id).join(", ")}). A table reads like a report: keep at most one, and draw the others as what they list \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
+      `${t2.id} draws a table, and so does ${tables[0]?.id}. A table reads like a report: keep at most one, and draw this one as what it lists \u2014 results as \`place\` (margin or plane), what was and was not evaluated as \`place\` sets, experiments not run as \`place\` combos, earlier approaches as \`prior-work\`, reported costs as \`place\` length \u2014 or leave \`literal\` null where nothing is honest.`
     );
   const byVectors = /* @__PURE__ */ new Map();
   for (const b of beats) {
@@ -24400,20 +24400,20 @@ function literalFindings(storyboard, source, opts = {}) {
     const key = JSON.stringify(l.vectors.map((v) => v.values));
     byVectors.set(key, [...byVectors.get(key) ?? [], b.id]);
   }
-  for (const ids of byVectors.values())
-    if (ids.length > 1)
+  for (const [first, ...rest] of byVectors.values())
+    for (const id2 of rest)
       out.push(
-        `${ids.join(" and ")} run operate on the same vectors, so the deck shows one chart twice. Give the second beat's chain to the first (one longer chain), or draw the second another way.`
+        `${id2} runs operate on the same vectors as ${first}, so the deck shows one chart twice. Give its chain to ${first} (one longer chain), or draw ${id2} another way.`
       );
   const forms = /* @__PURE__ */ new Map();
   for (const b of beats) {
     const f = b.literal && wordForm(b.literal);
     if (f) forms.set(f, [...forms.get(f) ?? [], b.id]);
   }
-  for (const [f, ids] of forms)
-    if (ids.length > 1)
+  for (const [f, [first, ...rest]] of forms)
+    for (const id2 of rest)
       out.push(
-        `The plan draws \`${f}\` ${ids.length} times (${ids.join(", ")}). It draws no picture, so a second one is the same slide again: keep it on one beat, and draw the others another way or with \`literal\` null.`
+        `${id2} draws \`${f}\`, as ${first} already does. It draws no picture, so a second one is the same slide again: draw ${id2} another way, or with \`literal\` null.`
       );
   return out;
 }
@@ -24489,15 +24489,26 @@ function isScene(beat, design2) {
       return pictured(p.backdrop);
   }
 }
+function shapesFor(storyboard, i, offered, images) {
+  const beats = storyboard.beats;
+  const others = beats.filter((_, k) => k !== i);
+  const kinetic2 = others.filter((b) => b.archetype === "kinetic").length;
+  const panels = others.filter((b) => PANEL_ARCHETYPES.has(b.archetype)).length;
+  const panelCap = panelsAllowed(beats.length, images);
+  return offered.filter(
+    (a) => a !== beats[i - 1]?.archetype && a !== beats[i + 1]?.archetype && (a !== "title" || i === 0) && (a !== "kinetic" || kinetic2 < KINETIC_MAX) && (!PANEL_ARCHETYPES.has(a) || panels < panelCap)
+  );
+}
 function varietyFindings(storyboard, images, design2) {
   const beats = storyboard.beats;
   const out = [];
+  const avoid = (beat, other) => [beat.archetype, other?.archetype].filter((x, k, xs) => x !== void 0 && xs.indexOf(x) === k).map((x) => `\`${x}\``).join(" or ");
   for (let i = 1; i < beats.length; i++) {
     const a = beats[i - 1];
     const b = beats[i];
     if (a.archetype === b.archetype) {
       out.push(
-        `${a.id} and ${b.id} are both \`${a.archetype}\`, next to each other. Draw one of them as a different shape.`
+        `${a.id} and ${b.id} are both \`${a.archetype}\`, next to each other. Redraw ${a.id} as anything but ${avoid(a, beats[i - 2])}, or ${b.id} as anything but ${avoid(b, beats[i + 1])}.`
       );
     }
   }
@@ -25814,13 +25825,39 @@ function operateVariants(v) {
   return [only(OPERATE_CHAIN, OPERATE_TERMS), only(OPERATE_TERMS)];
 }
 function schemaFor(prefs, source) {
-  return splitOperate(
-    hideFromPlanner(
-      forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
-      plannerInvisible(prefs, source)
+  return shareLiteral(
+    splitOperate(
+      hideFromPlanner(
+        forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
+        plannerInvisible(prefs, source)
+      )
     )
   );
 }
+function shareLiteral(schema2) {
+  const root2 = schema2;
+  const variants = root2.properties.beats.items.anyOf;
+  const literal = variants[0]?.properties.literal;
+  if (!literal) return schema2;
+  const one2 = JSON.stringify(literal);
+  if (!variants.every((v) => JSON.stringify(v.properties.literal) === one2))
+    throw new Error("schemaFor: the beat variants carry different `literal` schemas.");
+  const ref = { $ref: "#/$defs/literal" };
+  return {
+    ...root2,
+    $defs: { literal },
+    properties: {
+      ...root2.properties,
+      beats: {
+        ...root2.properties.beats,
+        items: {
+          ...root2.properties.beats.items,
+          anyOf: variants.map((v) => ({ ...v, properties: { ...v.properties, literal: ref } }))
+        }
+      }
+    }
+  };
+}
 var SCHEMA = schemaFor(prefsSchema.parse({}));
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});
@@ -25828,7 +25865,8 @@ async function codexPlanner(source, opts = {}) {
   try {
     const schemaPath = join11(dir, "storyboard.schema.json");
     const outPath = join11(dir, "storyboard.json");
-    await writeFile8(schemaPath, JSON.stringify(schemaFor(prefs, source)));
+    const schema2 = schemaFor(prefs, source);
+    await writeFile8(schemaPath, JSON.stringify(schema2));
     const ask = async (prompt2) => {
       await rm5(outPath, { force: true });
       await (opts.run ?? runCodex)({
@@ -25972,6 +26010,46 @@ ${left.map((m) => `  ${m}`).join("\n")}`
         );
       return plan;
     };
+    const beatSchemaPath = join11(dir, "beat.schema.json");
+    const offered = beatVariants(schema2).map((v) => v.properties.archetype.const);
+    const reshape2 = async (deck, i) => {
+      const beat = deck.beats[i];
+      const shapes = shapesFor(deck, i, offered, prefs.images);
+      if (!shapes.length) return deck;
+      await writeFile8(beatSchemaPath, JSON.stringify(beatSchemaFor(schema2, shapes)));
+      let problems = [];
+      for (let t2 = 1; t2 <= SCENE_REPAIRS; t2++) {
+        opts.onReshape?.(beat.id, shapes);
+        const out = join11(dir, `beat-${beat.id}-${t2}.json`);
+        try {
+          await (opts.run ?? runCodex)({
+            prompt: beatPrompt(prompt, deck, beat, shapes, problems),
+            schemaPath: beatSchemaPath,
+            outPath: out,
+            ...opts.model === void 0 ? {} : { model: opts.model },
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
+          });
+          const got = stripNulls(JSON.parse(await readFile9(out, "utf8")))?.beat;
+          const redrawn = {
+            ...got,
+            id: beat.id,
+            ...beat.literal ? { literal: beat.literal } : {}
+          };
+          const beats = deck.beats.map((b, k) => k === i ? redrawn : b);
+          return withStockLabels(checkPlan({ ...deck, beats }, source, prefs), source);
+        } catch (err) {
+          problems = err instanceof PlanRejected ? err.problems : [`the ask failed: ${err instanceof Error ? err.message : err}`];
+        }
+      }
+      return deck;
+    };
+    const neighbours = async (planned) => {
+      let plan = planned;
+      for (let i = 1; i < plan.beats.length; i++)
+        if (plan.beats[i]?.archetype === plan.beats[i - 1]?.archetype)
+          plan = await reshape2(plan, i);
+      return plan;
+    };
     let answer = await attempt2(prompt);
     if (answer.plan && listOf(answer.broken).length === 0) return await scenes(answer.plan);
     const firstBeats = beatCount(answer.json);
@@ -25991,7 +26069,13 @@ ${left.map((m) => `  ${m}`).join("\n")}`
         advice: []
       };
       if (next.plan && listOf(still).length === 0) return await scenes(next.plan);
-      if (round6 === REPAIRS) throw unrepaired(next, still, round6);
+      if (round6 === REPAIRS) {
+        if (!next.plan || !listOf(still).every(isNeighbour)) throw unrepaired(next, still, round6);
+        const plan = await neighbours(next.plan);
+        const left = { ...findings(plan), advice: [] };
+        if (listOf(left).length) throw unrepaired(next, left, round6);
+        return await scenes(plan);
+      }
       merging ||= still.size.length > 0;
       answer = { ...next, broken: still };
     }
@@ -26046,6 +26130,37 @@ ${list2}
 
 Return {"literal": ...}: beat ${id2}'s scene, redrawn so none of these hold \u2014 every number, word and figure one the source states, every slot its verb needs filled. Keep its verb unless a finding names another. Return a scene: this ask has no way to leave it out. No other beat is yours to change.
 
+THE STORYBOARD:
+${JSON.stringify(plan, null, 2)}`;
+}
+function isNeighbour(finding) {
+  return /^\S+ and \S+ are both `[^`]+`, next to each other\./.test(finding);
+}
+function beatVariants(schema2) {
+  return schema2.properties.beats.items.anyOf;
+}
+function beatSchemaFor(schema2, shapes) {
+  const anyOf = beatVariants(schema2).filter((v) => shapes.includes(v.properties.archetype.const)).map((v) => hideFromPlanner(v, /* @__PURE__ */ new Set(["literal"])));
+  return {
+    type: "object",
+    properties: { beat: { anyOf } },
+    required: ["beat"],
+    additionalProperties: false
+  };
+}
+function beatPrompt(prompt, plan, beat, shapes, problems) {
+  const refused = problems.length ? `
+Your last answer was refused for:
+${problems.map((m) => `  - ${m}`).join("\n")}
+` : "";
+  return `${prompt}
+
+THE DECK IS PLANNED. ONE BEAT'S SHAPE IS LEFT.
+
+The storyboard below is settled, but beat ${beat.id} is \`${beat.archetype}\` beside a beat of the same shape, and no two beats in a row may share an archetype.
+${refused}
+Return {"beat": ...}: beat ${beat.id} redrawn as one of ${shapes.map((s) => `\`${s}\``).join(", ")} \u2014 whichever shows its point best \u2014 with the params that shape needs, every number, word and figure one the source states. Keep its id, its point, its evidence, its narration and its part. No other beat is yours to change.
+
 THE STORYBOARD:
 ${JSON.stringify(plan, null, 2)}`;
 }
@@ -26143,7 +26258,9 @@ async function readPlan(outPath, source, prefs) {
 ${raw2.slice(0, 200)}`
     );
   }
-  const plan = stripNulls(parsed);
+  return checkPlan(stripNulls(parsed), source, prefs);
+}
+function checkPlan(plan, source, prefs) {
   const result = storyboardSchema.safeParse(plan);
   if (!result.success) {
     const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);

package/dist/types/plan/codex.d.ts

@@ -31,6 +31,8 @@ export interface CodexOptions {
     onScene?: (beat: string, broken: readonly string[]) => void;
     /** Told the beats whose scene was dropped (still broken after its own repairs, or broken only by a symbolic quantity), and why. */
     onDropScenes?: (beats: readonly string[], why: readonly string[]) => void;
+    /** Told a beat still beside its own shape after the last repair is redrawn on its own, as one of `shapes`. */
+    onReshape?: (beat: string, shapes: readonly string[]) => void;
     /** Each source figure's panel count as the build will cut it, when the caller read them. */
     panels?: Readonly<Record<string, number>>;
 }

package/dist/types/plan/variety.d.ts

@@ -12,7 +12,8 @@
  * So the rule is a minimum, not an invitation, and it is CHECKED: the prompt
  * (src/plan/prompt.ts) states these numbers by importing them from here, and
  * `codexPlanner` (src/plan/codex.ts) runs `varietyFindings` on what comes back,
- * asks once for a repair, and refuses a plan that still breaks it. One table,
+ * asks for up to three repairs, redraws a beat still beside its own shape on
+ * its own (`shapesFor`), and refuses a plan that still breaks it. One table,
  * read by both, so the sentence the model is given and the check it is held to
  * cannot drift apart.
  *
@@ -90,6 +91,16 @@ export declare function scenesRequired(beats: number, images: Prefs["images"]):
  * the cards-on-paper the share exists to refuse.
  */
 export declare function isScene(beat: Beat, design?: Design): boolean;
+/**
+ * The shapes, of those `offered`, that beat `i` may be redrawn as: not either
+ * neighbour's, not a title past the first beat, and not one that tips the
+ * kinetic or panel cap. What the last-resort redraw of one beat
+ * (src/plan/codex.ts) offers in its schema, so the shape cannot be wrong.
+ *
+ * ponytail: the A/B/A/B and scene-share rules are not foreseen here; the plan
+ * is checked whole after the redraw, and refused if one of them broke.
+ */
+export declare function shapesFor(storyboard: Storyboard, i: number, offered: readonly Archetype[], images: Prefs["images"]): Archetype[];
 /**
  * Every way `storyboard` breaks the variety rule, as sentences the planner can
  * act on. Empty is a pass.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jokerized/decksmith",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Turn a source document into an animated explanation deck.",
   "type": "module",
   "license": "MIT",