@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{packager-tool-kyrm4e5m.js → packager-tool-9ar5829n.js}

@@ -1,49 +1,68 @@
 import {
-  ledgerMissFor
-} from "./packager-tool-b250k6w4.js";
+  catchError2
+} from "./packager-tool-psmb758n.js";
 import {
-  dedupedId,
-  exactKey,
-  indexKey,
-  lookupOutput,
-  modelKey,
-  stageSpellings
-} from "./packager-tool-9kvkzc05.js";
-import {
-  outputSourceFor
-} from "./packager-tool-ydyvtknp.js";
-import {
-  comparableFolder
-} from "./packager-tool-21qfsbxn.js";
-import {
-  cellAt,
-  columnField,
-  columnIndex,
-  fenceOf,
+  withoutTrailingSlug,
   field,
-  firstTable,
-  isBlank,
   isDigit,
   isLetter,
   isLowerLetter,
-  isSeparatorCell,
-  namedValue,
+  trimQuotes,
   norm,
-  pipeTables,
-  splitRowCells,
   stripTicks,
-  trimQuotes,
-  withoutAnnotation
-} from "./packager-tool-9y1w2wds.js";
+  isBlank,
+  namedValue,
+  splitRowCells,
+  isSeparatorCell,
+  firstTable,
+  fenceOf,
+  pipeTables,
+  columnIndex,
+  cellAt,
+  withoutAnnotation,
+  columnField
+} from "./packager-tool-fcektt1g.js";
+import {
+  CASE_APP_VERSIONS_WITH_ROLES,
+  roleActionKeyOf,
+  readCaseRoles
+} from "./packager-tool-1wgav5ma.js";
+import {
+  resolvePersonas
+} from "./packager-tool-yh8mmj3p.js";
+import {
+  CONNECTOR_CALL_TASK_TYPES
+} from "./packager-tool-7x1tmb8a.js";
+import {
+  outputSourceFor
+} from "./packager-tool-0w4fsdzv.js";
+import {
+  STAGE_SELECTOR_RULES,
+  TASK_SELECTOR_RULES,
+  parseIfCell,
+  outputTypeCell,
+  canonicalExpression
+} from "./packager-tool-1nfdj0zm.js";
 import {
-  isAnyTriggerNode,
-  isStageNode
-} from "./packager-tool-nj4seavy.js";
+  ledgerMissFor,
+  ledgerFoundFor
+} from "./packager-tool-z1fw9a8v.js";
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  comparableFolder
+} from "./packager-tool-yaertxsw.js";
+import {
+  stageSpellings
+} from "./packager-tool-5w0gjcck.js";
+import {
+  isStageNode,
+  isAnyTriggerNode
+} from "./packager-tool-35c9npcy.js";
 
 // src/services/sdd-normalizer.ts
+var ownBodyOf = (section) => {
+  const first = section.children[0];
+  return first === undefined ? section.body : section.body.slice(0, first.start - section.contentStart);
+};
 var readSddHeading = (line) => {
   let level = 0;
   while (level < line.length && line[level] === "#")
@@ -93,8 +112,10 @@ var readSddSections = (source) => {
   });
   const stack = [];
   for (const section of sections) {
-    while (stack.length > 0 && stack.at(-1)?.level >= section.level) {
+    let top = stack.at(-1);
+    while (top !== undefined && top.level >= section.level) {
       stack.pop();
+      top = stack.at(-1);
     }
     const parent = stack.at(-1);
     if (parent !== undefined)
@@ -235,7 +256,14 @@ var SLA_RESPONSE_MAP_HEADINGS = ["SLA Response Map"];
 var CASE_METADATA_HEADINGS = ["Case Metadata"];
 var CASE_SLA_PROPERTY = "Case-Level SLA";
 var CASE_VARIABLE_HEADINGS = ["Case Variables"];
+var PERSONA_HEADINGS = [
+  "Personas",
+  "Case Roles",
+  "Case Roles and Permissions",
+  "Roles and Permissions"
+];
 var CANVAS_NOTE_HEADINGS = ["Canvas Notes", "Sticky Notes"];
+var BUSINESS_EVENT_HEADINGS = ["Business Events"];
 var STAGE_ENTRY_HEADINGS = ["Stage Entry Conditions"];
 var STAGE_EXIT_HEADINGS = [
   "Stage Exit Conditions",
@@ -254,12 +282,12 @@ var CASE_CONDITIONAL_SLA_HEADINGS = [
 ];
 var STAGE_TASK_HEADINGS = ["Tasks"];
 var VARIABLE_GROUPS = ["inputs", "outputs", "inputOutputs"];
-var VARIABLE_PLACEMENT = new Map([
+var VARIABLE_PLACEMENT2 = new Map([
   ["in", ["inputs", "inputOutputs"]],
   ["out", ["outputs", "inputOutputs"]],
   ["variable", ["inputOutputs"]]
 ]);
-var DEFAULT_GROUP = new Map([
+var DEFAULT_GROUP2 = new Map([
   ["in", "inputs"],
   ["out", "inputOutputs"],
   ["variable", "inputOutputs"]
@@ -303,8 +331,8 @@ var bindingId = (expression) => {
   if (!text.startsWith(prefix))
     return;
   const id = text.slice(prefix.length);
-  const isWordChar2 = (ch) => isDigit(ch) || ch === "_" || isLowerLetter(ch.toLowerCase());
-  return id !== "" && [...id].every(isWordChar2) ? id : undefined;
+  const isWordChar = (ch) => isDigit(ch) || ch === "_" || isLowerLetter(ch.toLowerCase());
+  return id !== "" && [...id].every(isWordChar) ? id : undefined;
 };
 var bindingDefault = (bindings, expression) => {
   const id = bindingId(expression);
@@ -372,7 +400,11 @@ var parseCaseplan = (doc) => {
     bindings,
     caseExitConditions: asArray(metadata.caseExitRules),
     caseSla: asArray(metadata.slaRules).length > 0,
-    caseSlaRules: asArray(metadata.slaRules)
+    caseSlaRules: asArray(metadata.slaRules),
+    caseRoles: readCaseRoles(doc),
+    ...typeof metadata.caseAppVersion === "string" && {
+      caseAppVersion: metadata.caseAppVersion
+    }
   };
   for (const node of asArray(doc.nodes)) {
     const record = asRecord(node);
@@ -488,6 +520,7 @@ var customRowsOf = (header, rows) => {
   const bindingAt = columnIndex(header, ...INPUT_VALUE_COLUMNS);
   if (bindingAt === undefined)
     return [];
+  const typeAt = columnIndex(header, "Type");
   const found = [];
   for (const row of rows) {
     const binding = unwrapCodeSpan(cellAt(row, bindingAt));
@@ -501,7 +534,12 @@ var customRowsOf = (header, rows) => {
     const emptyLiteral = /^(""|'')$/.test(expression);
     if (!emptyLiteral && (!expression || isBlank(expression)))
       continue;
-    found.push({ variable, expression });
+    const type = typeAt === undefined ? "" : cellAt(row, typeAt).trim();
+    found.push({
+      variable,
+      expression,
+      ...type !== "" && !isBlank(type) && { type }
+    });
   }
   return found;
 };
@@ -615,6 +653,7 @@ var xrefArguments = (text) => {
     return value.trim();
   }).filter((part) => part !== "");
 };
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
 var producerSegments = (raw) => {
   if (raw.includes(XREF_OPEN))
     return xrefArguments(raw);
@@ -625,9 +664,13 @@ var producerSegments = (raw) => {
 };
 var readProducer = (raw) => {
   const segments = producerSegments(raw);
-  if (segments.length !== 3)
+  if (segments.length < 3)
     return;
-  const [stage, task, output] = segments;
+  if (segments.length > 3 && (raw.includes(XREF_OPEN) || !segments.slice(2).every((part) => IDENTIFIER.test(part)))) {
+    return;
+  }
+  const [stage, task, ...path] = segments;
+  const output = path.join(".");
   return stage && task && output ? { stage, task, output } : undefined;
 };
 var resourceOutputsByTask = (document) => {
@@ -711,19 +754,24 @@ var detailProducerInputs = (block) => {
 };
 
 // src/services/strict-sdd-audit/references.ts
-var OPEN_QUOTES = new Set(['"', "“", "‘", "'"]);
-var CLOSE_QUOTES = new Set(['"', "”", "’", "'"]);
+var QUOTE_PAIRS = new Map([
+  ['"', '"'],
+  ["“", "”"],
+  ["‘", "’"],
+  ["'", "'"]
+]);
 var quotedArgs = (argumentList) => {
   const args = [];
   let at = 0;
   while (at < argumentList.length) {
-    if (!OPEN_QUOTES.has(argumentList[at])) {
+    const close = QUOTE_PAIRS.get(argumentList[at]);
+    if (close === undefined) {
       at += 1;
       continue;
     }
     const from = at + 1;
     let end = from;
-    while (end < argumentList.length && !CLOSE_QUOTES.has(argumentList[end])) {
+    while (end < argumentList.length && argumentList[end] !== close) {
       end += 1;
     }
     if (end >= argumentList.length)
@@ -831,7 +879,7 @@ var pairLeftovers = (sddKeys, planKeys) => {
   return pairs.sort(([a], [b]) => a - b);
 };
 var pairByEvidence = (sddCount, planCount, related) => {
-  const candidates = Array.from({ length: sddCount }, (_, s) => Array.from({ length: planCount }, (_2, p) => p).filter((p) => related(s, p)));
+  const candidates = Array.from({ length: sddCount }, (_, s) => Array.from({ length: planCount }, (_, p) => p).filter((p) => related(s, p)));
   const pairs = [];
   candidates.forEach((planAts, s) => {
     if (planAts.length !== 1)
@@ -939,19 +987,22 @@ var conditionNameFindings = (declared, planConditions, path, label, once) => {
   return findings;
 };
 
+// src/services/strict-sdd-audit/input-lookup.ts
+var inputNamed = (inputs, name) => inputs.find((i) => norm(i.name) === norm(name)) ?? inputs.find((i) => typeof i.displayName === "string" && norm(i.displayName) === norm(name));
+
 // src/services/strict-sdd-audit/wiring.ts
-var parsesAsJson = (text) => catchError(() => JSON.parse(text))[0] === undefined;
+var parsesAsJson = (text) => catchError2(() => JSON.parse(text))[0] === undefined;
 var sameLiteral = (declared, actual) => {
   if (declared === actual)
     return true;
-  const parse = (text) => catchError(() => JSON.parse(text))[1];
+  const parse = (text) => catchError2(() => JSON.parse(text))[1];
   const canonical = (value) => {
     if (Array.isArray(value)) {
       return `[${value.map(canonical).join(",")}]`;
     }
     const record = asRecord(value);
     if (record) {
-      return `{${Object.keys(record).sort((a2, b2) => a2.localeCompare(b2)).map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+      return `{${Object.keys(record).sort((a, b) => a.localeCompare(b)).map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
     }
     return JSON.stringify(value) ?? "null";
   };
@@ -1113,7 +1164,7 @@ var wiringFindings = (task, found, path, label) => {
   const findings = [];
   const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
   for (const declared of task.expressionInputs) {
-    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    const input = inputNamed(inputs, declared.name);
     if (!input)
       continue;
     const actual = input.value;
@@ -1149,6 +1200,21 @@ var referenceTokensIn = (text) => {
   return tokens;
 };
 var isReferenceToken = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+var RESPONSE_PREFIX = "response.";
+var outputLabels = (output) => {
+  const labels = [output.name, output.var];
+  const source = output.source;
+  if (typeof source !== "string" || !source.startsWith("="))
+    return labels;
+  const path = source.slice(1).trim();
+  if (!path.split(".").every((part) => IDENTIFIER.test(part)))
+    return labels;
+  labels.push(path);
+  if (path.startsWith(RESPONSE_PREFIX)) {
+    labels.push(path.slice(RESPONSE_PREFIX.length));
+  }
+  return labels;
+};
 var planOutputFor = (plan, producer) => {
   for (const stage of plan.stages) {
     if (norm(stage.name) !== norm(producer.stage))
@@ -1160,7 +1226,7 @@ var planOutputFor = (plan, producer) => {
         const output = asRecord(entry);
         if (output === undefined)
           continue;
-        for (const label of [output.name, output.var]) {
+        for (const label of outputLabels(output)) {
           if (typeof label === "string" && norm(label) === norm(producer.output)) {
             return output;
           }
@@ -1229,7 +1295,7 @@ var producerIndex = (plan) => {
         }
         if (tokens.size === 0)
           continue;
-        for (const label of [output.name, output.var]) {
+        for (const label of outputLabels(output)) {
           if (typeof label !== "string" || label === "")
             continue;
           const key = `${norm(stage.name)}|${norm(planTask.name)}|${norm(label)}`;
@@ -1385,8 +1451,8 @@ var conditionExpressionFindings = (declared, planConditions, plan, path, label)
     if (resolved === undefined)
       continue;
     const expected = comparableExpression(resolved.expected);
-    const comparable = (actual2) => {
-      let normalised = actual2;
+    const comparable = (actual) => {
+      let normalised = actual;
       for (const token of resolved.tokens) {
         normalised = normalised.replaceAll(`${VARS_PREFIX}${token}`, VARIABLE_PLACEHOLDER);
       }
@@ -1423,7 +1489,7 @@ var expressionShapeFindings = (task, found, plan, path, label) => {
     const resolved = resolveXrefExpression(declared.expression, index);
     if (resolved === undefined)
       continue;
-    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    const input = inputNamed(inputs, declared.name);
     const actual = input?.value;
     if (typeof actual !== "string" || actual.trim() === "")
       continue;
@@ -1439,20 +1505,213 @@ var expressionShapeFindings = (task, found, plan, path, label) => {
   return findings;
 };
 
+// src/services/strict-sdd-audit/personas.ts
+var personaFindings = (sdd, plan) => {
+  if (sdd.personas.length === 0)
+    return [];
+  const planStageId = new Map;
+  for (const stage of plan.stages) {
+    if (stage.name === undefined || stage.id === undefined)
+      continue;
+    planStageId.set(norm(withoutTrailingSlug(stage.name)), stage.id);
+  }
+  const declared = new Set(sdd.stages.map((stage) => norm(withoutTrailingSlug(stage.name))));
+  const { roles, problems } = resolvePersonas(sdd.personas, (name) => {
+    const key = norm(withoutTrailingSlug(name));
+    if (!declared.has(key))
+      return;
+    return planStageId.get(key) ?? `${UNPLANNED_STAGE}${key}`;
+  });
+  const strictFor = new Map(sdd.personas.map((persona) => [
+    persona.name.toLowerCase(),
+    persona.templateShape
+  ]));
+  const finding = (personaName, code, path, message) => (strictFor.get(personaName.toLowerCase()) ? error : warning)(code, path, message);
+  const issues = problems.map((problem) => {
+    const code = problemCode(problem.code);
+    const path = `metadata.caseRoles[${problem.persona}]`;
+    const message = `Persona "${problem.persona}": ${problem.detail}.`;
+    return problem.code === "stages-on-case" || problem.code === "permission-gated" ? warning(code, path, message) : finding(problem.persona, code, path, message);
+  });
+  if (roles.length === 0)
+    return issues;
+  if (plan.caseAppVersion === undefined || !CASE_APP_VERSIONS_WITH_ROLES.includes(plan.caseAppVersion)) {
+    issues.push((roles.some((role) => strictFor.get(role.name.toLowerCase())) ? error : warning)("STRICT_SDD_PERSONA_APP_VERSION", "metadata.caseAppVersion", `The SDD declares ${roles.length} persona(s) and caseplan metadata.caseAppVersion is "${plan.caseAppVersion ?? ""}"; roles are honoured only under "v2" or "custom", so the deployed case would carry none.`));
+  }
+  const byName = new Map(plan.caseRoles.map((role) => [role.name.toLowerCase(), role]));
+  const matched = new Set;
+  for (const persona of roles) {
+    const role = byName.get(persona.name.toLowerCase());
+    if (role === undefined) {
+      issues.push(finding(persona.name, "STRICT_SDD_PERSONA_MISSING", `metadata.caseRoles[${persona.name}]`, `Persona "${persona.name}" has no entry in caseplan metadata.caseRoles, so nobody can be assigned it.`));
+      continue;
+    }
+    matched.add(role);
+    issues.push(...roleFindings(persona, role, (code, path, message) => finding(persona.name, code, path, message)));
+  }
+  for (const role of plan.caseRoles) {
+    if (matched.has(role))
+      continue;
+    issues.push(warning("STRICT_SDD_PERSONA_EXTRA", `metadata.caseRoles[${role.name}]`, `Role "${role.name}" is in caseplan metadata.caseRoles with no matching SDD persona.`));
+  }
+  return issues;
+};
+var UNPLANNED_STAGE = "sdd:";
+var problemCode = (code) => `STRICT_SDD_PERSONA_${code.toUpperCase().replace(/-/g, "_")}`;
+var sameSet = (left, right) => left.length === right.length && left.every((item) => right.includes(item));
+var keysOf = (actions) => actions.map((action) => roleActionKeyOf(action) ?? action).join(", ");
+var roleFindings = (persona, role, report) => {
+  const path = `metadata.caseRoles[${persona.name}]`;
+  const issues = [];
+  if (role.scope !== persona.scope) {
+    issues.push(report("STRICT_SDD_PERSONA_SCOPE_MISMATCH", `${path}.scope`, `Persona "${persona.name}": the SDD scopes it to ${persona.scope === "case" ? "the whole case" : "stages"} and the caseplan role has scope "${role.scope}".`));
+    return issues;
+  }
+  if (persona.scope === "stages" && persona.stageIds.every((id) => !id.startsWith(UNPLANNED_STAGE)) && !sameSet(persona.stageIds, role.stageIds ?? [])) {
+    issues.push(report("STRICT_SDD_PERSONA_STAGES_MISMATCH", `${path}.stageIds`, `Persona "${persona.name}": the SDD scopes it to stage(s) ${persona.stageNames.join(", ")} and the caseplan role's stageIds select different stages.`));
+  }
+  if (!sameSet(persona.actions, role.actions)) {
+    issues.push(report("STRICT_SDD_PERSONA_PERMISSIONS_MISMATCH", `${path}.actions`, `Persona "${persona.name}": the SDD grants ${keysOf(persona.actions)} and the caseplan role grants ${keysOf(role.actions) || "nothing"}.`));
+  }
+  return issues;
+};
+
+// src/services/strict-sdd-audit/inputs.ts
+var CONNECTOR_ENVELOPE_INPUTS = new Set([
+  "pathParameters",
+  "queryParameters",
+  "body"
+]);
+var resolveEnvelopeKey = (body, name) => {
+  const named = (record, part) => Object.entries(record).find(([key]) => norm(key) === norm(part));
+  const direct = named(body, name);
+  if (direct !== undefined)
+    return { value: direct[1] };
+  const parts = name.split(".").filter((part) => part !== "");
+  if (parts.length < 2)
+    return;
+  let current = body;
+  for (const part of parts) {
+    const record = asRecord(current);
+    if (record === undefined)
+      return;
+    const hit = named(record, part);
+    if (hit === undefined)
+      return;
+    current = hit[1];
+  }
+  return { value: current };
+};
+var carriedInput = (found, name) => {
+  const absent = { present: false, value: undefined, valueless: false };
+  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
+  const direct = inputNamed(inputs, name);
+  if (direct !== undefined) {
+    return {
+      present: true,
+      value: direct.value,
+      valueless: !("value" in direct)
+    };
+  }
+  if (typeof found.type !== "string" || !CONNECTOR_CALL_TASK_TYPES.has(found.type)) {
+    return absent;
+  }
+  for (const entry of inputs) {
+    const entryName = entry.name;
+    if (typeof entryName !== "string" || !CONNECTOR_ENVELOPE_INPUTS.has(entryName)) {
+      continue;
+    }
+    const body = asRecord(entry.body);
+    if (body === undefined)
+      continue;
+    const carried = resolveEnvelopeKey(body, name) ?? (entryName === "body" && found.type === "wait-for-connector" ? ["parameters", "queryParams"].map((key) => asRecord(body[key])).filter((nested) => nested !== undefined).map((nested) => resolveEnvelopeKey(nested, name)).find((key) => key !== undefined) : undefined);
+    if (carried !== undefined) {
+      return { present: true, value: carried.value, valueless: false };
+    }
+  }
+  return absent;
+};
+var declaredInputNames = (task) => {
+  const names = [];
+  const add = (name) => {
+    if (!names.some((existing) => norm(existing) === norm(name))) {
+      names.push(name);
+    }
+  };
+  for (const entry of task.literalInputs)
+    add(entry.name);
+  for (const entry of task.expressionInputs)
+    add(entry.name);
+  for (const entry of task.producerInputs)
+    add(entry.name);
+  return names;
+};
+var boundInputNames = (task) => task.boundInputs.map((entry) => entry.name);
+var emptyLiteralInputNames = (task) => task.literalInputs.filter((entry) => isBlank(entry.value)).map((entry) => entry.name);
+var envelopeFindings = (task, found, path, label) => {
+  const findings = [];
+  const columns = [
+    {
+      declared: task.required,
+      actual: found.isRequired,
+      column: "Required",
+      field: "isRequired"
+    },
+    {
+      declared: task.runOnlyOnce,
+      actual: found.shouldRunOnlyOnce,
+      column: "Run Only Once",
+      field: "shouldRunOnlyOnce"
+    }
+  ];
+  for (const { declared, actual, column, field } of columns) {
+    if (declared === undefined)
+      continue;
+    if (typeof actual === "boolean" && actual === declared)
+      continue;
+    findings.push(error("STRICT_SDD_TASK_ENVELOPE_MISMATCH", `${path}.${field}`, `${label}: the SDD Tasks table declares a "${column}" value for this task and its \`${field}\` ${typeof actual === "boolean" ? "disagrees" : "is absent"}. Set it from that column.`));
+  }
+  return findings;
+};
+var emptyInputFindings = (task, found, path, label) => {
+  const declared = declaredInputNames(task);
+  if (declared.length === 0)
+    return [];
+  if (Object.keys(found.data).length === 0)
+    return [];
+  const bound = boundInputNames(task);
+  const emptyLiteral = emptyLiteralInputNames(task);
+  const findings = [];
+  const names = (list, name) => list.some((entry) => norm(entry) === norm(name));
+  for (const name of declared) {
+    const carried = carriedInput(found, name);
+    const value = carried.value;
+    const missing = !carried.present;
+    if (!missing && !carried.valueless && (typeof value !== "string" || value.trim() !== "")) {
+      continue;
+    }
+    if (!missing && (names(bound, name) || names(emptyLiteral, name))) {
+      continue;
+    }
+    const declares = names(emptyLiteral, name) ? "the empty literal" : "a value";
+    findings.push(error("STRICT_SDD_INPUT_EMPTY", `${path}.data.inputs[${name}]`, `${label}: the SDD Inputs row for "${name}" declares ${declares}, and the caseplan input ${missing ? "is absent" : carried.valueless ? "carries no `value` at all" : "is empty"}. Nothing reaches the task for it, and none of the value comparisons can run against an input that carries nothing. ${missing ? "The row exists, so the input has to exist too — add it, carrying that row's value." : carried.valueless ? "Its value has to live under `value` — data under `body` is the connector envelope, which does not apply to this task type." : "Re-read that row and set the input from it."}`));
+  }
+  return findings;
+};
+
 // src/services/strict-sdd-audit/producer-findings.ts
 var producerFindings = (task, found, plan, path, label) => {
   if (task.producerInputs.length === 0)
     return [];
   const findings = [];
   const index = producerIndex(plan);
-  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
   for (const declared of task.producerInputs) {
     const { stage, task: producerTask, output } = declared.producer;
     const candidates = index.get(`${norm(stage)}|${norm(producerTask)}|${norm(output)}`);
     if (candidates === undefined || candidates.length !== 1)
       continue;
-    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
-    if (input === undefined)
+    const input = carriedInput(found, declared.name);
+    if (!input.present)
       continue;
     const value = input.value;
     if (typeof value !== "string" || value.trim() === "")
@@ -1562,289 +1821,212 @@ var capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
 var noCategoryColumnNote = (title, header) => `section "${title}": the table has rows but no Category column ` + `(header: ${header.join(" | ") || "<none>"}) — no row can be checked ` + "for `variables` group placement, so a formal argument missing half its " + "pair passes";
 var unrecognizedHeadingNote = (title, level) => `heading "${title}" (level ${level}) reads like an audited section but ` + "matches no accepted spelling — rename it to one of the canonical " + "headings, or the checks it feeds are skipped";
 
-// src/services/sdd-convert/xrefs.ts
-var QUOTED = String.raw`(?:'((?:\\.|[^'\\])*)'|"((?:\\.|[^"\\])*)"|` + "`((?:\\\\.|[^`\\\\])*)`" + String.raw`|\u201c([^\u201d]*)\u201d)`;
-var XREF_CALL = new RegExp(String.raw`vars\.\$xref\(\s*${QUOTED}\s*,\s*${QUOTED}\s*,\s*${QUOTED}\s*\)`, "g");
-var argumentOf = (groups) => groups.find((value) => value !== undefined) ?? "";
-var unresolvedXrefDetail = (whole, found) => {
-  if (found === undefined) {
-    return `\`${whole}\` names an output this SDD does not declare, so the marker is left in place rather than pointed at a guess`;
-  }
-  const spellings = new Set(found.names);
-  const listed = [...spellings].map((name) => `\`${name}\``).join(", ");
-  if (spellings.size < found.names.length) {
-    return `\`${whole}\` names a task that ${found.names.length} tasks in that stage answer to (${listed}), so the marker is left in place rather than pointed at one of them. Task names are unique across the case, so rename all but one`;
-  }
-  return `\`${whole}\` names its task in a spelling that ${found.names.length} tasks answer to (${listed}), so the marker is left in place rather than pointed at one of them — write the task's name as its heading spells it`;
-};
-var DOTTED_READ = /^\.[A-Za-z_$]/;
-var deferredOutputs = new WeakMap;
-var markDeferredOutputs = (index, ids) => {
-  deferredOutputs.set(index, ids);
-};
-var expandXrefs = (text, context) => text.replace(XREF_CALL, (whole, ...rest) => {
-  const offset = rest[rest.length - 2];
-  const captured = rest.slice(0, -2);
-  const stage = argumentOf(captured.slice(0, 4));
-  const task = argumentOf(captured.slice(4, 8));
-  const output = argumentOf(captured.slice(8, 12));
-  const found = lookupOutput(context.outputs, `${indexKey(stage)}|${indexKey(task)}|${indexKey(output)}`, task);
-  if (found !== undefined && "id" in found) {
-    if (deferredOutputs.get(context.outputs)?.has(found.id)) {
-      context.unresolved.push({
-        kind: "placeholder",
-        where: context.where,
-        detail: `\`${whole}\` reads an output of a task the resolved file defers, so \`vars.${found.id}\` resolves to nothing until that task is filled`
-      });
-    }
-    const after = text.slice(offset + whole.length);
-    return DOTTED_READ.test(after) ? `vars.${found.id}?` : `vars.${found.id}`;
-  }
-  context.unresolved.push({
-    kind: "producer-reference",
-    where: context.where,
-    detail: unresolvedXrefDetail(whole, found)
-  });
-  return whole;
-});
-var expandOutputMarkers = (output, context) => {
-  const expand = (value2) => typeof value2 === "string" && value2.includes("$xref") ? expandXrefs(value2, context) : value2;
-  const value = expand(output.value);
-  const source = expand(output.source);
-  return value === output.value && source === output.source ? output : { ...output, value, source };
+// src/services/strict-sdd-audit/selector-targets.ts
+var idsIn = (value) => {
+  const values = Array.isArray(value) ? value : [value];
+  return values.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+};
+var selectedIds = (rule) => Object.entries(rule ?? {}).filter(([key]) => key.startsWith("selected")).flatMap(([, value]) => idsIn(value));
+var hasSelector = (rule) => selectedIds(rule).length > 0 || idsIn(rule?.slaId).length > 0;
+var ruleTargets = (rule, resolve, same) => {
+  const named = selectedIds(rule).map((id) => resolve.stage(id) ?? resolve.task(id)).filter((name) => name !== undefined);
+  const owners = idsIn(rule?.slaId).map((id) => resolve.sla?.(id)).filter((name) => name !== undefined);
+  if (named.length === 0)
+    return { names: owners };
+  const conflict = owners.find((owner) => !named.some((name) => same(name, owner)));
+  return conflict === undefined ? { names: named } : { names: named, conflict };
 };
 
-// src/services/sdd-convert/io.ts
-var taskMatcher = (model, taskName) => {
-  const mine = exactKey(taskName);
-  const folded = indexKey(taskName);
-  const filed = modelKey(taskName);
-  let unique = true;
-  let filedUnique = true;
-  for (const stage of model.stages) {
-    for (const other of stage.tasks) {
-      const name = exactKey(String(other.name ?? ""));
-      if (name === mine)
-        continue;
-      if (indexKey(name) === folded)
-        unique = false;
-      if (modelKey(name) === filed)
-        filedUnique = false;
-    }
+// src/services/strict-sdd-audit/selectors.ts
+var sameLabel = (a, b) => norm(a) === norm(b) || normAnnotationless(a) === normAnnotationless(b);
+var leadingSegment = (name) => {
+  for (const dash of [" - ", " – ", " — "]) {
+    const at = name.indexOf(dash);
+    if (at > 0)
+      return name.slice(0, at);
   }
-  return {
-    names: (spelled) => exactKey(spelled) === mine || unique && indexKey(spelled) === folded,
-    unique,
-    filedUnique
-  };
+  return name;
 };
-var declaredOutputs = (model, stageName, position, task) => {
-  const taskName = String(task.name ?? "");
-  const { names: own, slug, ordinal } = stageSpellings(stageName, position);
-  const names = [...own, ...slug === undefined ? [] : [slug], ordinal].map(indexKey);
-  const matcher = taskMatcher(model, taskName);
-  const mine = (producer) => names.includes(indexKey(producer.stage)) && matcher.names(producer.task);
-  const rows = (task.outputRows ?? []).map((row) => ({ row, aliases: [] }));
-  const sameOutput = (a, b) => indexKey(a) === indexKey(b) || (!a.includes(".") || !b.includes(".")) && indexKey(emittedName(a)) === indexKey(emittedName(b));
-  const dotted = (one) => [one.row, ...one.aliases].find((spelling) => spelling.includes("."));
-  const takes = (one, name) => {
-    if (!sameOutput(one.row, name))
-      return false;
-    if (!name.includes("."))
-      return true;
-    const held = dotted(one);
-    return held === undefined || indexKey(held) === indexKey(name);
-  };
-  const add = (name) => {
-    if (name === "")
-      return;
-    const found = rows.find((one) => takes(one, name));
-    if (found === undefined)
-      rows.push({ row: name, aliases: [] });
-    else if (found.row !== name && !found.aliases.includes(name)) {
-      found.aliases.push(name);
+var targetsOf = (rule, selectors) => norm(rule) === norm("sla-status-change") ? selectors.slice(0, 1) : norm(rule) === norm("api-event") ? [] : selectors;
+var undeclaredGateFinding = (row, planRules, path, label, resolve) => {
+  if (row.ungated !== true || row.when === undefined)
+    return;
+  const { rule, selectors: named } = whenRule(row.when);
+  if (!rule || isBlank(rule))
+    return;
+  const selectors = targetsOf(rule, named);
+  const belongsToRow = (candidate) => {
+    if (norm(rule) === norm("api-event")) {
+      return candidate?.businessEventType === named[0];
     }
+    if (selectors.length === 0)
+      return !hasSelector(candidate);
+    if (!hasSelector(candidate))
+      return false;
+    if (resolve === undefined)
+      return false;
+    const pointsAt = ruleTargets(candidate, resolve, sameLabel).names;
+    if (pointsAt.length === 0)
+      return false;
+    return selectors.some((want) => {
+      const denotes = resolve.label(want);
+      return pointsAt.some((got) => sameLabel(got, want) || denotes !== undefined && got === denotes);
+    });
   };
-  if (matcher.filedUnique) {
-    for (const name of model.resourceOutputs[modelKey(taskName)] ?? []) {
-      add(name);
-    }
-  }
-  for (const producer of model.xrefOutputs) {
-    if (mine(producer))
-      add(producer.output);
-  }
-  for (const stage of model.stages) {
-    for (const other of stage.tasks) {
-      for (const row of other.producerInputs ?? []) {
-        const producer = row.producer;
-        if (producer !== undefined && mine(producer)) {
-          add(producer.output);
-        }
-      }
-    }
-  }
-  return rows;
-};
-var emittedName = (row) => row.split(".").at(-1) ?? row;
-var OUTPUT_TYPES = new Map([
-  ["string", "string"],
-  ["object", "jsonSchema"],
-  ["json", "jsonSchema"],
-  ["jsonschema", "jsonSchema"]
-]);
-var readsOutput = (reference, row) => indexKey(reference) === indexKey(row) || !reference.includes(".") && indexKey(reference) === indexKey(emittedName(row));
-var outputTypeFor = (model, stageNames, taskName, output) => {
-  const matcher = taskMatcher(model, taskName);
-  for (const stage of model.stages) {
-    for (const task of stage.tasks) {
-      for (const row of task.producerInputs ?? []) {
-        const producer = row.producer;
-        if (producer === undefined || row.direct !== true || typeof row.type !== "string" || !stageNames.includes(indexKey(producer.stage)) || !matcher.names(producer.task) || !readsOutput(producer.output, output)) {
-          continue;
-        }
-        const mapped = OUTPUT_TYPES.get(row.type.trim().toLowerCase().replaceAll(" ", ""));
-        if (mapped !== undefined)
-          return mapped;
-      }
-    }
-  }
-  return;
+  const gated = planRules.filter((candidate) => {
+    if (norm(candidate?.rule) !== norm(rule))
+      return false;
+    if (!belongsToRow(candidate))
+      return false;
+    const expression = candidate?.conditionExpression;
+    return typeof expression === "string" && !isBlank(expression);
+  });
+  if (gated.length === 0)
+    return;
+  const expressions = [
+    ...new Set(gated.map((candidate) => String(candidate?.conditionExpression)).filter((expression) => expression !== ""))
+  ];
+  const on = selectors.length > 0 ? ` on "${selectors.join('", "')}"` : "";
+  return error("STRICT_SDD_CONDITION_EXPRESSION_UNDECLARED", `${path}[${row.displayName}].conditionExpression`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\`${on} with no IF gate, and the caseplan's \`${rule}\` carries \`${expressions.join("`, `")}\`. A gate the SDD does not declare narrows the transition to one branch, so it fires where the row says it should fire every time. Remove the expression, or add the IF cell that justifies it.`);
 };
-var outputFor = (row, elementId, taken, type, taskType) => {
-  const leaf = row.split(".").at(-1) ?? row;
-  const base = leaf === "" ? leaf : `${leaf[0].toLowerCase()}${leaf.slice(1)}`;
-  const id = dedupedId(base, taken);
-  return {
-    name: leaf,
-    ...type !== undefined && { type },
-    id,
-    var: id,
-    value: id,
-    source: outputSourceFor(taskType, row),
-    target: `=${id}`,
-    elementId
-  };
+var apiEventFinding = (row, rules, wanted, path, label) => {
+  if (wanted === undefined || isBlank(wanted))
+    return;
+  const carried = rules.map((r) => r?.businessEventType).filter((one) => typeof one === "string");
+  if (carried.includes(wanted))
+    return;
+  return error(carried.length === 0 ? "STRICT_SDD_CONDITION_SELECTOR_MISSING" : "STRICT_SDD_CONDITION_SELECTOR_MISMATCH", `${path}[${row.displayName}].rule`, carried.length === 0 ? `${label}: the SDD row ${rowLabel(row)} declares WHEN \`api-event\` on business event "${wanted}", and the caseplan's \`api-event\` names no \`businessEventType\`. The rule then listens for nothing and never fires. Set \`businessEventType\` to "${wanted}".` : `${label}: the SDD row ${rowLabel(row)} declares WHEN \`api-event\` on business event "${wanted}", and the caseplan's \`api-event\` listens for "${carried.join('", "')}". Rules match on the exact name, so it fires on a different event. Set \`businessEventType\` to "${wanted}".`);
 };
-var variableOutputType = (model, variable) => {
-  const declared = model.variableTypes[modelKey(variable)];
-  if (typeof declared !== "string" || declared.trim() === "") {
+var whenCellFinding = (row, planRules, path, label, resolve, ownRules) => {
+  if (row.when === undefined)
+    return;
+  const { rule, selectors: named } = whenRule(row.when);
+  if (!rule || isBlank(rule))
     return;
+  const wanted = targetsOf(rule, named);
+  const matching = planRules.filter((r) => norm(r?.rule) === norm(rule));
+  if (matching.length === 0) {
+    return error("STRICT_SDD_CONDITION_RULE_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\`, no rule on it uses that predicate. A different predicate starts the task at a different moment. Re-read that row's WHEN cell.`);
   }
-  const key = declared.trim().toLowerCase().replaceAll(" ", "");
-  return OUTPUT_TYPES.get(key) ?? "string";
-};
-var extractOutputFor = (row, elementId, taken, type, taskType) => {
-  const leaf = row.field.split(".").at(-1) ?? row.field;
-  const base = leaf === "" ? leaf : `${leaf[0].toLowerCase()}${leaf.slice(1)}`;
-  const id = dedupedId(base, taken);
-  return {
-    name: leaf,
-    ...type !== undefined && { type },
-    id,
-    var: row.variable,
-    value: row.variable,
-    source: outputSourceFor(taskType, row.field),
-    target: `=${id}`,
-    originalVar: id,
-    elementId
-  };
-};
-var customOutputFor = (row, type) => ({
-  name: row.variable,
-  ...type !== undefined && { type },
-  custom: true,
-  var: row.variable,
-  value: canonicalExpression(unquoteLiteral(row.expression)),
-  source: canonicalExpression(unquoteLiteral(row.expression)),
-  target: "",
-  body: "",
-  elementId: "root"
-});
-var canonicalExpression = (value) => value.startsWith("=metadata.") ? `=js:${value.slice(1)}` : value;
-var unquoteLiteral = (cell) => {
-  const text = cell.trim();
-  const quote = text[0];
-  if (quote !== '"' && quote !== "'")
-    return cell;
-  if (text.length < 2 || text[text.length - 1] !== quote)
-    return cell;
-  const inner = text.slice(1, -1);
-  for (let at = 0;at < inner.length; at += 1) {
-    if (inner[at] === "\\") {
-      at += 1;
-      continue;
-    }
-    if (inner[at] === quote)
-      return cell;
+  if (norm(rule) === norm("api-event")) {
+    const own = (ownRules ?? []).filter((r) => norm(r?.rule) === norm(rule));
+    return apiEventFinding(row, own.length > 0 ? own : matching, named[0], path, label);
   }
-  return inner.replaceAll(`\\${quote}`, quote);
-};
-var RANK_LITERAL = 1;
-var RANK_PRODUCER = 2;
-var RANK_EXPRESSION = 3;
-var unboundProducerDetail = (target, found) => {
-  if (found === undefined) {
-    return `the Inputs row reads an output (${target}) that no task in this SDD declares`;
+  if (wanted.length === 0)
+    return;
+  const own = (ownRules ?? []).filter((r) => norm(r?.rule) === norm(rule));
+  const targeted = own.length > 0 ? own : matching;
+  if (!targeted.some(hasSelector)) {
+    return error("STRICT_SDD_CONDITION_SELECTOR_MISSING", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\` on "${wanted.join('", "')}", and the caseplan's \`${rule}\` carries no target. The predicate then refers to nothing, so it never becomes true and the gate never opens. Set the rule's \`selected*\` field to the target the row names.`);
   }
-  const spellings = new Set(found.names);
-  const listed = [...spellings].map((task) => `"${task}"`).join(", ");
-  if (spellings.size < found.names.length) {
-    return `the Inputs row reads an output (${target}) of a task that ${found.names.length} tasks in that stage answer to (${listed}), so it is left unbound rather than pointed at one of them. Task names are unique across the case, so rename all but one`;
+  if (resolve === undefined)
+    return;
+  const resolved = targeted.map((candidate) => ruleTargets(candidate, resolve, sameLabel));
+  const pointsAt = resolved.flatMap((target) => target.names);
+  if (pointsAt.length === 0)
+    return;
+  const missed = wanted.filter((want) => {
+    const denotes = resolve.label(want);
+    return !pointsAt.some((got) => sameLabel(got, want) || denotes !== undefined && got === denotes);
+  });
+  const conflict = resolved.find((target) => target.conflict !== undefined);
+  if (missed.length === 0 && conflict?.conflict !== undefined) {
+    return error("STRICT_SDD_CONDITION_SELECTOR_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\` on "${wanted.join('", "')}", and the caseplan's \`${rule}\` names "${conflict.names.join('", "')}" but its \`slaId\` is the SLA of "${conflict.conflict}". The rule watches one stage's SLA while naming another, so it fires on a deadline the row did not ask for. Point \`slaId\` at the SLA of "${wanted.join('", "')}" and drop the \`selected*\` field, which convert does not write for this rule.`);
   }
-  return `the Inputs row reads an output (${target}) whose task spelling ${found.names.length} tasks answer to (${listed}), so it is left unbound rather than pointed at one of them`;
+  if (missed.length === 0)
+    return;
+  return error("STRICT_SDD_CONDITION_SELECTOR_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\` on "${missed.join('", "')}", and the caseplan's \`${rule}\` points at "${pointsAt.join('", "')}". A selector that resolves to the wrong target builds a transition the SDD never asked for and leaves the declared one absent, which no count or predicate check can see.`);
 };
-var inputsFor = (task, elementId, where, unresolved, outputs) => {
-  const ranked = new Map;
-  const offer = (name, rank, input) => {
-    const existing = ranked.get(name);
-    if (existing === undefined || rank > existing.rank) {
-      ranked.set(name, { rank, input });
-    }
+var conditionRuleFindings = (declared, planConditions, path, label, resolve) => {
+  if (declared.length === 0)
+    return [];
+  const conditions = planConditions.map(asRecord);
+  const rulesOf = (of) => of.flatMap((condition) => asArray(condition?.rules).flatMap((group) => asArray(group).map(asRecord)));
+  const planRules = rulesOf(conditions);
+  if (planRules.length === 0)
+    return [];
+  const owners = bindByName(declared, conditions);
+  const taken = new Set(owners.filter((one) => one !== undefined));
+  const openRows = declared.map((row, at) => ({ row, at })).filter(({ at }) => owners[at] === undefined);
+  const openConditions = conditions.filter((one) => !taken.has(one));
+  const gated = (condition) => rulesOf([condition]).some((rule) => {
+    const expression = rule?.conditionExpression;
+    return typeof expression === "string" && !isBlank(expression);
+  });
+  const rowGated = (row) => row.ungated === true ? false : row.ifExpression !== undefined ? true : undefined;
+  const shapeKey = (rule, isGated) => {
+    const name = norm(rule);
+    if (name === "" || isGated === undefined)
+      return;
+    return `${name}|${isGated ? "gated" : "open"}`;
   };
-  for (const row of task.literalInputs ?? []) {
-    offer(String(row.name ?? ""), RANK_LITERAL, {
-      name: String(row.name ?? ""),
-      value: unquoteLiteral(String(row.value ?? "")),
-      elementId
-    });
-  }
-  for (const row of task.expressionInputs ?? []) {
-    offer(String(row.name ?? ""), RANK_EXPRESSION, {
-      name: String(row.name ?? ""),
-      value: canonicalExpression(expandXrefs(String(row.expression ?? row.value ?? ""), {
-        outputs,
-        where,
-        unresolved
-      })),
-      elementId
-    });
+  for (const [rowAt, conditionAt] of pairLeftovers(openRows.map(({ row }) => shapeKey(whenRule(row.when ?? "").rule, rowGated(row))), openConditions.map((condition) => {
+    const rules = new Set(rulesOf([condition]).map((r) => norm(r?.rule)));
+    return rules.size === 1 ? shapeKey([...rules][0], gated(condition)) : undefined;
+  }))) {
+    owners[openRows[rowAt].at] = openConditions[conditionAt];
   }
-  for (const row of task.producerInputs ?? []) {
-    const name = String(row.name ?? "");
-    const producer = row.producer;
-    const found = producer === undefined ? undefined : lookupOutput(outputs, `${indexKey(producer.stage)}|${indexKey(producer.task)}|${indexKey(producer.output)}`, producer.task);
-    if (found === undefined || !("id" in found)) {
-      const target = producer === undefined ? "unnamed producer" : `"${producer.stage}"."${producer.task}".${producer.output}`;
-      unresolved.push({
-        kind: "producer-reference",
-        where: `${where}.inputs[${name}]`,
-        detail: unboundProducerDetail(target, found)
-      });
+  const unownedBy = (at) => {
+    const others = new Set(owners.filter((one, index) => index !== at && one !== undefined));
+    return rulesOf(conditions.filter((one) => !others.has(one)));
+  };
+  return declared.flatMap((row, at) => [
+    whenCellFinding(row, planRules, path, label, resolve, owners[at] === undefined ? undefined : rulesOf([owners[at]])),
+    undeclaredGateFinding(row, unownedBy(at), path, label, resolve)
+  ]).filter((finding) => finding !== undefined);
+};
+var CONDITION_FLAGS = [
+  ["interrupting", "isInterrupting", "Interrupting"],
+  ["marksComplete", "marksStageComplete", "Marks Stage Complete"]
+];
+var conditionShapeFindings = (declared, planConditions, path, label) => {
+  const findings = [];
+  const bound = bindConditions(declared, planConditions);
+  for (const [at, row] of declared.entries()) {
+    const { match, shaped } = bound[at];
+    if (match === undefined)
       continue;
+    const planName = String(match.displayName ?? "");
+    const where = shaped ? planName : row.displayName;
+    const which = shaped ? `the condition "${planName}", the only one in this scope no row names that holds this row's rule,` : "the condition";
+    if (row.exitType !== undefined) {
+      const has = typeof match.type === "string" && match.type !== "";
+      const effective = norm(has ? match.type : "exit-only");
+      if (effective !== norm(row.exitType)) {
+        findings.push(error("STRICT_SDD_CONDITION_EXIT_TYPE_MISMATCH", `${path}[${where}].type`, `${label}: the SDD row ${rowLabel(row)} declares Exit Type "${row.exitType}", ${which} has ${has ? `"${String(match.type)}"` : "no `type` at all, which the runtime reads as exit-only"}. The exit type decides where the case goes when the gate opens, so this sends it somewhere else${has ? "" : " — check for an invented key like `exitType` holding the value `type` should carry"}.`));
+      }
+    }
+    for (const [cell, field, title] of CONDITION_FLAGS) {
+      const want = row[cell];
+      const got = typeof match[field] === "boolean" ? match[field] : false;
+      if (want === undefined)
+        continue;
+      if (want === got)
+        continue;
+      findings.push(error("STRICT_SDD_CONDITION_FLAG_MISMATCH", `${path}[${where}].${field}`, `${label}: the SDD row ${rowLabel(row)} declares ${title}=${want ? "Yes" : "No"}, ${which} has ${typeof match[field] === "boolean" ? String(got) : "no such field, which the runtime reads as false"}.`));
     }
-    const id = found.id;
-    offer(name, RANK_PRODUCER, {
-      name,
-      value: row.direct === false ? expandXrefs(String(row.value ?? `=js:vars.${id}`), {
-        outputs,
-        where,
-        unresolved
-      }) : `=vars.${id}`,
-      elementId
-    });
   }
-  return [...ranked.values()].map((entry) => entry.input);
+  return findings;
+};
+var undeclaredHandoffFindings = (stage, planConditions, stageLabels, path, label) => {
+  if (stage.exitToColumn !== true)
+    return [];
+  if (stage.exitConditions.some((row) => row.exitToStage !== undefined)) {
+    return [];
+  }
+  return planConditions.flatMap((raw) => {
+    const condition = asRecord(raw);
+    const target = condition?.exitToStageId;
+    if (typeof target !== "string" || target === "")
+      return [];
+    const name = String(condition?.displayName ?? "");
+    const where = name === "" ? String(condition?.id ?? "") : name;
+    const targetLabel = stageLabels.get(target);
+    const named = targetLabel === undefined ? `"${target}"` : `"${targetLabel}" (${target})`;
+    return [
+      error("STRICT_SDD_CONDITION_UNDECLARED_HANDOFF", `${path}[${where}].exitToStageId`, `${label}: the SDD's exit tables name no Exit-To Stage for this stage, so it hands off to no one, and the condition "${where}" routes the case to ${named}. Remove exitToStageId (in Case SDK source, drop \`exitToStage\` from the exitWhen options): the next stage starts from its own entry rule.`)
+    ];
+  });
 };
 
 // src/services/strict-sdd-audit/sla-durations.ts
@@ -2016,133 +2198,6 @@ var slaDurationFindings = (sdd, plan) => {
   return findings;
 };
 
-// src/services/strict-sdd-audit/inputs.ts
-var AUDIT_CONNECTOR_TASK_TYPES = new Set([
-  "execute-connector-activity",
-  "wait-for-connector"
-]);
-var CONNECTOR_ENVELOPE_INPUTS = new Set([
-  "pathParameters",
-  "queryParameters",
-  "body"
-]);
-var resolveEnvelopeKey = (body, name) => {
-  const named = (record, part) => Object.entries(record).find(([key]) => norm(key) === norm(part));
-  const direct = named(body, name);
-  if (direct !== undefined)
-    return { value: direct[1] };
-  const parts = name.split(".").filter((part) => part !== "");
-  if (parts.length < 2)
-    return;
-  let current = body;
-  for (const part of parts) {
-    const record = asRecord(current);
-    if (record === undefined)
-      return;
-    const hit = named(record, part);
-    if (hit === undefined)
-      return;
-    current = hit[1];
-  }
-  return { value: current };
-};
-var carriedInput = (found, name) => {
-  const absent = { present: false, value: undefined, valueless: false };
-  const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
-  const direct = inputs.find((i) => norm(i.name) === norm(name));
-  if (direct !== undefined) {
-    return {
-      present: true,
-      value: direct.value,
-      valueless: !("value" in direct)
-    };
-  }
-  if (typeof found.type !== "string" || !AUDIT_CONNECTOR_TASK_TYPES.has(found.type)) {
-    return absent;
-  }
-  for (const entry of inputs) {
-    const entryName = entry.name;
-    if (typeof entryName !== "string" || !CONNECTOR_ENVELOPE_INPUTS.has(entryName)) {
-      continue;
-    }
-    const body = asRecord(entry.body);
-    if (body === undefined)
-      continue;
-    const carried = resolveEnvelopeKey(body, name);
-    if (carried !== undefined) {
-      return { present: true, value: carried.value, valueless: false };
-    }
-  }
-  return absent;
-};
-var declaredInputNames = (task) => {
-  const names = [];
-  const add = (name) => {
-    if (!names.some((existing) => norm(existing) === norm(name))) {
-      names.push(name);
-    }
-  };
-  for (const entry of task.literalInputs)
-    add(entry.name);
-  for (const entry of task.expressionInputs)
-    add(entry.name);
-  for (const entry of task.producerInputs)
-    add(entry.name);
-  return names;
-};
-var boundInputNames = (task) => task.boundInputs.map((entry) => entry.name);
-var emptyLiteralInputNames = (task) => task.literalInputs.filter((entry) => isBlank(entry.value)).map((entry) => entry.name);
-var envelopeFindings = (task, found, path, label) => {
-  const findings = [];
-  const columns = [
-    {
-      declared: task.required,
-      actual: found.isRequired,
-      column: "Required",
-      field: "isRequired"
-    },
-    {
-      declared: task.runOnlyOnce,
-      actual: found.shouldRunOnlyOnce,
-      column: "Run Only Once",
-      field: "shouldRunOnlyOnce"
-    }
-  ];
-  for (const { declared, actual, column, field: field2 } of columns) {
-    if (declared === undefined)
-      continue;
-    if (typeof actual === "boolean" && actual === declared)
-      continue;
-    findings.push(error("STRICT_SDD_TASK_ENVELOPE_MISMATCH", `${path}.${field2}`, `${label}: the SDD Tasks table declares a "${column}" value for this task and its \`${field2}\` ${typeof actual === "boolean" ? "disagrees" : "is absent"}. Set it from that column.`));
-  }
-  return findings;
-};
-var emptyInputFindings = (task, found, path, label) => {
-  const declared = declaredInputNames(task);
-  if (declared.length === 0)
-    return [];
-  if (Object.keys(found.data).length === 0)
-    return [];
-  const bound = boundInputNames(task);
-  const emptyLiteral = emptyLiteralInputNames(task);
-  const findings = [];
-  const names = (list, name) => list.some((entry) => norm(entry) === norm(name));
-  for (const name of declared) {
-    const carried = carriedInput(found, name);
-    const value = carried.value;
-    const missing = !carried.present;
-    if (!missing && !carried.valueless && (typeof value !== "string" || value.trim() !== "")) {
-      continue;
-    }
-    if (!missing && (names(bound, name) || names(emptyLiteral, name))) {
-      continue;
-    }
-    const declares = names(emptyLiteral, name) ? "the empty literal" : "a value";
-    findings.push(error("STRICT_SDD_INPUT_EMPTY", `${path}.data.inputs[${name}]`, `${label}: the SDD Inputs row for "${name}" declares ${declares}, and the caseplan input ${missing ? "is absent" : carried.valueless ? "carries no `value` at all" : "is empty"}. Nothing reaches the task for it, and none of the value comparisons can run against an input that carries nothing. ${missing ? "The row exists, so the input has to exist too — add it, carrying that row's value." : carried.valueless ? "Its value has to live under `value` — data under `body` is the connector envelope, which does not apply to this task type." : "Re-read that row and set the input from it."}`));
-  }
-  return findings;
-};
-
 // src/services/strict-sdd-audit/task-inputs.ts
 var PAYLOAD_SLOTS = ["body", "queryParameters", "pathParameters"];
 var usesSlotInputs = (found) => {
@@ -2153,7 +2208,7 @@ var usesSlotInputs = (found) => {
   return names.includes(norm("pathParameters")) || names.includes(norm("queryParameters"));
 };
 var carriesPayload = (inputs) => PAYLOAD_SLOTS.some((slot) => {
-  const input = inputs.find((i) => norm(i.name) === norm(slot));
+  const input = inputNamed(inputs, slot);
   if (typeof input?.body === "string")
     return input.body !== "";
   return Object.keys(asRecord(input?.body) ?? {}).length > 0;
@@ -2163,10 +2218,10 @@ var boundInputFindings = (task, found, path, label) => {
     return [];
   const inputs = asArray(found.data.inputs).map(asRecord).filter((i) => i !== undefined);
   const findings = [];
-  const isConnector = AUDIT_CONNECTOR_TASK_TYPES.has(found.type ?? "") && usesSlotInputs(found);
+  const isConnector = CONNECTOR_CALL_TASK_TYPES.has(found.type ?? "") && usesSlotInputs(found);
   let connectorRows = 0;
   for (const declared of task.boundInputs) {
-    const input = inputs.find((i) => norm(i.name) === norm(declared.name));
+    const input = inputNamed(inputs, declared.name);
     if (input) {
       const valueless = !("value" in input);
       if (!valueless && input.value !== "")
@@ -2214,6 +2269,35 @@ var customOutputFindings = (task, found, path, label) => {
   }
   return findings;
 };
+var outputTypeFindings = (task, found, path, label) => {
+  if (task.extractRows.length === 0 && task.customRows.length === 0) {
+    return [];
+  }
+  const outputs = asArray(found.data.outputs).map(asRecord).filter((o) => o !== undefined);
+  const declared = [
+    ...task.extractRows.map((row) => ({
+      row: `\`${row.field} -> ${row.variable}\``,
+      type: row.type,
+      output: outputs.find((o) => o.custom !== true && o.source === outputSourceFor(found.type, row.field) && o.var === row.variable)
+    })),
+    ...task.customRows.map((row) => ({
+      row: `\`${row.variable} = ${row.expression}\``,
+      type: row.type,
+      output: outputs.find((o) => o.custom === true && o.var === row.variable)
+    }))
+  ];
+  const findings = [];
+  for (const { row, type, output } of declared) {
+    const wanted = outputTypeCell(type).type;
+    if (wanted === undefined || output === undefined)
+      continue;
+    const actual = typeof output.type === "string" ? output.type : "";
+    if (actual === "" || actual === wanted)
+      continue;
+    findings.push(error("STRICT_SDD_OUTPUT_TYPE_MISMATCH", `${path}.data.outputs[${String(output.name ?? output.var)}].type`, `${label}: the SDD row ${row} types this output "${type}", so the output's \`type\` must be "${wanted}"; the caseplan has "${actual}". The row's Type is the resource's output-schema type, which is what Studio Web and \`uip maestro case splice --described\` write.`));
+  }
+  return findings;
+};
 var gatedSlaFindings = (rules, path, label) => {
   if (rules.length === 0)
     return [];
@@ -2232,7 +2316,7 @@ var gatedSlaFindings = (rules, path, label) => {
 // src/services/strict-sdd-audit/case-level.ts
 var variablePlacementFindings = (sdd, plan, name, key) => {
   const category = sdd.variableCategories.get(key);
-  const required = VARIABLE_PLACEMENT.get(category ?? "");
+  const required = VARIABLE_PLACEMENT2.get(category ?? "");
   if (category === undefined || required === undefined)
     return [];
   const issues = [];
@@ -2247,7 +2331,7 @@ var variablePlacementFindings = (sdd, plan, name, key) => {
 var variableDefaultFindings = (sdd, plan, name, key) => {
   const declared = sdd.variableDefaults.get(key);
   const category = sdd.variableCategories.get(key);
-  const group = DEFAULT_GROUP.get(category ?? "");
+  const group = DEFAULT_GROUP2.get(category ?? "");
   if (declared === undefined || group === undefined)
     return [];
   const entry = plan.variableEntries[group].get(key);
@@ -2269,12 +2353,14 @@ var variableDefaultFindings = (sdd, plan, name, key) => {
 var compareCaseLevel = (sdd, plan) => {
   const issues = [
     ...coverageFinding("metadata.caseExitRules", "case", "exit", sdd.caseExitRows, plan.caseExitConditions),
+    ...conditionRuleFindings(sdd.caseExitConditions.filter((row) => norm(whenRule(row.when ?? "").rule) === norm("api-event")), plan.caseExitConditions, "metadata.caseExitRules", "case"),
     ...gatedSlaFindings(plan.caseSlaRules, "metadata.slaRules", "case"),
     ...conditionalSlaFindings(sdd.caseConditionalSlas, plan.caseSlaRules, "metadata.slaRules", "case", plan, sdd.stages, slaReferences(sdd))
   ];
   if (sdd.caseSla && !plan.caseSla) {
     issues.push(error("STRICT_SDD_SLA_MISSING", "metadata.slaRules", "case: the SDD declares Case-Level SLA Escalation Rules, the caseplan metadata.slaRules is empty."));
   }
+  issues.push(...personaFindings(sdd, plan));
   issues.push(...escalationFindings(sdd.caseSlaEscalations, plan.caseSlaRules, "metadata.slaRules", "case", sdd.caseSlaResponses), ...xrefOutputFindings(sdd, plan), ...conditionExpressionFindings(sdd.caseExitConditions, plan.caseExitConditions, plan, "metadata.caseExitRules", "case"), ...conditionNameFindings(sdd.caseExitConditions, plan.caseExitConditions, "metadata.caseExitRules", "case", namesDeclaredOnce(sdd)));
   issues.push(...slaDurationFindings(sdd, plan));
   const caseDefaults = withoutConditional(plan.caseSlaRules, sdd.caseConditionalSlas, plan, sdd.stages, slaReferences(sdd));
@@ -2446,7 +2532,39 @@ var slaDurationOf = (block) => {
   return;
 };
 
+// src/services/strict-sdd-audit/document-extraction-detail.ts
+var readDocumentExtraction = (block) => {
+  const read = (label) => {
+    const raw = field(block, label);
+    if (raw === undefined)
+      return;
+    const text = stripTicks(raw).trim();
+    return text === "" || isBlank(text) ? undefined : text;
+  };
+  const extraction = {
+    deployment: read("IXP Deployment"),
+    modelName: read("Model Name"),
+    deploymentKey: read("Deployment Key"),
+    folderKey: read("Folder Key")
+  };
+  const stated = Object.entries(extraction).filter(([, value]) => value !== undefined);
+  return stated.length === 0 ? undefined : Object.fromEntries(stated);
+};
+var extractionFields = (block) => {
+  const extraction = readDocumentExtraction(block);
+  return extraction === undefined ? {} : { extraction };
+};
+
 // src/services/strict-sdd-audit/http-request-detail.ts
+var HTTP_METHODS = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
 var readHttpRequest = (block) => {
   const read = (label) => {
     const raw = field(block, label);
@@ -2500,79 +2618,6 @@ var resourceReference = (block) => {
   };
 };
 
-// src/services/sdd-condition-cell.ts
-var STAGE_SELECTOR_RULES = new Set([
-  "selected-stage-completed",
-  "selected-stage-exited"
-]);
-var TASK_SELECTOR_RULES = new Set(["selected-tasks-completed"]);
-var IF_PARTS = new Map([
-  ["conditionexpression", "expression"],
-  ["selected tasks", "tasks"],
-  ["selected task", "tasks"],
-  ["selected stage", "stage"],
-  ["selected stages", "stage"]
-]);
-var splitIfParts = (text) => {
-  const pieces = [];
-  let current = "";
-  let quote;
-  for (let index = 0;index < text.length; index += 1) {
-    const char = text[index];
-    if (quote !== undefined) {
-      current += char;
-      if (char === "\\") {
-        current += text[index + 1] ?? "";
-        index += 1;
-      } else if (char === quote)
-        quote = undefined;
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      current += char;
-      continue;
-    }
-    if (char !== ";") {
-      current += char;
-      continue;
-    }
-    pieces.push(current);
-    current = "";
-  }
-  pieces.push(current);
-  return pieces;
-};
-var parseIfCell = (cell) => {
-  const text = cell.trim();
-  const found = {
-    expression: ""
-  };
-  const parts = [];
-  let structured = false;
-  const partKey = (text2) => text2.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-  for (const piece of splitIfParts(text)) {
-    const at = piece.indexOf(":");
-    const key = at === -1 ? "" : partKey(piece.slice(0, at));
-    const slot = IF_PARTS.get(key);
-    if (slot === undefined) {
-      parts.push(piece);
-      continue;
-    }
-    structured = true;
-    const value = piece.slice(at + 1).trim();
-    if (slot === "expression")
-      found.expression = value;
-    else if (slot === "tasks")
-      found.tasks = value;
-    else
-      found.stage = value;
-  }
-  if (!structured)
-    return { expression: text };
-  return found;
-};
-
 // src/services/strict-sdd-audit/task-detail-rows.ts
 var entryConditionBlocks = (section) => {
   const block = section.body;
@@ -2659,6 +2704,7 @@ var declaredCell = (row, at) => {
   const text = unwrapCodeSpan(cellAt(row, at));
   return isBlank(text) ? "" : text;
 };
+var API_EVENT_RULE = "api-event";
 var ARGUMENT_RULES = new Set([
   ...STAGE_SELECTOR_RULES,
   ...TASK_SELECTOR_RULES,
@@ -2669,6 +2715,8 @@ var labelledWhen = (when, ifCell) => {
   if (match === null)
     return { when };
   const [, rule, label] = match;
+  if (rule === API_EVENT_RULE)
+    return { when };
   if (!ARGUMENT_RULES.has(rule))
     return { when: rule, label };
   const parts = parseIfCell(ifCell);
@@ -2826,15 +2874,21 @@ var detailExtractRows = (block) => {
     const bindingAt = columnIndex(header, "Binding / Value", "Binding", "Value");
     if (fieldAt === undefined || bindingAt === undefined)
       continue;
+    const typeAt = columnIndex(header, "Type");
     for (const row of tableRows) {
-      const field2 = stripTicks(cellAt(row, fieldAt).trim());
+      const field = stripTicks(cellAt(row, fieldAt).trim());
       const binding = unwrapCodeSpan(cellAt(row, bindingAt));
-      if (!field2 || isBlank(field2) || !binding.startsWith("->"))
+      if (!field || isBlank(field) || !binding.startsWith("->"))
         continue;
       const variable = binding.slice(2).trim();
       if (!variable || isBlank(variable))
         continue;
-      rows.push({ field: field2, variable });
+      const type = typeAt === undefined ? "" : stripTicks(cellAt(row, typeAt).trim()).trim();
+      rows.push({
+        field,
+        variable,
+        ...type !== "" && !isBlank(type) && { type }
+      });
     }
   }
   return rows;
@@ -2848,10 +2902,10 @@ var timerFields = (block) => {
   if (!declared || isBlank(declared))
     return {};
   if (TIMER_VALUE_FIELDS.has(norm(declared).replaceAll(" ", ""))) {
-    const value2 = stripTicks(field(block, "Value") ?? "");
+    const value = stripTicks(field(block, "Value") ?? "");
     return {
       timerType: declared,
-      ...value2 && !isBlank(value2) && { timerValue: value2 }
+      ...value && !isBlank(value) && { timerValue: value }
     };
   }
   const configured = stripTicks(field(block, "Timer Configuration") ?? "");
@@ -2895,15 +2949,6 @@ var resourceNameOf = (block) => {
   }
   return resourceReference(block).name;
 };
-var HTTP_METHODS = new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "HEAD",
-  "OPTIONS"
-]);
 var readConnectorTail = (text, into) => {
   const open = text.lastIndexOf("(");
   const close = text.lastIndexOf(")");
@@ -2944,10 +2989,12 @@ var readRecipient = (block) => {
   if (declared === undefined || isBlank(declared))
     return;
   const text = stripTicks(declared).trim();
+  if (text.startsWith("="))
+    return { kind: "expression", value: text };
   const at = text.indexOf(":");
   if (at === -1)
     return { kind: "", value: text };
-  const value = text.slice(at + 1).trim();
+  const value = stripTicks(text.slice(at + 1));
   if (value === "" || isBlank(value))
     return;
   return { kind: norm(text.slice(0, at)), value };
@@ -2993,6 +3040,15 @@ var readTaskDetail = (section) => {
     type: stripTicks(field(block, "Type") ?? ""),
     resolvedResource: field(block, "Resolved Resource"),
     identityResolved: identity.length > 0 && !identity.some(hasUnresolvedMarker),
+    identityStated: (() => {
+      const stated = [
+        field(block, "Resource Identity"),
+        field(block, "Connection ID"),
+        field(block, "Activity Type ID"),
+        field(block, "Action App ID")
+      ].filter((value) => !!value && !isBlank(value));
+      return stated.length > 0 && !stated.some(hasUnresolvedMarker);
+    })(),
     folder: field(block, "Deployment Folder") ?? field(block, "Folder Path") ?? resourceReference(block).folder,
     ...(() => {
       const skip = namedValue(unwrapCodeSpan(field(block, "Skip Condition") ?? columnField(block, "Skip Condition") ?? ""));
@@ -3022,7 +3078,8 @@ var readTaskDetail = (section) => {
     customRows: detailCustomRows(block),
     unreadTables: unreadIoTables(block),
     ...timerFields(block),
-    ...httpFields(block)
+    ...httpFields(block),
+    ...extractionFields(block)
   };
 };
 var TIMER_CONFIGURATION_TYPES = new Map([
@@ -3070,8 +3127,8 @@ var literalDifference = (actual, declared) => {
   return "does not match the literal the SDD declares";
 };
 var missingLiteralFields = (declared, actual) => {
-  const [declaredError, declaredValue] = catchError(() => JSON.parse(declared));
-  const [actualError, actualValue] = catchError(() => JSON.parse(actual));
+  const [declaredError, declaredValue] = catchError2(() => JSON.parse(declared));
+  const [actualError, actualValue] = catchError2(() => JSON.parse(actual));
   if (declaredError || actualError)
     return;
   const declaredRecord = asRecord(declaredValue);
@@ -3090,7 +3147,18 @@ var missingLiteralFields = (declared, actual) => {
     firstMissing: missing[0]
   };
 };
-var literalFindings = (task, found, path, label) => {
+var pickedValue = (found, actual, rootBindings) => {
+  const id = /^=bindings\.(.+)$/.exec(actual)?.[1];
+  if (id === undefined)
+    return;
+  const taskCopies = Array.isArray(found.data.bindings) ? found.data.bindings.map(asRecord) : [];
+  const binding = rootBindings.find((entry) => entry.id === id) ?? taskCopies.find((entry) => entry?.id === id);
+  return binding?.resource !== "Connection" && typeof binding?.default === "string" ? binding.default : undefined;
+};
+var pickedFindings = (declared, picked, path, label) => sameLiteral(declared.value, picked) ? [] : [
+  warning("STRICT_SDD_LITERAL_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" picks a resource that ${literalDifference(picked, declared.value)}. Re-read the Inputs row for "${declared.name}" and resolve the picker to the resource it names.`)
+];
+var literalFindings = (task, found, rootBindings, path, label) => {
   const findings = [];
   for (const declared of task.literalInputs) {
     const carried = carriedInput(found, declared.name);
@@ -3099,6 +3167,11 @@ var literalFindings = (task, found, path, label) => {
     const actual = carried.value;
     if (typeof actual !== "string")
       continue;
+    const picked = pickedValue(found, actual, rootBindings);
+    if (picked !== undefined) {
+      findings.push(...pickedFindings(declared, picked, path, label));
+      continue;
+    }
     if (actual.startsWith("=")) {
       findings.push(error("STRICT_SDD_LITERAL_MISMATCH", `${path}.data.inputs[${declared.name}]`, `${label}: input "${declared.name}" carries an expression where the SDD's Inputs row declares a literal value. Re-read that row and set the literal it gives.`));
       continue;
@@ -3116,181 +3189,41 @@ var literalFindings = (task, found, path, label) => {
   return findings;
 };
 
-// src/services/strict-sdd-audit/selector-targets.ts
-var idsIn = (value) => {
-  const values = Array.isArray(value) ? value : [value];
-  return values.filter((entry) => typeof entry === "string" && entry.trim() !== "");
-};
-var selectedIds = (rule) => Object.entries(rule ?? {}).filter(([key]) => key.startsWith("selected")).flatMap(([, value]) => idsIn(value));
-var hasSelector = (rule) => selectedIds(rule).length > 0 || idsIn(rule?.slaId).length > 0;
-var ruleTargets = (rule, resolve, same) => {
-  const named = selectedIds(rule).map((id) => resolve.stage(id) ?? resolve.task(id)).filter((name) => name !== undefined);
-  const owners = idsIn(rule?.slaId).map((id) => resolve.sla?.(id)).filter((name) => name !== undefined);
-  if (named.length === 0)
-    return { names: owners };
-  const conflict = owners.find((owner) => !named.some((name) => same(name, owner)));
-  return conflict === undefined ? { names: named } : { names: named, conflict };
-};
-
-// src/services/strict-sdd-audit/selectors.ts
-var sameLabel = (a, b) => norm(a) === norm(b) || normAnnotationless(a) === normAnnotationless(b);
-var leadingSegment = (name) => {
-  for (const dash of [" - ", " – ", " — "]) {
-    const at = name.indexOf(dash);
-    if (at > 0)
-      return name.slice(0, at);
-  }
-  return name;
-};
-var targetsOf = (rule, selectors) => norm(rule) === norm("sla-status-change") ? selectors.slice(0, 1) : selectors;
-var undeclaredGateFinding = (row, planRules, path, label, resolve) => {
-  if (row.ungated !== true || row.when === undefined)
-    return;
-  const { rule, selectors: named } = whenRule(row.when);
-  if (!rule || isBlank(rule))
-    return;
-  const selectors = targetsOf(rule, named);
-  const belongsToRow = (candidate) => {
-    if (selectors.length === 0)
-      return !hasSelector(candidate);
-    if (!hasSelector(candidate))
-      return false;
-    if (resolve === undefined)
-      return false;
-    const pointsAt = ruleTargets(candidate, resolve, sameLabel).names;
-    if (pointsAt.length === 0)
-      return false;
-    return selectors.some((want) => {
-      const denotes = resolve.label(want);
-      return pointsAt.some((got) => sameLabel(got, want) || denotes !== undefined && got === denotes);
-    });
-  };
-  const gated = planRules.filter((candidate) => {
-    if (norm(candidate?.rule) !== norm(rule))
-      return false;
-    if (!belongsToRow(candidate))
-      return false;
-    const expression = candidate?.conditionExpression;
-    return typeof expression === "string" && !isBlank(expression);
-  });
-  if (gated.length === 0)
-    return;
-  const expressions = [
-    ...new Set(gated.map((candidate) => String(candidate?.conditionExpression)).filter((expression) => expression !== ""))
-  ];
-  const on = selectors.length > 0 ? ` on "${selectors.join('", "')}"` : "";
-  return error("STRICT_SDD_CONDITION_EXPRESSION_UNDECLARED", `${path}[${row.displayName}].conditionExpression`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\`${on} with no IF gate, and the caseplan's \`${rule}\` carries \`${expressions.join("`, `")}\`. A gate the SDD does not declare narrows the transition to one branch, so it fires where the row says it should fire every time. Remove the expression, or add the IF cell that justifies it.`);
-};
-var whenCellFinding = (row, planRules, path, label, resolve, ownRules) => {
-  if (row.when === undefined)
-    return;
-  const { rule, selectors: named } = whenRule(row.when);
-  if (!rule || isBlank(rule))
-    return;
-  const wanted = targetsOf(rule, named);
-  const matching = planRules.filter((r) => norm(r?.rule) === norm(rule));
-  if (matching.length === 0) {
-    return error("STRICT_SDD_CONDITION_RULE_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\`, no rule on it uses that predicate. A different predicate starts the task at a different moment. Re-read that row's WHEN cell.`);
-  }
-  if (wanted.length === 0)
-    return;
-  const own = (ownRules ?? []).filter((r) => norm(r?.rule) === norm(rule));
-  const targeted = own.length > 0 ? own : matching;
-  if (!targeted.some(hasSelector)) {
-    return error("STRICT_SDD_CONDITION_SELECTOR_MISSING", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\` on "${wanted.join('", "')}", and the caseplan's \`${rule}\` carries no target. The predicate then refers to nothing, so it never becomes true and the gate never opens. Set the rule's \`selected*\` field to the target the row names.`);
-  }
-  if (resolve === undefined)
-    return;
-  const resolved = targeted.map((candidate) => ruleTargets(candidate, resolve, sameLabel));
-  const pointsAt = resolved.flatMap((target) => target.names);
-  if (pointsAt.length === 0)
-    return;
-  const missed = wanted.filter((want) => {
-    const denotes = resolve.label(want);
-    return !pointsAt.some((got) => sameLabel(got, want) || denotes !== undefined && got === denotes);
-  });
-  const conflict = resolved.find((target) => target.conflict !== undefined);
-  if (missed.length === 0 && conflict?.conflict !== undefined) {
-    return error("STRICT_SDD_CONDITION_SELECTOR_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\` on "${wanted.join('", "')}", and the caseplan's \`${rule}\` names "${conflict.names.join('", "')}" but its \`slaId\` is the SLA of "${conflict.conflict}". The rule watches one stage's SLA while naming another, so it fires on a deadline the row did not ask for. Point \`slaId\` at the SLA of "${wanted.join('", "')}" and drop the \`selected*\` field, which convert does not write for this rule.`);
+// src/services/strict-sdd-audit/recipients.ts
+var recipientFindings = (task, found, path, label) => {
+  if (task.recipient === undefined)
+    return [];
+  const carried = found.data.recipient;
+  if (carried === undefined) {
+    return [
+      error("STRICT_SDD_TASK_RECIPIENT_MISSING", `${path}.data.recipient`, `${label}: the SDD's \`**Recipient:**\` line names "${task.recipient.value}" and the caseplan task carries no \`data.recipient\`. \`case validate\` does not check this field's presence, so a dropped recipient passes the build and the task is created with no assignee. Add \`data.recipient\` as the \`{Type, Value}\` object the SDD's recipient line resolves to.`)
+    ];
   }
-  if (missed.length === 0)
-    return;
-  return error("STRICT_SDD_CONDITION_SELECTOR_MISMATCH", `${path}[${row.displayName}].rule`, `${label}: the SDD row ${rowLabel(row)} declares WHEN \`${rule}\` on "${missed.join('", "')}", and the caseplan's \`${rule}\` points at "${pointsAt.join('", "')}". A selector that resolves to the wrong target builds a transition the SDD never asked for and leaves the declared one absent, which no count or predicate check can see.`);
-};
-var conditionRuleFindings = (declared, planConditions, path, label, resolve) => {
-  if (declared.length === 0)
+  if (task.recipient.kind !== "expression")
     return [];
-  const conditions = planConditions.map(asRecord);
-  const rulesOf = (of) => of.flatMap((condition) => asArray(condition?.rules).flatMap((group) => asArray(group).map(asRecord)));
-  const planRules = rulesOf(conditions);
-  if (planRules.length === 0)
+  const recipient = asRecord(carried);
+  if (recipient === undefined)
+    return [];
+  const value = recipient.Value;
+  if (recipient.Type === 3 && typeof value === "string" && value.startsWith("=")) {
     return [];
-  const owners = bindByName(declared, conditions);
-  const taken = new Set(owners.filter((one) => one !== undefined));
-  const openRows = declared.map((row, at) => ({ row, at })).filter(({ at }) => owners[at] === undefined);
-  const openConditions = conditions.filter((one) => !taken.has(one));
-  const gated = (condition) => rulesOf([condition]).some((rule) => {
-    const expression = rule?.conditionExpression;
-    return typeof expression === "string" && !isBlank(expression);
-  });
-  const rowGated = (row) => row.ungated === true ? false : row.ifExpression !== undefined ? true : undefined;
-  const shapeKey = (rule, isGated) => {
-    const name = norm(rule);
-    if (name === "" || isGated === undefined)
-      return;
-    return `${name}|${isGated ? "gated" : "open"}`;
-  };
-  for (const [rowAt, conditionAt] of pairLeftovers(openRows.map(({ row }) => shapeKey(whenRule(row.when ?? "").rule, rowGated(row))), openConditions.map((condition) => {
-    const rules = new Set(rulesOf([condition]).map((r) => norm(r?.rule)));
-    return rules.size === 1 ? shapeKey([...rules][0], gated(condition)) : undefined;
-  }))) {
-    owners[openRows[rowAt].at] = openConditions[conditionAt];
   }
-  const unownedBy = (at) => {
-    const others = new Set(owners.filter((one, index) => index !== at && one !== undefined));
-    return rulesOf(conditions.filter((one) => !others.has(one)));
-  };
-  return declared.flatMap((row, at) => [
-    whenCellFinding(row, planRules, path, label, resolve, owners[at] === undefined ? undefined : rulesOf([owners[at]])),
-    undeclaredGateFinding(row, unownedBy(at), path, label, resolve)
-  ]).filter((finding) => finding !== undefined);
+  return [
+    error("STRICT_SDD_TASK_RECIPIENT_EXPRESSION", `${path}.data.recipient`, `${label}: the SDD's \`**Recipient:**\` line is the expression "${task.recipient.value}", and the caseplan task carries \`{Type: ${String(recipient.Type)}, Value: ${JSON.stringify(value)}}\`. The engine assigns a \`Type 3\` recipient to the user or group its value evaluates to; any other Type, or a value that is not an \`=\` expression, sends the literal text to a lookup and the task reaches nobody. ${expressionFix(task.recipient.value)}`)
+  ];
 };
-var CONDITION_FLAGS = [
-  ["interrupting", "isInterrupting", "Interrupting"],
-  ["marksComplete", "marksStageComplete", "Marks Stage Complete"]
-];
-var conditionShapeFindings = (declared, planConditions, path, label) => {
-  const findings = [];
-  const bound = bindConditions(declared, planConditions);
-  for (const [at, row] of declared.entries()) {
-    const { match, shaped } = bound[at];
-    if (match === undefined)
-      continue;
-    const planName = String(match.displayName ?? "");
-    const where = shaped ? planName : row.displayName;
-    const which = shaped ? `the condition "${planName}", the only one in this scope no row names that holds this row's rule,` : "the condition";
-    if (row.exitType !== undefined) {
-      const has = typeof match.type === "string" && match.type !== "";
-      const effective = norm(has ? match.type : "exit-only");
-      if (effective !== norm(row.exitType)) {
-        findings.push(error("STRICT_SDD_CONDITION_EXIT_TYPE_MISMATCH", `${path}[${where}].type`, `${label}: the SDD row ${rowLabel(row)} declares Exit Type "${row.exitType}", ${which} has ${has ? `"${String(match.type)}"` : "no `type` at all, which the runtime reads as exit-only"}. The exit type decides where the case goes when the gate opens, so this sends it somewhere else${has ? "" : " — check for an invented key like `exitType` holding the value `type` should carry"}.`));
-      }
-    }
-    for (const [cell, field2, title] of CONDITION_FLAGS) {
-      const want = row[cell];
-      const got = typeof match[field2] === "boolean" ? match[field2] : false;
-      if (want === undefined)
-        continue;
-      if (want === got)
-        continue;
-      findings.push(error("STRICT_SDD_CONDITION_FLAG_MISMATCH", `${path}[${where}].${field2}`, `${label}: the SDD row ${rowLabel(row)} declares ${title}=${want ? "Yes" : "No"}, ${which} has ${typeof match[field2] === "boolean" ? String(got) : "no such field, which the runtime reads as false"}.`));
-    }
+var expressionFix = (sddValue) => {
+  if (sddValue.startsWith("=") && !sddValue.includes("$xref(")) {
+    return `Write \`{"Type": 3, "Value": ${JSON.stringify(sddValue)}}\`.`;
   }
-  return findings;
+  if (sddValue.includes("$xref(")) {
+    return "Write `Type: 3` with the expression's `$xref(...)` replaced by the producing output's `vars.<id>`, as `sdd convert` does.";
+  }
+  return "Write `Type: 3` with an `=` expression for it (`=vars.<variable>`), and fix the SDD line to `Expression: =vars.<variable>` so the next convert writes it.";
 };
 
 // src/services/strict-sdd-audit/compare-task.ts
-var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stageSpellings2 = [], once = new Set) => {
+var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stageSpellings = [], once = new Set) => {
   const issues = [];
   const taskPath = `${stagePath}.data.tasks[${found.name ?? task.name}]`;
   if (task.type && found.type && norm(task.type) !== norm(found.type)) {
@@ -3309,7 +3242,7 @@ var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stage
     issues.push(error("STRICT_SDD_ENTRY_RULE_EMPTY", `${taskPath}.entryConditions`, `${label}: entryConditions carry no rules.`));
   }
   const isPlaceholder = Object.keys(found.data).length === 0;
-  const miss = isPlaceholder ? ledgerMissFor(ledger, stageSpellings2, task.name) : undefined;
+  const miss = isPlaceholder ? ledgerMissFor(ledger, stageSpellings, task.name) : undefined;
   if (isPlaceholder && task.identityResolved && miss !== undefined) {
     issues.push(warning("STRICT_SDD_PLACEHOLDER_UNRESOLVABLE", `${taskPath}.data`, `${label}: placeholder task, and the run's registry ledger records no match for "${miss.query}"${miss.cacheFile ? ` in ${miss.cacheFile}` : ""} — so the placeholder is correct and the SDD names a resource this tenant does not have. Resolve it on a tenant that does, or leave the placeholder.`));
   } else if (isPlaceholder && task.identityResolved) {
@@ -3318,13 +3251,17 @@ var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stage
   } else if (isPlaceholder) {
     issues.push(warning("STRICT_SDD_PLACEHOLDER_TASK", `${taskPath}.data`, `${label}: placeholder task (empty \`data\`) — the SDD leaves its resource unresolved.`));
   }
+  if (!isPlaceholder && task.identityStated !== true && task.resourceName !== undefined && bindingId(found.data.name) !== undefined && !ledgerFoundFor(ledger, stageSpellings, task.name, {
+    name: namedValue(task.resourceName),
+    folder: namedValue(task.folder)
+  })) {
+    issues.push(warning("STRICT_SDD_RESOURCE_UNVERIFIED", `${taskPath}.data.name`, `${label}: bound to "${task.resourceName}", which the SDD names without a Resource Identity, and no registry ledger records finding it — so nothing checked that this ${task.type || "resource"} exists on the tenant. A binding to a resource that does not exist passes validate and faults at \`case debug\`. Run \`uip maestro case registry pull\`, then \`uip maestro case sdd resolve <sdd> --out tasks/registry-resolved.json\` from the caseplan's folder (validate reads the ledger only from a file of that name beside the caseplan or above it): bind it if it is found, and use a placeholder (empty \`data\`) if it is not.`));
+  }
   issues.push(...conditionRuleFindings(task.entryConditions, found.entry, `${taskPath}.entryConditions`, label, selectors), ...conditionNameFindings(task.entryConditions, found.entry, `${taskPath}.entryConditions`, label, once), ...envelopeFindings(task, found, taskPath, label));
   if (isPlaceholder)
     return issues;
-  if (task.recipient !== undefined && found.data.recipient === undefined) {
-    issues.push(error("STRICT_SDD_TASK_RECIPIENT_MISSING", `${taskPath}.data.recipient`, `${label}: the SDD's \`**Recipient:**\` line names "${task.recipient.value}" and the caseplan task carries no \`data.recipient\`. \`case validate\` does not check this field's presence, so a dropped recipient passes the build and the task is created with no assignee. Add \`data.recipient\` as the \`{Type, Value}\` object the SDD's recipient line resolves to.`));
-  }
-  issues.push(...bindingFindings(plan, found, taskPath, label, namedValue(task.folder) || undefined), ...literalFindings(task, found, taskPath, label), ...boundInputFindings(task, found, taskPath, label), ...timerFindings(task, found, taskPath, label), ...wiringFindings(task, found, taskPath, label), ...producerFindings(task, found, plan, taskPath, label), ...emptyInputFindings(task, found, taskPath, label), ...expressionShapeFindings(task, found, plan, taskPath, label), ...outputRowFindings(task, found, taskPath, label), ...extractFindings(task, found, taskPath, label), ...customOutputFindings(task, found, taskPath, label));
+  issues.push(...recipientFindings(task, found, taskPath, label));
+  issues.push(...bindingFindings(plan, found, taskPath, label, namedValue(task.folder) || undefined), ...literalFindings(task, found, plan.bindings, taskPath, label), ...boundInputFindings(task, found, taskPath, label), ...timerFindings(task, found, taskPath, label), ...wiringFindings(task, found, taskPath, label), ...producerFindings(task, found, plan, taskPath, label), ...emptyInputFindings(task, found, taskPath, label), ...expressionShapeFindings(task, found, plan, taskPath, label), ...outputRowFindings(task, found, taskPath, label), ...extractFindings(task, found, taskPath, label), ...customOutputFindings(task, found, taskPath, label), ...outputTypeFindings(task, found, taskPath, label));
   return issues;
 };
 
@@ -3332,7 +3269,7 @@ var compareTask = (plan, task, found, stagePath, label, selectors, ledger, stage
 var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, once = new Set, sddStages = [stage], references = []) => {
   const stagePath = `nodes[${planStage.name ?? stage.name}]`;
   const ordinal = stagePosition === undefined ? undefined : `Stage ${stagePosition + 1}`;
-  const stageSpellings2 = [
+  const stageSpellings = [
     stage.name,
     ordinal,
     ordinal === undefined ? undefined : `${ordinal}: ${stage.name}`,
@@ -3352,7 +3289,7 @@ var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, on
   if (stage.hasSla && stageDefaults.length > 1) {
     issues.push(error("STRICT_SDD_SLA_EXTRA", `${stagePath}.data.slaRules`, `${stageLabel}: the SDD declares one Stage SLA and ${stageDefaults.length} SLA rules are present. Its escalations belong to that one SLA, so splitting them across rules leaves each with part of it and the runtime applies whichever rule it reaches — the other escalations are lost. Carry one rule with every escalation the table declares.`));
   }
-  issues.push(...conditionRuleFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel, selectors), ...conditionRuleFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel, selectors), ...conditionShapeFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel), ...conditionShapeFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel), ...conditionNameFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel, once), ...conditionNameFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel, once), ...conditionExpressionFindings(stage.entryConditions, planStage.entry, plan, `${stagePath}.data.entryConditions`, stageLabel), ...conditionExpressionFindings(stage.exitConditions, planStage.exit, plan, `${stagePath}.data.exitConditions`, stageLabel), ...escalationFindings(stage.slaEscalations, planStage.sla, `${stagePath}.data.slaRules`, stageLabel, stage.slaResponses));
+  issues.push(...conditionRuleFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel, selectors), ...conditionRuleFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel, selectors), ...conditionShapeFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel), ...conditionShapeFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel), ...undeclaredHandoffFindings(stage, planStage.exit, new Map(plan.stages.flatMap((one) => one.id !== undefined && one.name !== undefined ? [[one.id, one.name]] : [])), `${stagePath}.data.exitConditions`, stageLabel), ...conditionNameFindings(stage.entryConditions, planStage.entry, `${stagePath}.data.entryConditions`, stageLabel, once), ...conditionNameFindings(stage.exitConditions, planStage.exit, `${stagePath}.data.exitConditions`, stageLabel, once), ...conditionExpressionFindings(stage.entryConditions, planStage.entry, plan, `${stagePath}.data.entryConditions`, stageLabel), ...conditionExpressionFindings(stage.exitConditions, planStage.exit, plan, `${stagePath}.data.exitConditions`, stageLabel), ...escalationFindings(stage.slaEscalations, planStage.sla, `${stagePath}.data.slaRules`, stageLabel, stage.slaResponses));
   const bound = resolveTasks(stage.tasks, planStage.tasks);
   const unboundRows = stage.tasks.map((_, row) => row).filter((row) => bound[row] === undefined);
   const unboundTasks = planStage.tasks.map((_, index) => index).filter((index) => !bound.includes(index));
@@ -3370,7 +3307,7 @@ var compareStage = (plan, stage, planStage, selectors, ledger, stagePosition, on
       issues.push(error("STRICT_SDD_TASK_MISSING", `${stagePath}.data.tasks[${task.name}]`, `${label} is declared in the SDD and absent from the caseplan.`));
       return;
     }
-    issues.push(...compareTask(plan, task, planStage.tasks[taskIndex], stagePath, label, selectors, ledger, stageSpellings2, once));
+    issues.push(...compareTask(plan, task, planStage.tasks[taskIndex], stagePath, label, selectors, ledger, stageSpellings, once));
   });
   planStage.tasks.forEach((extra, index) => {
     if (bound.includes(index))
@@ -3415,7 +3352,7 @@ var compare = (sdd, plan, ledger) => {
     }
   };
   const paired = new Set;
-  for (const [s, p] of pairByEvidence(unbound.length, leftover.length, (s2, p2) => evidence(sdd.stages[unbound[s2]], plan.stages[leftover[p2]]) !== undefined)) {
+  for (const [s, p] of pairByEvidence(unbound.length, leftover.length, (s, p) => evidence(sdd.stages[unbound[s]], plan.stages[leftover[p]]) !== undefined)) {
     const sddIndex = unbound[s];
     const at = leftover[p];
     const stage = sdd.stages[sddIndex];
@@ -3499,6 +3436,89 @@ class SddNameCollisionError extends Error {
   }
 }
 
+// src/services/sdd-personas-table.ts
+var PERSONA_NAME_COLUMNS = [
+  "Persona",
+  "Role",
+  "Case Role",
+  "Name"
+];
+var WHOLE_CASE_CELLS = new Set(["all", "case", "all stages", "whole case"]);
+var splitList = (cell) => cell.split(/[,;]/).map((part) => stripTicks(part.trim()).trim()).filter((part) => part !== "" && !isBlank(part));
+var EMPTY = { personas: [], notes: [] };
+var personasOf = (block) => {
+  const tables = pipeTables(block).map(firstTable).filter(({ header }) => columnIndex(header, ...PERSONA_NAME_COLUMNS) !== undefined);
+  const table = tables.find(({ rows }) => rows.length > 0) ?? tables[0];
+  if (table === undefined)
+    return EMPTY;
+  const { header, rows } = table;
+  const nameAt = columnIndex(header, ...PERSONA_NAME_COLUMNS);
+  const scopeAt = columnIndex(header, "Scope");
+  const stagesAt = columnIndex(header, "Stages", "Stage Scope", "Stage");
+  const permissionsAt = columnIndex(header, "Permissions", "Actions");
+  const descriptionAt = columnIndex(header, "Description");
+  const hasScopeColumn = scopeAt !== undefined;
+  const templateShape = hasScopeColumn && permissionsAt !== undefined;
+  const personas = [];
+  const notes = [];
+  for (const [at, row] of rows.entries()) {
+    const name = stripTicks(cellAt(row, nameAt).trim()).trim();
+    if (name === "" || isBlank(name)) {
+      notes.push(`Personas row ${at + 1} has no name and is not read; a persona becomes a role by its name`);
+      continue;
+    }
+    const stagesCell = cellAt(row, stagesAt).trim();
+    const scopeCell = stripTicks(cellAt(row, scopeAt).trim()).trim();
+    const legacyWholeCase = !hasScopeColumn && (stagesCell === "" || isBlank(stagesCell) || WHOLE_CASE_CELLS.has(stagesCell.toLowerCase()));
+    const description = cellAt(row, descriptionAt).trim();
+    personas.push({
+      name,
+      ...hasScopeColumn ? { scope: scopeCell } : { scope: legacyWholeCase ? "Case" : "Stages" },
+      stages: legacyWholeCase ? [] : splitList(stagesCell),
+      permissions: splitList(cellAt(row, permissionsAt)),
+      ...description !== "" && !isBlank(description) && { description },
+      templateShape
+    });
+  }
+  return { personas, notes };
+};
+
+// src/services/strict-sdd-audit/business-events-read.ts
+var readBusinessEvents = (sdd, title, body) => {
+  const { header, rows } = firstTable(body);
+  const wanted = ["Name", "Event", "Business Event"];
+  const nameAt = columnIndex(header, ...wanted);
+  if (nameAt === undefined) {
+    if (rows.length > 0) {
+      sdd.parseNotes.push(noNameColumnNote(title, wanted, header));
+    }
+    return;
+  }
+  const descriptionAt = columnIndex(header, "Description");
+  const payloadAt = columnIndex(header, "Payload", "Schema", "Payload Schema");
+  const seen = new Set;
+  for (const [at, row] of rows.entries()) {
+    const name = stripTicks(cellAt(row, nameAt)).trim();
+    if (name === "" || isBlank(name)) {
+      sdd.parseNotes.push(`section "${title}": row ${at + 1} has no Name, so no business event was declared for it`);
+      continue;
+    }
+    if (seen.has(name)) {
+      sdd.parseNotes.push(`section "${title}": business event "${name}" is declared twice; rules match on the name, so only the first row is kept`);
+      continue;
+    }
+    seen.add(name);
+    const description = cellAt(row, descriptionAt).trim();
+    const payload = stripTicks(cellAt(row, payloadAt)).trim();
+    sdd.businessEvents.push({
+      row: at + 1,
+      name,
+      ...description !== "" && !isBlank(description) && { description },
+      ...payload !== "" && !isBlank(payload) && { payload }
+    });
+  }
+};
+
 // src/services/strict-sdd-audit/canvas-notes-read.ts
 var cellsOf = (line) => splitRowCells(line.trim().replace(/^\|/, "").replace(/\|$/, ""));
 var noteTable = (table) => {
@@ -3541,9 +3561,8 @@ var readCanvasNotes = (sdd, title, body) => {
   }
 };
 var readCanvasNotesSection = (sdd, section, seen) => {
-  const { title, body } = section;
-  const own = section.children.length > 0 ? body.slice(0, section.children[0].start - section.contentStart) : body;
-  const tables = pipeTables(own).filter((table) => noteTable(table).rows.some((row) => row.some((cell) => cell.trim() !== "")));
+  const { title } = section;
+  const tables = pipeTables(ownBodyOf(section)).filter((table) => noteTable(table).rows.some((row) => row.some((cell) => cell.trim() !== "")));
   if (tables.length === 0)
     return seen;
   const later = seen ? tables.length : tables.length - 1;
@@ -3602,6 +3621,9 @@ var applyStageSection = (stage, title, block, notes) => {
     const merged = addConditionTable(stage.exitRows, stage.exitConditions, block);
     stage.exitRows = merged.rows;
     stage.exitConditions = merged.conditions;
+    if (columnIndex(firstTable(block).header, "Exit-To Stage", "Target Stage") !== undefined) {
+      stage.exitToColumn = true;
+    }
   } else if (headingIs(title, STAGE_CONDITIONAL_SLA_HEADINGS)) {
     stage.conditionalSlas = conditionalSlaRows(block);
   } else if (headingIs(title, STAGE_SLA_HEADINGS)) {
@@ -3712,16 +3734,16 @@ var parseStage = (name, section, notes) => {
       });
     }
   }
-  const tasksUnder = (key, name2) => stage.tasks.filter((other) => key(other.name) === key(name2)).length;
+  const tasksUnder = (key, name) => stage.tasks.filter((other) => key(other.name) === key(name)).length;
   const exactSeen = new Map;
-  const detailFor = (name2) => {
-    const candidates = details.get(norm(name2)) ?? [];
-    if (candidates.length === 1 && tasksUnder(norm, name2) === 1) {
+  const detailFor = (name) => {
+    const candidates = details.get(norm(name)) ?? [];
+    if (candidates.length === 1 && tasksUnder(norm, name) === 1) {
       return candidates[0].detail;
     }
-    const exact = candidates.filter((c) => c.name === name2.trim());
-    const nth = exactSeen.get(name2.trim()) ?? 0;
-    exactSeen.set(name2.trim(), nth + 1);
+    const exact = candidates.filter((c) => c.name === name.trim());
+    const nth = exactSeen.get(name.trim()) ?? 0;
+    exactSeen.set(name.trim(), nth + 1);
     return exact[nth]?.detail;
   };
   for (const task of stage.tasks) {
@@ -3745,6 +3767,7 @@ var parseStage = (name, section, notes) => {
     task.unreadTables = detail.unreadTables;
     task.resolvedResource = detail.resolvedResource;
     task.identityResolved = detail.identityResolved;
+    task.identityStated = detail.identityStated;
     task.folder = detail.folder;
     task.proseLabel = detail.proseLabel;
     task.prose = detail.prose;
@@ -3770,6 +3793,8 @@ var parseStage = (name, section, notes) => {
       task.type = detail.type;
     if (detail.http !== undefined && String(task.type ?? "").trim().toLowerCase() === "http-request")
       task.http = detail.http;
+    if (detail.extraction !== undefined && String(task.type ?? "").trim().toLowerCase() === "document-extraction")
+      task.extraction = detail.extraction;
   }
   const empty = {
     conditions: !(stage.entryRows && stage.exitRows),
@@ -3788,7 +3813,7 @@ var parseStage = (name, section, notes) => {
 };
 
 // src/services/strict-sdd-audit/sdd-parse.ts
-var applyCaseSection = (sdd, title, body, headingLine, declaredNames) => {
+var applyCaseSection = (sdd, title, body, headingLine, declaredNames, own = body) => {
   if (headingIs(title, CASE_EXIT_HEADINGS)) {
     const merged = addConditionTable(sdd.caseExitRows, sdd.caseExitConditions, body);
     sdd.caseExitRows = merged.rows;
@@ -3882,6 +3907,13 @@ var applyCaseSection = (sdd, title, body, headingLine, declaredNames) => {
         }
       }
     }
+  } else if (headingIs(title, PERSONA_HEADINGS)) {
+    const { personas, notes } = personasOf(own);
+    sdd.personas.push(...personas);
+    sdd.personaNotes.push(...notes);
+    sdd.parseNotes.push(...notes.map((note) => `section "${title}": ${note}`));
+  } else if (headingIs(title, BUSINESS_EVENT_HEADINGS)) {
+    readBusinessEvents(sdd, title, body);
   } else if (headingIs(title, CASE_VARIABLE_HEADINGS)) {
     sdd.sawVariableSection = true;
     const { header, rows, rowLines } = firstTable(body);
@@ -3915,7 +3947,7 @@ var applyCaseSection = (sdd, title, body, headingLine, declaredNames) => {
           sdd.variableBodies.set(norm(name), bodySchema);
         }
         const category = norm(cellAt(row, categoryAt));
-        if (VARIABLE_PLACEMENT.has(category)) {
+        if (VARIABLE_PLACEMENT2.has(category)) {
           sdd.variableCategories.set(norm(name), category);
         }
         const boundTrigger = stripTicks(cellAt(row, sourceTriggersAt).trim()).trim();
@@ -4038,7 +4070,10 @@ var parseSdd = (text) => {
     caseConditionalSlas: [],
     xrefOutputs: xrefProducers(document),
     resourceOutputs: resourceOutputsByTask(document),
+    personas: [],
+    personaNotes: [],
     canvasNotes: [],
+    businessEvents: [],
     parseNotes: []
   };
   const lookalikes = [];
@@ -4053,7 +4088,7 @@ var parseSdd = (text) => {
     if (level !== 3)
       continue;
     const headingLine = lineAt(text, section.start);
-    if (applyCaseSection(sdd, title, body, headingLine, declaredNames))
+    if (applyCaseSection(sdd, title, body, headingLine, declaredNames, ownBodyOf(section)))
       continue;
     const stageName = readStageHeading(title);
     if (stageName !== undefined) {
@@ -4083,7 +4118,7 @@ var parseSdd = (text) => {
 };
 
 // src/services/strict-sdd-audit/entry.ts
-var parseSddToJson = (text) => {
+var parseSddToJson2 = (text) => {
   const sdd = parseSdd(text);
   return {
     stages: sdd.stages.map((stage) => ({
@@ -4145,7 +4180,12 @@ var parseSddToJson = (text) => {
     ...sdd.caseDescription !== undefined && {
       caseDescription: sdd.caseDescription
     },
+    personas: sdd.personas,
+    ...sdd.personaNotes.length > 0 && { personaNotes: sdd.personaNotes },
     ...sdd.canvasNotes.length > 0 && { canvasNotes: sdd.canvasNotes },
+    ...sdd.businessEvents.length > 0 && {
+      businessEvents: sdd.businessEvents
+    },
     intake: {
       caseExitRows: sdd.caseExitRows,
       sawVariableSection: sdd.sawVariableSection,
@@ -4153,8 +4193,8 @@ var parseSddToJson = (text) => {
     }
   };
 };
-var auditCaseplanAgainstSdd = (parsed, sddText, sddName, ledger) => {
-  const [parseError, sdd] = catchError(() => parseSdd(sddText));
+var auditCaseplanAgainstSdd2 = (parsed, sddText, sddName, ledger) => {
+  const [parseError, sdd] = catchError2(() => parseSdd(sddText));
   if (parseError instanceof SddNameCollisionError) {
     return [
       error("STRICT_SDD_NAME_COLLISION", sddName, `"${sddName}": ${parseError.message}`)
@@ -4171,6 +4211,6 @@ var auditCaseplanAgainstSdd = (parsed, sddText, sddName, ledger) => {
   issues.push(...slaReferenceFindings(sddText, sddName));
   return issues;
 };
-export { CASE_SLA_PROPERTY, VARIABLE_PLACEMENT, DEFAULT_GROUP, markDeferredOutputs, expandXrefs, expandOutputMarkers, declaredOutputs, outputTypeFor, outputFor, variableOutputType, extractOutputFor, customOutputFor, canonicalExpression, unquoteLiteral, inputsFor, STAGE_SELECTOR_RULES, TASK_SELECTOR_RULES, parseIfCell, bodySchemaIn, parseSddToJson, auditCaseplanAgainstSdd };
+export { CASE_SLA_PROPERTY, VARIABLE_PLACEMENT2, DEFAULT_GROUP2, parseSddToJson2, auditCaseplanAgainstSdd2 };
 
-//# debugId=1BFE2BF48D4AB38A64756E2164756E21
+//# debugId=0BFEE81926C8921664756E2164756E21