@uchibeke/gallivant 0.2.1 → 0.3.0

package/lib/task_contract.mjs

@@ -5,6 +5,8 @@ import { isDeepStrictEqual } from "node:util";
 import { parseSourcesMeta } from "./config.mjs";
 import { contentDigest } from "./start_contract.mjs";
 import { OWNER_DELIVERY_SECTION, validateOwnerDelivery } from "./owner_delivery.mjs";
+import { MAX_ANSWER_ID_CHARACTERS } from "./task_limits.mjs";
+import { FRAGMENT_VERSION, sourceFragmentVersion, sourceFragments, DELIVERY_PROFILE_SECTION, savedProfile, stableProfile, describeProfile, deliveryScreen, deliveryScreens, validateDeliveryTag, profileCovers, unaccountedTerms, deliveryReplyGrounded, deliveryQuestion, deliveryQuestionId, isDeliveryQuestion, profileAssumption } from "./task_profile.mjs";
 
 export const TASK_VERSION = 1;
 export const MAX_REPAIRS = 3;
@@ -44,12 +46,18 @@ export function requireText(value, name, max = MAX_INPUT_BYTES) {
 
 // Cover all nonblank input, rather than entrusting requirement extraction to a
 // model that could silently omit a sentence. IDs are immutable across repairs.
-export function fragments(text, prefix = "r") {
-  return text.split(/\r?\n/).map(s => s.trim()).filter(Boolean).map((text, i) => ({ id: `${prefix}-${i + 1}`, text }));
+// Each fragment records its exact UTF-16 span in the immutable source text, so
+// a mapping always points back at the owner's words rather than a paraphrase.
+export { FRAGMENT_VERSION, sourceFragmentVersion };
+export function fragments(text, prefix = "r", source = prefix === "r" ? "original" : `answer:${prefix.replace(/^a-/, "")}`, version = FRAGMENT_VERSION) {
+  return sourceFragments(text, { prefix, source, version });
+}
+export function fragmentsForTask(task, text, prefix = "r", source = prefix === "r" ? "original" : `answer:${prefix.replace(/^a-/, "")}`) {
+  return fragments(text, prefix, source, sourceFragmentVersion(task));
 }
 
 export function requireRequirementCapacity(requirements) {
-  if (requirements.length > MAX_REQUIREMENTS) throw Object.assign(new Error(`task has ${requirements.length} requirements; the mapping limit is ${MAX_REQUIREMENTS}; prepare a smaller task with fewer nonblank request and answer lines`), { code: "TASK_INPUT" });
+  if (requirements.length > MAX_REQUIREMENTS) throw Object.assign(new Error(`task has ${requirements.length} requirements; the mapping limit is ${MAX_REQUIREMENTS}; prepare a smaller task with fewer material request and answer clauses`), { code: "TASK_INPUT" });
   return requirements;
 }
 
@@ -57,10 +65,12 @@ export function requireRequirementCapacity(requirements) {
 // criteria, plus at least one story. Render the smallest possible organization
 // with the real quoting/clarification rules; this is a lower bound, not a draft.
 export function requireTaskCapacity(task) {
+  sourceFragmentVersion(task);
   if (task.ownerDelivery) {
     validateOwnerDelivery(task.ownerDelivery);
     if (task.original !== undefined && task.ownerDelivery.source !== task.original) throw Object.assign(new Error("Delivery ownership must preserve the exact original request"), { code: "TASK_DELIVERY_SCOPE" });
   }
+  savedProfile(task);
   requireRequirementCapacity(task.requirements);
   const minimum = {
     title: "Taskbrief", problem: "context ".repeat(40).trim(),
@@ -82,8 +92,8 @@ const line = (s, label, max = MAX_INPUT_BYTES) => {
   if (/[\r\n]/.test(s)) throw new Error(`${label} must be one line`);
   return s;
 };
-const list = (v, label) => {
-  if (!Array.isArray(v) || !v.length || v.length > 64) throw new Error(`${label} must have 1 to 64 entries`);
+const list = (v, label, max = 64) => {
+  if (!Array.isArray(v) || !v.length || v.length > max) throw new Error(`${label} must have 1 to ${max} entries`);
   return v;
 };
 
@@ -209,7 +219,7 @@ JSON schema (version 1):
 {"version":1,"title":"8 to 80 characters","problem":"at least 40 words",
 "stories":[{"id":"us-1","text":"As a user, I want an outcome, so that I can benefit.","requirements":["r-1"]}],
 "criteria":[{"id":"ac-1","text":"Given a condition, when an action occurs, then an observable outcome holds."}],
-"mapping":[{"requirementId":"r-1","criteria":["ac-1"]}],
+"mapping":[{"requirementId":"r-1","criteria":["ac-1"]},{"requirementId":"r-2","assumption":"exact text also listed in assumptions"},{"requirementId":"r-3","criteria":["ac-1"],"delivery":{"action":"pull_request","prohibits":["merge"]}}],
 "questions":[{"id":"q-r-1","text":"One concise material question?","requirements":["r-1"]}],
 "assumptions":["An explicitly identified assumption, or None."],
 "verify":["exact command from the supplied command candidates"],
@@ -218,8 +228,36 @@ JSON schema (version 1):
 "exclusions":["An explicit exclusion"]}
 
 Every immutable requirement ID must appear exactly once in mapping, with
-nonempty criteria OR a questionId from questions. Ask only material unknowns or
-conflicting constraints. Question IDs are stable q- identifiers; retain them on
+nonempty criteria, OR one explicit assumption string that also appears in
+assumptions (only for context or notes with no executable content; the caller
+still preserves the exact owner words in executable scope), OR a
+questionId from questions. Ask only material unknowns or conflicting constraints.
+deliveryProfile, when present, is the owner's typed delivery selection and the
+only delivery authority. Only when deliveryProfile is present and a clause asks for, forbids or conditions an
+external action (pull request, merge, deploy, release, publish including
+submitting or uploading a package or build to a registry or store, push,
+commit, branch, waiting for someone's approval or review, local-only output),
+add a delivery tag
+that reads the clause literally: action is what the clause asks for
+(pull_request, merge, deploy, release, publish, local_only, wait_for_approval,
+or restrict when it only forbids effects); prohibits lists effects it forbids
+(branch, commit, push, pull_request, merge, deploy, release, publish, and
+direct_push for a write aimed at the base branch or at skipping the pull
+request);
+completion is delivery_ready or integrated when the clause names one. target
+retains any named repository (owner/name) and/or base branch literally; never
+replace a requested destination with the selected profile's destination. Still map the clause's implementation
+content to criteria. Never drop, soften or rewrite such a clause, never treat
+the profile as satisfied by prose. For typed-profile tasks, never author new question IDs beginning with
+q-delivery-; the caller generates those from the profile. For typed-profile tasks, every fragment of an
+answer to a q-delivery- question must carry a delivery tag that reads the
+reply literally: restrict with the effects it explicitly forbids or the action
+it explicitly requests. An empty restriction or a tag unsupported by the reply's
+own text cannot resolve a delivery question; ask for an explicit restatement of
+the selected delivery action or prohibited effects. Historical tasks without a deliveryProfile
+must not emit delivery tags or adopt typed-profile question ownership. Retain every
+saved question ID, including q-delivery- IDs, with its original text and requirement
+ownership. Question IDs are stable q- identifiers; retain them on
 resumption. Each question's requirements must exactly match the requirements
 whose mappings use its questionId, without duplicates. A prior requirement
 resolved by an explicit answer may instead map
@@ -252,7 +290,14 @@ the original fragments remain unchanged. Generated rationale, assumptions,
 locations and exclusions cannot authorize, replace or override owner scope.
 
 INTAKE DATA (JSON):
-${JSON.stringify({ original: task.original, ...(task.ownerDelivery ? { ownerDelivery: task.ownerDelivery } : {}), requirements: task.requirements, answers: task.answers, questionHistory: task.questionHistory, repository: task.repo, base: task.base, harness: task.harness, context: task.context, commandCandidates: candidates.commands, commandSources: candidates.sources, commandIssues: candidates.issues, previous: task.output, validationFailures: failures })}`;
+${JSON.stringify({ original: task.original, ...(task.ownerDelivery ? { ownerDelivery: task.ownerDelivery } : {}), ...(savedProfile(task) ? { deliveryProfile: savedProfile(task) } : {}), requirements: task.requirements, answers: task.answers, questionHistory: task.questionHistory, repository: task.repo, base: task.base, harness: task.harness, ...(task.repositoryContext ? { repositoryContext: promptRepositoryContext(task.repositoryContext) } : {}), context: task.context, commandCandidates: candidates.commands, commandSources: candidates.sources, commandIssues: candidates.issues, previous: task.output, validationFailures: failures })}`;
+}
+
+// The snapshot reaches the planner as bounded metadata only: revision, digest
+// and tracked paths. Unavailable context is passed through as unavailable.
+function promptRepositoryContext(snapshot) {
+  if (snapshot.status !== "collected") return { status: snapshot.status, reason: snapshot.reason || null };
+  return { status: "collected", revision: snapshot.revision, digest: snapshot.digest, paths: snapshot.paths, counts: snapshot.counts };
 }
 
 export function parseDraft(message, task) {
@@ -274,7 +319,9 @@ export function parseDraft(message, task) {
     // Owner quotations plus the wrapper can exceed the raw input's byte limit.
     // The whole new or saved envelope remains bounded by the result limit.
     line(story.text, "story text", 256 * 1024);
-    list(story.requirements, "story requirements");
+    // Normalization carries assumption-mapped owner clauses into a story.
+    // Its requirement IDs have the same ceiling as the complete task mapping.
+    list(story.requirements, "story requirements", MAX_REQUIREMENTS);
     if (new Set(story.requirements).size !== story.requirements.length || story.requirements.some(id => !requirements.has(id))) throw new Error("story requirements must be unique authorized requirement IDs");
   });
   const criteria = new Set(output.criteria.map((c, i) => {
@@ -282,11 +329,18 @@ export function parseDraft(message, task) {
     line(c.text, "criterion", 256 * 1024);
     return c.id;
   }));
+  const profile = savedProfile(task);
   const questions = new Map();
   for (const q of output.questions) {
-    if (!/^q-[a-z0-9-]{1,64}$/.test(q.id) || questions.has(q.id)) throw new Error("question IDs must be unique stable q- identifiers");
-    line(q.text, "question");
-    if (q.text.length > 300) throw new Error("question exceeds 300 characters");
+    const savedDelivery = profile && isDeliveryQuestion(q.id) && q.id.length <= MAX_ANSWER_ID_CHARACTERS && task.questionHistory?.[q.id];
+    if ((!/^q-[a-z0-9-]{1,64}$/.test(q.id) && !(savedDelivery && /^q-[a-z0-9-]+$/.test(q.id))) || questions.has(q.id)) throw new Error("question IDs must be unique stable bounded q- identifiers; resume a saved oversized delivery question before answering it");
+    line(q.text, "question", 1024);
+    if (profile && isDeliveryQuestion(q.id)) {
+      // Reserved service questions are reproduced only from the profile and the
+      // immutable clause; a planner cannot author or vary them.
+      const requirement = requirements.get(q.requirements?.[0]);
+      if (!profile || !requirement || !isDeepStrictEqual(q, deliveryQuestion(profile, requirement, task))) throw new Error(`question ${q.id} is reserved for the delivery profile and must not be planner-authored`);
+    } else if (q.text.length > 300) throw new Error("question exceeds 300 characters");
     list(q.requirements, "question requirements");
     if (q.requirements.some(id => !requirements.has(id))) throw new Error("question names an unknown requirement");
     const previous = task.questionHistory[q.id];
@@ -298,12 +352,24 @@ export function parseDraft(message, task) {
   for (const m of output.mapping) {
     if (!requirements.has(m.requirementId) || seen.has(m.requirementId)) throw new Error("mapping has an unknown or duplicate requirement");
     seen.add(m.requirementId);
+    if (m.delivery !== undefined) {
+      if (!profile) throw new Error("delivery tags require a typed delivery profile; legacy tasks keep their saved contract");
+      validateDeliveryTag(m.delivery);
+    }
     if (m.questionId) {
-      if (m.criteria?.length || m.resolvedBy || !questions.get(m.questionId)?.requirements.includes(m.requirementId)) throw new Error(`invalid unresolved mapping for ${m.requirementId}`);
+      if (m.criteria?.length || m.assumption !== undefined || m.resolvedBy || !questions.get(m.questionId)?.requirements.includes(m.requirementId)) throw new Error(`invalid unresolved mapping for ${m.requirementId}`);
     } else {
-      list(m.criteria, "mapped criteria");
-      if (m.criteria.some(id => !criteria.has(id))) throw new Error("mapping names an unknown criterion");
-      for (const id of m.criteria) mappedCriteria.add(id);
+      if (m.assumption !== undefined) {
+        // An explicit assumption is a visible, reviewable target; it is never a
+        // silent omission and it cannot coexist with executable criteria.
+        if (m.criteria?.length) throw new Error(`mapping for ${m.requirementId} must select criteria or one explicit assumption, not both`);
+        line(m.assumption, "mapped assumption", 4096);
+        if (!output.assumptions.includes(m.assumption)) throw new Error(`mapped assumption for ${m.requirementId} must appear verbatim in assumptions`);
+      } else {
+        list(m.criteria, "mapped criteria");
+        if (m.criteria.some(id => !criteria.has(id))) throw new Error("mapping names an unknown criterion");
+        for (const id of m.criteria) mappedCriteria.add(id);
+      }
       if (m.resolvedBy) {
         if (!clarifications.get(m.requirementId)?.includes(m.resolvedBy)) throw new Error("only an explicit answer to a mapped question can resolve a conflicting requirement; saved question ownership is missing or inconsistent");
       }
@@ -323,15 +389,106 @@ export function parseDraft(message, task) {
     const missing = (candidates.sources[command] || []).filter(path => !paths.includes(path));
     if (missing.length) throw new Error(`Verify command ${command} requires carried sources: ${missing.join(", ")}`);
   }
-  if (!questions.size && !output.verify.length) throw new Error("no repository Verify command; ask a material question");
+  const generated = [];
+  // An answer to a delivery question clarifies the original conflict only when
+  // every fragment of that answer carries a typed reading the profile covers
+  // (or is itself clarified the same way). An anaphoric reply such as "Do it
+  // anyway" has no delivery vocabulary to screen, so without that reading the
+  // reply fragment gets its own question instead of closing the conflict.
+  const screens = profile ? requirementDeliveryScreens(task, profile.target) : new Map();
+  const unresolvedReplies = profile ? unresolvedDeliveryReplies(task, profile, output.mapping, screens) : new Set();
   const mapping = output.mapping.map(m => {
     const ids = clarifications.get(m.requirementId);
-    return !m.questionId && ids?.length ? { ...m, resolvedBy: ids.at(-1) } : m;
+    const base = !m.questionId && ids?.length ? { ...m, resolvedBy: ids.at(-1) } : m;
+    if (!profile || m.questionId) return base;
+    return screenMapping(task, profile, requirements.get(m.requirementId), base, generated, unresolvedReplies, screens.get(m.requirementId));
   });
-  const normalized = normalizeCriteria(task, { ...output, mapping });
+  for (const q of generated) if (!questions.has(q.id)) questions.set(q.id, q);
+  const withQuestions = { ...output, mapping, questions: [...output.questions, ...generated] };
+  mappedQuestions(withQuestions);
+  if (!questions.size && !output.verify.length) throw new Error("no repository Verify command; ask a material question");
+  const normalized = normalizeCriteria(task, withQuestions);
   return { ...normalized, ...deriveExecutableScope(task, normalized), sources: paths };
 }
 
+// Compare one mapped clause with the owner's typed profile. A planner tag that
+// the profile does not cover, or escalating delivery vocabulary the planner
+// left untagged, becomes a deterministic clarification; ordinary vocabulary
+// becomes a visible assumption. Nothing here can grant an external action.
+// Reply fragments of answered delivery questions that lack a covered typed
+// reading and whose own delivery question is not yet answered. Each is asked
+// about explicitly; a chain of replies resolves only when every link does.
+function requirementDeliveryScreens(task, target) {
+  const groups = new Map(), screens = new Map();
+  for (const requirement of task.requirements) {
+    const source = requirement.source?.of;
+    if (!groups.has(source)) groups.set(source, []);
+    groups.get(source).push(requirement);
+  }
+  for (const [source, requirements] of groups) {
+    const text = source === "original" ? task.original : source?.startsWith("answer:") ? task.answers?.[source.slice(7)] : null;
+    if (typeof text === "string") for (const [id, screen] of deliveryScreens(text, requirements, target)) screens.set(id, screen);
+    else for (const requirement of requirements) screens.set(requirement.id, deliveryScreen(requirement.text, target));
+  }
+  return screens;
+}
+function unresolvedDeliveryReplies(task, profile, entries, screens) {
+  const byId = new Map(entries.map(m => [m.requirementId, m]));
+  const answers = task.answers || {}, unresolved = new Set();
+  const resolved = requirementId => {
+    const entry = byId.get(requirementId), tag = entry?.delivery === undefined ? null : entry.delivery;
+    let covered = false;
+    try {
+      const reading = tag && validateDeliveryTag(tag);
+      const screen = screens.get(requirementId);
+      covered = Boolean(reading) && profileCovers(profile, reading).covered && unaccountedTerms(screen, reading).length === 0 && deliveryReplyGrounded(screen, reading);
+    } catch { covered = false; }
+    if (covered) return true;
+    const questionId = deliveryQuestionId(requirementId, task);
+    if (!Object.hasOwn(answers, questionId)) { unresolved.add(requirementId); return false; }
+    const replies = task.requirements.filter(r => r.id.startsWith(`a-${questionId}-`));
+    return replies.length > 0 && replies.map(r => resolved(r.id)).every(Boolean);
+  };
+  for (const id of Object.keys(answers)) {
+    if (!isDeliveryQuestion(id)) continue;
+    for (const reply of task.requirements.filter(r => r.id.startsWith(`a-${id}-`))) resolved(reply.id);
+  }
+  return unresolved;
+}
+
+const deliveryConflictReason = screen => [...(screen.targetConflicts || []), ...(screen.modeConflicts || []), ...(screen.externalConflicts || [])].join("; ");
+function screenMapping(task, profile, requirement, entry, generated, unresolvedReplies = new Set(), screen = deliveryScreen(requirement.text, profile.target)) {
+  const questionId = deliveryQuestionId(requirement.id, task);
+  const answered = Object.hasOwn(task.answers || {}, questionId);
+  const tag = entry.delivery === undefined ? null : validateDeliveryTag(entry.delivery);
+  const coverage = tag ? profileCovers(profile, tag) : null;
+  if (unresolvedReplies.has(requirement.id) && !answered) {
+    generated.push(deliveryQuestion(profile, requirement, task));
+    const { delivery: _d, covered: _c, screen: _s, conflict: _k, criteria: _cr, assumption: _a, resolvedBy: _r, ...unresolved } = entry;
+    const unaccounted = tag ? unaccountedTerms(screen, tag) : [];
+    return { ...unresolved, questionId, conflict: { reason: deliveryConflictReason(screen) || (tag ? (coverage.reason || (unaccounted.length ? `the planner reading does not account for ${unaccounted.join(", ")} in the reply` : "the reply must explicitly restate the supported delivery action or prohibited effects; its planner tag is not grounded in the reply text")) : "the reply to a delivery question carries no typed delivery reading the profile covers"), ...(tag ? { delivery: tag } : {}), screen } };
+  }
+  // Replies to delivery questions are screened like every other clause. An
+  // owner who insists on an action the profile does not perform gets the
+  // same deterministic question for the reply; only a planner reading that the
+  // profile covers (for example a `restrict` tag for a restated prohibition)
+  // lets escalating vocabulary in a reply map to criteria.
+  // A covered tag speaks only for the terms it names. Escalating terms (and,
+  // under a control word, effect terms) that the tag leaves unaccounted for
+  // keep the screen's own conflict, so "open a PR and deploy it" tagged as
+  // pull_request still asks about the deployment.
+  const unaccounted = tag ? unaccountedTerms(screen, tag) : [];
+  const conflict = tag ? !coverage.covered || unaccounted.length > 0 : screen.tier === "question";
+  const { delivery: _delivery, covered: _covered, screen: _screen, conflict: _conflict, ...rest } = entry;
+  if (conflict && !answered) {
+    generated.push(deliveryQuestion(profile, requirement, task));
+    const { criteria: _criteria, assumption: _assumption, resolvedBy: _resolvedBy, ...unresolved } = rest;
+    const reason = deliveryConflictReason(screen) || (tag ? (coverage.covered ? `the planner reading ${tag.action} does not account for ${unaccounted.join(", ")} in the clause` : coverage.reason) : `the clause mentions ${screen.terms.join(", ")} with ${screen.controls.join(", ") || "an escalating delivery term"}`);
+    return { ...unresolved, questionId, conflict: { reason, ...(tag ? { delivery: tag } : {}), screen } };
+  }
+  return { ...rest, ...(tag ? { delivery: tag, covered: coverage.covered } : {}), ...(screen.terms.length ? { screen: { terms: screen.terms, tier: conflict ? "clarified" : screen.tier } } : {}) };
+}
+
 // Criteria prose is derived from owner requirements, so two identical coverage
 // sets are the same criterion. Normalize only new completion-aware tasks: old
 // approved drafts/receipts retain their criterion IDs and are never rewritten.
@@ -376,7 +533,7 @@ function questionClarifications(task) {
     for (const requirementId of owned) for (const parent of origins.get(requirementId)?.scope || []) scope.add(parent);
     targets.set(id, scope);
     for (const requirementId of scope) result.set(requirementId, [...(result.get(requirementId) || []), id]);
-    for (const fragment of fragments(answer, `a-${id}`)) {
+    for (const fragment of fragmentsForTask(task, answer, `a-${id}`)) {
       if (requirements.get(fragment.id)?.text === fragment.text) origins.set(fragment.id, { index, scope });
     }
   }
@@ -401,8 +558,14 @@ function deriveExecutableScope(task, output) {
     return ` ${label} clarified requirement ${id}: ${quoteRequirement(requirements.get(id).text)}` + ids.map(q => ` ${label} answer ${q}: ${quoteRequirement(task.answers[q])} The answer governs any conflict with that requirement.`).join("") + (ids.length > 1 ? " Later answers govern conflicts with earlier answers." : "");
   };
   return {
-    stories: output.stories.map(s => ({ id: s.id, requirements: s.requirements,
-      text: "As a task owner, I want the quoted requirements fulfilled, so that the result matches my request." + s.requirements.map(id => quoted(id, "Owner")).join("") })),
+    // An assumption target organizes context; it cannot remove owner input
+    // from executable scope. Carry its exact words once in the first story,
+    // without trusting the planner to identify every language's imperatives.
+    stories: output.stories.map((s, index) => {
+      const ids = [...new Set([...s.requirements, ...(index === 0 ? output.mapping.filter(m => m.assumption !== undefined && !m.questionId).map(m => m.requirementId) : [])])];
+      return { id: s.id, requirements: ids,
+        text: "As a task owner, I want the quoted requirements fulfilled, so that the result matches my request." + ids.map(id => quoted(id, "Owner")).join("") };
+    }),
     criteria: output.criteria.map(c => ({ id: c.id,
       text: "Given the selected repository, when this task is implemented, then the following owner requirements hold." + output.mapping.filter(m => m.criteria?.includes(c.id)).map(m => quoted(m.requirementId)).join("") })),
   };
@@ -415,16 +578,27 @@ export function renderDraft(task, output) {
   const stories = scope.stories.map(s => `${s.text} Authorized requirements: ${s.requirements.join(", ")}.`);
   const mapped = scope.criteria.map(c => c.text);
   const clarifications = questionClarifications(task);
+  const profile = savedProfile(task);
+  const screened = [];
   const mapping = output.mapping.map(m => {
     const r = task.requirements.find(r => r.id === m.requirementId);
     const ids = clarifications.get(m.requirementId);
-    const target = (m.questionId ? `unresolved ${m.questionId}` : m.criteria.join(", ")) + (ids?.length ? `; clarified by answer ${ids.join(", ")}` : "");
+    // Exact source spans live in the structured requirement record and review;
+    // the brief quotes the owner's words verbatim and stays within the checker's
+    // word limit at full mapping capacity.
+    let target = m.questionId ? `unresolved ${m.questionId}` : m.assumption !== undefined ? `assumption ${quoteRequirement(m.assumption)}` : m.criteria.join(", ");
+    target += ids?.length ? `; clarified by answer ${ids.join(", ")}` : "";
+    if (m.conflict) target += `; delivery conflict: ${m.conflict.reason}`;
+    else if (m.delivery) target += `; delivery reading ${m.delivery.action}${m.covered ? " is covered by the typed profile" : " was clarified by the owner"}`;
+    if (m.screen?.tier === "assumption" && profile) screened.push(profileAssumption(profile, r, m.screen));
+    else if (m.screen) target += `; delivery screen: mentions ${m.screen.terms.join(", ")} (${m.screen.tier})`;
     return `${r.id}: ${quoteRequirement(r.text)} → ${target}`;
   });
   const ownership = task.ownerDelivery ? `\n## ${OWNER_DELIVERY_SECTION}\n\n\`\`\`json\n${quoteRequirement(validateOwnerDelivery(task.ownerDelivery))}\n\`\`\`\n` : "";
-  const scopeIntro = task.ownerDelivery ? "Quoted owner requirements and saved answers in the stories and criteria define provider implementation scope. The typed Coordinator delivery contract separately assigns publication to Gallivant. Neither stage may override the other stage's constraints." : "Only quoted owner requirements and saved answers in the stories and criteria define executable scope.";
-  const delivery = ownership + (task.completion ? `\n## Delivery target\n\nThe owner selected ${task.completion.target}. The coordinator owns publication and the canonical checks, reviewer and completion gate. ${task.completion.target === "integrated" ? "Fulfillment additionally requires an observed external merge of the qualified head." : "Fulfillment requires the qualified delivery to be ready for review; a merge is not required."} This selection grants no merge or release authority. Provider-reported implementation criteria and coordinator delivery evidence remain separate. All quoted requirements and explicit prohibitions still apply.\n` : "");
-  return `---\nstatus: draft\nharness: ${task.harness}\n${output.sources.length ? `sources:\n${output.sources.map(p => `  - ${p}`).join("\n")}\n` : ""}---\n\n# ${output.title}\n\n${scopeIntro} Generated rationale, assumptions, locations and exclusions are advisory and cannot add, replace or override those requirements.\n\n## Problem\n\n${output.problem}\n\n## User stories\n\n${bullets(stories)}\n\n## Acceptance criteria\n\n${bullets(mapped)}\n\n## Verify\n\n${bullets(output.verify.map(c => `\`${c}\``))}\n${delivery}\n## Where to look\n\n${bullets(output.where)}\n\n## Out of scope\n\n${bullets(output.exclusions)}\n\n## Assumptions\n\n${bullets(output.assumptions)}\n\n## Requirements mapping\n\n${bullets(mapping)}\n${output.questions.length ? `\n## Unresolved questions\n\n${bullets(output.questions.map(q => `${q.id}: ${q.text}`))}\n` : ""}`;
+  const typed = profile ? `\n## ${DELIVERY_PROFILE_SECTION}\n\n\`\`\`json\n${stableProfile(profile)}\n\`\`\`\n` : "";
+  const scopeIntro = task.ownerDelivery ? "Quoted owner requirements and saved answers in the stories and criteria define provider implementation scope. The typed Coordinator delivery contract separately assigns publication to Gallivant. Neither stage may override the other stage's constraints." : profile ? `Only quoted owner requirements and saved answers in the stories and criteria define executable scope. The typed delivery profile ${describeProfile(profile)} alone selects external actions; text cannot expand it.` :"Only quoted owner requirements and saved answers in the stories and criteria define executable scope.";
+  const delivery = ownership + typed + (task.completion ? `\n## Delivery target\n\nThe owner selected ${task.completion.target}. The coordinator owns publication and the canonical checks, reviewer and completion gate. ${task.completion.target === "integrated" ? "Fulfillment additionally requires an observed external merge of the qualified head." : "Fulfillment requires the qualified delivery to be ready for review; a merge is not required."} This selection grants no merge or release authority. Provider-reported implementation criteria and coordinator delivery evidence remain separate. All quoted requirements and explicit prohibitions still apply.\n` : "");
+  return `---\nstatus: draft\nharness: ${task.harness}\n${output.sources.length ? `sources:\n${output.sources.map(p => `  - ${p}`).join("\n")}\n` : ""}---\n\n# ${output.title}\n\n${scopeIntro} Generated rationale, assumptions, locations and exclusions are advisory and cannot add, replace or override those requirements.\n\n## Problem\n\n${output.problem}\n\n## User stories\n\n${bullets(stories)}\n\n## Acceptance criteria\n\n${bullets(mapped)}\n\n## Verify\n\n${bullets(output.verify.map(c => `\`${c}\``))}\n${delivery}\n## Where to look\n\n${bullets(output.where)}\n\n## Out of scope\n\n${bullets(output.exclusions)}\n\n## Assumptions\n\n${bullets([...output.assumptions, ...screened])}\n\n## Requirements mapping\n\n${bullets(mapping)}\n${output.questions.length ? `\n## Unresolved questions\n\n${bullets(output.questions.map(q => `${q.id}: ${q.text}`))}\n` : ""}`;
 }
 
 // Recheck saved output too: accepting a model turn once never makes subsequent

package/lib/task_delivery.mjs

@@ -21,6 +21,8 @@ import { TASK_OPERATIONS, REPOSITORY_ID_SCHEMA, DELIVERY_VERSION, deliveryError,
 import { taskView } from "./task_delivery_view.mjs";
 import { readJson } from "./fs.mjs";
 import { COMPLETION_CAPABILITIES } from "./task_completion.mjs";
+import { DELIVERY_CAPABILITIES } from "./task_profile.mjs";
+import { intakeModelRouteSummary } from "./task_model_config.mjs";
 const validators = new Map(TASK_OPERATIONS.map(op => [op.name, new Ajv({ strict: true, allErrors: true }).compile(op.inputSchema)]));
 const validRepositoryId = new Ajv({ strict: true }).compile(REPOSITORY_ID_SCHEMA);
 const hash = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
@@ -76,7 +78,12 @@ export function createTaskDelivery({ authorize, contextFor, store, schedule, man
       const ids = [...new Set(scope.repositories)].sort().filter(id => !input.cursor || id > input.cursor);
       for (const id of ids.slice(0, 100)) {
         const { ctx } = await getContext(id);
-        repositories.push({ id, completion: COMPLETION_CAPABILITIES, providers: executionCapabilities().map(capability => ({ ...capability,
+        // Delivery actions and the model route are operator/server facts: no
+        // endpoint, credential name or budget secret leaves this projection.
+        const modelRoute = intakeModelRouteSummary(ctx.config, ctx.env ?? process.env);
+        repositories.push({ id, completion: COMPLETION_CAPABILITIES, delivery: DELIVERY_CAPABILITIES, routes: ["harness", "model"],
+          modelRoute: { enabled: modelRoute.enabled, adapter: modelRoute.adapter, model: modelRoute.model, budget: modelRoute.budget, ceilings: modelRoute.ceilings, tools: [], reason: modelRoute.enabled ? null : "APort must configure intake_model and its credential for this account" },
+          providers: executionCapabilities().map(capability => ({ ...capability,
           configured: Boolean(ctx.config.harness[capability.name]),
           available: capability.available && Boolean(ctx.config.harness[capability.name]),
           accountAccess: "unverified-until-setup-check", setup: capability.reason || (!ctx.config.harness[capability.name] ? "APort must configure this provider for the authorized account" : "Dispatch validates the configured account/model/environment and allowance"),
@@ -175,7 +182,7 @@ export function createTaskDelivery({ authorize, contextFor, store, schedule, man
         let result, cancellationPending;
         const shared = { taskId: input.taskId, expectedRevision: input.expectedRevision, noDaemon: true };
         try {
-        if (name === "prepare") result = await service.prepare({ text: input.text, dir: repository.dir, repo: repository.repo, harness: input.harness, context: ctxPaths, verifyCommands: input.verifyCommands || [], completion: input.completion, requestId: hash([scopeKey(scope), key]), noDaemon: true });
+        if (name === "prepare") result = await service.prepare({ text: input.text, dir: repository.dir, repo: repository.repo, harness: input.harness, context: ctxPaths, verifyCommands: input.verifyCommands || [], completion: input.completion, delivery: input.delivery, route: input.route ?? null, requestId: hash([scopeKey(scope), key]), noDaemon: true });
         else if (name === "answer") result = await service.answer({ ...shared, answers: input.answers, verifyCommands: input.verifyCommands || [], operationId: key });
         else if (name === "control") {
           if (!task.implementation) throw deliveryError("DELIVERY_CONTROL", "No implementation exists to control");

package/lib/task_delivery_contract.mjs

@@ -1,15 +1,19 @@
 // Portable wire contract. No filesystem, credentials, configuration or providers.
 import { COMPLETION_SCHEMA } from "./task_completion.mjs";
+import { DELIVERY_PROFILE_SCHEMA } from "./task_profile.mjs";
+import { MAX_ANSWER_BYTES, MAX_ANSWER_CHARACTERS, MAX_ANSWER_COUNT, MAX_LEGACY_ANSWER_COUNT, MAX_ANSWER_ID_CHARACTERS } from "./task_limits.mjs";
 export { COMPLETION_SCHEMA, COMPLETION_CAPABILITIES, coordinatorEntryActive } from "./task_completion.mjs";
+export { DELIVERY_PROFILE_SCHEMA, DELIVERY_CAPABILITIES, PROFILE_VERSION } from "./task_profile.mjs";
+export const ROUTE_SCHEMA = Object.freeze({ type: "string", enum: ["harness", "model"] });
 export const DELIVERY_VERSION = 1;
-export const CORE_VERSION = "0.2.1";
+export const CORE_VERSION = "0.3.0";
 // One byte limit for the built APort MCP resource, package and runtime reader.
 export const MAX_TASK_UI_BYTES = 2_000_000;
 export const deliveryError = (code, message) => Object.assign(new Error(message), { code, version: DELIVERY_VERSION });
 // Only the delivery receipt boundary may label a bounded/redacted rejection.
-// Arbitrary provider errors with a TASK_* code must not expose their message.
+// Arbitrary provider errors cannot expose their message by copying a code.
 const settledRejections = new WeakMap();
-const safeRejectionCodes = new Set(["DELIVERY_CONFLICT", "TASK_INPUT", "TASK_DELIVERY_SCOPE", "TASK_CONFLICT", "TASK_NOT_READY", "TASK_AUTHORIZATION", "TASK_SECRET", "TASK_PREPARATION_BOUNDARY"]);
+const safeRejectionCodes = new Set(["EXECUTION_UNAVAILABLE", "DELIVERY_CONFLICT", "TASK_INPUT", "TASK_DELIVERY_SCOPE", "TASK_CONFLICT", "TASK_NOT_READY", "TASK_AUTHORIZATION", "TASK_SECRET", "TASK_PREPARATION_BOUNDARY", "TASK_MODEL_ROUTE", "TASK_PROFILE_UNSUPPORTED"]);
 export function settledTaskRejection(code, message) {
   const error = deliveryError(code, message);
   if (safeRejectionCodes.has(code) && typeof message === "string") settledRejections.set(error, { code, message: message.slice(0, 500) });
@@ -17,10 +21,10 @@ export function settledTaskRejection(code, message) {
 }
 export const taskRejectionForModel = error => settledRejections.get(error) || null;
 
-const id = { type: "string", pattern: "^[A-Za-z0-9_-]{1,128}$" };
+const id = { type: "string", maxLength: MAX_ANSWER_ID_CHARACTERS, pattern: "^[A-Za-z0-9_-]{1,128}$" };
 export const REPOSITORY_ID_SCHEMA = { type: "string", maxLength: 128, pattern: "^[A-Za-z0-9_-][A-Za-z0-9_.-]*(/[A-Za-z0-9_-][A-Za-z0-9_.-]*)*$" };
 const taskId = { type: "string", pattern: "^task-[a-f0-9]{24}$" };
-const text = { type: "string", minLength: 1, maxLength: 32768 };
+const text = { type: "string", minLength: 1, maxLength: MAX_ANSWER_CHARACTERS };
 const revision = { type: "integer", minimum: 1 };
 const verifyCommands = { type: "array", maxItems: 32, uniqueItems: true, items: { type: "string", minLength: 1, maxLength: 500 } };
 const object = (properties, required = Object.keys(properties)) => ({ type: "object", properties, required, additionalProperties: false });
@@ -31,12 +35,12 @@ const definition = (name, description, inputSchema, { write = false, destructive
 });
 export const TASK_OPERATIONS = Object.freeze([
   definition("capabilities", "Read up to 100 authorized repositories and configured harness capabilities; pass nextCursor as cursor for more. Does not probe providers.", object({ cursor: REPOSITORY_ID_SCHEMA }, [])),
-  definition("prepare", "Prepare requirements using an authorized repository and allowance; may use paid inference.", object({
-    repositoryId: REPOSITORY_ID_SCHEMA, text, harness: id, contextIds: { type: "array", items: id, maxItems: 100, uniqueItems: true }, verifyCommands, completion: COMPLETION_SCHEMA,
+  definition("prepare", "Prepare requirements using an authorized repository and allowance; may use paid inference. The typed delivery profile (action, completion) is the only delivery authority; request text cannot expand it. route selects the connected harness or the operator's bounded model route.", object({
+    repositoryId: REPOSITORY_ID_SCHEMA, text, harness: id, contextIds: { type: "array", items: id, maxItems: 100, uniqueItems: true }, verifyCommands, completion: COMPLETION_SCHEMA, delivery: DELIVERY_PROFILE_SCHEMA, route: ROUTE_SCHEMA,
     allowance: object({ budgetUsd: { type: "number", exclusiveMinimum: 0 }, runtimeMs: { type: "integer", minimum: 1 } }),
     operationId: id, expectedRevision: { type: "integer", const: 0 },
   }, ["repositoryId", "text", "harness", "allowance", "operationId", "expectedRevision"]), { write: true, open: true }),
-  definition("answer", "Answer saved question IDs and optionally select verification commands on the expected revision; may continue paid preparation.", mutation({ taskId, answers: { type: "object", minProperties: 1, maxProperties: 100, propertyNames: id, additionalProperties: text }, verifyCommands }, ["taskId", "answers"]), { write: true, open: true }),
+  definition("answer", `Answer saved question IDs on the expected revision; new operations allow at most ${MAX_ANSWER_COUNT} answers and ${MAX_ANSWER_BYTES} combined UTF-8 bytes across question IDs and strings. Exact saved retries may contain up to ${MAX_LEGACY_ANSWER_COUNT} saved answers. Optionally select up to 32 verification commands. New over-limit answer batches return TASK_INPUT. May continue paid preparation.`, mutation({ taskId, answers: { type: "object", minProperties: 1, maxProperties: MAX_LEGACY_ANSWER_COUNT, propertyNames: id, additionalProperties: text }, verifyCommands }, ["taskId", "answers"]), { write: true, open: true }),
   definition("resume", "Resume owned preparation without allocating another task.", mutation({ taskId }), { write: true, open: true }),
   definition("validate", "Run the canonical readiness gate and preserve its decision.", mutation({ taskId }), { write: true, open: true }),
   definition("start", "Start the exact approved task revision with explicit execution authorization.", mutation({ taskId, run: { type: "boolean", const: true } }), { write: true, open: true }),
@@ -48,7 +52,7 @@ export const TASK_OPERATIONS = Object.freeze([
 ]);
 
 export function assertCompatible({ coreVersion, operationVersion, taskVersion, executionVersion }) {
-  if (!/^0\.2\.\d+$/.test(coreVersion || "") || operationVersion !== DELIVERY_VERSION || taskVersion !== 1 || executionVersion !== 1) {
+  if (!/^0\.3\.\d+$/.test(coreVersion || "") || operationVersion !== DELIVERY_VERSION || taskVersion !== 1 || executionVersion !== 1) {
     throw deliveryError("DELIVERY_VERSION", "Incompatible core or contract. Stop wake-ups, back up the durable namespace, migrate with a compatible package, or restore the matching package and state backup. Never replace active-job code.");
   }
 }

package/lib/task_delivery_view.mjs

@@ -1,3 +1,4 @@
+import { pullRequestUrl } from "./host_definitions.mjs";
 import { DELIVERY_VERSION } from "./task_delivery_contract.mjs";
 import { redact } from "./execution_io.mjs";
 
@@ -7,13 +8,19 @@ export function taskView(task, { entry = null, run = null, result = null, verifi
   // the implementation owns an execution, without polling from the projection.
   const ex = run?.execution || entry?.execution || task.preparation?.attempts?.at(-1)?.execution || {};
   const pr = task.implementation?.pr || entry?.pr || null;
-  const url = pr && /^[-\w.]+\/[-\w.]+$/.test(task.repo) ? `https://github.com/${task.repo}/pull/${Number(pr)}` : null;
+  const url = pr ? pullRequestUrl(task.repo, pr) : null;
   return redact({ version: DELIVERY_VERSION, taskId: task.taskId, revision: task.revision, status: task.status,
     repo: task.repo, base: task.base, harness: task.harness, original: task.original,
     questions: task.questions, answers: task.answers, requirements: task.requirements,
     assumptions: task.assumptions, mapping: task.mapping, stories: task.stories,
     brief: task.draft ? { hash: task.draft.hash, revision: task.draft.revision, current: task.draft.current, text: task.draft.text } : null,
     readiness: task.readiness, validation: task.validation, allowance: task.preparation?.allowance, completion: task.completion,
+    // One revision-pinned review: immutable request, clause map, open questions,
+    // assumptions, draft, typed profile, harness, allowance, route and cost.
+    deliveryProfile: task.deliveryProfile ?? null, route: task.route ?? "harness", modelRoute: task.modelRoute ?? null, cost: task.cost ?? null,
+    repositoryContext: task.repositoryContext ? { status: task.repositoryContext.status, revision: task.repositoryContext.revision, digest: task.repositoryContext.digest, counts: task.repositoryContext.counts, reason: task.repositoryContext.reason ?? null } : null,
+    review: task.review ? { ...task.review, draft: task.review.draft ? { hash: task.review.draft.hash, revision: task.review.draft.revision, text: task.review.draft.text } : null, repositoryContext: task.review.repositoryContext ? { status: task.review.repositoryContext.status, revision: task.review.repositoryContext.revision, digest: task.review.repositoryContext.digest } : null } : null,
+    approval: task.approval ?? null,
     failures: task.failures, errorCode: task.errorCode, nextAction: task.nextAction,
     progress: { workflowState: entry?.state || task.status, providerState: ex.providerState || null,
       observedAt: ex.observedAt || null, reconciledAt: ex.reconciledAt || null, nextAttemptAt: ex.nextAttemptAt || null,
@@ -32,7 +39,11 @@ export function taskView(task, { entry = null, run = null, result = null, verifi
 export function modelSummary(view) {
   // Only bounded redacted recovery reasons enter model context; raw diagnostics,
   // briefs and logs remain in the explicit UI/evidence projection.
+  const profile = view.deliveryProfile;
   return { version: view.version, taskId: view.taskId, revision: view.revision, status: view.status, harness: view.harness, repo: boundedText(view.repo, 256), completion: view.completion,
+    deliveryProfile: profile ? { version: profile.version ?? null, action: boundedText(profile.action, 64), completion: boundedText(profile.completion?.condition, 64), legacy: profile.legacy === true, supported: profile.supported !== false } : null,
+    route: boundedText(view.route, 16), cost: view.cost ? { status: boundedText(view.cost.status, 32), usd: Number.isFinite(view.cost.usd) ? view.cost.usd : null } : null,
+    review: view.review ? { revision: view.review.revision, digest: boundedText(view.review.digest, 128), openQuestions: (view.review.questions || []).length, approved: Boolean(view.approval) } : null,
     recovery: view.status === "blocked" ? {
       code: /^TASK_[A-Z_]{1,64}$/.test(view.errorCode || "") ? view.errorCode : "TASK_BLOCKED",
       reasons: (Array.isArray(view.failures) ? view.failures : []).slice(0, 5).map(reason => boundedText(reason, 500)).filter(Boolean),
@@ -48,7 +59,12 @@ export function modelSummary(view) {
 // fields are projected; server config, paths and arbitrary adapter extras stay out.
 export function capabilitySummary(view) {
   return { version: view.version, repositories: view.repositories.slice(0, 100).map(repo => ({
-    id: repo.id, completion: repo.completion, providers: repo.providers.map(provider => ({
+    id: repo.id, completion: repo.completion,
+    // The typed delivery actions and planner routes a prepare call selects from.
+    // The model route summary carries no endpoint, credential name or key.
+    delivery: repo.delivery ?? null, routes: repo.routes ?? ["harness"],
+    modelRoute: repo.modelRoute ? { enabled: repo.modelRoute.enabled === true, adapter: repo.modelRoute.adapter ?? null, model: repo.modelRoute.model ?? null, budget: repo.modelRoute.budget ?? null, ceilings: repo.modelRoute.ceilings ?? null, tools: [], reason: repo.modelRoute.reason ?? null } : null,
+    providers: repo.providers.map(provider => ({
       name: provider.name, configured: provider.configured, available: provider.available,
       transport: provider.transport, continuation: provider.continuation,
       controls: { cancel: provider.controls?.cancel, interrupt: provider.controls?.interrupt },

package/lib/task_environment.mjs

@@ -95,6 +95,9 @@ export function preparationEnvironment(harness, cwd, adapterEnv, source = proces
   const nativeData = providerPath(source.XDG_DATA_HOME || join(nativeHome, ".local/share"));
   const nativeState = providerPath(source.XDG_STATE_HOME || join(nativeHome, ".local/state"));
   const home = ensureDir(join(cwd, "home"));
+  if (!isInside(realpathSync(home), realpathSync(cwd)) || realpathSync(home) === realpathSync(cwd)) {
+    throw taskError("TASK_PREPARATION_ENV", "the private preparation home must remain inside its workspace; remove the unsafe alias before retrying");
+  }
   const config = ensureDir(join(home, ".config")), data = ensureDir(join(home, ".local/share")), state = ensureDir(join(home, ".local/state"));
   const env = { ...pick(source, BASICS), ...pick(source, adapterFor(harness).preparationEnv), ...adapterEnv,
     HOME: home, USERPROFILE: home, XDG_CONFIG_HOME: config, XDG_DATA_HOME: data, XDG_STATE_HOME: state, XDG_CACHE_HOME: ensureDir(join(home, ".cache")),
@@ -206,7 +209,16 @@ export function preparationEnvironment(harness, cwd, adapterEnv, source = proces
   const googleAdc = () => carry(join(nativeConfig, "gcloud/application_default_credentials.json"), join(config, "gcloud/application_default_credentials.json"));
   if (harness === "codex") {
     env.CODEX_HOME = join(home, ".codex");
-    profile(providerPath(source.CODEX_HOME || join(nativeHome, ".codex")), env.CODEX_HOME, ["auth.json", "config.toml", "managed_config.toml", "requirements.toml", "hooks.json", "rules", "plugins", "skills"]);
+    const selectedHome = providerPath(source.CODEX_HOME || join(nativeHome, ".codex"));
+    selectedResource(selectedHome); // Reject source/private overlap before cleanup.
+    // Rebuild the private root as well as omitting disabled caches. A reused
+    // pre-fix home can contain aliases into the native profile; unlink aliases
+    // without following them before writing any selected authentication file.
+    rmSync(env.CODEX_HOME, { recursive: true, force: true });
+    // Preparation verifies plugins and skills disabled before inference. Their
+    // potentially huge caches are neither provider credentials nor selected
+    // context; copying them for every review piece wastes disk and startup I/O.
+    profile(selectedHome, env.CODEX_HOME, ["auth.json", "config.toml", "managed_config.toml", "requirements.toml", "hooks.json", "rules"]);
   } else if (harness === "claude") {
     env.CLAUDE_CONFIG_DIR = join(home, ".claude");
     const from = providerPath(source.CLAUDE_CONFIG_DIR || join(nativeHome, ".claude"));

package/lib/task_limits.mjs

@@ -0,0 +1,13 @@
+// Keep the public answer schema and coordinator-side work limits aligned.
+// A single answer keeps the normal task-text bound; a batch may not multiply it.
+export const MAX_ANSWER_COUNT = 100;
+// The earlier in-process service could accept every question in a 128-item
+// planner output as one answer operation; only new operations use the lower cap.
+export const MAX_LEGACY_ANSWER_COUNT = 128;
+export const MAX_ANSWER_CHARACTERS = 32 * 1024;
+export const MAX_ANSWER_BYTES = 32 * 1024;
+// Prior releases bounded each answer and ID individually but not their batch.
+// This is the largest aggregate that could have passed those checks, so exact
+// stored-operation retries remain compatible without reopening unbounded hashes.
+export const MAX_ANSWER_ID_CHARACTERS = 128;
+export const MAX_LEGACY_ANSWER_BATCH_BYTES = MAX_LEGACY_ANSWER_COUNT * (MAX_ANSWER_CHARACTERS + MAX_ANSWER_ID_CHARACTERS);