flowviant 0.105.0 → 0.107.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

@@ -27,10 +27,8 @@
  * 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, 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;
+ *    delivery — `match` over the artifact file name, 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. */
@@ -51,18 +49,19 @@ export const AGENT_TASK_KINDS = Object.freeze({
     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.
+   * THE 3D-MODEL KIND (0.105.0; one page since 0.107.0): a three.js page that
+   * builds the model in code, which the person exports to one .glb in Review.
+   * 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. Proven by its page alone — the model is
+   * IN the page; 0.105.0's second proof (a .gltf/.glb/.obj beside it) went
+   * with the files it asked for.
    */
   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/',
+      missing: 'the turn ended without writing a 3D model page under .flowviant/artifacts/',
     }),
     offRuntime: () => CLAUDE_ONLY,
   }),

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 in the one three.js page, at the scale and in the units of the ' +
+      'target the card names, else 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

@@ -56,62 +56,84 @@ or, if you are stopping to ask:
 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).
+ * THE 3D-MODEL CARD (rewritten 0.107.0, the owner, 2026-09-27: "yeah just
+ * glb"). The product is ONE .glb a person downloads and imports; the card
+ * hands back ONE three.js page that builds the model in code and shows it —
+ * how Claude makes a model a person can look at anywhere else — and Flowviant
+ * exports that page's model group to a .glb with three.js's own GLTFExporter
+ * when the person presses Download .glb in Review (apps/web
+ * `workbench/glbExport.ts`, the other half of the handshake below).
  *
- * 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.
+ * WHY NOT A MODEL FILE ON DISK. This kind runs under the `design` posture:
+ * Read, `ls`, and `Edit(.flowviant/artifacts/**)` — text only, no shell. A
+ * .glb is binary; a .gltf's buffer is base64 floats nobody writes by hand.
+ * The 0.105.0 contract asked for OBJ + .mtl + SVG textures instead, and a
+ * katana came back as seven files, textures no game engine imports and a
+ * generator script (2026-09-27). Built in code, drawn textures are canvases,
+ * and the exporter embeds them in the .glb as PNGs.
+ *
+ * THE HANDSHAKE IS SPELLED WORD FOR WORD because the web keys on it: the page
+ * announces `glb-ready` once its model stands, and answers `export-glb` with
+ * the binary. The page runs in a scripts-only sandbox with an opaque origin,
+ * so it posts to `parent` with `'*'`; the app accepts only its own frame's
+ * messages. A page with no handshake (every 0.105.0 bundle) is still viewed;
+ * it is just never offered a Download .glb.
  */
 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.
+do here edits the product: the person turns the model around, downloads it as
+one .glb, 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.
+1. Read the card and the repository first. If the card names where the model
+   will be used — a game engine, a platform, a printer — meet that target's
+   import rules: its scale and units, its up axis, its triangle and texture
+   limits. Otherwise match the scale and units of any 3D assets the repository
+   already has. Say in your summary what you assumed.
+
+2. Write ONE file, .flowviant/artifacts/<kebab-name>/index.html — a short
+   kebab-case name for what it is (for example
+   .flowviant/artifacts/reading-chair/index.html). Nothing else goes in that
+   folder: no model files, no textures, no scripts, no notes. The page BUILDS
+   THE MODEL IN CODE and shows it:
+   - three.js as ES modules from cdn.jsdelivr.net/npm, through an import map
+     for "three" and "three/addons/"; orbit controls, lights and a neutral
+     ground. Nothing else loads from the network, and nothing can be sent.
+   - the model is ONE THREE.Group named for what it is, built from three.js
+     geometry (lathe, extrude, tube, box and the rest, one mesh per part),
+     with MeshStandardMaterial only. Colour, roughness and metalness are
+     material values, or textures you DRAW ON A CANVAS in the page
+     (THREE.CanvasTexture, 1024px or less) — never an image file.
+   - the ground, a grid, the lights, a figure for scale and every other
+     helper stay OUTSIDE that group: they are the viewer's, not the model.
+   - no download or save button of your own: the page cannot download
+     anything. Flowviant's Download .glb is the way out.
+   - once the group is built, hand it to Flowviant exactly like this, with
+     MODEL the group:
+
+     import { GLTFExporter } from 'three/addons/exporters/GLTFExporter.js';
+     addEventListener('message', (e) => {
+       if (e.source !== parent || e.data?.flowviant !== 'export-glb') return;
+       new GLTFExporter().parse(
+         MODEL,
+         (glb) => parent.postMessage({ flowviant: 'glb', glb }, '*', [glb]),
+         (err) => parent.postMessage({ flowviant: 'glb-error', message: String(err) }, '*'),
+         { binary: true }
+       );
+     });
+     parent.postMessage({ flowviant: 'glb-ready' }, '*');
+
+   Keep the page under 2 MB.
 
 ${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',
+  summary: 'one or two sentences on what the model shows, the folder it is in, and the scale and target you assumed',
 })}`;
 
 /**

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/prompts.mjs

@@ -3,19 +3,26 @@
  * hands a coding CLI, in one place. Split out of claude.mjs purely for size
  * (the permission sets are claudePosture.mjs's, the turn plumbing runTurn.mjs's);
  * every call site imports them from here. These are strings and
- * nothing else: no environment, no I/O, and three imports — the card-kind
+ * nothing else: no environment, no I/O, and five imports — the card-kind
  * table (agentTaskKinds.mjs, itself pure data), which selects among them; the
+ * card-type table (agentTaskTypes.mjs, pure data, 0.106.0), which holds each
+ * type's label and its one contract sentence; the
  * 3D-model and presentation contracts and the tail every file-handing contract
- * ends in (artifactContracts.mjs, strings split out for size); and the kept
+ * ends in (artifactContracts.mjs, strings split out for size); the kept
  * library's reference rule (knowledgeLibrary.mjs, pure but for the pure
- * safe-name rule), which decides which card references are printed.
+ * safe-name rule), which decides which card references are printed; and the
+ * card-thread reader (cardThread.mjs, pure), which decides which of a card's
+ * discussion is printed (0.106.0).
  */
 
 // A card's kind is read through agentTaskKinds.mjs — the one table of what a
 // kind is. This file keeps only the STRINGS each kind is handed.
 import { agentTaskKindOf } from './agentTaskKinds.mjs';
+// A card's type (0.106.0) likewise: the table holds the words, this file prints them.
+import { AGENT_TASK_TYPES, agentTaskTypeFor } from './agentTaskTypes.mjs';
 import { ARTIFACT_CONTRACT_TAIL, SYSTEM_AGENT_DECK, SYSTEM_AGENT_MODEL } from './artifactContracts.mjs';
 import { isLibraryReference } from './knowledgeLibrary.mjs';
+import { readCardThread } from './cardThread.mjs';
 
 // Wiki-gen turn: the local Claude READS the repo (cwd) and writes/maintains the
 // knowledge VAULT — a plain directory of markdown files with [[wikilinks]]
@@ -538,8 +545,8 @@ MECHANICS OF THIS CHAT:
    - "code": a change to the code — commits they review and merge. The default.
    - "design": a UI mockup — one HTML page to look at; no code changed.
      "Mockup", "design page X", "show me what the settings page could look like".
-   - "model": a 3D model — a viewable bundle (an HTML viewer and the model
-     files); no code changed. "3D model", "mesh", "a chair model", "glTF", "OBJ".
+   - "model": a 3D model — one page to turn it around in, downloaded as a
+     .glb; no code changed. "3D model", "mesh", "a chair model", "glTF", "OBJ".
    - "deck": a presentation — one HTML slide deck; no code changed. "Slides",
      "a deck", "a presentation", "a pitch".
    - "research": a write-up — read the repo and the web; no code changed.
@@ -791,7 +798,10 @@ exactly as given.`;
  * The cards and the live agents are FENCED: their titles, briefs and criteria
  * are written by whoever files cards in this project and by agents themselves,
  * and this turn reads a repository afterwards. The instruction that matters —
- * "split this" — is ours and sits outside the fence.
+ * "split this" — is ours and sits outside the fence. A card's discussion
+ * (0.106.0) is the same kind of text and sits inside the same fence. A card's
+ * TYPE (0.106.0) is printed under its kind by its label alone — the planner
+ * splits work, and the type's contract sentence is for the agent that does it.
  */
 export const AGENT_PLAN_KICKOFF = ({ tasks, liveAgents, agentCap }) => {
   const cards = tasks
@@ -802,10 +812,18 @@ export const AGENT_PLAN_KICKOFF = ({ tasks, liveAgents, agentCap }) => {
         // by it (SYSTEM_PLAN rule 8), and an absent line would read as "not
         // stated" rather than as the default. Absent on the wire IS code.
         `  kind: ${agentTaskKindOf(t.taskKind)}\n` +
+        // WHAT KIND OF WORK IT ASKS FOR (0.106.0), by its label — only on a
+        // typed card (a type on another kind is none), so an untyped card's
+        // listing, and every plan from an older server, is unchanged.
+        (agentTaskTypeFor(t) ? `  type: ${AGENT_TASK_TYPES[agentTaskTypeFor(t)].label}\n` : '') +
         (t.points ? `  points: ${t.points}\n` : '') +
         (t.anchors?.length ? `  owns: ${t.anchors.join(', ')}\n` : '') +
         (t.brief ? `  brief: ${t.brief}\n` : '') +
-        (t.criteria?.length ? `  done when:\n${t.criteria.map((c) => `    - ${c}`).join('\n')}\n` : '')
+        (t.criteria?.length ? `  done when:\n${t.criteria.map((c) => `    - ${c}`).join('\n')}\n` : '') +
+        // WHAT HAS BEEN SAID ON IT (0.106.0) — at the plan row of the budget,
+        // inside the fence with the rest of the card. Absent on a card nobody
+        // discussed (and from an older server), so its listing is unchanged.
+        cardThreadText(readCardThread(t.thread, 'plan'), '  ')
     )
     .join('\n');
   const live = liveAgents.length
@@ -1030,7 +1048,7 @@ export const AGENT_CONTRACTS = Object.freeze({
 });
 export const AGENT_HANDS_BACK = Object.freeze({
   design: 'a DESIGN card: it hands back a mockup',
-  model: 'a 3D MODEL card: it hands back a viewable model bundle',
+  model: 'a 3D MODEL card: it hands back a model to view and download as a .glb',
   deck: 'a PRESENTATION card: it hands back an HTML slide deck',
   research: 'a RESEARCH card: it hands back a write-up',
 });
@@ -1040,18 +1058,20 @@ export const AGENT_HANDS_BACK = Object.freeze({
  *
  * The card is FENCED: its title, brief and criteria are written by whoever
  * files cards in this project, and this turn is about to edit code. The
- * instruction is ours and sits outside the fence.
+ * instruction is ours and sits outside the fence. The card's DISCUSSION
+ * (`cardThread`, 0.106.0) is printed inside the same fence, as part of the
+ * spec (`AGENT_TASK_SPEC`), so the spec stashed for the pre-review carries it.
  *
  * The queue POSITION is stated because it changes behaviour: an agent that
  * thinks it is finishing tidies up, writes summaries and stops; one that knows
  * three more cards are coming leaves the ground ready for them.
  */
-export const AGENT_TASK_KICKOFF = ({ agentName, task, position, total }) =>
+export const AGENT_TASK_KICKOFF = ({ agentName, task, cardThread, position, total }) =>
   agentTaskKindOf(task?.taskKind) === 'code'
     ? `You are the agent "${safeName(agentName)}", working card ${position} of ${total} ` +
       `on this branch. Everything you commit here is reviewed and merged TOGETHER with ` +
       `the other cards in this run.\n\n` +
-      `${fence('THE CARD', taskBlock(task))}\n\n` +
+      `${fence('THE CARD', taskBlock(task, cardThread))}\n\n` +
       `When you commit, put this trailer on the LAST line of each commit message so ` +
       `the card can find its own commits:\n` +
       `Flowviant-Task: ${task?.id ?? ''}\n\n` +
@@ -1063,7 +1083,7 @@ export const AGENT_TASK_KICKOFF = ({ agentName, task, position, total }) =>
       `You are the agent "${safeName(agentName)}", working card ${position} of ${total} ` +
       `in this run. This card is ${AGENT_HANDS_BACK[agentTaskKindOf(task?.taskKind)]}, ` +
       `written under .flowviant/artifacts/, and changes nothing in the repository.\n\n` +
-      `${fence('THE CARD', taskBlock(task))}\n\n` +
+      `${fence('THE CARD', taskBlock(task, cardThread))}\n\n` +
       `Do it, and end with the JSON object.`;
 
 /**
@@ -1091,7 +1111,7 @@ const safeName = (n) =>
  * renderings of a card that can drift — and the drift would be invisible,
  * because nobody reads both prompts side by side.
  */
-export const AGENT_TASK_SPEC = (task) =>
+export const AGENT_TASK_SPEC = (task, cardThread) =>
   `id: ${task?.id ?? ''}\n` +
   `title: ${task?.title ?? ''}\n` +
   // THE KIND, when it is news (0.97.0). A code card's spec stays byte-for-byte
@@ -1099,6 +1119,11 @@ export const AGENT_TASK_SPEC = (task) =>
   // and a line saying "kind: code" on every card is a change to every prompt
   // for a fact that was always true.
   (agentTaskKindOf(task?.taskKind) !== 'code' ? `kind: ${agentTaskKindOf(task.taskKind)}\n` : '') +
+  // THE TYPE AND ITS ONE CONTRACT SENTENCE (0.106.0), right under the kind:
+  // "type: Bug fix — reproduce it first, …". Only a type this daemon knows,
+  // on its own kind (`agentTaskTypeFor`); an untyped card's spec — and every
+  // job from an older server — is byte-for-byte what it was.
+  typeLine(task) +
   (task?.brief ? `\nbrief:\n${task.brief}\n` : '') +
   (task?.criteria?.length ? `\ndone when:\n${task.criteria.map((c) => `- ${c}`).join('\n')}\n` : '') +
   (task?.anchors?.length ? `\nthis card owns:\n${task.anchors.map((a) => `- ${a}`).join('\n')}\n` : '') +
@@ -1111,8 +1136,48 @@ export const AGENT_TASK_SPEC = (task) =>
         .filter(isReference)
         .map((r) => `- ${oneLine(r.name, 200)} — ${oneLine(r.title, 200)}`)
         .join('\n')}\n`
+    : '') +
+  // WHAT HAS BEEN SAID ON THE CARD (0.106.0) — the task turn's `cardThread`,
+  // LAST, after everything the card asks. Printed only when it names THIS
+  // card and holds something, so every spec without a discussion — every
+  // stash and every prompt before 0.106.0 — is byte-for-byte what it was.
+  (cardThread && task?.id && String(cardThread.taskId ?? '') === String(task.id)
+    ? prefixed('\n', cardThreadText(readCardThread(cardThread, 'turn')))
     : '');
 
+/** A card's type as the spec prints it, or ''. */
+const typeLine = (task) => {
+  const type = agentTaskTypeFor(task);
+  if (!type) return '';
+  const { label, contract } = AGENT_TASK_TYPES[type];
+  return `type: ${label} — ${contract}\n`;
+};
+
+/**
+ * A CARD'S DISCUSSION AS TEXT — the one renderer, for the spec, a human
+ * turn's own block and the plan's listing (0.106.0). '' for a null thread.
+ *
+ * Oldest first, one header line per entry (who, and when when it is known),
+ * the words beneath it indented two spaces, so no line of somebody's comment
+ * can start a new entry under another name. How many earlier entries the
+ * budget left out is said, not hidden: an agent reading a reply without the
+ * message it answers should know there was one.
+ */
+const cardThreadText = (thread, indent = '') => {
+  if (!thread) return '';
+  const lines = [`${indent}discussion on this card (oldest first):`];
+  if (thread.omitted > 0) {
+    lines.push(`${indent}(${thread.omitted} earlier message${thread.omitted === 1 ? '' : 's'} not shown)`);
+  }
+  for (const e of thread.entries) {
+    lines.push(`${indent}- ${e.who}${e.at ? `, ${e.at}` : ''}:`);
+    for (const line of e.text.split('\n')) lines.push(line ? `${indent}  ${line}` : '');
+  }
+  return `${lines.join('\n')}\n`;
+};
+/** `head` before `text`, or '' when there is no text. */
+const prefixed = (head, text) => (text ? `${head}${text}` : '');
+
 /** A reference as the server sends it: a library path and its title. Anything
  *  else is not printed — this text is fenced as card content, but a path that
  *  is not a path is not worth handing an agent.
@@ -1135,16 +1200,33 @@ const taskBlock = AGENT_TASK_SPEC;
  * It is the same shape as a task turn on purpose: the agent still ends with the
  * JSON object, because whatever it does next either finishes the card it was on
  * or blocks again, and those are the only two things the board can act on.
+ *
+ * THE CARD'S DISCUSSION (0.106.0) — when the turn is about one card (an
+ * answer that names it, or a message to an agent holding one), the server
+ * sends that card's thread, and it is printed AFTER the person's words in a
+ * fence of its own, naming the card (a message often carries no `task` to name
+ * it by). Never inside THE CARD YOU ARE ON: that block is the spec, as it
+ * always was. Absent, nothing is printed, and the prompt is what it was.
  */
-export const AGENT_HUMAN_KICKOFF = ({ agentName, message, askedByName, task, position, total }) =>
+export const AGENT_HUMAN_KICKOFF = ({ agentName, message, askedByName, task, cardThread, position, total }) =>
   `You are the agent "${safeName(agentName)}"` +
   (task ? `, working card ${position} of ${total} on this branch` : '') +
   `.\n\n` +
   `${fence('WHO IS TALKING', askedByName || 'a member of this project')}\n\n` +
   `${fence('WHAT THEY SAID', message)}\n\n` +
   (task ? `${fence('THE CARD YOU ARE ON', taskBlock(task))}\n\n` : '') +
+  cardDiscussionBlock(cardThread) +
   `Carry on, and end with the JSON object as usual.`;
 
+/** A human turn's card discussion, fenced, naming the card — '' when there is
+ *  none to print. */
+const cardDiscussionBlock = (cardThread) => {
+  const text = cardThreadText(readCardThread(cardThread, 'turn'));
+  if (!text) return '';
+  const head = `card: ${oneLine(cardThread.taskId, 64)}\ntitle: ${oneLine(cardThread.title, 300)}\n\n`;
+  return `${fence("THE CARD'S DISCUSSION", `${head}${text}`)}\n\n`;
+};
+
 /**
  * THE AI PRE-REVIEW — a FRESH Claude reads the branch before the human does
  * (2026-09-16).

package/bin/lib/workAgentTurnExecution.mjs

@@ -282,7 +282,9 @@ export function createAgentTurnExecution({
      * what was asked for either way.
      *
      * ONE SPEC BUILDER (`AGENT_TASK_SPEC`) shared with the kickoff below, so
-     * what the reviewer reads is byte-identical to what the agent read.
+     * what the reviewer reads is byte-identical to what the agent read — the
+     * card's discussion included (0.106.0): both are handed the same
+     * `job.cardThread`, and the builder prints it inside the spec.
      * Failure is swallowed inside `stashCard`: a note about a turn may never
      * cost the turn.
      */
@@ -290,7 +292,7 @@ export function createAgentTurnExecution({
       stashCard(
         sessionMetaPath(wt, 'flowviant-agent-cards', agentId),
         job.task.id,
-        AGENT_TASK_SPEC(job.task)
+        AGENT_TASK_SPEC(job.task, job.cardThread)
       );
     }
 
@@ -372,6 +374,9 @@ export function createAgentTurnExecution({
             ? AGENT_TASK_KICKOFF({
                 agentName: job.agentName,
                 task: job.task,
+                // The card's discussion (0.106.0), printed inside THE CARD by
+                // the same builder the stash above wrote down.
+                cardThread: job.cardThread,
                 position: job.position ?? 1,
                 total: job.total ?? 1,
               })
@@ -380,6 +385,9 @@ export function createAgentTurnExecution({
                 message: job.body ?? '',
                 askedByName: job.askedByName,
                 task: job.task,
+                // The discussion on the one card this message is about, in a
+                // fence of its own after the person's words (0.106.0).
+                cardThread: job.cardThread,
                 position: job.position ?? 1,
                 total: job.total ?? 1,
               }),

package/bin/lib/workAgentTurnOutcome.mjs

@@ -78,8 +78,8 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    *
    * Its product is under `.flowviant/artifacts/`, and the kind's table
    * (agentTaskKinds.mjs) says which file proves it: a `.html` mockup for
-   * design, a `.html` deck, a `.md` write-up for research, and for a 3D
-   * model a `.html` viewer AND a `.gltf`/`.glb`/`.obj` beside it. A turn that
+   * design, a `.html` deck, a `.md` write-up for research, and a `.html`
+   * page for a 3D model (the model is built in it, 0.107.0). A turn that
    * says "delivered" without having written one would land the agent in Review
    * with nothing to look at and a summary describing a page that does not
    * exist — so it settles `nothing` with the measured sentence, and the
@@ -108,19 +108,10 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    */
   if (res.outcome === 'delivered' && kind.artifact) {
     const want = kind.artifact.match;
-    // THE 3D-MODEL KIND'S SECOND PROOF (0.105.0): its viewer page alone is a
-    // page, not a model — a `.gltf`/`.glb`/`.obj` must stand beside it. A
-    // task turn delivers when it wrote EITHER half this turn and BOTH stand
-    // (a re-modelled mesh — a rewritten .gltf/.glb/.obj — need not rewrite
-    // its viewer; a texture or .mtl alone is neither half). The halves are
-    // not paired by folder (pinned in the test). With no companion this is
-    // exactly the one-file rule design, deck and research have.
-    const also = kind.artifact.companion;
-    const need = (l) => l.some((e) => want.test(e.name)) && (!also || l.some((e) => also.test(e.name)));
+    const has = (l) => l.some((e) => want.test(e.name));
     const standing = scanArtifacts(wt);
-    const touched = changedArtifacts(artifactsBefore, standing);
-    const wrote = touched.some((e) => want.test(e.name) || also?.test(e.name)) && need(standing);
-    const present = wrote || ((job.kind !== 'task' || job.redo === true) && need(standing));
+    const wrote = has(changedArtifacts(artifactsBefore, standing));
+    const present = wrote || ((job.kind !== 'task' || job.redo === true) && has(standing));
     if (!present) {
       return report({
         turnId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.105.0",
+  "version": "0.107.0",
   "description": "Run your own coding CLIs as build agents for Flowviant — Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {