@@ -41,7 +41,7 @@ import type { AgentDriver, StepRef } from './driver.js';
 import { citationLabels, namespaceOfArtifact, namespacedScenario, permissionSetName, templateHostName } from './namespace.js';
 import { observeOperation, touchedRowId, type Row } from './observe.js';
 import type { CommandResult } from './project.js';
-import { buildPrompt, iteratePrompt, operationPrompt, personaHandles, questionPrompt, templateIteratePrompt, verifyFlags } from './prompts.js';
+import { buildPrompt, iteratePrompt, operationPrompt, personaHandles, questionPrompt, templateIteratePrompt, userHandleFields, verifyArgs } from './prompts.js';
 import type { ParsedTurn } from './transcript.js';
 
 // ── What the orchestrator needs from the outside world ──────────────────────
@@ -97,6 +97,8 @@ export interface BuildHalf {
 export interface QuestionResult {
   question: string;
   persona: string | null;
+  /** Why this turn was not asked: it reads a row the seed could not load ({@link seedDependence}). Not measured, never a fail. */
+  notMeasured?: string;
   grade?: PersonaRunGrade;
   turn?: TurnSummary;
   error?: string;
@@ -105,6 +107,8 @@ export interface QuestionResult {
 export interface OperationResult {
   operation: string;
   persona: string;
+  /** Why this operation was not run: it acts on a row the seed could not load ({@link seedDependence}). Not measured, never a fail. */
+  notMeasured?: string;
   observation?: OperationObservation;
   grade?: OperationGrade;
   turn?: TurnSummary;
@@ -113,7 +117,12 @@ export interface OperationResult {
 
 export interface RunHalf {
   personas: Array<Omit<PersonaAccount, 'apiKey'>>;
-  seed: { inserted: number; refused: Array<{ object: string; id: string; code?: string; message?: string }> };
+  seed: {
+    inserted: number;
+    refused: Array<{ object: string; id: string; code?: string; message?: string }>;
+    /** Handles a user-handle field named that no persona holds, each loaded as the admin user (`u_tia`). */
+    handlesAsAdmin?: string[];
+  };
   questions: QuestionResult[];
   operations: OperationResult[];
   error?: string;
@@ -236,6 +245,78 @@ export function hiddenValues(scenario: LoadedScenario, personaId: string): Array
   return [...out];
 }
 
+type Card = LoadedScenario['card'];
+type Question = Card['run']['questions'][number];
+type Operation = Card['run']['operations'][number];
+
+/**
+ * What a refused seed row takes out of the Run half, read from what the card
+ * names. The rows out are the refused ones plus, transitively, every seed row
+ * whose declared lookup (`expect.lookups`) names a row that is out — a contact
+ * of a refused account, whether or not the app refused it too. Then:
+ *
+ *   - a question is not measured when its `object` has a row that is out: its
+ *     truth was computed over rows the app does not hold;
+ *   - an operation is not measured when its `target`, a lookup value it writes,
+ *     or a post-state row (`id`, or a lookup value in its `values`) names a row
+ *     that is out.
+ *
+ * Everything else grades as usual. A not-measured turn is not asked and counts
+ * in neither passed nor total.
+ */
+export function seedDependence(
+  card: Card,
+  refused: ReadonlyArray<{ object: string; id: string }>,
+): { out: Map<string, string>; question(q: Question): string | undefined; operation(op: Operation): string | undefined } {
+  /** `object/id` → the refused row it hangs off, as `object id`. */
+  const out = new Map<string, string>(refused.map((r) => [`${r.object}/${r.id}`, `${r.object} ${r.id}`]));
+  const lookups = card.expect.lookups ?? [];
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const l of lookups) {
+      for (const row of card.run.seed[l.object] ?? []) {
+        const parent = out.get(`${l.to}/${String(row[l.field])}`);
+        if (parent !== undefined && !out.has(`${l.object}/${row.id}`)) {
+          out.set(`${l.object}/${row.id}`, parent);
+          grew = true;
+        }
+      }
+    }
+  }
+  const why = (object: string, id: unknown): string | undefined => {
+    const root = typeof id === 'string' ? out.get(`${object}/${id}`) : undefined;
+    if (root === undefined) return undefined;
+    return root === `${object} ${String(id)}` ? `seed: needs ${root}, which the app refused` : `seed: needs ${object} ${String(id)}, a child of ${root}, which the app refused`;
+  };
+  const viaLookups = (object: string, values: Record<string, unknown> | undefined): string | undefined => {
+    for (const l of lookups) {
+      const w = l.object === object && values && l.field in values ? why(l.to, values[l.field]) : undefined;
+      if (w) return w;
+    }
+    return undefined;
+  };
+  return {
+    out,
+    question: (q) => {
+      for (const row of card.run.seed[q.object] ?? []) {
+        const w = why(q.object, row.id);
+        if (w) return w;
+      }
+      return undefined;
+    },
+    operation: (op) => {
+      const direct = (op.target !== undefined ? why(op.object, op.target) : undefined) ?? viaLookups(op.object, op.values);
+      if (direct) return direct;
+      if (op.outcome.kind !== 'applied') return undefined;
+      for (const st of op.outcome.state) {
+        const w = (st.id !== undefined ? why(st.object, st.id) : undefined) ?? viaLookups(st.object, st.values);
+        if (w) return w;
+      }
+      return undefined;
+    },
+  };
+}
+
 /** The persona (not a card artifact) a scenario's audit trail names, from the user id the app recorded. */
 function personaOfUser(userId: string | null, accounts: readonly PersonaAccount[], adminId: string): string | null {
   if (userId === null) return null;
@@ -276,7 +357,7 @@ async function buildHalf(
   }
   half.commands.push(await ops.os(dir, ['validate']));
   half.commands.push(await ops.os(dir, ['build']));
-  half.commands.push(await ops.os(dir, ['verify', ...verifyFlags(scenario.card)]));
+  half.commands.push(await ops.os(dir, verifyArgs(scenario.card))); // the invocation every authoring prompt names
   const artifact = ops.readArtifact(dir);
   if (artifact === undefined) {
     half.error = half.error ?? 'no dist/objectstack.json after `objectstack build`';
@@ -311,16 +392,31 @@ export async function runHalf(
     }
     const adminKey = await app.adminApiKey();
 
-    // Seed, with row ownership mapped from the persona handles.
+    // Seed, with row ownership mapped from the persona handles. A row whose
+    // direct scope field names a persona's handle is owned (`owner_id`, the
+    // platform's record owner) by that persona's user. A user-handle field
+    // (`account.owner`, `userHandleFields`) is itself loaded with a user id —
+    // the persona's, or the admin's for a handle no persona holds (`u_tia`) —
+    // because a faithful build models it as a user lookup, which refuses the
+    // handle text. Any other scope field names a row or an option and is sent
+    // verbatim.
     const handles = personaHandles(card);
     const ownerFields = new Set(card.run.personas.flatMap((p) => (p.scope ?? []).filter((s) => !s.field.includes('.')).map((s) => `${s.object}.${s.field}`)));
+    const userFields = userHandleFields(card);
     for (const object of seedOrder(scenario)) {
       for (const row of card.run.seed[object] ?? []) {
         const body: Record<string, unknown> = { ...row };
         for (const [k, v] of Object.entries(row)) {
-          const persona = typeof v === 'string' && ownerFields.has(`${object}.${k}`) ? handles.get(v) : undefined;
+          if (typeof v !== 'string' || !ownerFields.has(`${object}.${k}`)) continue;
+          const persona = handles.get(v);
           const acct = persona ? accounts.find((a) => a.persona === persona) : undefined;
           if (acct) body.owner_id = acct.userId;
+          if (userFields.has(`${object}.${k}`)) {
+            const userId = acct?.userId ?? app.adminUserId();
+            body[k] = userId;
+            body.owner_id = userId;
+            if (!acct) half.seed.handlesAsAdmin = [...new Set([...(half.seed.handlesAsAdmin ?? []), v])].sort();
+          }
         }
         const r = await app.insertRow(object, body);
         if (r.ok) half.seed.inserted++;
@@ -329,11 +425,18 @@ export async function runHalf(
     }
 
     const keyOf = (persona: string | null) => (persona === null ? adminKey : accounts.find((a) => a.persona === persona)!.apiKey);
+    // A refused seed row makes what reads it not measured — never a fail of the app's answer.
+    const dependence = seedDependence(card, half.seed.refused);
 
     for (const q of card.run.questions) {
+      const notMeasured = dependence.question(q);
       for (const persona of [null, ...(q.personas ?? [])]) {
         if (persona === null && q.personas?.length) continue; // a persona-scoped question is asked as its personas
         const res: QuestionResult = { question: q.id, persona };
+        if (notMeasured) {
+          half.questions.push({ ...res, notMeasured });
+          continue;
+        }
         try {
           const turn = await driver.ask({ ...ref, step: q.id, ...(persona ? { persona } : {}), prompt: questionPrompt(scenario, q.id), mcp: { url: app.mcpUrl, apiKey: keyOf(persona) } });
           res.turn = summarize(turn);
@@ -352,6 +455,11 @@ export async function runHalf(
 
     for (const op of card.run.operations) {
       const res: OperationResult = { operation: op.id, persona: op.actingAs };
+      const notMeasured = dependence.operation(op);
+      if (notMeasured) {
+        half.operations.push({ ...res, notMeasured });
+        continue;
+      }
       try {
         const before = (await app.listRows(op.object)).rows as Row[];
         const turn = await driver.ask({ ...ref, step: op.id, persona: op.actingAs, prompt: operationPrompt(card, op.id), mcp: { url: app.mcpUrl, apiKey: keyOf(op.actingAs) } });
 
@@ -50,6 +50,43 @@ export function personaHandles(card: Card): Map<string, string> {
   return out;
 }
 
+/**
+ * The scope fields whose seed values are user handles, `object.field`: a
+ * field a persona's direct (non-path) `scope` rule names that the card does
+ * not declare as a lookup or a select, and that is not `id`. In the crm card
+ * that is `account.owner` (`u_sam`, `u_tia`). Every other direct scope field
+ * holds a row id or an option value (`asset.custodian` = `e06`, an employee
+ * row; `ticket_comment.visibility` = `public`), which the seed loads verbatim.
+ */
+export function userHandleFields(card: Card): Set<string> {
+  const declared = new Set([
+    ...(card.expect.lookups ?? []).map((l) => `${l.object}.${l.field}`),
+    ...(card.expect.selectFields ?? []).map((s) => `${s.object}.${s.field}`),
+  ]);
+  const out = new Set<string>();
+  for (const p of card.run.personas) {
+    for (const sc of p.scope ?? []) {
+      const key = `${sc.object}.${sc.field}`;
+      if (!sc.field.includes('.') && sc.field !== 'id' && !declared.has(key)) out.add(key);
+    }
+  }
+  return out;
+}
+
+/** The handles a seed row names in a {@link userHandleFields} field that no persona signs in as (`u_tia`): the seed loads each as the admin user. */
+export function unheldHandles(card: Card): string[] {
+  const held = personaHandles(card);
+  const out = new Set<string>();
+  for (const key of userHandleFields(card)) {
+    const [object, field] = key.split('.') as [string, string];
+    for (const row of card.run.seed[object] ?? []) {
+      const v = row[field];
+      if (typeof v === 'string' && !held.has(v)) out.add(v);
+    }
+  }
+  return [...out].sort();
+}
+
 /** The every-item-prefixed rule, in every authoring prompt. */
 export function namingRule(card: Card): string {
   const ns = scenarioNamespace(card);
@@ -102,6 +139,22 @@ export function dataContract(card: Card): string {
       `Row ownership: a row whose ${[...new Set(card.run.personas.flatMap((p) => (p.scope ?? []).filter((s) => !s.field.includes('.')).map((s) => `\`${s.field}\``)))].join(' / ')} names a handle ` +
         `(${[...handles].map(([h, id]) => `\`${h}\` = \`${id}\``).join(', ')}) is loaded as owned by that person’s user.`,
     );
+    const userFields = [...userHandleFields(card)];
+    if (userFields.length) {
+      const unheld = unheldHandles(card);
+      const held = [
+        ...new Set(
+          card.run.personas.flatMap((p) => (p.scope ?? []).filter((sc) => userHandleFields(card).has(`${sc.object}.${sc.field}`)).map((sc) => `\`${String(sc.value)}\` → the \`${p.id}\` user`)),
+        ),
+      ];
+      lines.push(
+        `In ${userFields.map((k) => `\`${k}\``).join(' / ')} the value is a handle that stands for a user, and the handle text is never stored: ` +
+          `the runner loads that field, and the row’s owner (\`owner_id\`), with that user’s id (${[
+            ...held,
+            ...(unheld.length ? [`${unheld.map((h) => `\`${h}\``).join(', ')}, which no person below holds → the admin user the runner signs in as`] : []),
+          ].join('; ')}). Make that field accept a user id; a rule on it matches that user.`,
+      );
+    }
   }
   if (card.run.agentActions?.length) {
     lines.push('');
@@ -111,19 +164,35 @@ export function dataContract(card: Card): string {
   return lines.join('\n');
 }
 
-const BUILD_PREAMBLE =
-  'You are building an ObjectStack app in this project (scaffolded by `create-objectstack`; follow the project’s AGENTS.md ' +
-  'and its objectstack skills). Author the metadata, then run `npx objectstack validate` and `npx objectstack build` ' +
-  'and fix what they report until both pass. Work without asking questions.';
+/**
+ * The `objectstack verify` arguments the runner scores a build with
+ * (`buildHalf` in `orchestrate.ts` runs exactly these), so every authoring
+ * loop can be told to run the same proof before it stops.
+ */
+export function verifyArgs(card: Card): string[] {
+  return ['verify', ...verifyFlags(card)];
+}
+
+/** The three commands a scratch build is scored on, as the agent runs them: `validate`, `build`, then {@link verifyArgs}. */
+function authoringChecks(card: Card): string {
+  return `run \`npx objectstack validate\`, \`npx objectstack build\` and \`npx objectstack ${verifyArgs(card).join(' ')}\` and fix what they report until all three pass`;
+}
+
+function buildPreamble(card: Card): string {
+  return (
+    'You are building an ObjectStack app in this project (scaffolded by `create-objectstack`; follow the project’s AGENTS.md ' +
+    `and its objectstack skills). Author the metadata, then ${authoringChecks(card)}. Work without asking questions.`
+  );
+}
 
 export function buildPrompt(card: Card): string {
-  return [BUILD_PREAMBLE, '', '## The app', '', text(card.prompt.detailed), '', dataContract(card)].join('\n');
+  return [buildPreamble(card), '', '## The app', '', text(card.prompt.detailed), '', dataContract(card)].join('\n');
 }
 
 export function iteratePrompt(card: Card): string {
   return [
-    'This project holds a working ObjectStack app. Apply the change below, then run `npx objectstack validate` and ' +
-      '`npx objectstack build` and fix what they report until both pass. Keep everything else working. Work without asking questions.',
+    `This project holds a working ObjectStack app. Apply the change below, then ${authoringChecks(card)}. ` +
+      'Keep everything else working. Work without asking questions.',
     '',
     namingRule(card),
     '',