@staix/agent-hub 0.17.0 → 0.19.0

package/src/hub/dogfood-profile.ts

@@ -0,0 +1,248 @@
+import type { DogfoodInput, Source } from "./dogfood.ts";
+import { CLASSES, type TaskState } from "./board.ts";
+import { PII_CATEGORIES, type ScreenItem, type ScreenMiss, type ScreenRecord } from "./inference.ts";
+import type { Attribution } from "./attribution.ts";
+import { PROFILE_NAMES, projectProfile, type ProfileName } from "./profiles.ts";
+import { summarizeByTask } from "./report.ts";
+import type { StampedEvent } from "./events.ts";
+
+export interface ProfileHistory {
+  at: number; event: string; criteria?: string[]; criteriaPrivate?: true; deliverables?: string[];
+}
+export interface ProfileTaskMetadata {
+  profile: ProfileName; state?: string; class: string; alias: string | null; history: ProfileHistory[];
+  plan?: { sources: number | null; claims: number | null };
+}
+const complete = (s: Source<unknown>) => s.available && s.complete;
+const number = (n: unknown): n is number => typeof n === "number" && Number.isFinite(n) && n >= 0;
+const declarationCount = (n: unknown): n is number => Number.isSafeInteger(n) && (n as number)>=0 && (n as number)<=50;
+const positive = (n: unknown): n is number => Number.isSafeInteger(n) && (n as number) > 0;
+const peer = (s: string) => /^[a-z][a-z0-9-]{0,63}$/.test(s) && !Object.hasOwn(Object.prototype, s);
+export const dogfoodProfileName = (s: unknown): s is ProfileName => typeof s === "string" && (PROFILE_NAMES as readonly string[]).includes(s);
+const baseClass = (s: unknown): s is string => typeof s === "string" && (CLASSES as readonly string[]).includes(s);
+const criterion = (s: unknown): s is string => typeof s === "string" && /^[A-Za-z][A-Za-z0-9-]{0,47}$/.test(s);
+
+// Exhaustive maps make producer union changes a compile-time review point.
+const taskStates: Record<TaskState,true> = {backlog:true,proposed:true,in_progress:true,in_review:true,approved:true,changes_requested:true,cancelled:true};
+const usageSources: Record<Extract<StampedEvent,{type:"usage"}>["source"],true> = {omniroute:true,claude_transcript:true,claude_result:true,codex_appserver:true,kimi_wire:true};
+const attributions: Record<Attribution,true> = {delivery:true,single_open:true,unattributed:true};
+const screenItems: Record<ScreenItem,true> = {task:true,summary:true,"review note":true,handoff:true,note:true};
+const screenMisses: Record<ScreenMiss,true> = {"too long":true,"off campus":true,timeout:true,unreadable:true,failed:true};
+const screenSources: Record<ScreenRecord["source"],true> = {regex:true,screen:true,unknown:true,inherited:true};
+const screenLabels: Record<ScreenRecord["label"],true> = {pii:true,clear:true};
+const member = (value: unknown, choices: object) => typeof value === "string" && Object.hasOwn(choices,value);
+
+/** One validation boundary for the profile consumer and its bounded collector. Unknown event types stay forward compatible. */
+export function profileEventValid(value: unknown): boolean {
+  if (!value || typeof value!=="object" || Array.isArray(value)) return false;
+  const e=value as Record<string,unknown>;
+  if (e.v!==1 || typeof e.at!=="string" || !Number.isFinite(Date.parse(e.at)) || typeof e.type!=="string") return false;
+  const optional = (key:string, valid:(value:unknown)=>boolean) => e[key]===undefined || valid(e[key]);
+  const text = (value:unknown): value is string => typeof value==="string" && value.length>0;
+  const peerId = (value:unknown) => typeof value==="string" && peer(value);
+  const strings = (value:unknown) => Array.isArray(value) && value.every(v=>typeof v==="string");
+  const bool = (value:unknown) => typeof value==="boolean";
+  const oneOf = (value:unknown, choices:readonly string[]) => typeof value==="string" && choices.includes(value);
+  const taskId = () => optional("task",positive);
+  if (e.type==="task") {
+    return positive(e.id) && baseClass(e.class) && text(e.event)
+      && member(e.state,taskStates)
+      && optional("profile",dogfoodProfileName) && optional("profileClass",v=>typeof v==="string" && /^[a-z][a-z0-9_]{0,47}$/.test(v))
+      // Older metadata projections may omit privacy; absence remains conservative at event-only binding.
+      && optional("pii",bool) && optional("by",peerId)
+      && optional("owner",v=>v===null || peerId(v)) && optional("reviewer",v=>v===null || peerId(v));
+  }
+  if (e.type==="overlap") {
+    return positive(e.task) && optional("owner",peerId) && Array.isArray(e.others) && e.others.every(other=>{
+      if (!other || typeof other!=="object" || Array.isArray(other)) return false;
+      return positive(other.task) && strings(other.paths) && (other.owner===undefined || peerId(other.owner))
+        && (other.symbols===undefined || strings(other.symbols));
+    });
+  }
+  if (e.type==="conflict") {
+    return taskId() && positive(e.other) && strings(e.paths) && bool(e.concurrent)
+      && optional("peer",peerId) && optional("owner",peerId)
+      && optional("turns",v=>Array.isArray(v) && v.length===2 && v.every(text));
+  }
+  if (e.type==="tokens" || e.type==="usage" || e.type==="turn_end") {
+    if (!peerId(e.peer) || !taskId() || !optional("pii",bool)
+      || !optional("attribution",v=>member(v,attributions))) return false;
+    if ((e.attribution==="delivery" || e.attribution==="single_open") && !positive(e.task)) return false;
+    if (e.type==="tokens") return number(e.n);
+    if (e.type==="turn_end") return number(e.ms) && optional("turn",text) && optional("snapshotMs",number) && optional("tokens",number) && optional("files",number);
+    return text(e.id) && member(e.source,usageSources)
+      && ["inputTokens","outputTokens","cacheReadTokens","cacheWriteTokens","totalTokens","reasoningTokens"].every(key=>optional(key,number))
+      && optional("measuredAt",v=>typeof v==="string" && Number.isFinite(Date.parse(v)));
+  }
+  if (e.type==="pii_screen") {
+    return taskId() && member(e.item,screenItems) && member(e.label,screenLabels)
+      && member(e.source,screenSources) && optional("ms",number)
+      && optional("category",v=>oneOf(v,PII_CATEGORIES))
+      && optional("miss",v=>member(v,screenMisses));
+  }
+  return true;
+}
+
+/** Private custom aliases never become grouping keys; public aliases remain bounded stored identifiers. */
+export function dogfoodAlias(profile: ProfileName, base: string, raw: unknown, privateTask: boolean): string | null {
+  if (raw == null) return baseClass(base) ? base : null;
+  if (typeof raw !== "string" || !/^[a-z][a-z0-9_]{0,47}$/.test(raw) || Object.hasOwn(Object.prototype, raw)) return "withheld";
+  if (Object.hasOwn(projectProfile(profile).classes, raw) && projectProfile(profile).classes[raw] === base) return raw;
+  return privateTask ? "withheld" : raw;
+}
+
+type BoundTask = { id: number; pii: boolean; metadata: ProfileTaskMetadata; full: boolean };
+function quantiles(values: number[]) {
+  values.sort((a,b) => a-b);
+  const at = (q: number) => values.length ? values[Math.ceil(values.length*q)-1]! : null;
+  return { samples: values.length, p50: at(.5), p90: at(.9) };
+}
+
+/** Additive metadata projection. No PR, file, model or config execution and no telemetry inference from prose. */
+export function profileScorecard(input: DogfoodInput) {
+  // Do not trust a direct Source caller's completeness claim after a malformed consumed record.
+  const validEvents=input.events.data.filter(profileEventValid);
+  input={...input,events:{...input.events,data:validEvents,complete:input.events.complete && validEvents.length===input.events.data.length}};
+  const inWindow = (at: number) => number(at) && at >= input.since && at <= input.until;
+  const events = input.events.data.filter(e => inWindow(Date.parse(e.at)));
+  const bindingLimit = 500;
+  let bindingsTruncated = false;
+  const observedProfiles = new Set<ProfileName>();
+  const bound = new Map<number, BoundTask>();
+  for (const task of input.tasks.data) {
+    const m = task.profileMetadata;
+    if (!positive(task.id) || !m || !dogfoodProfileName(m.profile) || !baseClass(m.class)) continue;
+    if (m.history.some(h=>inWindow(h.at))) observedProfiles.add(m.profile);
+    if (!bound.has(task.id) && bound.size>=bindingLimit) { bindingsTruncated=true; continue; }
+    bound.set(task.id, {id: task.id, pii: task.pii, metadata: {...m, alias: dogfoodAlias(m.profile,m.class,m.alias,task.pii)}, full: complete(input.tasks)});
+  }
+  // Index at most 500 identities once. Beyond-cap profile names remain visible, but never aliases or task rows.
+  const taskEvents = new Map<number, Extract<StampedEvent,{type:"task"}>[]>([...bound.keys()].map(id=>[id,[]]));
+  let eventBindingsComplete = true;
+  for (const e of events) {
+    if (e.type!=="task") continue;
+    if (dogfoodProfileName(e.profile)) observedProfiles.add(e.profile);
+    if (!positive(e.id)) {eventBindingsComplete=false;continue;}
+    if (!taskEvents.has(e.id)) {
+      if (!dogfoodProfileName(e.profile) || !baseClass(e.class)) {eventBindingsComplete=false;continue;}
+      if (taskEvents.size>=bindingLimit) {bindingsTruncated=true;eventBindingsComplete=false;continue;}
+      taskEvents.set(e.id,[]);
+    }
+    taskEvents.get(e.id)!.push(e);
+  }
+  // Event windows prove recorded milestones, but cannot restore pre-window history or first-pass review.
+  for (const [id, recorded] of taskEvents) {
+    const existing = bound.get(id);
+    if (existing) { if (recorded.some(e=>e.pii)) existing.pii=true; continue; }
+    const e=recorded.find(e=>dogfoodProfileName(e.profile) && baseClass(e.class));
+    if (!e || !dogfoodProfileName(e.profile)) {eventBindingsComplete=false;continue;}
+    const privateTask=recorded.some(e=>e.pii!==false);
+    const history=recorded.map(e=>({at:Date.parse(e.at),event:e.event}));
+    bound.set(id,{id,pii:privateTask,full:false,metadata:{profile:e.profile,class:e.class,alias:dogfoodAlias(e.profile,e.class,e.profileClass,privateTask),history}});
+  }
+  const activeIds = new Set<number>();
+  for (const e of events) {
+    const id = e.type === "task" ? e.id : "task" in e ? e.task : undefined;
+    if (positive(id) && bound.has(id)) {
+      activeIds.add(id);
+      if ("pii" in e && e.pii) bound.get(id)!.pii=true;
+    }
+    if (e.type === "overlap" && Array.isArray(e.others)) for (const other of e.others) if (other && bound.has(other.task)) activeIds.add(other.task);
+    if (e.type === "conflict" && bound.has(e.other)) activeIds.add(e.other);
+  }
+  eventBindingsComplete &&= !bindingsTruncated;
+  const eventsFull = complete(input.events) && eventBindingsComplete;
+  const bindingsComplete = !bindingsTruncated && complete(input.tasks) && input.tasks.data.every(t=>bound.has(t.id));
+  const edits = new Map<string, Map<string, number>>();
+  const pair = (a:number,b:number) => [a,b].sort((x,y)=>x-y).join(":");
+  for (const e of events) {
+    if (e.type!=="conflict" || !positive(e.task) || !positive(e.other) || !Array.isArray(e.paths)) continue;
+    const key=pair(e.task,e.other), paths=edits.get(key)??new Map<string,number>();
+    for (const path of e.paths) if (typeof path==="string") paths.set(path,Math.max(paths.get(path)??0,Date.parse(e.at)));
+    edits.set(key,paths);
+  }
+  const selectedProjectProfile = input.projectProfile && complete(input.projectProfile) && dogfoodProfileName(input.projectProfile.data) ? input.projectProfile.data : null;
+  const active = [...bound.values()].filter(t => t.metadata.history.some(h => inWindow(h.at)) || activeIds.has(t.id));
+  if (![...observedProfiles].some(profile=>profile!=="dev") && !active.some(t => t.metadata.profile !== "dev") && (selectedProjectProfile === null || selectedProjectProfile === "dev")) return {};
+  const profiles = [...new Set([...observedProfiles,...active.map(t=>t.metadata.profile), ...(selectedProjectProfile && selectedProjectProfile!=="dev" ? [selectedProjectProfile] : [])])].sort();
+  const rows = profiles.flatMap(profile => {
+    const tasks = active.filter(t=>t.metadata.profile === profile);
+    const groups: {alias: string|null; base: string|null; tasks: BoundTask[]}[] = [{alias:null,base:null,tasks}];
+    for (const task of tasks) {
+      const alias = dogfoodAlias(profile,task.metadata.class,task.metadata.alias,task.pii);
+      const group = groups.find(g=>g.base === task.metadata.class && g.alias === alias);
+      if (group) group.tasks.push(task); else groups.push({alias,base:task.metadata.class,tasks:[task]});
+    }
+    return groups.map(group => {
+      const ids = new Set(group.tasks.map(t=>t.id));
+      const full = bindingsComplete && group.tasks.every(t=>t.full);
+      const history = group.tasks.flatMap(t=>t.metadata.history.filter(h=>inWindow(h.at)).map(h=>({...h,task:t})));
+      const recorded = [...ids].flatMap(id=>taskEvents.get(id)??[]);
+      const autoApprovals = recorded.filter(e=>e.event==="done" && e.state==="approved");
+      const milestones = full ? history : recorded.map(e=>({at:Date.parse(e.at),event:e.event,task:bound.get(e.id)!}));
+      const milestoneKnown = full || eventsFull;
+      const scope = full ? "history" : eventsFull ? "recorded_events" : null;
+      const count = (event: string) => milestoneKnown ? new Set(milestones.filter(h=>h.event===event || event==="proposed" && h.event==="backlog pulled").map(h=>h.task.id)).size : null;
+      const approvalIds = new Set(milestones.filter(h=>h.event==="approved").map(h=>h.task.id));
+      for (const e of autoApprovals) approvalIds.add(e.id);
+      // A current approved state alone cannot date a reviewer-less done. Never place it in this window by guessing.
+      const approvalUnknown = full && group.tasks.some(t=>t.metadata.state==="approved" && !t.metadata.history.some(h=>h.event==="approved") && !autoApprovals.some(e=>e.id===t.id));
+      const leads: number[] = [], first: number[] = [];
+      for (const task of group.tasks) {
+        const all = task.metadata.history.filter(h=>h.at<=input.until).sort((a,b)=>a.at-b.at);
+        const proposed = all.find(h=>h.event==="proposed" || h.event==="backlog pulled");
+        const approval = all.findLast(h=>h.event==="approved" && inWindow(h.at));
+        const automatic = autoApprovals.filter(e=>e.id===task.id).map(e=>Date.parse(e.at)).sort((a,b)=>b-a)[0];
+        const approvedAt = approval?.at ?? automatic;
+        if (proposed && approvedAt!==undefined && approvedAt>=proposed.at) leads.push(approvedAt-proposed.at);
+        // An automatic completion is an approval transition, never a reviewer verdict or first-pass review sample.
+        if (approval) { const verdict = all.find(h=>h.event==="approved" || h.event==="changes_requested"); if (verdict) first.push(Number(verdict.event==="approved")); }
+      }
+      const verdicts = milestones.filter(h=>h.event==="approved" || h.event==="changes_requested");
+      const rounds = verdicts.length;
+      const rejectionCount = verdicts.filter(h=>h.event==="changes_requested").length;
+      const rejections = history.filter(h=>h.event==="changes_requested");
+      const criteriaKnown = full && rejections.every(h=>h.criteria !== undefined);
+      const criteria = new Map<string,number>(); let privateCriteria = 0;
+      for (const h of rejections) {
+        for (const id of h.criteria ?? []) {
+          if (h.task.pii || h.criteriaPrivate) privateCriteria++; else if (criterion(id)) criteria.set(id,(criteria.get(id)??0)+1);
+        }
+      }
+      const selected = events.filter(e => "task" in e && typeof e.task === "number" && ids.has(e.task));
+      const overlaps = events.filter((e): e is Extract<StampedEvent,{type:"overlap"}> => e.type==="overlap" && positive(e.task) && Array.isArray(e.others) && (ids.has(e.task) || e.others.some(o=>o && ids.has(o.task))));
+      const warnings = overlaps.flatMap(e=>e.others.filter(o=>o && positive(o.task) && (ids.has(e.task) || ids.has(o.task)) && Array.isArray(o.paths)).map(o=>({at:Date.parse(e.at),a:e.task,b:o.task,paths:o.paths,sections:Array.isArray(o.symbols) && o.symbols.some(s=>typeof s==="string" && s.startsWith("section "))})));
+      // conflict is snapshot/fact edit evidence, not another overlap advisory. Concurrent snapshots do not assign authorship.
+      const confirmed = new Set<string>();
+      for (const warning of warnings) {
+        const key=pair(warning.a,warning.b), edited=edits.get(key);
+        if (warning.paths.some(p=>typeof p==="string" && (edited?.get(p)??0)>warning.at)) confirmed.add(key);
+      }
+      const snapshots = selected.flatMap(e=>e.type==="turn_end" && (e.attribution==="delivery" || e.attribution==="single_open") && number(e.snapshotMs) ? [e.snapshotMs] : []);
+      const accounting = selected.filter(e => (e.type==="tokens" || e.type==="usage" || e.type==="turn_end") && peer(e.peer) && (e.attribution==="delivery" || e.attribution==="single_open") && (e.type!=="tokens" || number(e.n)));
+      const report = summarizeByTask(accounting);
+      const costs = [...ids].sort((a,b)=>a-b).map(task=>({task,peers:complete(input.events) && report.tasks[String(task)] ? Object.fromEntries(Object.entries(report.tasks[String(task)]!.peers).map(([id,p])=>[id,{tokens:p.tokens,input:p.usage.inputTokens,output:p.usage.outputTokens,cacheRead:p.usage.cacheReadTokens,cacheWrite:p.usage.cacheWriteTokens,total:p.usage.totalTokens,records:p.usage.records}])) : null}));
+      const screened = selected.filter(e=>e.type==="pii_screen" && e.item==="note" && e.label==="pii");
+      const eventCount = (n:number) => full && complete(input.events) ? n : null;
+      const planCount = (t: BoundTask,key:"sources"|"claims") => {
+        const count=t.metadata.plan?.[key];
+        return full && declarationCount(count) ? count : null;
+      };
+      const research = profile === "research" ? {research:{
+        declarations:{scope:"current_plan",perTask:group.tasks.map(t=>({task:t.id,sources:planCount(t,"sources"),claims:planCount(t,"claims")}))},
+        claims:{reachedPersonVerdict:null,perTask:group.tasks.map(t=>{const count=planCount(t,"claims");return {task:t.id,claims:count===null?null:Array.from({length:count},(_,i)=>({slot:i+1,modelLabel:null,personVerdict:null,agreement:null}))};})},
+        observedCheckOutcomes:{scope:"task_check_history",passed:full?history.filter(h=>h.event==="check passed").length:null,failed:full?history.filter(h=>h.event==="check failed").length:null},
+        factCheck:{scope:null,selection:null,passed:null,failed:null,missingKeysPerRun:null,
+          agreement:["supported","unsupported","unclear"].map(label=>({label,count:null}))}
+      }} : {};
+      return {...research,profile, alias:group.alias, baseClass:group.base, tasks:[...ids].sort((a,b)=>a-b),
+        flow:{scope,autoApprovalTransitions:{scope:"recorded_events",value:eventsFull?new Set(autoApprovals.map(e=>e.id)).size:null},proposed:count("proposed"),accepted:count("accepted"),approved:milestoneKnown&&!approvalUnknown?approvalIds.size:null,cancelled:count("cancelled"),proposeToApproveMs:full&&!approvalUnknown?quantiles(leads):{samples:null,p50:null,p90:null},reviewRounds:milestoneKnown?rounds:null,firstPassApproval:full&&!approvalUnknown&&first.length?first.reduce((a,b)=>a+b,0)/first.length:null,escalations:count("escalated")},
+        review:{changesRequested:milestoneKnown?rejectionCount:null,checklistItems:null,criteria:criteriaKnown?[...criteria].sort(([a],[b])=>a.localeCompare(b)).map(([id,count])=>({id,count})):null,privateCriteria:criteriaKnown?privateCriteria:null},
+        overlap:{pathNotices:eventCount(warnings.filter(w=>w.paths.length).length),sectionNotices:eventCount(warnings.filter(w=>w.sections).length),observedPathEditPairs:eventCount(confirmed.size),sectionEditPairs:null},
+        deliverables:{recordedCount:full&&history.some(h=>h.deliverables!==undefined)?group.tasks.reduce((n,t)=>n+new Set(history.filter(h=>h.task.id===t.id).flatMap(h=>h.deliverables??[])).size,0):null,changedSinceApproval:null,unknownStates:null},
+        privacy:{privateTasks:full?group.tasks.filter(t=>t.pii).length:null,refusals:null,memoryNotesDropped:null,observedPiiNoteScreens:!bindingsTruncated&&complete(input.events)&&screened.length?screened.length:null,captureRowsDropped:null},
+        undo:{requests:null,completed:null,guardRefused:null},snapshots:{budgetExhaustions:null,durationMs:!bindingsTruncated&&complete(input.events)?quantiles(snapshots):{samples:null,p50:null,p90:null}},profileErrors:{unknownAlias:null,otherProfileAlias:null},cost:{perTask:ids.size || bindingsComplete || eventsFull ? costs : null}};
+    });
+  });
+  return {profile:{bindings:{limit:bindingLimit,retained:bound.size,complete:!bindingsTruncated},sources:{tasks:{available:input.tasks.available,complete:complete(input.tasks),bindingsComplete},events:{available:input.events.available,complete:complete(input.events),bindingsComplete:eventBindingsComplete},config:input.projectProfile?{available:input.projectProfile.available,complete:complete(input.projectProfile)}:null},rows}};
+}

package/src/hub/dogfood-read.ts

@@ -5,6 +5,9 @@ import { HUB_DB_BUSY_TIMEOUT_MS } from "./db-timeout.ts";
 import { readPrCostHistory, sdlcGh, type SdlcGh } from "./sdlc.ts";
 import { dogfoodScorecard, missing, source, type DogfoodTask, type DogfoodPr, type FeatureEvidence, type Source } from "./dogfood.ts";
 import type { HistoryEntry } from "./board.ts";
+import { dogfoodAlias, dogfoodProfileName, profileEventValid, type ProfileTaskMetadata } from "./dogfood-profile.ts";
+import { CLASSES } from "./board.ts";
+import type { ProfileName } from "./profiles.ts";
 import type { StampedEvent } from "./events.ts";
 
 export const DOGFOOD_BYTE_CAP = 16 * 1024 * 1024;
@@ -37,14 +40,10 @@ export function dogfoodEvents(lines: Source<string[]>, since: number, until: num
     try {
       const e = JSON.parse(line);
       if (!e || typeof e !== "object" || e.v !== 1 || typeof e.type !== "string" || date(e.at) === undefined) { complete = false; continue; }
-      const number = (n:unknown) => typeof n === "number" && Number.isFinite(n) && n >= 0;
-      const peer = typeof e.peer === "string" && /^[a-z][a-z0-9-]{0,63}$/.test(e.peer) && !Object.hasOwn(Object.prototype,e.peer);
-      const malformed = ["tokens","usage","turn_end","task","overflow","undeliverable"].includes(e.type) &&
-        (e.type === "task" ? !id(e.id) || typeof e.class !== "string" || typeof e.event !== "string" || typeof e.state !== "string" : !peer ||
-          e.type === "tokens" && !number(e.n) || e.type === "turn_end" && !number(e.ms) ||
-          e.type === "usage" && (typeof e.id !== "string" || typeof e.source !== "string") ||
-          ["overflow","undeliverable"].includes(e.type) && typeof e.id !== "string");
-      if (malformed) {complete=false;continue;}
+      // Other dogfood rows retain their existing validation; profile-consumed types share one predicate.
+      const malformed = ["overflow","undeliverable"].includes(e.type) &&
+        (typeof e.peer!=="string" || !/^[a-z][a-z0-9-]{0,63}$/.test(e.peer) || Object.hasOwn(Object.prototype,e.peer) || typeof e.id!=="string");
+      if (malformed || !profileEventValid(e)) {complete=false;continue;}
       const at = e.type === "usage" && date(e.measuredAt) !== undefined ? date(e.measuredAt)! : date(e.at)!;
       if (at >= since && at <= until) out.push({ ...e, at: new Date(at).toISOString() });
     } catch { complete = false; }
@@ -57,14 +56,23 @@ export function dogfoodTasks(file: string): Source<DogfoodTask[]> {
   try {
     db = new Database(file, { readonly: true });
     db.run(`PRAGMA busy_timeout = ${HUB_DB_BUSY_TIMEOUT_MS}`);
-    const rows = db.query(`SELECT id, (sdlc IS NOT NULL AND length(sdlc) > 65536) AS receipt_cut, CASE WHEN length(sdlc) <= 65536 THEN sdlc END AS sdlc,
+    const columns = new Set((db.query("PRAGMA table_info(tasks)").all() as {name:string}[]).map(c=>c.name));
+    const metadata = columns.has("class") ? "CASE WHEN length(class) <= 48 THEN class END" : "NULL";
+    const profile = columns.has("project_profile") ? "CASE WHEN length(project_profile) <= 65536 THEN project_profile END" : "NULL";
+    const plan = columns.has("plan") ? "CASE WHEN length(plan) <= 65536 THEN plan END" : "NULL";
+    const planCut = columns.has("plan") ? "(plan IS NOT NULL AND length(plan) > 65536)" : "0";
+    const state = columns.has("state") ? "CASE WHEN length(state) <= 32 THEN state END" : "NULL";
+    const metadataCut = [columns.has("class") ? "(class IS NOT NULL AND length(class) > 48)" : "0", columns.has("state") ? "(state IS NOT NULL AND length(state) > 32)" : "0"].join(" OR ");
+    const profileCut = columns.has("project_profile") ? "(project_profile IS NOT NULL AND length(project_profile) > 65536)" : "0";
+    const rows = db.query(`SELECT (${planCut}) AS plan_cut, ${plan} AS plan, (${metadataCut}) AS metadata_cut, ${state} AS current_state, ${metadata} AS base_class, ${profileCut} AS profile_cut, ${profile} AS project_profile, id, (sdlc IS NOT NULL AND length(sdlc) > 65536) AS receipt_cut, CASE WHEN length(sdlc) <= 65536 THEN sdlc END AS sdlc,
       CASE WHEN length(signals) <= 65536 THEN signals END AS signals,
-      CASE WHEN length(history) <= 131072 THEN history END AS history FROM tasks ORDER BY id DESC LIMIT ?`).all(MAX_TASKS + 1) as { id: number; receipt_cut: number; sdlc: string | null; signals: string | null; history: string | null }[];
+      CASE WHEN length(history) <= 131072 THEN history END AS history FROM tasks ORDER BY id DESC LIMIT ?`).all(MAX_TASKS + 1) as { plan_cut: number; plan: string | null; metadata_cut: number; current_state: string | null; profile_cut: number; base_class: string | null; project_profile: string | null; id: number; receipt_cut: number; sdlc: string | null; signals: string | null; history: string | null }[];
     let complete = rows.length <= MAX_TASKS, bytes = 0;
     const tasks: DogfoodTask[] = [];
     for (const row of rows.slice(0,MAX_TASKS)) {
-      if (row.receipt_cut) complete = false;
-      bytes += (row.sdlc?.length ?? 0) + (row.signals?.length ?? 0) + (row.history?.length ?? 0);
+      // A cut plan nulls only that task's declarations and stays out of the byte cap: the dev scorecard never reads the plan column, so a plan nobody consumes cannot blank every PR row.
+      if (row.receipt_cut || row.profile_cut || row.metadata_cut) complete = false;
+      bytes += Buffer.byteLength(row.base_class ?? "") + Buffer.byteLength(row.current_state ?? "") + (row.project_profile?.length ?? 0) + (row.sdlc?.length ?? 0) + (row.signals?.length ?? 0) + (row.history?.length ?? 0);
       if (bytes > DOGFOOD_BYTE_CAP) { complete = false; break; }
       try {
         const signals = JSON.parse(row.signals ?? "null"), history = JSON.parse(row.history ?? "null"), receipt = JSON.parse(row.sdlc ?? "{}");
@@ -75,7 +83,42 @@ export function dogfoodTasks(file: string): Source<DogfoodTask[]> {
           if (!h || !Number.isFinite(h.at) || typeof h.event !== "string") { complete = false; continue; }
           clean.push({ at: h.at, by: "hub", event: h.event, ...(h.reviewCost && typeof h.reviewCost === "object" ? { reviewCost: { ...(h.reviewCost.review && ["none","delta","full"].includes(h.reviewCost.review.scope) ? {review:{scope:h.reviewCost.review.scope,reviewers:1}} : {}) } } : {}), ...(Array.isArray(h.reviewFindings?.items) ? { reviewFindings: { items:h.reviewFindings.items.filter((f:any)=>f && typeof f.id === "string" && ["important","nit"].includes(f.severity)).map((f:any)=>({id:f.id,severity:f.severity,pass:"bugs",disposition:"open"})) } } : {}) });
         }
-        tasks.push({ id: row.id, pii: signals.includes("pii") || signals.includes("pii_path"), ...(repoName(receipt?.repo) ? { repo: receipt.repo } : {}), ...(id(receipt?.pr) ? { pr: receipt.pr } : {}), history: clean });
+        const pii = signals.includes("pii") || signals.includes("pii_path");
+        let profileMetadata: ProfileTaskMetadata | undefined;
+        try {
+          if (!row.profile_cut && row.base_class && (CLASSES as readonly string[]).includes(row.base_class)) {
+            const raw = row.project_profile === null ? {profile:"dev",profileClass:row.base_class} : JSON.parse(row.project_profile);
+            if (!dogfoodProfileName(raw?.profile)) complete = false;
+            else {
+              // A plan that parses but holds a malformed declaration list is this task's bad plan only:
+              // its declarations go unknown, the source stays complete (#799 nit 1).
+              let planBad=false;
+              if (history.some((h:any) => h && (h.unmetCriteria !== undefined && (!Array.isArray(h.unmetCriteria) || h.unmetCriteria.length>32 || new Set(h.unmetCriteria).size!==h.unmetCriteria.length || h.unmetCriteria.some((v:unknown)=>typeof v!=="string" || !/^[A-Za-z][A-Za-z0-9-]{0,47}$/.test(v))) || h.deliverables !== undefined && (!Array.isArray(h.deliverables) || h.deliverables.length>16 || h.deliverables.some((v:any)=>typeof v?.id!=="string" || !/^d-[0-9a-f]{12}$/.test(v.id)))))) complete=false;
+              const projection = history.filter((h:any)=>h && Number.isFinite(h.at) && typeof h.event==="string").map((h:any) => ({at:h.at,event:h.event,
+                ...(Array.isArray(h.unmetCriteria) ? {criteria:h.unmetCriteria.slice(0,32).filter((v:unknown)=>typeof v === "string" && /^[A-Za-z][A-Za-z0-9-]{0,47}$/.test(v)).map((v:string)=>pii || h.withheld ? "withheld" : v), ...(h.withheld ? {criteriaPrivate:true as const} : {})} : {}),
+                ...(Array.isArray(h.deliverables) ? {deliverables:h.deliverables.slice(0,16).filter((v:any)=>typeof v?.id==="string" && /^d-[0-9a-f]{12}$/.test(v.id)).map((v:any)=>v.id)} : {})}));
+              let declarations: ProfileTaskMetadata["plan"];
+              if (!row.plan_cut && row.plan !== null) {
+                try {
+                  const rawPlan = JSON.parse(row.plan);
+                  if (!rawPlan || typeof rawPlan!=="object" || Array.isArray(rawPlan)) planBad=true;
+                  else {
+                    const count = (key:"sources"|"claims") => {
+                      const value=rawPlan[key];
+                      // cleanPlan never stores an empty list, so a board plan omitting a key is an explicit zero, not an unknown (#799 nit 2).
+                      if (value===undefined) return 0;
+                      if (!Array.isArray(value) || value.length>50 || value.some((v:unknown)=>typeof v!=="string" || v.length>300)) throw new Error("plan list malformed");
+                      return value.length;
+                    };
+                    declarations={sources:count("sources"),claims:count("claims")};
+                  }
+                } catch {planBad=true;}
+              }
+              profileMetadata = {...(declarations?{plan:declarations}:{}),...(row.current_state ? {state:row.current_state} : {}),profile:raw.profile,class:row.base_class,alias:dogfoodAlias(raw.profile,row.base_class,raw.profileClass,pii),history:projection};
+            }
+          }
+        } catch { complete=false; }
+        tasks.push({ id: row.id, pii, ...(profileMetadata ? {profileMetadata} : {}), ...(repoName(receipt?.repo) ? { repo: receipt.repo } : {}), ...(id(receipt?.pr) ? { pr: receipt.pr } : {}), history: clean });
       } catch { complete = false; }
     }
     return source(tasks, complete);
@@ -184,6 +227,26 @@ export function dogfoodFeatures(file: string): Source<FeatureEvidence[]> {
   const rows = text.data.filter(line=>line.startsWith("| ") && !line.startsWith("| Feature ") && !line.startsWith("| ---"));
   return {available:text.available,complete:text.complete,data:rows.map((row,index)=>{const rule=mappings.find(([re])=>re.test(row.split("|")[1] ?? ""));return {id:index+1,types:rule?.[1] ?? null,...(rule?.[2] ? {taskEvents:rule[2]} : {})};})};
 }
+/** Data-only profile selection; never load daemon configuration or project adapter modules. */
+export function dogfoodProjectProfile(root: string): Source<ProfileName | null> {
+  let selected: ProfileName = "dev";
+  for (const name of ["config.json", "config.local.json"]) {
+    const file = join(root,".agenthub",name);
+    let fd: number | undefined;
+    try {
+      fd = openSync(file,constants.O_RDONLY | constants.O_NONBLOCK);
+      const stat = fstatSync(fd);
+      if (!stat.isFile() || stat.size > 128*1024) return missing(null);
+      const buffer = Buffer.alloc(stat.size), n = readSync(fd,buffer,0,buffer.length,0);
+      if (n !== stat.size) return missing(null);
+      const raw = JSON.parse(buffer.toString("utf8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return missing(null);
+      if (raw.profile !== undefined) { if (!dogfoodProfileName(raw.profile)) return missing(null); selected = raw.profile; }
+    } catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") continue; return missing(null); }
+    finally { if (fd !== undefined) closeSync(fd); }
+  }
+  return source(selected);
+}
 export async function readDogfood(root: string, stateDir: string, since: number, until = Date.now(), run: SdlcGh = sdlcGh) {
   const tasks = dogfoodTasks(join(stateDir,"hub.db"));
   let repo = "";
@@ -195,5 +258,5 @@ export async function readDogfood(root: string, stateDir: string, since: number,
     if (at === undefined) { log.complete = false; return false; }
     return at >= since && at <= until;
   });
-  return dogfoodScorecard({since,until,tasks,events,log,journal:dogfoodJournal(join(stateDir,"hub.db"),since,until),prs:await dogfoodPrs(repo,tasks,since,until,run),features:dogfoodFeatures(join(root,"docs/dogfood.md"))});
+  return dogfoodScorecard({since,until,tasks,events,log,projectProfile:dogfoodProjectProfile(root),journal:dogfoodJournal(join(stateDir,"hub.db"),since,until),prs:await dogfoodPrs(repo,tasks,since,until,run),features:dogfoodFeatures(join(root,"docs/dogfood.md"))});
 }

package/src/hub/dogfood.ts

@@ -1,3 +1,5 @@
+import { profileScorecard, type ProfileTaskMetadata } from "./dogfood-profile.ts";
+import type { ProfileName } from "./profiles.ts";
 import { costMetrics, type CostPr, type CostTask } from "./cost-governance.ts";
 import type { HistoryEntry } from "./board.ts";
 import { parseSince } from "./events.ts";
@@ -22,7 +24,7 @@ export function dogfoodSince(args: string[], now = Date.now()): number {
 export interface Source<T> { data: T; complete: boolean; available: boolean }
 export const source = <T>(data: T, complete = true): Source<T> => ({ data, complete, available: true });
 export const missing = <T>(data: T): Source<T> => ({ data, complete: false, available: false });
-export interface DogfoodTask { id: number; repo?: string; pr?: number; pii: boolean; history: HistoryEntry[] }
+export interface DogfoodTask { id: number; repo?: string; pr?: number; pii: boolean; history: HistoryEntry[]; profileMetadata?: ProfileTaskMetadata }
 export interface DogfoodPr extends CostPr {
   firstPassCi?: boolean;
   sameHeadReruns?: number;
@@ -32,6 +34,7 @@ export interface DogfoodPr extends CostPr {
 export interface FeatureEvidence { id: number; types: string[] | null; taskEvents?: string[] }
 export interface DogfoodInput {
   since: number; until: number;
+  projectProfile?: Source<ProfileName | null>;
   events: Source<StampedEvent[]>; tasks: Source<DogfoodTask[]>; prs: Source<DogfoodPr[]>;
   journal?: Source<{ digests: number; held: number; rows: number }>;
   log: Source<string[]>; features: Source<FeatureEvidence[]>;
@@ -154,6 +157,7 @@ export function dogfoodScorecard(input: DogfoodInput) {
     adoption: input.features.data.map(feature => ({ id: feature.id, events: feature.types && known(input.events) ? events.filter(e => feature.types!.includes(e.type) && (!feature.taskEvents || e.type === "task" && feature.taskEvents.includes(e.event))).length : null })),
     journalSource: input.journal ? {available:input.journal.available,complete:input.journal.complete,rows:input.journal.data.rows} : {available:false,complete:false,rows:0},
     piiTasks: known(input.tasks) ? tasks.filter(t => t.pii).length : null,
+    ...profileScorecard(input),
   };
 }
 export type DogfoodScorecard = ReturnType<typeof dogfoodScorecard>;

package/src/hub/events.ts

@@ -17,7 +17,7 @@ export type HubEvent =
   | { type: "permission_mode"; peer: string; from: import("./permission-mode.ts").PermissionMode; to: import("./permission-mode.ts").PermissionMode }
   | { type: "role"; peer?: string; task?: number; actor: string; stage: "prepared" | "assigned"; roles: { id: string; layer: "shipped" | "project"; hash: string }[] }
   /** A settings change (#269): the registry key, the bounded registry values before/after and their source; an optional person reason is sanitized and capped at 400 UTF-8 bytes. */
-  | { type: "settings"; key: string; from: import("./settings.ts").SettingValue; to: import("./settings.ts").SettingValue; source: "dashboard" | "terminal"; undo?: boolean; reason?: string }
+  | { type: "settings"; key: string; from: import("./settings.ts").SettingValue; to: import("./settings.ts").SettingValue; source: "dashboard" | "terminal" | "conductor"; peer?: string; undo?: boolean; reason?: string }
   /** A structural config edit (#689): the file, key paths with short hashes of their values before and after (never a value), the file revisions and the person who made it. */
   | { type: "config_edit"; file: "config.local.json" | "sdlc.toml"; paths: { path: string; before: string | null; after: string | null }[]; fileBefore: string; fileAfter: string; tier: 2 | 3; by: "person"; source: "dashboard" | "terminal"; backup?: string; reason?: string }
   | { type: "envelope"; id: string; from: string; to?: string[]; priority: string; hop: number; kind?: string; task?: string; bytes?: number; private?: boolean; dropped?: string }

package/src/hub/host-executable.ts

@@ -1,11 +1,31 @@
+import type { ReadOnlyProgram } from "./read-only-shell.ts";
 import { isAbsolute, relative } from "node:path";
+import { lstatSync } from "node:fs";
 import { realPath } from "./project.ts";
 
 /** A repo-writable PATH shim is not a host-owned authenticated capability. No caller-selected binary. */
-export function hostExecutable(name: "gh" | "container" | "git" | "dot", projectDir: string, path = process.env.PATH ?? ""): string {
+export function hostExecutable(name: "gh" | "bun" | "container" | "git" | "dot" | "ssh" | "tar" | ReadOnlyProgram, projectDir: string, path = process.env.PATH ?? ""): string {
   const found = Bun.which(name, { PATH: path });
   if (!found || !isAbsolute(found)) throw new Error(`${name} unavailable`);
   const target = realPath(found), inside = relative(realPath(projectDir), target);
   if (!inside || inside !== ".." && !inside.startsWith("../") && !isAbsolute(inside)) throw new Error(`${name} unavailable`);
   return target;
 }
+
+/** A privileged command's children must not discover a project-controlled PATH shim either. */
+export function hostShellPath(projectDir: string, executionDir: string, value = process.env.PATH ?? "/usr/bin:/bin"): string | undefined {
+  try {
+    if (!value || value.length > 16384 || value.split(":").length > 128) return;
+    const roots = [realPath(projectDir), realPath(executionDir)], directories = new Set<string>();
+    const inside = (path: string) => roots.some(root => { const p = relative(root, path); return !p || p !== ".." && !p.startsWith("../") && !isAbsolute(p); });
+    for (const entry of value.split(":")) {
+      if (!isAbsolute(entry) || entry.split("/").includes("..")) return;
+      if (inside(entry)) continue;
+      try {
+        const canonical = realPath(entry);
+        if (!inside(canonical) && lstatSync(canonical).isDirectory()) directories.add(canonical);
+      } catch { /* A missing PATH directory supplies no trusted program. */ }
+    }
+    return directories.size ? [...directories].join(":") : undefined;
+  } catch { return undefined; }
+}

package/src/hub/hub-tools.ts

@@ -103,7 +103,7 @@ export const TASK_TOOLS: HubTool[] = [
 
   tool("hub_task_propose", "Put a piece of work on the shared task board. The hub assigns an owner by class (routing.toml) unless you name one. Classes: plan, implement, bulk_edit, test, review, summarize, triage. Name the class when you know it; without one the hub tries to pick it. Name yourself as owner to claim work nobody assigned you: it starts in progress. Put the paths the work touches in refs, set refs.repo for work in another repository, and when you claim work, a plan; the hub says when they overlap another open task.", { title: str, class: { type: "string", enum: ["plan", "implement", "bulk_edit", "test", "review", "summarize", "triage"] }, detail: str, role: { type: "string", description: "catalog role id for this task class; guidance only, no routing or authority change" }, refs, plan, owner: { type: "string", description: "peer id; yours to claim the work, omit to let the hub route it. With after, the owner is reserved: offered the task first once it is ready" }, after: { type: "array", items: { type: "integer" }, description: "ids of tasks that must be approved first; until then this one waits, offered to nobody, and cannot be claimed" }, backlog: { type: "boolean", description: "stage unoffered work; owner is only a reservation, even when naming yourself" }, urgent: { type: "boolean", description: "hand it over even when its owner is paused for quota only briefly" }, goal: { type: "string", description: "id of this project's long-term task (ahub goal list) the work is part of" } }, ["title"]),
   tool("hub_task_accept", "Take a task that was assigned to you, with your plan for it. Set refs.repo for work in another repository; acceptance may correct only that repository metadata.", { id, plan: acceptPlan, refs: { ...refs, properties: { repo: refs.properties.repo } } }, ["id"]),
-  tool("hub_task_cancel", "Cancel unaccepted proposed/backlog work you proposed as its configured planner; accepted work is person-only. Keeps history and does not stop a native turn or delete files.", { id, reason: str, superseded_by: str, revision: { type: "integer", minimum: 0 } }, ["id", "reason"]),
+  tool("hub_task_cancel", "Cancel proposed/backlog work you proposed as its configured planner, including work an owner accepted and then declined while it has no execution, branch, commit or PR evidence; work with any such evidence is person-only. Keeps history and does not stop a native turn or delete files.", { id, reason: str, superseded_by: str, revision: { type: "integer", minimum: 0 } }, ["id", "reason"]),
   tool("hub_task_decline", "Pass on a task assigned to you; the hub offers it to the next peer. A plain decline is a lasting refusal: you are never offered this task again. Pass capacity: true when you only have no room right now: you are skipped for this move only, and a later reroute or planner pull may offer it to you again.", { id, reason: str, capacity: { type: "boolean" } }, ["id"]),
   tool("hub_task_done", "Mark your task finished. It goes to its reviewer with your summary and refs; no duplicate hub_send chat is needed. When the project configures a check for its class, the hub runs it first and the result comes as a task message: a failed check keeps the task with you.", { id, summary: { type: "string", description: "what changed, why, and the check you ran with its result" }, refs, deliverables: deliverablesSchema }, ["id", "summary"]),
   tool("hub_sdlc_record", "Record artifact ids or claimed local checks on your task. This grants no authority or external-check evidence. Only its owner/reviewer or the person may record; only its reviewer/person may name a reviewed head or phase checklist. Phase evidence refs are content hashes, not external verification.", { id, receipt: { type: "object", properties: { deliverables: deliverablesSchema, stage: { type: "string", enum: ["spec", "plan", "implement", "review", "verify", "merge", "release"] }, repo: str, issue: id, pr: id, localHead: str, localResult: { type: "string", enum: ["passed", "failed", "unknown"] }, reviewedHead: str, phase: { type: "object", properties: { id: str, head: str, tasks: { type: "array", maxItems: 64, items: { type: "object", properties: { id, after: { type: "array", maxItems: 16, items: id } }, required: ["id", "after"], additionalProperties: false } }, criteria: { type: "array", maxItems: 32, items: { type: "object", properties: { id: str, required: { type: "boolean" }, result: { type: "string", enum: ["verified", "failed", "unverified"] }, refs: { type: "array", maxItems: 8, items: str } }, required: ["id", "required", "result", "refs"], additionalProperties: false } } }, required: ["id", "tasks", "criteria"], additionalProperties: false } }, additionalProperties: false } }, ["id", "receipt"]),
@@ -130,7 +130,7 @@ export const TASK_TOOL_NAMES = new Set(TASK_TOOLS.map((t) => t.name));
 /** Separately published: serving a schema grants no authority, only the daemon's explicit role does. */
 export const CONDUCTOR_TOOLS: HubTool[] = [
   tool("hub_status", "Inspect public team state, holds, quota windows, task counts and pending approval peer/tool/age. Only the configured conductor may use this tool.", {}),
-  tool("hub_task_show", "Read a task's public view and history, its done summary and check result included. PII tasks remain stubs. Only the conductor and the task's current owner and reviewer may use this tool.", { id }, ["id"]),
+  tool("hub_task_show", "Read a task's public view and history, its done summary and check result included. PII tasks remain stubs. Only the conductor, the configured planner and the task's current owner and reviewer may use this tool.", { id }, ["id"]),
   tool("hub_task_assign", "Name an owner (default role) or reviewer. Only the conductor may name a reviewer through this tool. A proposer may redirect an unaccepted proposed task's owner; a task that still waits reserves that owner. Pull-only peers receive work when named while attached or when they claim it; a peer that cannot take the task is refused with the reason, and the task is unchanged. With an explicit capabilities list, the conductor needs assign capability for either role, the proposer only to give ownership to another peer.", { id, peer: str, role: { type: "string", enum: ["owner", "reviewer"] } }, ["id", "peer"]),
   tool("hub_task_escalate", "Escalate a task through the normal task flow, as the conductor. Requires assign capability when explicitly listed.", { id }, ["id"]),
   tool("hub_peer_start", "Start local, kimi, qwen, jcode, pi, claude or codex in the start mode a person set for it; you cannot choose the mode. A headless peer starts at once. A TUI peer (claude, and pi and codex by default) opens in a terminal with a fixed command; when the hub cannot open a terminal the call fails with the command for the person to run.", { peer: { type: "string", enum: CONDUCTOR_START_PEERS } }, ["peer"]),

package/src/hub/instances.ts

@@ -4,6 +4,7 @@ import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { canonicalPath, realPath } from "./project.ts";
 import { defaultPeerRoles, definitionOf, type AdapterDefinition, type StartForm, type ProjectAdapterCatalog } from "../adapters/registry.ts";
 import { isPermissionMode, type PermissionMode } from "./permission-mode.ts";
+import { isReviewScope } from "./review-scope.ts";
 
 export interface InstanceConfig {
   kind: string;
@@ -11,9 +12,11 @@ export interface InstanceConfig {
   start_mode?: StartForm;
   permission_mode?: PermissionMode;
   review_mode?: "fresh";
+  /** A fresh reviewer's review scope (#852): `code` reads the code only, `full` also runs tests and reads CI. Machine-local, tier 3. */
+  review_scope?: "full" | "code";
   worktree?: string;
   readOnly?: boolean;
-  /** Jcode instances only (#685): their own native data home, and optional model selection. Machine-local, never editable from settings. */
+  /** Jcode instances (#685): their own native data home, and optional model selection. A headless Claude implementer also takes `model` (#844). Machine-local, never editable from settings. */
   jcode_home?: string;
   provider?: string;
   model?: string;
@@ -129,7 +132,9 @@ export function validateInstances(raw: unknown, catalog: ProjectAdapterCatalog):
     const path = `instances.${id}`, entry = fields(descriptor.value, path);
     const declaredKind: unknown = entry.kind?.value;
     const jcodeFields = typeof declaredKind === "string" && resolve(declaredKind)?.instances?.nativeHome === true;
-    if (Object.keys(entry).some(key => !["kind", "roles", "start_mode", "permission_mode", "worktree", "review_mode", "readOnly", ...(jcodeFields ? JCODE_FIELDS : [])].includes(key))) return fail(path, "unsupported field");
+    // #844: a kind whose headless variant declares `instances.modelSelect` may name its model; no other kind but Jcode has the field.
+    const modelSelect = typeof declaredKind === "string" && resolve(declaredKind)?.headlessVariant?.instances?.modelSelect === true;
+    if (Object.keys(entry).some(key => !["kind", "roles", "start_mode", "permission_mode", "worktree", "review_mode", "readOnly", "review_scope", ...(jcodeFields ? JCODE_FIELDS : []), ...(modelSelect ? ["model"] : [])].includes(key))) return fail(path, "unsupported field");
     const kind: unknown = entry.kind?.value;
     if (typeof kind !== "string") return fail(`${path}.kind`, "must name a native kind");
     const definition = resolve(kind), prefix = `${kind}-`;
@@ -185,6 +190,17 @@ export function validateInstances(raw: unknown, catalog: ProjectAdapterCatalog):
       if (++jcodeCount > MAX_JCODE_INSTANCES) return fail("instances", `at most ${MAX_JCODE_INSTANCES} extra Jcode instances are supported per project`);
       Object.assign(value, jcodeInstanceFields(entry, path));
     }
+    if (entry.model && modelSelect) {
+      if (!headlessWriter) return fail(`${path}.model`, "only a headless implementer takes a model");
+      const word: unknown = entry.model.value;
+      if (typeof word !== "string" || !NATIVE_WORD.test(word)) return fail(`${path}.model`, "must be one bounded printable word without spaces");
+      value.model = word;
+    }
+    if (entry.review_scope) {
+      if (!freshReviewer) return fail(`${path}.review_scope`, "only a fresh reviewer instance has a review scope");
+      if (!isReviewScope(entry.review_scope.value)) return fail(`${path}.review_scope`, 'must be "code" or "full"');
+      value.review_scope = entry.review_scope.value;
+    }
     if (entry.readOnly) value.readOnly = entry.readOnly.value as boolean;
     if (entry.roles) { value.roles = roles(entry.roles.value, `${path}.roles`); Object.freeze(value.roles); }
     if (entry.start_mode) {

package/src/hub/lifecycle.ts

@@ -119,7 +119,7 @@ export async function runProjectDaemon(project: Project, unattended = false): Pr
         try {
           daemon = await startDaemon({ cwd: project.root, stateDir: project.stateDir, projectId: project.id, instanceId,
             controlPort: base + CONTROL, codexAppPort: base + CODEX_APP, codexProxyPort: base + CODEX_PROXY,
-            unattended, onShutdownStart,
+            unattended, onShutdownStart, agentDrift: true,
             // #269: the real terminal providers belong to the running product; a daemon built without them opens nothing.
             terminal: (template) => terminalOpener({ template, cwd: project.root, stateDir: project.stateDir }) });
           break;