refactor(turn): unify plan, host input and recovery on one source

.github/GOVERNANCE.md

@@ -208,7 +208,7 @@ access, and takes effect only when the invited contributor accepts it.
 | [`@hhyykk`](https://github.com/hhyykk) | Write | Active external collaborator; the 2026-10-21 organization invitation is no longer pending, and active organization membership was not established |
 | [`@maxliux5`](https://github.com/maxliux5) | Write | Active; external collaborator |
 | [`@JackyCSer`](https://github.com/JackyCSer) | Write | Active; organization Member |
-| [`@cocolord`](https://github.com/cocolord) | Write | Active; organization Member |
+| [`@cocolord`](https://github.com/cocolord) | Maintain | Active organization Member; repository role updated 2026-11-07 |
 | [`@wujc12`](https://github.com/wujc12) | Write | Active; organization Member |
 | [`@songoow`](https://github.com/songoow) | Maintain | Active; organization Member |
 | [`@now-ing`](https://github.com/now-ing) | Write | Active; organization Member |
@@ -274,6 +274,19 @@ Update this snapshot through a pull request when invitations are accepted,
 expire or are otherwise resolved. Maintainer appointments follow the separate
 process below.
 
+On 2026-11-07, the lead maintainer granted `@cocolord` repository Maintain
+to help carry the small-kernel refactors through review and merge. Recent
+work includes deferred loading at the Host and process boundaries in
+[#8185](https://github.com/loopx-project/loopx/pull/8185) and CLI registry
+inspection in [#8233](https://github.com/loopx-project/loopx/pull/8233).
+The existing [main ruleset](https://github.com/loopx-project/loopx/rules/18121976)
+allows Maintain holders to bypass branch rules when merging through a PR.
+The [repository merge policy](../AGENTS.md#merge-authority-and-validation)
+still requires explicit maintainer authorization, review of the proposed
+revision and validation for core refactors. Its limits on merging one's own
+PRs continue to apply. Code ownership and release authority follow their
+separate procedures.
+
 ## Subsystem Maintainers
 
 A subsystem maintainer is accountable for review quality and contract

apps/presentation/dashboard/smoke/capability-configuration-smoke.ts

@@ -178,3 +178,14 @@ assert.deepEqual(goalReplanCadenceEditorValue(null, enabledStrideDefault), enabl
 assert.equal(goalReplanCadenceEditorValue({stride_strategy: "off"}, enabledStrideDefault).stride_strategy, "off");
 assert.equal(goalReplanCadenceEditorValue({count_unit: "effective_turns", count: 3}, enabledStrideDefault).stride_strategy, "off");
 assert.equal(projectEditableCapabilityConfiguration(cadenceEditor, {}, enabledStrideDefault).stride_strategy, "evidence_conditioned_v1");
+
+// Independent Yardstick inheritance must not be pinned by editing the interval.
+const yardstickEffective = {...inheritedReview, yardstick_enabled: true};
+assert.equal(goalReplanCadenceEditorValue({count_unit: "effective_turns", count: 2}, yardstickEffective).yardstick_enabled, true);
+assert.deepEqual(goalReplanCadenceWriteValue({...yardstickEffective, count: 2}, true, false, false),
+  {...inheritedReview, count: 2}, "an unchanged inherited measurement choice stays live");
+for (const enabled of [true, false]) {
+  assert.deepEqual(goalReplanCadenceWriteValue({...yardstickEffective, yardstick_enabled: enabled}, false, false, true),
+    {stride_strategy: "off", yardstick_enabled: enabled}, "explicit measurement opt-in and opt-out survive form saving");
+}
+assert.equal(replanCadenceEditorDefaults(yardstickEffective, {...cadenceDefault, yardstick_enabled: false}).yardstick_enabled, true);

apps/presentation/dashboard/smoke/goal-acceptance-contract-smoke.mjs

@@ -31,6 +31,9 @@ for (const copy of Object.values(deliveryReviewCopy)) {
     scope: { kind: "selected_work", todo_ids: ["todo_confirmed"] } }), snapshot.goal_id);
   assert.ok(deliveryReviewMarkdown(selected, copy).includes(copy.contract.selectedWork));
   assert.ok(deliveryReviewMarkdown(parseDeliveryReview(withContract(contract), snapshot.goal_id), copy).includes(copy.contract.allWork));
+  const goalOnly = parseDeliveryReview(withContract({ ...contract,
+    scope: { kind: "goal" }, tasks: [], held_todo_ids: [] }), snapshot.goal_id);
+  assert.ok(deliveryReviewMarkdown(goalOnly, copy).includes(copy.contract.goalOnly));
   const empty = parseDeliveryReview(withContract({ ...contract, criteria: [], tasks: [] }), snapshot.goal_id);
   assert.ok(deliveryReviewMarkdown(empty, copy).includes(copy.contract.noTasks));
   assert.ok(deliveryReviewMarkdown(empty, copy).includes(copy.contract.noCriteria));

apps/presentation/dashboard/smoke/research-analysis-read-smoke.mjs

@@ -5,8 +5,50 @@ import {mkdtemp, mkdir, readFile, writeFile, rm} from "node:fs/promises";
 import {tmpdir} from "node:os";
 import {resolve} from "node:path";
 import {createInterface} from "node:readline";
+import {createElement} from "react";
+import {renderToStaticMarkup} from "react-dom/server";
 import {resolveTestPython} from "../../../../scripts/test-python.mjs";
-import {readAnalysisSnapshot} from "../src/features/personal-workspace/goal-research-analysis.tsx";
+import {readAnalysisSnapshot, ResearchAnalysisPanel} from "../src/features/personal-workspace/goal-research-analysis.tsx";
+import {ResearchCaseStudy} from "../src/features/personal-workspace/research-case-study.tsx";
+import {fetchExploreResults} from "../src/data/chat.ts";
+import {ResearchGoalNavigation} from "../src/features/personal-workspace/goal-research-workbench.tsx";
+
+// The persisted directory can organize explicitly linked physical sources.
+// Navigation must not turn organization into shared evidence or execution.
+const caseFixture = JSON.parse(await readFile(resolve('src/data/fixtures/case-study-child.json'), 'utf8'));
+const study = caseFixture.analyses[0].case_study;
+const renderedStudy = renderToStaticMarkup(createElement(ResearchCaseStudy, {
+  study, zh: false, historical: true, scope: caseFixture.analyses[0].input.scope, onCitation: () => {throw Error('read executed a citation');},
+}));
+assert.ok(renderedStudy.includes(study.title));
+assert.ok(renderedStudy.includes('Showing the saved Chinese original.'));
+assert.ok(renderedStudy.includes('not current results'));
+assert.ok(renderedStudy.includes('unknown'), 'Missing values do not become zero');
+for (const section of study.sections) assert.ok(renderedStudy.includes(section.title));
+const goals = [
+  {goalId:'parent',title:'Benchmark'},
+  {goalId:'child',parentGoalId:'parent',title:'Local case'},
+  {goalId:'foreign',parentGoalId:'parent',title:'Foreign case',sourceAccess:{namespace:'other',label:'Other',readOnly:true}},
+];
+const navigate = goalId => renderToStaticMarkup(createElement(ResearchGoalNavigation, {
+  goalId, goals, zh:false, onSelect: () => {throw Error('read navigated');},
+}));
+assert.ok(navigate('parent').includes('Local case'));
+assert.ok(navigate('parent').includes('Foreign case'));
+assert.ok(navigate('child').includes('Benchmark'));
+assert.ok(navigate('foreign').includes('Benchmark'), 'Explicit directory links retain their local parent');
+
+// Transport uses the workspace view; immutable findings still identify the native Goal.
+const sourceFetch = globalThis.fetch, sourceWindow = globalThis.window;
+try {
+  globalThis.window = {location: {href: "http://127.0.0.1:12345/chat/"}};
+  globalThis.fetch = async input => {
+    assert.equal(new URL(input, window.location.href).searchParams.get("goal_id"), "view-a");
+    return Response.json({ok: true, goal_id: "native", total: 0, items: [], next_cursor: null});
+  };
+  assert.equal((await fetchExploreResults("view-a", undefined, undefined, "native")).goal_id, "native");
+  await assert.rejects(fetchExploreResults("view-a"), /mismatch/);
+} finally { globalThis.fetch = sourceFetch; globalThis.window = sourceWindow; }
 
 // A language-specific cache miss must not hide the same registered pack's
 // older, unspecified-language result or turn a read into model execution.
@@ -86,6 +128,25 @@ try {
   failOriginal = false;
   assert.deepEqual((await read()).originalPack, original, "The ordinary read retries recovery without execution");
 
+  // A failed/in-flight observation is unknown; only a successful empty read
+  // supports the absence message. Keep the existing read retry as recovery.
+  for (const zh of [true, false]) {
+    const empty = {...pack, availability: "available", selection: {exhaustive: false}, episode_count: 0};
+    const controller = {zh, pack: empty, requestPack: empty, location: {open: true}, panel: {current: null},
+      readOnly: true, loading: false, snapshot: {catalog: {}}, read: async () => {}, close: () => {}};
+    const noSaved = zh ? "此来源尚无已保存的分析。" : "This source has no saved analysis yet.";
+    const render = state => renderToStaticMarkup(createElement(ResearchAnalysisPanel, {analysis: {...controller, ...state}}));
+    assert.ok(render({}).includes(noSaved), "A successful empty source retains its ordinary absence state");
+    for (const state of [{loading: true}, {readError: "Source unavailable"}, {snapshot: {catalog: {}, originalReadError: "Original unavailable"}}]) {
+      const html = render(state);
+      assert.ok(!html.includes(noSaved), "An incomplete source read must not claim that no saved analysis exists");
+      if (!state.loading) {
+        assert.ok(html.includes('role="alert"'));
+        assert.ok(html.includes(zh ? 'aria-label="重试读取"' : 'aria-label="Retry reading"'));
+      }
+    }
+  }
+
   for (const options of [{current: () => false}, {signal: AbortSignal.abort()}]) {
     reset("zh");
     value = await read(true, undefined, options.signal, options.current);

apps/presentation/dashboard/src/data/capability-configuration.ts

@@ -78,6 +78,7 @@ export function replanCadenceEditorDefaults(effective: unknown, fallback: unknow
   if (Object.hasOwn(live, "count_unit")) defaults.count_unit = live.count_unit;
   if (Object.hasOwn(live, "count")) defaults.count = live.count;
   if (Object.hasOwn(live, "planning_horizon_goal")) defaults.planning_horizon_goal = live.planning_horizon_goal;
+  if (Object.hasOwn(live, "yardstick_enabled")) defaults.yardstick_enabled = live.yardstick_enabled;
   // Strategy omission keeps the existing default-off meaning.
   return defaults;
 }
@@ -102,13 +103,15 @@ export function goalReplanCadenceWriteValue(
   draft: Record<string, unknown>,
   cadenceOverride: boolean,
   horizonOverride = Object.hasOwn(draft, "planning_horizon_goal"),
+  yardstickOverride = Object.hasOwn(draft, "yardstick_enabled"),
 ): Record<string, unknown> {
   const value = { ...draft };
   if (!cadenceOverride) {
     delete value.count_unit;
     delete value.count;
   }
   if (!horizonOverride) delete value.planning_horizon_goal;
+  if (!yardstickOverride) delete value.yardstick_enabled;
   return value;
 }
 

apps/presentation/dashboard/src/data/chat.ts

@@ -1,3 +1,4 @@
+import {normalizeWorkYardstickCapture} from "../../../../../loopx/control_plane/work_items/yardstick_decision.js";
 import {sourceReadApiUrl} from "./local-status-query";
 import type {OracleEvidence} from "./goal-acceptance-observation";
 import { HANDOFF_MODES, EXECUTION_HANDOFF_MODES, type ExecutionHandoffMode } from "../../../../../loopx/control_plane/coordination/handoff_mode_vocabulary.js";
@@ -3008,16 +3009,47 @@ const exploreResultPageSchema = z.object({
     evidence_refs: z.array(z.string()), last_updated_at: z.string(),
     measurements: z.unknown().transform(value => normalizeExploreMeasurements(value)).optional(),
     measurement_error: z.string().optional(),
+    work_yardstick: z.unknown().transform(capture => normalizeWorkYardstickCapture({capture})).optional(),
     linked_todos_available: z.boolean().optional(),
     linked_todos: z.array(z.object({
       todo_id: z.string(), text: z.string(), status: z.string(), claimed_by: z.string(),
     })),
   })),
 });
 export type ExploreResultPage = z.infer<typeof exploreResultPageSchema>;
-export async function fetchExploreResults(goalId: string, cursor?: string, readSourceUrl?: string) {
+export async function fetchExploreResults(goalId: string, cursor?: string, readSourceUrl?: string, originalGoalId = goalId) {
   const query = new URLSearchParams({goal_id: goalId, view: "findings", ...(cursor ? {cursor} : {})});
   const page = exploreResultPageSchema.parse(await requestJson<unknown>(sourceReadApiUrl(readSourceUrl, `/api/chat/explore-results?${query}`)));
-  if (page.goal_id !== goalId) throw new Error("Explore result Goal mismatch");
+  if (page.goal_id !== originalGoalId) throw new Error("Explore result Goal mismatch");
+  for (const item of page.items) if (item.work_yardstick) normalizeWorkYardstickCapture({
+    capture: item.work_yardstick, goal_id: originalGoalId, agent_id: item.agent_id, evidence_refs: item.evidence_refs,
+  });
   return page;
 }
+
+const researchHistoryTimingSchema = z.object({
+  ok: z.literal(true),
+  goal_id: z.string(),
+  source_namespace: z.string().nullable(),
+  first_recorded_at: z.iso.datetime().nullable(),
+  last_recorded_at: z.iso.datetime().nullable(),
+  untimed_record_count: z.number().int().nonnegative(),
+  strategy_recorded_at: z.iso.datetime().nullable(),
+}).refine(value => value.first_recorded_at === null
+  ? value.last_recorded_at === null
+  : value.last_recorded_at !== null && Date.parse(value.first_recorded_at) <= Date.parse(value.last_recorded_at));
+export type ResearchHistoryTiming = z.infer<typeof researchHistoryTimingSchema>;
+
+export async function fetchResearchHistoryTiming(
+  goalId: string, originalGoalId: string, namespace: string | null, directoryUrl: string | undefined, signal: AbortSignal,
+): Promise<ResearchHistoryTiming> {
+  const statusUrl = namespace ? `/status.json?source_namespace=${namespace}` : directoryUrl;
+  const query = new URLSearchParams({goal_id: goalId, view: "history-timing"});
+  const timing = researchHistoryTimingSchema.parse(await requestJson<unknown>(
+    sourceReadApiUrl(statusUrl, `/api/chat/explore-results?${query}`), {signal},
+  ));
+  if (timing.goal_id !== originalGoalId || timing.source_namespace !== namespace) {
+    throw new Error("Research timing source mismatch");
+  }
+  return timing;
+}

apps/presentation/dashboard/src/data/conversation-returns.test.mjs

@@ -167,6 +167,28 @@ assert.deepEqual(distinct.map(row => row.marker), ["stream", "foreign", "another
   "Equal text, other Sessions/Turns and separate follow-up identities remain distinct");
 console.log("conversation-returns: history-before-admission preserves the live identity and distinct replies");
 
+// A fast queued Turn can finish before its start/stream is observed. Its
+// canonical answer replaces the waiting receipt, never a live stream.
+const queuedReply = {sourceSessionId: "current", sourceTurnId: "same-turn", role: "assistant",
+  text: "", queued: true, pending: false};
+const completedQueue = reconcileConversationHistory([queuedReply], [storedRoles[1]], createHistory);
+assert.equal(completedQueue.length, 1);
+assert.equal(completedQueue[0].text, storedRoles[1].text);
+assert.equal(completedQueue[0].queued, false);
+assert.equal(completedQueue[0].sourceMessageId, "agent-message");
+assert.equal(reconcileConversationHistory(completedQueue, [storedRoles[1]], createHistory), completedQueue);
+const unboundQueuedReply = {...queuedReply, sourceTurnId: undefined, sourceMessageId: "agent-message"};
+const unboundAnswer = reconcileConversationReturns([unboundQueuedReply], "current", [{...storedRoles[1], turn_id: undefined}], createHistory);
+assert.equal(unboundAnswer[0].text, "");
+assert.equal(unboundAnswer[0].queued, true, "Two absent Turn identities do not prove queue execution");
+for (const change of [{pending: true, text: "Live fragment"}, {queued: false, text: "Existing answer"},
+  {sourceSessionId: "foreign"}, {sourceTurnId: "another-turn"}]) {
+  const original = {...queuedReply, ...change};
+  const observed = reconcileConversationHistory([original], [storedRoles[1]], createHistory);
+  assert.equal(observed.find(row => row === original || row.sourceTurnId === original.sourceTurnId
+    && row.sourceSessionId === original.sourceSessionId)?.text, original.text);
+}
+
 // A revised brief keeps its return obligation despite a delivered old conclusion.
 const revised = [{sourceSessionId: "original", collaborations: [
   {request_id: "a", request_revision: 2, returns: [{phase: "conclusion", status: "delivered", request_revision: 1}]},

apps/presentation/dashboard/src/data/conversation-returns.ts

@@ -9,6 +9,7 @@ type ConversationMessage = {
   sourceCreatedAt?: string;
   role?: string;
   pending?: boolean;
+  queued?: boolean;
   collaboration?: ChatVisibleMessage["collaboration"];
   collaborations?: ChatVisibleMessage["collaborations"];
   returnDelivery?: ChatVisibleMessage["return_delivery"];
@@ -81,16 +82,19 @@ export function reconcileConversationReturns<T extends ConversationMessage>(
       && source.queue_input_revision > (row.queueInputRevision ?? 0);
     const queueInputRevision = inputChanged ? source.queue_input_revision : row.queueInputRevision;
     const queueInputCancelled = inputChanged ? source.queue_input_cancelled : row.queueInputCancelled;
-    const text = inputChanged ? source.text : row.role === "user" && source.reply_context && row.text === source.text
+    const queueAnswered = row.queued === true && !row.pending && row.role === "assistant"
+      && Boolean(row.sourceTurnId) && source.role !== "user" && source.origin !== "manager_followup" && source.turn_id === row.sourceTurnId;
+    const queued = queueAnswered ? false : row.queued;
+    const text = inputChanged || queueAnswered ? source.text : row.role === "user" && source.reply_context && row.text === source.text
       ? source.reply_context.source_text : row.text;
     if (row.sourceMessageId === source.message_id && JSON.stringify(row.returnDelivery) === JSON.stringify(returnDelivery)
       && JSON.stringify(row.collaboration) === JSON.stringify(collaboration)
       && JSON.stringify(row.collaborations) === JSON.stringify(collaborations) && row.sourceCreatedAt === sourceCreatedAt
       && JSON.stringify(row.replyContext) === JSON.stringify(replyContext) && row.text === text
-      && row.queueInputRevision === queueInputRevision && row.queueInputCancelled === queueInputCancelled) return row;
+      && row.queueInputRevision === queueInputRevision && row.queueInputCancelled === queueInputCancelled && row.queued === queued) return row;
     changed = true;
     return { ...row, sourceMessageId: source.message_id, sourceCreatedAt, returnDelivery, collaboration, collaborations, replyContext, text,
-      queueInputRevision, queueInputCancelled };
+      queueInputRevision, queueInputCancelled, ...(queueAnswered ? {queued: false} : {}) };
   });
   for (const message of messages) {
     if (message.origin !== "manager_followup" || seen.has(message.message_id)) continue;