flowviant 0.104.0 → 0.106.0

package/bin/lib/agentCards.mjs

@@ -37,6 +37,7 @@
  */
 
 import { appendFileSync, readFileSync } from 'node:fs';
+import { CARD_THREAD_RENDER_MAX } from './cardThread.mjs';
 
 /**
  * How many card specs one agent may accumulate.
@@ -49,8 +50,14 @@ import { appendFileSync, readFileSync } from 'node:fs';
 export const MAX_STASHED_CARDS = 40;
 /** The most one spec may contribute. A brief is written by whoever filed the
  *  card and the server caps it, but this file is composed into a prompt and a
- *  bound it owns is a bound that cannot be argued away upstream. */
-export const MAX_SPEC_CHARS = 8_000;
+ *  bound it owns is a bound that cannot be argued away upstream.
+ *
+ *  8,000 is the record's brief ceiling; since 0.106.0 the spec also carries
+ *  the card's discussion, so the bound grows by the most a turn's discussion
+ *  can render to (`CARD_THREAD_RENDER_MAX`). The discussion is printed LAST,
+ *  and a stash that cut it would hand the pre-review a thread missing its
+ *  newest words — the ones the agent read most recently. */
+export const MAX_SPEC_CHARS = 8_000 + CARD_THREAD_RENDER_MAX;
 
 /**
  * Write down the spec this turn is about to hand the agent.

package/bin/lib/agentTaskKinds.mjs

@@ -1,8 +1,12 @@
 /**
  * A CARD'S KIND — the daemon's one table of what each kind IS (0.97.0):
- * `code` (the default), `design` and `research`. Every reader of a kind goes
+ * `code` (the default), `design` and `research`; since 0.105.0 also `model`
+ * (the 3D-model kind — not an AI-model pin, which is `job.model`) and `deck`
+ * (the presentation kind — not the review deck). Every reader of a kind goes
  * through this module: the prompts that print it and pick a contract
- * (prompts.mjs, which keeps the strings), the agent lane that picks a posture,
+ * (prompts.mjs, which keeps the strings, with the 3D-model and presentation
+ * contracts and the shared tail in artifactContracts.mjs), the agent lane
+ * that picks a posture,
  * refuses a runtime (workAgentTurnExecution.mjs) and checks the artifact
  * (workAgentTurnOutcome.mjs), and the turn runner that fences the non-code
  * postures (runTurn.mjs and claudePosture.mjs, via turnProfile.mjs).
@@ -23,10 +27,15 @@
  * The kinds. Per kind:
  *  - `posture`: the turn profile the card runs under (turnProfile.mjs);
  *  - `artifact`: null for code (it delivers commits), else what proves a
- *    delivery — `match` over the artifact file name and the `missing`
- *    sentence a turn settles `nothing` with when none was written;
+ *    delivery — `match` over the artifact file name, an optional `companion`
+ *    that must ALSO stand beside it (the 3D-model kind's model file: an HTML
+ *    viewer alone is a page, not a model), and the `missing` sentence a turn
+ *    settles `nothing` with when the proof was not written;
  *  - `offRuntime(rt)`: the sentence when the chosen CLI cannot run the posture.
  */
+/** Every non-code kind runs on Claude: the one CLI that declares their postures. */
+const CLAUDE_ONLY = 'mockup, 3D model, presentation and write-up cards run on Claude on this machine';
+
 export const AGENT_TASK_KINDS = Object.freeze({
   code: Object.freeze({
     posture: 'build',
@@ -39,7 +48,32 @@ export const AGENT_TASK_KINDS = Object.freeze({
       match: /\.html?$/i,
       missing: 'the turn ended without writing a mockup under .flowviant/artifacts/',
     }),
-    offRuntime: () => 'design and research cards run on Claude on this machine',
+    offRuntime: () => CLAUDE_ONLY,
+  }),
+  /**
+   * THE 3D-MODEL KIND (0.105.0): a viewable bundle — an HTML viewer and the
+   * model files beside it. Under the design fence (read the repo, write only
+   * `.flowviant/artifacts/**`): a model is a picture of an asset, and
+   * committing it is a separate code card a person raises at Accept.
+   */
+  model: Object.freeze({
+    posture: 'design',
+    artifact: Object.freeze({
+      match: /\.html?$/i,
+      companion: /\.(gltf|glb|obj)$/i,
+      missing:
+        'the turn ended without writing a model bundle (an HTML viewer and a .gltf, .glb or .obj file) under .flowviant/artifacts/',
+    }),
+    offRuntime: () => CLAUDE_ONLY,
+  }),
+  /** THE PRESENTATION KIND (0.105.0): one HTML slide deck, under the design fence. */
+  deck: Object.freeze({
+    posture: 'design',
+    artifact: Object.freeze({
+      match: /\.html?$/i,
+      missing: 'the turn ended without writing a deck under .flowviant/artifacts/',
+    }),
+    offRuntime: () => CLAUDE_ONLY,
   }),
   research: Object.freeze({
     posture: 'research',
@@ -47,7 +81,7 @@ export const AGENT_TASK_KINDS = Object.freeze({
       match: /\.md$/i,
       missing: 'the turn ended without writing a write-up under .flowviant/artifacts/',
     }),
-    offRuntime: () => 'design and research cards run on Claude on this machine',
+    offRuntime: () => CLAUDE_ONLY,
   }),
 });
 
@@ -85,9 +119,12 @@ export const unknownAgentTaskKind = (v) =>
 /** The table entry for a kind value, read the printing way (unknown → code). */
 export const agentTaskKind = (v) => AGENT_TASK_KINDS[agentTaskKindOf(v)];
 
-/** The postures only a card's kind selects (every kind's but code's). */
-export const KIND_POSTURES = Object.freeze(
-  Object.values(AGENT_TASK_KINDS)
-    .map((k) => k.posture)
-    .filter((p) => p !== 'build')
-);
+/** The postures only a card's kind selects (every kind's but code's), each
+ *  once: the 3D-model and presentation kinds reuse the design posture. */
+export const KIND_POSTURES = Object.freeze([
+  ...new Set(
+    Object.values(AGENT_TASK_KINDS)
+      .map((k) => k.posture)
+      .filter((p) => p !== 'build')
+  ),
+]);

package/bin/lib/agentTaskTypes.mjs

@@ -0,0 +1,135 @@
+/**
+ * A CARD'S TYPE — the daemon's one table of what each type ASKS (0.106.0).
+ *
+ * A type is the kind of WORK a card asks for — a Bug fix, a Refactor, a Code
+ * review — a flavour over the card's KIND (agentTaskKinds.mjs), which stays the
+ * end product and the posture the turn runs under. Every type runs as exactly
+ * one kind (`kind` below, the app's `TASK_TYPE_KIND`), and adds the one thing
+ * the kind cannot say: a bug fix reproduces first, a refactor must not change
+ * behaviour, a code review changes nothing.
+ *
+ * The server sends the id — `agentTurnJobs[].task.taskType` and
+ * `agentPlanJobs[].tasks[].taskType` — and only to a daemon at 0.106.0 (below
+ * it the server parks a typed card's turn rather than hand it to a daemon that
+ * would drop the key). THE DAEMON OWNS THE WORDS: each type's `contract` is
+ * the one sentence an agent is held to, printed inside THE CARD right after
+ * the kind line (`AGENT_TASK_SPEC`), so the spec stashed for the pre-review
+ * carries it too. Each sentence is true to what its kind's posture can do: a
+ * code type may build and test; a write-up type reads and writes one Markdown
+ * file; a mockup type writes under .flowviant/artifacts/ and nothing else.
+ *
+ * `label` is the app's `TASK_TYPE_LABEL`, the word a person picked. The ids
+ * (in the app's picker order), their kinds and their labels are held to the
+ * app's `taskType.ts` by the release gate (`scripts/check-app-parity.mjs`,
+ * rule 6): a type the server sends that this table lacks is printed as
+ * nothing, and one it has that the server never sends is dead.
+ *
+ * Pure data and pure functions; its one import is the kind table's reader.
+ */
+
+import { agentTaskKindOf } from './agentTaskKinds.mjs';
+
+export const AGENT_TASK_TYPES = Object.freeze({
+  feature: Object.freeze({
+    label: 'Feature',
+    kind: 'code',
+    contract: 'new behaviour: build it, and cover it with tests where the repository has them.',
+  }),
+  fix: Object.freeze({
+    label: 'Bug fix',
+    kind: 'code',
+    contract:
+      'reproduce it first, with a failing test where the repository has tests, then make that test pass.',
+  }),
+  tests: Object.freeze({
+    label: 'Tests',
+    kind: 'code',
+    contract:
+      'add tests for code that already exists and change no production code; if a test exposes a bug, ' +
+      'say so in your summary instead of fixing it.',
+  }),
+  refactor: Object.freeze({
+    label: 'Refactor',
+    kind: 'code',
+    contract: 'behaviour must not change; if an existing test would have to change, stop and ask.',
+  }),
+  infra: Object.freeze({
+    label: 'Infra & deploy',
+    kind: 'code',
+    contract: 'change the configuration in the repository; never run a deploy or touch a live environment.',
+  }),
+  automation: Object.freeze({
+    label: 'Automation',
+    kind: 'code',
+    contract:
+      "add the scheduled job to the repository (a CI schedule, or a script and its schedule) so it runs " +
+      "where the repository's CI runs; do not run it.",
+  }),
+  review: Object.freeze({
+    label: 'Code review',
+    kind: 'research',
+    contract:
+      'read the code the card names and write up what is wrong, by file and line, most serious first; ' +
+      'change nothing.',
+  }),
+  ui: Object.freeze({
+    label: 'UI design',
+    kind: 'design',
+    contract: "draw the screens and flows the card names as the mockup page, in this product's own components and words.",
+  }),
+  prototype: Object.freeze({
+    label: 'Prototype',
+    kind: 'design',
+    contract: 'make every control in the flow work, with realistic sample data, in the one page.',
+  }),
+  slides: Object.freeze({
+    label: 'Slides',
+    kind: 'deck',
+    contract: 'one deck for the audience and the length the card asks for, one point to a slide.',
+  }),
+  model3d: Object.freeze({
+    label: '3D model',
+    kind: 'model',
+    contract:
+      'model the object the card describes as the viewable bundle, at the scale and in the units of any ' +
+      '3D assets the repository already has.',
+  }),
+  vector: Object.freeze({
+    label: 'Icons & vector',
+    kind: 'design',
+    contract:
+      'write each icon as its own .svg file directly in .flowviant/artifacts/, and make the mockup page ' +
+      'the sheet that shows them all, inline, at the sizes they are used.',
+  }),
+  research: Object.freeze({
+    label: 'Research',
+    kind: 'research',
+    contract: 'answer the question the card asks, leading with the answer and citing what you read.',
+  }),
+  writing: Object.freeze({
+    label: 'Writing',
+    kind: 'research',
+    contract: 'write the document the card asks for, for the reader it names, in words that reader uses.',
+  }),
+});
+
+/**
+ * A CARD'S TYPE, READ THE ONE WAY THE DAEMON READS IT — a type this table
+ * knows, else null. ABSENT IS NO TYPE (every card before 0.106.0, and every
+ * job from an older server), and an unknown id (a newer server, a typo) is
+ * dropped rather than guessed at: a type only adds a sentence, so dropping one
+ * leaves the card running on its kind, which is what it always did.
+ */
+export const agentTaskTypeOf = (v) => (typeof v === 'string' && Object.hasOwn(AGENT_TASK_TYPES, v) ? v : null);
+
+/**
+ * The type of a card AS IT WILL BE PRINTED — null unless the card's type is
+ * known here AND runs as the card's own kind. The server sends a type only on
+ * its kind, but the card is a document any editor writes; a Bug fix sentence
+ * ("with a failing test") under a mockup's posture is a contract the turn
+ * cannot keep, so a type on another kind is printed as nothing.
+ */
+export const agentTaskTypeFor = (task) => {
+  const type = agentTaskTypeOf(task?.taskType);
+  return type && AGENT_TASK_TYPES[type].kind === agentTaskKindOf(task?.taskKind) ? type : null;
+};

package/bin/lib/artifactContracts.mjs

@@ -0,0 +1,153 @@
+/**
+ * THE 3D-MODEL AND PRESENTATION CARDS' CONTRACTS (2026-09-27, 0.105.0).
+ *
+ * Two more kinds that hand back a file rather than a change, beside the design
+ * and research contracts in prompts.mjs (which is past its size and keeps
+ * those two). `prompts.mjs` imports these into `AGENT_CONTRACTS`; the kind
+ * table (agentTaskKinds.mjs) runs both under the `design` posture — read the
+ * repo, write only `.flowviant/artifacts/**`, no web, no shell beyond `ls` —
+ * so "change no repository file" is enforced, not asked.
+ *
+ * THE SAME BONES AS THE DESIGN CONTRACT, deliberately: its header, its rule 3
+ * (commit nothing), its rule 4 (stop and ask) and its final JSON — one shape
+ * `parseTurnResult`, the settle, the board and the review deck already read.
+ * The tail is spelled ONCE, in `ARTIFACT_CONTRACT_TAIL`, and every
+ * file-handing contract renders it — these two, and the design and research
+ * contracts in prompts.mjs (whose bytes `taskKind.test.mjs` pins unchanged by
+ * the move), so no two of them can drift apart.
+ *
+ * "model" here is the 3D-model KIND (not an AI-model pin, `job.model`), and
+ * "deck" the presentation kind (not the review deck).
+ *
+ * Pure strings: no imports, no environment, no I/O.
+ */
+
+/**
+ * Rule 3, rule 4 and the final JSON a file-handing contract ends with.
+ * `ask` is rule 4's body after its number (the decision only a person can
+ * make); `summary` is the delivered shape's summary gloss.
+ */
+export const ARTIFACT_CONTRACT_TAIL = ({ ask, summary }) => `3. CHANGE NO REPOSITORY FILE AND COMMIT NOTHING. You can only write under
+   .flowviant/artifacts/, and the daemon keeps that directory out of git.
+
+4. ${ask}
+
+END YOUR TURN WITH ONE JSON OBJECT AND NOTHING AFTER IT, in a \`\`\`json fence:
+
+\`\`\`json
+{
+  "status": "delivered",
+  "summary": "${summary}",
+  "progress": "two or three sentences on what you have done in this run SO FAR, across every card"
+}
+\`\`\`
+
+or, if you are stopping to ask:
+
+\`\`\`json
+{
+  "status": "blocked",
+  "progress": "two or three sentences on what you have done in this run SO FAR, across every card",
+  "question": "the specific thing you need decided, in one or two sentences"
+}
+\`\`\`
+
+"progress" is REQUIRED on both shapes and REPLACES the previous one whole —
+past tense, plain sentences, no card ids.`;
+
+/**
+ * THE 3D-MODEL CARD. The product is a model a person can turn around in
+ * Review: one folder holding a three.js viewer and the model files it loads
+ * by relative URL — the bundle shape the artifact scan keeps (relative paths
+ * to depth four, 0.99.0) and the library keeps as one versioned folder. The
+ * daemon calls it delivered only when an `.html` AND a `.gltf`/`.glb`/`.obj`
+ * stand under `.flowviant/artifacts/` (agentTaskKinds.mjs).
+ *
+ * TEXT, BECAUSE TEXT IS ALL THIS POSTURE WRITES (2026-09-27, a call the owner
+ * may overrule). The kind runs under the `design` posture: Read, `ls`, and
+ * `Edit(.flowviant/artifacts/**)` — Claude's Write/Edit tools write text, and
+ * there is no shell that could produce bytes. The spec's first wording asked
+ * for glTF with a `.bin`, or a `.glb`, and `.png`/`.jpg` textures: outputs
+ * this card cannot make. So the contract asks for OBJ + `.mtl` (text, fetched
+ * by relative URL from the artifact host, which the viewer's `connect-src`
+ * admits) and SVG or procedural textures (`img-src` admits the host). NOT a
+ * `.gltf` with its buffer as a `data:` URI: three.js fetches that buffer, and
+ * the artifact CSP's `connect-src` names only the artifact host
+ * (apps/api/src/lib/artifactDelivery.ts), so the review viewer would refuse
+ * it. Binary files are still accepted — the artifact policy, the proof, the
+ * library and the 20 MB cap all keep them — for a folder that already holds
+ * one; widening the posture to write them is the owner's decision.
+ */
+export const SYSTEM_AGENT_MODEL = `You are the human's own Claude, working one 3D MODEL card in a git worktree of
+their repository. Nobody is watching this run. You have the repo and nothing
+else — no project tools, no board, no chat.
+
+A 3D MODEL CARD HANDS BACK A MODEL YOU CAN LOOK AT, NOT A CHANGE. Nothing you
+do here edits the product: the person turns the model around, and decides.
+
+WHAT TO DO:
+
+1. Read the repository first — the existing 3D assets and the scene they sit
+   in: their scale and units, their up axis, their style, their materials and
+   texture sizes. The model must fit THIS project, not a stock asset library.
+
+2. Write ONE folder, .flowviant/artifacts/<kebab-name>/ — a short kebab-case
+   name for what it is (for example .flowviant/artifacts/reading-chair/) —
+   holding:
+   - index.html, a viewer: three.js loaded from cdn.jsdelivr.net/npm or
+     unpkg.com, with orbit controls, loading the model by a RELATIVE URL
+     (./reading-chair.obj — never a path outside the folder);
+   - the model, written as TEXT: a .obj with its .mtl, each loaded by a
+     relative URL;
+   - its textures as .svg files referenced by relative paths, or drawn by
+     the viewer itself (procedural materials, canvas textures).
+   You can write only text files here. A .glb, .bin, .png or .jpg is kept
+   and shown if one already stands in the folder, but this card cannot make
+   one — never plan on one. Nothing else may load from the network, and
+   nothing can be sent. Keep every file under 2 MB — the viewer, the .obj,
+   the .mtl, each texture.
+
+${ARTIFACT_CONTRACT_TAIL({
+  ask: `If you cannot model it without a DECISION only a person can make — which of
+   two directions, what size or style, which asset it stands beside — STOP AND
+   ASK. Do not guess. A question costs one reply; a guessed model costs a review.`,
+  summary: 'one or two sentences on what the model shows, and the folder it is in',
+})}`;
+
+/**
+ * THE PRESENTATION CARD. One self-contained HTML deck under the design
+ * card's inline and CDN rules, navigable by keyboard and on screen, and
+ * printable one slide per page — so "send it as a PDF" is the browser's
+ * Print, never a converter this machine would have to run.
+ */
+export const SYSTEM_AGENT_DECK = `You are the human's own Claude, working one PRESENTATION card in a git worktree
+of their repository. Nobody is watching this run. You have the repo and nothing
+else — no project tools, no board, no chat.
+
+A PRESENTATION CARD HANDS BACK A DECK, NOT A CHANGE. Nothing you do here edits
+the product: the person pages through it, and decides.
+
+WHAT TO DO:
+
+1. Read what the deck is about first — the repository, the real product, its
+   brand and its own words. The deck must sound and look like THIS project,
+   not like a template.
+
+2. Write ONE self-contained HTML file directly in .flowviant/artifacts/ — a
+   short kebab-case name for the talk (for example
+   .flowviant/artifacts/q3-roadmap.html). Inline CSS (a Google Fonts
+   stylesheet may load). Scripts may be inline or loaded from
+   cdnjs.cloudflare.com, cdn.jsdelivr.net/npm or unpkg.com, and from nowhere
+   else; nothing else may load from the network and nothing can be sent, so
+   images are data: URIs or inline SVG. Each slide is a <section>; the arrow
+   keys and on-screen previous/next buttons move between them, and a counter
+   says which slide of how many is showing. Add @media print rules that put
+   one slide on each page (break-after: page), so the browser prints it to a
+   PDF. Keep it under 2 MB.
+
+${ARTIFACT_CONTRACT_TAIL({
+  ask: `If you cannot write it without a DECISION only a person can make — who the
+   audience is, how long it runs, what it must argue — STOP AND ASK. Do not
+   guess. A question costs one reply; a guessed deck costs a review.`,
+  summary: 'one or two sentences on what the deck covers, and the file it is in',
+})}`;

package/bin/lib/artifactPolicy.mjs

@@ -39,6 +39,7 @@ export const ARTIFACT_TYPES = {
   pdf: { mime: 'application/pdf', text: false },
   gltf: { mime: 'model/gltf+json', text: true },
   obj: { mime: 'model/obj', text: true },
+  mtl: { mime: 'model/mtl', text: true },
   glb: { mime: 'model/gltf-binary', text: false },
   bin: { mime: 'application/octet-stream', text: false },
 };

package/bin/lib/artifacts.mjs

@@ -28,7 +28,8 @@
  *
  * ── THE BOUNDS ──
  *
- * Regular files only, DEPTH ONE, `lstat` and never followed: a symlink an
+ * Regular files only, to DEPTH FOUR (relative paths, 0.99.0 — a bundle's
+ * sidecars), `lstat` and never followed: a symlink an
  * agent planted at `.flowviant/artifacts/x.txt -> ~/.ssh/id_ed25519` is
  * reported as nothing, and the read itself opens with `O_NOFOLLOW` so a swap
  * between the lstat and the open cannot turn one into a follow. The directory

package/bin/lib/cardThread.mjs

@@ -0,0 +1,89 @@
+/**
+ * A CARD'S DISCUSSION, AS THE WIRE HANDS IT OVER (0.106.0) — the owner,
+ * 2026-09-27: "yes agents should read card comments".
+ *
+ * The server relays a card's thread (people's comments AND agents' own notes,
+ * replies and delivery cards) onto the jobs that work or plan it:
+ * `agentTurnJobs[].cardThread` (the one card a turn is about, named by
+ * `taskId` and `title`) and `agentPlanJobs[].tasks[].thread`. Each is
+ * `{ entries: [{ who, at, text }], omitted }`, oldest first — the newest run
+ * of the thread that fits the server's budget, with `omitted` counting the
+ * older entries it left out.
+ *
+ * THE WIRE IS NOT TRUSTED. The server bounded it (`CARD_THREAD_BUDGET` in the
+ * app's agent-runner.schema.ts); this module reads it again, entry by entry,
+ * and applies the SAME numbers — a copy the release gate holds to the server's
+ * (`scripts/check-app-parity.mjs`, rule 5). A malformed entry is dropped
+ * alone; a name or a time is one bounded line (a line break would forge a
+ * second entry); a text past its cap is cut and marked; entries past the
+ * budget are dropped from the OLDEST end and counted, so an agent is never
+ * handed a thread that silently starts in the middle.
+ *
+ * Absent, empty or wholly malformed reads as null, and a null thread prints
+ * NOTHING — which is why every prompt for a card nobody discussed (and every
+ * job from a server older than 0.106.0) stays byte-identical.
+ *
+ * Pure data and pure functions: no imports, no environment, no I/O — prompts
+ * imports it, and prompts is strings.
+ */
+
+/** The server's `CARD_THREAD_BUDGET`, row for row: a TURN reads one card, a
+ *  PLAN glances at many. */
+export const CARD_THREAD_BUDGET = Object.freeze({
+  turn: Object.freeze({ entries: 30, chars: 6000, entryChars: 1500 }),
+  plan: Object.freeze({ entries: 6, chars: 1200, entryChars: 400 }),
+});
+/** The server's `CARD_THREAD_WHO_MAX` — a name is a label. */
+export const CARD_THREAD_WHO_MAX = 80;
+/** The server's `CARD_THREAD_AT_MAX` — an ISO time, with room. */
+export const CARD_THREAD_AT_MAX = 40;
+/** A count is a number a prompt prints; past this it is not a count. */
+const OMITTED_MAX = 1_000_000;
+
+/**
+ * THE MOST ONE TURN'S DISCUSSION CAN ADD TO A CARD SPEC, rendered — so the
+ * spec stash (agentCards.mjs `MAX_SPEC_CHARS`) can hold a card with its
+ * discussion whole, and the pre-review reads what the agent read. The text is
+ * at most `chars`; the renderer adds at most two characters and a newline per
+ * text line (<= 3x the text), a header line per entry, and two lines of its
+ * own. `cardThread.test.mjs` renders the worst case against it.
+ */
+export const CARD_THREAD_RENDER_MAX =
+  3 * CARD_THREAD_BUDGET.turn.chars +
+  CARD_THREAD_BUDGET.turn.entries * (CARD_THREAD_WHO_MAX + CARD_THREAD_AT_MAX + 10) +
+  200;
+
+const oneLine = (v, max) => String(v).replace(/[\r\n]+/g, ' ').trim().slice(0, max);
+
+/**
+ * A thread off the wire, re-bounded at `budget`'s row ('turn' | 'plan'; an
+ * unknown row is the tighter plan one), or null when there is nothing in it to
+ * print. Never throws.
+ */
+export function readCardThread(raw, budget = 'turn') {
+  const b = CARD_THREAD_BUDGET[budget] ?? CARD_THREAD_BUDGET.plan;
+  if (!raw || typeof raw !== 'object' || !Array.isArray(raw.entries)) return null;
+  const good = [];
+  for (const e of raw.entries) {
+    if (!e || typeof e !== 'object') continue;
+    if (typeof e.who !== 'string' || typeof e.at !== 'string' || typeof e.text !== 'string') continue;
+    const whole = e.text.replace(/\r\n?/g, '\n').trim();
+    if (!whole) continue;
+    good.push({
+      who: oneLine(e.who, CARD_THREAD_WHO_MAX) || 'member',
+      at: oneLine(e.at, CARD_THREAD_AT_MAX),
+      text: whole.length > b.entryChars ? `${whole.slice(0, b.entryChars - 1)}…` : whole,
+    });
+  }
+  // The newest contiguous run that fits — the server's own walk.
+  const kept = [];
+  let chars = 0;
+  for (let i = good.length - 1; i >= 0 && kept.length < b.entries; i--) {
+    if (chars + good[i].text.length > b.chars) break;
+    chars += good[i].text.length;
+    kept.push(good[i]);
+  }
+  if (kept.length === 0) return null;
+  const sent = Number.isInteger(raw.omitted) && raw.omitted > 0 ? Math.min(raw.omitted, OMITTED_MAX) : 0;
+  return { entries: kept.reverse(), omitted: sent + (good.length - kept.length) };
+}

package/bin/lib/claudePosture.mjs

@@ -219,8 +219,11 @@ export function consultPermFor(knowledgeDir) {
  *    `**` AND NOT `*`, measured the same day: `Edit(.flowviant/artifacts/*)`
  *    let a Write to `.flowviant/artifacts/sub/b.html` through exactly as `**`
  *    did, so the single-level spelling is not narrower on this CLI and would
- *    only read as if it were. The scan keeps top-level files, so the
- *    contracts say "no subfolders" — the prompt is the only thing that can.
+ *    only read as if it were. So where a file may sit under the artifacts
+ *    directory is the prompt's to say, never the posture's: the design and
+ *    research contracts say "no subfolders" (written when the scan kept
+ *    top-level files only; it walks to depth four since 0.99.0), and the
+ *    3D-model contract, under this same posture, asks for one folder.
  *
  * THEY ARE NOT THE SAME READER, and the difference is the network:
  *

package/bin/lib/knowledge.mjs

@@ -59,7 +59,7 @@
  *
  * This module is the ROSTER DRIVER alone: the rev held in memory, the
  * serialised sync, the backoff. The pure naming, path and catalog rules —
- * including the kept library's two subdirectories — are knowledgeLibrary.mjs;
+ * including the kept library's four subdirectories — are knowledgeLibrary.mjs;
  * the disk (the sync itself, the marker, `knowledgeDirFor`) is
  * knowledgeFiles.mjs; the `/fleet/knowledge` and `/fleet/library` download is
  * knowledgeFetch.mjs. Callers import the owner they need.

package/bin/lib/knowledgeFiles.mjs

@@ -288,7 +288,7 @@ export async function syncKnowledge({ checkoutDir, manifest, fetchFile, maxBytes
 /**
  * THE KEPT LIBRARY'S HALF OF A SYNC: each item into its subdirectory (fetched
  * only when its sha differs, written atomically, the bytes checked against the
- * manifest), every other entry in the two subdirectories removed, and
+ * manifest), every other entry in the library subdirectories removed, and
  * `LIBRARY.md` regenerated from the items that are on disk AS THE MANIFEST
  * NAMES THEM — the entry and every bundle file current (`isCurrent`,
  * knowledgeFileSync.mjs). A download that fails keeps whatever copy was there
@@ -296,7 +296,9 @@ export async function syncKnowledge({ checkoutDir, manifest, fetchFile, maxBytes
  * item over the cap is refused for this rev and left out of the catalog.
  */
 async function syncLibrary({ dir, items, fetchFile, maxBytes, keep, result }) {
-  const wanted = { designs: new Set(), research: new Set() };
+  // One set per library folder, from the one table — a fourth folder added
+  // there is synced and swept here with no second list to miss.
+  const wanted = Object.fromEntries(Object.values(LIBRARY_DIRS).map((d) => [d, new Set()]));
   const onDisk = [];
   for (const kind of Object.keys(LIBRARY_DIRS)) {
     if (items.some((it) => it.kind === kind)) {