flowviant 0.105.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/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/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]]
@@ -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
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.105.0",
+  "version": "0.106.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": {