diff --git a/apps/presentation/dashboard/src/data/chat.ts b/apps/presentation/dashboard/src/data/chat.ts
index 258c576ef5..bdae58f1a9 100644
--- a/apps/presentation/dashboard/src/data/chat.ts
+++ b/apps/presentation/dashboard/src/data/chat.ts
@@ -2630,6 +2630,14 @@ const privateConversationSchema = z.object({
       goal_active: z.boolean().optional(), monitor: z.object({todo_id: z.string(), status: z.string(),
         cadence_minutes: z.number().int().nullable(), next_due_at: z.string().nullable(),
         last_checked_at: z.string().nullable()}).nullable().optional(),
+      report: z.discriminatedUnion("available", [
+        z.object({available: z.literal(true), enabled: z.boolean(), configured: z.boolean(),
+          schedule: z.record(z.string(), z.unknown()).nullable().optional(), next_due_at: z.string().nullable().optional(),
+          retained_window_due_at: z.string().nullable().optional(), generation_id: z.string().nullable().optional(),
+          delivery_status: z.string().optional(), publication_verified: z.boolean().optional(),
+          destination: z.string().optional()}),
+        z.object({available: z.literal(false), error_code: z.string()}),
+      ]).optional(),
       goal_id: z.string().optional(), agent_id: z.string().optional(), session_id: z.string().optional()}),
     z.object({available: z.literal(false), error_code: z.string()}),
   ]).optional(),
@@ -2695,6 +2703,21 @@ export async function changePrivateAgentTarget(bindingId: string, revision: numb
   }));
 }
 
+const stewardReportPlanSchema = z.object({ok: z.literal(true), applied: z.boolean(), stop_status: z.string().optional(), plan: z.object({
+  schema_version: z.literal("loopx_steward_report_plan_v0"), plan_id: z.string().regex(/^[a-f0-9]{64}$/),
+})});
+export async function configureStewardReport(bindingId: string, operation: "enable" | "pause" | "cancel", schedule?: Record<string, unknown>) {
+  const path = "/api/chat/lark/private-conversations/managed-steward/report";
+  const send = (body: unknown) => requestJson<unknown>(path, {method: "POST",
+    headers: {"Content-Type": "application/json"}, body: JSON.stringify(body)});
+  const request = {binding_id: bindingId, operation, ...(operation === "enable" ? {schedule} : {})};
+  const preview = stewardReportPlanSchema.parse(await send({...request, execute: false}));
+  const applied = stewardReportPlanSchema.parse(await send({...request, execute: true, plan_id: preview.plan.plan_id}));
+  if (!applied.applied) throw new Error("The original report setting was not applied.");
+  if (applied.stop_status === "unconfirmed") throw new Error("汇报计划已取消；正在生成的任务是否停止尚未确认。Report cancelled; the active task's stop is unconfirmed.");
+  return applied;
+}
+
 export async function changeOwnerNotifications(bindingId: string, bindingRevision: number, revision: number, enabled: boolean) {
   return privateConversationsSchema.parse(await requestJson<unknown>("/api/chat/lark/private-conversations/owner-notifications", {
     method: "POST", headers: {"Content-Type": "application/json"},
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/periodic-report-schedule-field.tsx b/apps/presentation/dashboard/src/features/personal-workspace/periodic-report-schedule-field.tsx
index ca95e2137d..e7fdbb43f4 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/periodic-report-schedule-field.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/periodic-report-schedule-field.tsx
@@ -14,11 +14,12 @@ export function withReportScheduleTimezone(
   return result;
 }
 
-export function PeriodicReportScheduleField({ id, value, timezone, onChange }: Readonly<{
+export function PeriodicReportScheduleField({ id, value, timezone, onChange, calendarRequired = false }: Readonly<{
   id: string;
   value: unknown;
   timezone: string;
   onChange?: (value: Schedule | null) => void;
+  calendarRequired?: boolean;
 }>) {
   const { locale } = useWorkspaceI18n();
   const zh = locale === "zh-CN";
@@ -53,11 +54,11 @@ export function PeriodicReportScheduleField({ id, value, timezone, onChange }: R
   }
   return <div className="personal-report-schedule">
     <label className="is-boolean" htmlFor={id}>
-      <span>{zh ? "按日历汇报" : "Calendar reports"}</span>
-      <input id={id} type="checkbox" role="switch" checked={Boolean(schedule)} disabled={!onChange}
+      <span>{calendarRequired ? (zh ? "按日历汇报（必选）" : "Calendar reports (required)") : (zh ? "按日历汇报" : "Calendar reports")}</span>
+      <input id={id} type="checkbox" role="switch" checked={Boolean(schedule)} disabled={!onChange || calendarRequired}
         onChange={(event) => event.target.checked ? change({}) : onChange?.(null)} />
     </label>
-    {!schedule ? <p>{zh ? "未设置日历计划；保持阶段结束时汇报。" : "No calendar schedule; report at validated stage boundaries."}</p> : <>
+    {!schedule ? <p>{calendarRequired ? (zh ? "请配置必选的汇报日历。" : "Configure the required report calendar.") : (zh ? "未设置日历计划；保持阶段结束时汇报。" : "No calendar schedule; report at validated stage boundaries.")}</p> : <>
       {!supported ? <p role="alert">{zh ? "此计划需在 JSON 模式中编辑；当前内容已保留。" : "Edit this schedule in JSON mode; its current value is preserved."}</p> : <>
         <label htmlFor={`${id}-frequency`}><span>{zh ? "频率" : "Frequency"}</span>
           <select id={`${id}-frequency`} value={rule.FREQ} disabled={!onChange} onChange={(event) => change({ FREQ: event.target.value })}>
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/private-conversation-panel.tsx b/apps/presentation/dashboard/src/features/personal-workspace/private-conversation-panel.tsx
index 97c8a81596..1314572b65 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/private-conversation-panel.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/private-conversation-panel.tsx
@@ -1,6 +1,6 @@
 import {useEffect, useRef, useState} from "react";
 import {connectPrivateConversation, disconnectPrivateConversation, fetchPrivateConversations,
-  changePrivateAgentTarget, changeOwnerNotifications, prepareManagedSteward, configureStewardMonitor, fetchChatProjects, fetchChatCapabilities, fetchLarkGroupChats, type PrivateConversation,
+  changePrivateAgentTarget, changeOwnerNotifications, prepareManagedSteward, configureStewardMonitor, configureStewardReport, fetchChatProjects, fetchChatCapabilities, fetchLarkGroupChats, type PrivateConversation,
   discoverBoundChatSession, type BoundConversationTarget,
   type ChatProject, type LarkApp, type PrivateConversationStopRecovery} from "../../data/chat";
 import {useWorkspaceI18n} from "./i18n";
@@ -165,7 +165,8 @@ export function PrivateConversationPanel({apps, onOpenOriginal}: {apps: LarkApp[
       {row.context_kind === "steward" && row.audience === "owner" && row.executor_endpoint_id === "codex"
         ? <StewardManagedMode state={row.managed_steward} zh={zh} busy={busy} available={row.context_available}
             onPrepare={() => void act(() => prepareManagedSteward(row.binding_id))}
-            onMonitor={(operation, cadence) => void act(() => configureStewardMonitor(row.binding_id, operation, cadence))}/> : null}
+            onMonitor={(operation, cadence) => void act(() => configureStewardMonitor(row.binding_id, operation, cadence))}
+            onReport={(operation, schedule) => void act(() => configureStewardReport(row.binding_id, operation, schedule))}/> : null}
       {row.context_kind === "steward" && row.goal_scope !== "all_registered" ? <button disabled={busy || !row.context_available} onClick={() => void act(() => connectPrivateConversation(row.app_ref, row.project_ref, row.executor_endpoint_id, "steward"))} type="button">{zh ? "授权全部已注册工作" : "Authorize all registered work"}</button> : null}
       <button disabled={busy} onClick={() => void act(() => disconnectPrivateConversation(row.binding_id, revision))} type="button">{zh ? "解绑" : "Disconnect"}</button>
     </article>)}
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/steward-managed-mode.tsx b/apps/presentation/dashboard/src/features/personal-workspace/steward-managed-mode.tsx
index e3e988b7c1..e557398d2d 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/steward-managed-mode.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/steward-managed-mode.tsx
@@ -1,11 +1,13 @@
 import type {PrivateConversation} from "../../data/chat";
 import {useEffect, useState} from "react";
+import {StewardReport} from "./steward-report";
 
 /** Identity preparation is deliberately distinct from enabling scheduled work. */
-export function StewardManagedMode({state, zh, busy, available, onPrepare, onMonitor}: {
+export function StewardManagedMode({state, zh, busy, available, onPrepare, onMonitor, onReport}: {
   state: PrivateConversation["managed_steward"]; zh: boolean; busy: boolean;
   available: boolean; onPrepare: () => void;
   onMonitor: (operation: "enable" | "pause", cadenceMinutes: number) => void;
+  onReport: (operation: "enable" | "pause" | "cancel", schedule?: Record<string, unknown>) => void;
 }) {
   const initial = state?.available ? state.monitor?.cadence_minutes : null;
   const monitorId = state?.available ? state.monitor?.todo_id : null;
@@ -20,7 +22,7 @@ export function StewardManagedMode({state, zh, busy, available, onPrepare, onMon
           ? (zh ? "授权 Goal 状态监控已启用。" : "Authorized Goal monitoring is enabled.")
           : state.monitor ? (zh ? "状态监控已暂停。" : "Goal monitoring is paused.")
           : (zh ? "管家身份已准备，状态监控尚未启用。" : "The steward identity is prepared; monitoring is not enabled.")}</p>
-        <p>{zh ? "状态检查复用原生监控，不调用模型。每日汇报尚未启用。" : "State checks use the native monitor without model calls. Daily reports are not enabled."}</p>
+        <p>{zh ? "状态检查复用原生监控，不调用模型。" : "State checks use the native monitor without model calls."}</p>
         {state.goal_active === false ? <p role="status">{zh ? "管家的工作 Goal 已停止；恢复原 Goal 后才能继续监控。" : "The steward Goal is stopped. Resume that original Goal before monitoring."}</p> : null}
         {state.monitor ? <p>{state.scheduling_enabled ? (zh ? "下次检查：" : "Next check: ") : (zh ? "保留的到期时间：" : "Retained deadline: ")}{state.monitor.next_due_at ? new Date(state.monitor.next_due_at).toLocaleString(zh ? "zh-CN" : "en-US") : (zh ? "未排期" : "Unscheduled")}
           <br/>{zh ? "上次检查：" : "Last check: "}{state.monitor.last_checked_at ? new Date(state.monitor.last_checked_at).toLocaleString() : (zh ? "尚未完成首次检查" : "No completed check yet")}</p> : null}
@@ -32,6 +34,7 @@ export function StewardManagedMode({state, zh, busy, available, onPrepare, onMon
         <div className="personal-cadence-actions"><button className="is-primary" style={{minHeight: 44}} type="button" disabled={busy || !available || state.goal_active === false || !Number.isInteger(cadence) || cadence < 30 || cadence > 1440}
           onClick={() => onMonitor("enable", cadence)}>{state.scheduling_enabled ? (zh ? "更新周期" : "Update interval") : (zh ? "启用状态监控" : "Enable monitoring")}</button>
         {state.monitor?.status === "open" ? <button style={{minHeight: 44}} type="button" disabled={busy || !available} onClick={() => onMonitor("pause", initial ?? 30)}>{zh ? "暂停状态监控" : "Pause monitoring"}</button> : null}</div>
+        <StewardReport state={state.report} zh={zh} busy={busy} available={available} goalActive={state.goal_active !== false} onChange={onReport}/>
       </>
       : <>
         <p>{zh ? "为当前管家准备一个可见的 LoopX 工作身份，保留原对话和权限。此步骤不会启动定时任务或模型。" : "Prepare one visible LoopX identity for this steward, retaining its original conversation and permissions. This step starts neither scheduled tasks nor a model."}</p>
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/steward-report.css b/apps/presentation/dashboard/src/features/personal-workspace/steward-report.css
new file mode 100644
index 0000000000..ea5706e301
--- /dev/null
+++ b/apps/presentation/dashboard/src/features/personal-workspace/steward-report.css
@@ -0,0 +1,6 @@
+.personal-steward-report { display: grid; gap: 16px; min-width: 0; margin-top: 20px; padding-top: 20px; border-top: 1px solid var(--pw-line); }
+.personal-steward-report h4 { margin: 0; font-size: var(--text-heading); line-height: var(--leading-heading); }
+.personal-steward-report > p { margin: 0; color: var(--pw-muted); font-size: var(--text-body); line-height: var(--leading-body); overflow-wrap: anywhere; }
+.personal-steward-report > [role="status"] { color: var(--pw-text); font-weight: 600; }
+.personal-steward-report .personal-cadence-actions > button { min-height: 44px; }
+.personal-steward-report .personal-capability-fields > label { grid-column: 1 / -1; }
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/steward-report.tsx b/apps/presentation/dashboard/src/features/personal-workspace/steward-report.tsx
new file mode 100644
index 0000000000..da24073516
--- /dev/null
+++ b/apps/presentation/dashboard/src/features/personal-workspace/steward-report.tsx
@@ -0,0 +1,57 @@
+import {useEffect, useId, useState} from "react";
+import type {PrivateConversation} from "../../data/chat";
+import {PeriodicReportScheduleField, withReportScheduleTimezone} from "./periodic-report-schedule-field";
+import "./steward-report.css";
+
+type Managed = Extract<NonNullable<PrivateConversation["managed_steward"]>, {available: true}>;
+
+export function StewardReport({state, zh, busy, available, goalActive, onChange}: {
+  state: Managed["report"]; zh: boolean; busy: boolean; available: boolean; goalActive: boolean;
+  onChange: (operation: "enable" | "pause" | "cancel", schedule?: Record<string, unknown>) => void;
+}) {
+  const original = state?.available ? state.schedule : null;
+  const scheduleId = useId();
+  const defaultZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  const [zone, setZone] = useState(String(original?.timezone ?? defaultZone));
+  const [schedule, setSchedule] = useState<Record<string, unknown> | null>(original ?? {
+    schema_version: "periodic_report_schedule_v0", schedule_id: "steward-report",
+    timezone: defaultZone, rrule: "FREQ=DAILY;BYHOUR=9;BYMINUTE=0",
+    start_date: new Intl.DateTimeFormat("sv-SE", {timeZone: defaultZone}).format(new Date()),
+  });
+  const signature = JSON.stringify(original);
+  useEffect(() => {if (original) {setSchedule(original); setZone(String(original.timezone));}}, [signature]);
+  if (!state) return null;
+  const disabled = busy || !available;
+  let validZone = true;
+  try {new Intl.DateTimeFormat("en", {timeZone: zone}).format();} catch {validZone = false;}
+  const stamp = (value?: string | null) => value ? new Date(value).toLocaleString(zh ? "zh-CN" : "en-US") : (zh ? "暂无" : "None");
+  return <section className="personal-steward-report">
+    <h4>{zh ? "定期详细汇报" : "Detailed periodic reports"}</h4>
+    {!state.available ? <p role="status">{zh ? "汇报状态暂不可读；原计划和回执已保留。刷新连接后重试。" : "Report status is unavailable. The original schedule and receipts are retained; refresh the connection."}</p> : <>
+      <p role="status">{state.enabled ? (zh ? "已启用 · 完整中文正文回此私聊" : "Enabled · Full Chinese report returns to this private Chat")
+        : state.configured ? (zh ? "已暂停 · 原窗口和回执保留" : "Paused · Original windows and receipts retained")
+        : (zh ? "尚未启用" : "Not enabled")}</p>
+      <p>{zh ? "汇总全部获准本机 Goal，包括停止项和读取缺口。每天汇报前24小时，生成与实际送达分别核验；状态监控照常运行。" : "Covers every authorized local Goal, including stopped Goals and read gaps. Daily reports cover the previous 24 hours; generation and delivery are verified separately. Monitoring continues."}</p>
+      {state.configured ? <p>{zh ? "下次计划：" : "Next deadline: "}{stamp(state.next_due_at)}<br/>
+        {zh ? "最近窗口：" : "Latest window: "}{stamp(state.retained_window_due_at)} · {state.delivery_status === "delivered"
+          ? (zh ? "原私聊全文已核验送达" : "Full private reply verified")
+          : state.delivery_status === "generation_failed" ? (zh ? "本期生成失败，证据保留；取消失败窗口后，后续到期可继续" : "Generation failed; evidence retained. Cancel this failed window to continue at a later deadline.")
+          : state.delivery_status === "generation_cancelled" ? (zh ? "失败窗口已取消，未完成或送达；原证据保留" : "Failed window cancelled, not completed or delivered; evidence retained")
+          : state.delivery_status === "unconfirmed" ? (zh ? "发送结果待确认，不重复发送" : "Send unconfirmed; no blind resend")
+          : state.generation_id ? (zh ? "已生成，投递待核验" : "Generated; delivery pending") : (zh ? "尚未生成" : "Not generated")}</p> : null}
+      <div className="personal-capability-fields"><label>{zh ? "汇报时区" : "Report timezone"}<input value={zone} aria-invalid={!validZone} disabled={disabled} onChange={event => {
+        const value = event.target.value; setZone(value);
+        if (schedule) setSchedule(withReportScheduleTimezone({schedule}, "timezone", value).schedule as Record<string, unknown>);
+      }}/></label>
+      {!validZone ? <p role="alert">{zh ? "请输入有效时区，例如 Asia/Shanghai。" : "Enter a valid timezone, such as Asia/Shanghai."}</p> : null}
+      <PeriodicReportScheduleField id={scheduleId} value={schedule} timezone={zone} calendarRequired
+        onChange={disabled ? undefined : setSchedule}/></div>
+      <p>{zh ? "暂停只停止后续生成；取消还会请求停止正在生成的本期汇报。两者均保留已生成报告和投递回执，停用期间不再发送。" : "Pause stops future generation. Cancel also requests a stop for an active report. Both retain generated reports and receipts, and stop further delivery while disabled."}</p>
+      <div className="personal-cadence-actions"><button className="is-primary" type="button" disabled={disabled || !goalActive || !schedule || !zone.trim() || !validZone}
+        onClick={() => schedule && onChange("enable", schedule)}>{state.enabled ? (zh ? "更新汇报计划" : "Update report schedule") : (zh ? "启用详细汇报" : "Enable detailed reports")}</button>
+        {state.enabled ? <button type="button" disabled={disabled} onClick={() => onChange("pause")}>{zh ? "暂停汇报" : "Pause reports"}</button> : null}
+        {state.configured ? <button type="button" disabled={disabled} onClick={() => onChange("cancel")}>{state.delivery_status === "generation_failed" ? (zh ? "取消失败窗口" : "Cancel failed window") : (zh ? "取消汇报" : "Cancel reports")}</button> : null}
+      </div>
+    </>}
+  </section>;
+}
diff --git a/docs/assets/personal-workspace/steward-reports/baseline-desktop.png b/docs/assets/personal-workspace/steward-reports/baseline-desktop.png
new file mode 100644
index 0000000000..644fc1a701
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/baseline-desktop.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/cancelled-window-narrow.png b/docs/assets/personal-workspace/steward-reports/cancelled-window-narrow.png
new file mode 100644
index 0000000000..7e4d71aab5
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/cancelled-window-narrow.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/controls-narrow.png b/docs/assets/personal-workspace/steward-reports/controls-narrow.png
new file mode 100644
index 0000000000..ea287392f9
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/controls-narrow.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/default-narrow.png b/docs/assets/personal-workspace/steward-reports/default-narrow.png
new file mode 100644
index 0000000000..dd5858d02b
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/default-narrow.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/delivered-desktop.png b/docs/assets/personal-workspace/steward-reports/delivered-desktop.png
new file mode 100644
index 0000000000..e92c5d88c0
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/delivered-desktop.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/enabled-desktop.png b/docs/assets/personal-workspace/steward-reports/enabled-desktop.png
new file mode 100644
index 0000000000..d602818dfb
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/enabled-desktop.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/enabled-narrow.png b/docs/assets/personal-workspace/steward-reports/enabled-narrow.png
new file mode 100644
index 0000000000..1e715868e4
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/enabled-narrow.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/failed-window-cancelled.png b/docs/assets/personal-workspace/steward-reports/failed-window-cancelled.png
new file mode 100644
index 0000000000..24fd6c5e7a
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/failed-window-cancelled.png differ
diff --git a/docs/assets/personal-workspace/steward-reports/settings-first-desktop.png b/docs/assets/personal-workspace/steward-reports/settings-first-desktop.png
new file mode 100644
index 0000000000..fc0b1964c4
Binary files /dev/null and b/docs/assets/personal-workspace/steward-reports/settings-first-desktop.png differ
diff --git a/docs/product/periodic-reports.md b/docs/product/periodic-reports.md
index ad775ed0c5..7866161f74 100644
--- a/docs/product/periodic-reports.md
+++ b/docs/product/periodic-reports.md
@@ -1,14 +1,15 @@
 # Managed steward monitoring and periodic reports
 
-Status: native identity preparation and opt-in status monitoring are implemented.
-Daily portfolio reports remain the target described below. Preparing an identity
-enables neither monitoring nor reports.
+Status: source-bound identity preparation, opt-in status monitoring and the
+original steward's periodic full-body report path are implemented. Installation,
+an enabled subscription and a natural scheduled delivery require their own
+readback evidence. Preparing an identity enables neither monitoring nor reports.
 
-The steward should become a persistent LoopX-managed Agent. Its original private
+The steward becomes a persistent LoopX-managed Agent. Its original private
 conversation remains the user's entry point. Native monitor Todos, Turn
 admission, scheduling and periodic-report publication own recurring work.
 
-## What exists and what is missing
+## Lifecycle owners
 
 The current components already provide most of the lifecycle:
 
@@ -273,24 +274,110 @@ sent again, and uncertain sends are read back before retry. After extended
 offline time, produce the most recent complete window and disclose missing
 windows, rather than starting an unbounded series of model calls.
 
-## Implementation order and acceptance
+### Original private report settings and execution
+
+In **Settings → Lark → the original steward → Native periodic monitoring**,
+the owner can enable or update detailed reports, select daily/weekly frequency,
+local time, timezone and first report date, or pause/cancel. The existing calendar
+field is reused. A source-bound preview and exact-plan apply configure the
+existing `periodic_report` Goal setting with the `portfolio-progress` preset;
+the destination is derived from the original private binding. Neither the
+browser nor the model can supply another Goal, App or recipient. The generic
+single-Goal report consumer cannot consume this private portfolio preset.
+This preset requires a calendar; its switch cannot select the generic
+stage-boundary reporting mode. Pause or cancel through the report actions.
+
+The existing idle Chat wake producer admits one calendar window and creates
+one native finite generation Todo for it. The original Chat worker and native
+thread author the report, using complete frozen source records and the owner's
+`REPORTING.md` criteria. Public-safe Turn fields remain separate from private
+editorial content. A report-specific opt-in allows the kernel's existing
+`validated_completion`; its original task lease and independent artifact
+validator must pass before the generation Todo closes. Ordinary host prompts
+and result vocabulary retain their defaults.
+The finite postcondition is the validated generation itself: a complete valid
+editorial response closes this generation Todo even if the model labels it
+progress. This does not close the ongoing Goal or claim delivery.
+
+If generation has completed but native writeback or debit has not committed,
+the normal idle producer resumes the remaining effects of that same original
+Turn. It reads the canonical completion under the original Turn fence, without
+reopening the Todo or invoking the model again. Existing effect readbacks also
+reconcile a committed effect whose response was lost; a missing outer Chat
+result event can be recovered from the committed native journal. Historical
+failures and generated content remain intact. Delivery still requires the
+native committed result and current original authorization; unknown or
+contradictory journal identity remains blocked.
+
+The existing Lark outbound pool reads the committed native result, validates
+the frozen source/editorial/artifact lineage and returns the full Chinese body
+through the original reply owner, splitting long text into verified parts.
+Known part IDs are read back after restart; a send with unknown outcome and no
+locator is retained without another create. Only complete provider verification
+advances the existing publication cursor. No additional scheduler, consumer,
+model worker, business store or provider scope is created.
+
+Pause disables subsequent generation and delivery. Cancel also requests a stop
+only for an active report Turn; an unconfirmed stop is shown separately from
+the committed configuration. Original reports and delivery receipts remain.
+Revocation, subscription changes, source/provider changes or damaged artifacts
+block late publication. Monitoring and ordinary conversation retain their own
+lifecycles. The settings show the next due time, retained window, generation and
+verified/unconfirmed delivery as separate facts.
+Changing a frozen, unverified report's schedule is rejected with a specific
+pending-window explanation. Pause and restoration of the same plan remain
+available; schedule edits can proceed after verified publication. This keeps an
+unfinished original window from being stranded by a different subscription.
+
+A terminal native attempt with a retained invalid editorial response, no
+generation and no delivery attempt is shown as generation failed. The owner's
+existing cancel action can explicitly retire that failed window: its Todo is
+paused as blocked, the native failure, cost and artifacts remain, and the cadence journal
+records retirement separately from publication. Restoring the same plan does
+not replay the failed attempt; a later due window can progress. A changed future
+plan is also allowed after retirement. Unknown model outcomes and partial or
+unknown sends cannot take this exit; they keep the original recovery boundary.
+
+| Cancelled failure on the original settings page | Narrow retained-failure state |
+| --- | --- |
+| ![Cancelled generation is not completed or delivered](../assets/personal-workspace/steward-reports/failed-window-cancelled.png) | ![Retained cancelled window in a narrow viewport](../assets/personal-workspace/steward-reports/cancelled-window-narrow.png) |
+
+![Default narrow settings viewport before opening monitoring](../assets/personal-workspace/steward-reports/default-narrow.png)
+
+The packaged browser fixture uses actual HTTP/Core/calendar storage with a
+synthetic original provider/model. Screenshots below are that isolated journey,
+not production-message or real-phone proof.
+
+| Before integration: monitoring only | Enabled future first date |
+| --- | --- |
+| ![Original steward has only status monitoring](../assets/personal-workspace/steward-reports/baseline-desktop.png) | ![Future first report date saved and read back](../assets/personal-workspace/steward-reports/enabled-desktop.png) |
+
+![Report controls in a narrow viewport](../assets/personal-workspace/steward-reports/enabled-narrow.png)
+
+## Acceptance boundaries
 
 The original-Session host bridge now runs a bounded native Turn through the
 existing Chat worker and Codex app-server connection. It uses the explicit
 `codex_app_server` outer-controller profile, not Codex CLI execution or a
 desktop App heartbeat. Fresh native work selection, independent validation,
 writeback, quota and scheduler handoff remain with the existing Turn command.
-It preserves the original conversation thread, provider and portfolio grant;
-busy/queued user work wins admission, and revoked or stopped sources cannot
+It retains the original visible conversation, provider and portfolio grant.
+With unchanged authorization it reuses the upstream model thread. For an
+all-registered report whose authorized inventory or Goal lifetime changed before
+execution, the existing context owner discards old model history and prepares a
+fresh upstream context, records it through the existing context owner, then re-enters strict native
+execution admission. No new user message is required to repair this context.
+Selected-scope changes, revocation and changes during a model call still fail
+closed. Busy/queued user work wins admission, and revoked or stopped sources cannot
 commit a late model result. Same-request readback does not restart failed or
 unknown work.
 
 The native status-monitor producer now uses this original-Session bridge,
 with the separate no-model observation path described above. Identity
-preparation still leaves monitoring disabled. Calendar configuration, unfinished
-native-journal recovery and original report publication remain the next
-integration boundary. A passing synthetic File/SQLite host journey does not
-establish an enabled daily report or real model/report quality.
+preparation still leaves monitoring disabled. Calendar configuration, native
+generation and original private publication use the owners described above.
+A passing synthetic File/SQLite host journey does not establish an enabled
+production subscription, real model/report quality or natural deadline delivery.
 
 1. Qualify the native steward upgrade and rollback at an idle boundary. Verify
    one registered actor, preserved original history/requests/grants, and no
@@ -374,8 +461,8 @@ reader calls, 4,000 evidence rows and 4 MiB of evidence data, plus bounded sourc
 coverage metadata; exhaustion is partial coverage,
 not success or zero progress. These are IO bounds, not a model budget.
 
-This source can be read through the original Chat dynamic tool. It does not
-activate the daily subscription, wake the reporting actor, write an editorial
-response or deliver a report. The remaining production integration must bind
-this source to the original actor's calendar intent, generation and private
-full-body delivery, then verify that original route independently.
+This source can also be read through the original Chat dynamic tool. Reading
+alone does not activate a subscription or deliver a report. The opt-in original
+steward report path binds it to the admitted calendar window, native generation
+and private full-body delivery; installed adoption, current configuration and
+the original production route still need independent verification.
diff --git a/examples/personal-workspace-browser/steward_report_fixture.py b/examples/personal-workspace-browser/steward_report_fixture.py
new file mode 100644
index 0000000000..ffd3ea1042
--- /dev/null
+++ b/examples/personal-workspace-browser/steward_report_fixture.py
@@ -0,0 +1,116 @@
+"""Disposable packaged UI + native HTTP/Core fixture; model/provider are synthetic.
+
+Run with the project's development dependencies and --output-dir outside Git.
+The two control files change synthetic provider readiness or start the existing
+host wake/outbound owners. No real account, Goal, workspace or listener is used.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import signal
+import sys
+from tempfile import TemporaryDirectory
+import threading
+from types import SimpleNamespace
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--baseline-assets-dir", type=Path)
+    parser.add_argument("--invalid-editorial", action="store_true", help="Return a known invalid synthetic report to inspect owner cancellation and retained failure.")
+    args = parser.parse_args()
+    repo = Path(__file__).resolve().parents[2]
+    sys.path[:0] = [str(repo), str(repo / "tests")]
+    from test_native_steward_private import steward
+    from test_native_steward_managed_mode import original, storage
+    from test_native_steward_reports import install_model
+    from loopx.chat_server import ChatHTTPServer, ChatRequestHandler
+    from loopx.chat_loopx_mode import DelegationWakeService
+    from loopx.extensions.lark.goal_topic_runtime_service import LarkGoalTopicRuntimeService
+    from loopx.extensions.lark.cli_resolution import LarkCliResolution
+    from loopx.presentation.codex_accounts_api import CodexAccountService
+    from loopx.capabilities.native_chat.steward_reports import StewardReports
+
+    output = args.output_dir.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    with TemporaryDirectory(prefix="loopx-report-qa-") as directory:
+        root = Path(directory)
+        fixture = steward.__wrapped__(root)
+        data = next(fixture)
+        store, runtime, provider, transport, binding, capture, workspace = data
+        sid, managed = original(data)
+        storage(runtime, "file")
+        plan = managed.prepare(binding["binding_id"], session_id=sid)["plan"]
+        actor = managed.prepare(binding["binding_id"], session_id=sid, execute=True,
+            expected_plan_id=plan["plan_id"])["actor"]
+        transport.reconcile()
+        install_model(data, root, sid)
+        if args.invalid_editorial:
+            helper = root / "report_model.py"
+            helper.write_text(helper.read_text().replace('"request_digest": request["request_digest"]', '"request_digest": "known-invalid"'))
+        before_calls, before_messages = capture.read_bytes(), store.messages(sid)
+        server = ChatHTTPServer(("127.0.0.1", 0), ChatRequestHandler)
+        server.chat_store, server.runtime_controller = store, runtime
+        server.registry_path, server.runtime_root_override = runtime.registry_path, str(store.root.parent)
+        server.runtime_root = runtime.coordination_runtime_root
+        server.scan_roots, server.limit, server.selected_goal_id = [workspace], 20, None
+        current_assets = repo / "loopx/web/chat"
+        baseline_assets = args.baseline_assets_dir.resolve() if args.baseline_assets_dir else current_assets
+        if not (baseline_assets / "index.html").is_file():
+            raise ValueError("baseline assets must be an existing packaged Chat bundle")
+        server.assets_dir, server.verbose = baseline_assets, False
+        server.codex_bin, server.ssh_config_path = runtime.codex_bin, None
+        server.goal_subagent_configuration_enabled = False
+        server.codex_account_service = CodexAccountService(runtime.coordination_runtime_root)
+        server.action_service, server.action_store = transport.core.actions, transport.core.actions.store
+        server.lark_cli_resolution = LarkCliResolution(command="lark-cli", available=True,
+            source="explicit", version="synthetic-browser-fixture", error_code=None)
+        server.lark_runner, server.lark_private_conversations = provider, transport
+        server.lark_goal_topic_runtime = SimpleNamespace(health_snapshot=lambda: {
+            "steward-app": {"status": "listening"}, "notes-app": {"status": "stopped"}}, close=lambda: None)
+        server.lark_app_setup_manager = SimpleNamespace(session=None, close=lambda: None)
+        stop = threading.Event()
+        signal.signal(signal.SIGTERM, lambda *_: stop.set())
+        signal.signal(signal.SIGINT, lambda *_: stop.set())
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+        (output / "ready.json").write_text(json.dumps({"url": f"http://127.0.0.1:{server.server_port}/chat/",
+            "binding_id": binding["binding_id"], "session_id": sid}))
+        wake, outbound, delivery = None, None, None
+        try:
+            while not stop.wait(.2):
+                server.assets_dir = current_assets if (output / "use-current-assets").exists() else baseline_assets
+                provider.owner_ready = not (output / "provider-unavailable").exists()
+                if wake is None and (output / "start-existing-owners").exists():
+                    wake = DelegationWakeService(runtime, interval=.1).start()
+                    outbound = LarkGoalTopicRuntimeService(snapshot_provider=lambda: {},
+                        runtime_root=runtime.coordination_runtime_root, runtime_controller=runtime,
+                        private_conversations=transport)
+                    delivery = threading.Thread(target=outbound._reconcile_private)
+                    delivery.start()
+                (output / "observed.json").write_text(json.dumps({
+                    "report": StewardReports(runtime).health(binding["binding_id"]),
+                    "same_actor": managed.health(binding["binding_id"])["session_id"] == actor["session_id"],
+                    "history_prefix_retained": store.messages(sid)[:len(before_messages)] == before_messages,
+                    "model_call_count": sum(json.loads(line).get("method") == "turn/start"
+                        for line in capture.read_bytes()[len(before_calls):].splitlines()),
+                    "provider_writes": len(provider.writes),
+                    "synthetic_only": True}, ensure_ascii=False))
+        finally:
+            if wake:
+                wake.close()
+            if outbound:
+                outbound.close()
+                delivery.join(5)
+            server.shutdown()
+            server.server_close()
+            try:
+                next(fixture)
+            except StopIteration:
+                pass
+
+
+if __name__ == "__main__":
+    main()
diff --git a/loopx/capabilities/native_chat/steward_managed_mode.py b/loopx/capabilities/native_chat/steward_managed_mode.py
index 06b9da2acb..b416041d0c 100644
--- a/loopx/capabilities/native_chat/steward_managed_mode.py
+++ b/loopx/capabilities/native_chat/steward_managed_mode.py
@@ -158,9 +158,10 @@ def health(self, binding_id: str) -> dict[str, Any]:
             native_goal = load_goal_from_registry(self.controller.registry_path, actor["goal_id"])
             active = bool(native_goal and native_goal.get("status") == "active" and not goal_is_stopped(native_goal))
             cadence = monitor_cadence_delta(monitor.get("cadence")) if monitor else None
+            from .steward_reports import StewardReports
             return {"available": True, "prepared": True,
                     "scheduling_enabled": bool(active and monitor and monitor.get("status") == "open"),
-                    "goal_active": active,
+                    "goal_active": active, "report": StewardReports(self.controller).health(binding_id),
                     "monitor": ({"todo_id": monitor["todo_id"], "status": monitor["status"],
                         "cadence_minutes": int(cadence.total_seconds() / 60) if cadence else None,
                         "next_due_at": monitor.get("next_due_at"), "last_checked_at": monitor.get("last_checked_at")}
diff --git a/loopx/capabilities/native_chat/steward_monitor.py b/loopx/capabilities/native_chat/steward_monitor.py
index 6b1ba6a817..432f778eff 100644
--- a/loopx/capabilities/native_chat/steward_monitor.py
+++ b/loopx/capabilities/native_chat/steward_monitor.py
@@ -233,6 +233,20 @@ def pump_steward_monitors(controller: Any, *, cancelled=lambda: False) -> list[d
             # it immediately; external edits are observed within a minute. Every
             # actual dispatch rechecks native state, original grant and provider.
             cache[binding["binding_id"]] = time.monotonic() + 60
+            # The existing pump also observes the optional report frontier.
+            # No second consumer/timer is installed. Closed/not-due calendars
+            # never invoke a model, and original user work wins the idle check.
+            goal = load_goal_from_registry(controller.registry_path, actor["goal_id"])
+            report_config = (goal or {}).get("control_plane", {}).get("periodic_report", {})
+            if report_config.get("enabled") is True and report_config.get("profile_preset") == "portfolio-progress":
+                from .steward_reports import StewardReports
+                try:
+                    accepted, created = StewardReports(controller).frontier(binding)
+                    if created:
+                        changed.append(accepted)
+                        continue
+                except (OSError, ValueError, KeyError, TypeError, RuntimeError):
+                    _LOG.warning("An original steward report is unavailable; its window and other work are retained")
             todo = service.current(actor)
             if todo is None or not monitor_todo_is_due(todo):
                 if todo and todo.get("next_due_at") and todo.get("status") == "open":
diff --git a/loopx/capabilities/native_chat/steward_reports.py b/loopx/capabilities/native_chat/steward_reports.py
new file mode 100644
index 0000000000..d539b7b47b
--- /dev/null
+++ b/loopx/capabilities/native_chat/steward_reports.py
@@ -0,0 +1,288 @@
+"""Calendar/report IO on the original Chat worker, using the native owners.
+
+Subscription configuration belongs to configure-goal, window admission to
+periodic-report, tasks/settlement to LoopX Turn, and private delivery to the
+bound provider. This adapter creates no scheduler, executor or business store.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+import sys
+from typing import Any
+
+from ...agent_registry import load_goal_from_registry
+from ...file_lock import exclusive_file_lock
+from ..periodic_report.cadence import report_cadence_next_due_at
+from ..periodic_report.cadence_journal import admit_cadence_window, cadence_intent, read_cadence_journal
+from ..periodic_report.goal_configuration import configuration_summary, normalize_configuration
+from ..periodic_report.machine_defaults import resolve_active_goal_periodic_report_subscription
+from ..periodic_report.private_generation import (
+    attempt_directory, freeze_private_report, prepare_private_report, report_prompt,
+)
+from .steward_commands import native_command
+from .steward_managed_mode import StewardManagedMode
+
+PRESET = "portfolio-progress"
+
+
+class PendingStewardReportError(ValueError):
+    pass
+
+
+class StewardReports:
+    def __init__(self, controller: Any) -> None:
+        self.controller = controller
+        self.bindings = controller.project_contexts.conversation_bindings
+        self.managed = StewardManagedMode(controller, self.bindings)
+        self.root = controller.coordination_runtime_root
+
+    @staticmethod
+    def route_ref(binding: dict[str, Any], actor: dict[str, Any]) -> str:
+        return f"steward-private:{binding['binding_id']}:{actor['source_ref']}"
+
+    def selected(self, binding_id: str) -> dict[str, Any]:
+        session = self.managed._session(binding_id, None)
+        saved = session["steward_context"]
+        selected = self.bindings.resolve(binding_id=binding_id, session=session,
+            include_observation=True, origin="web", source_ref=saved["source_ref"],
+            sender_ref=saved["operator_ref"], private_human_message=False, session_context=saved)
+        actor = selected["binding"].get("managed_actor")
+        if not actor or actor["session_id"] != session["session_id"]:
+            raise ValueError("prepare the original steward before configuring reports")
+        return {**selected, "actor": actor, "session": session}
+
+    def subscription(self, binding_id: str, *, expected_revision: str | None = None) -> dict[str, Any] | None:
+        selected = self.selected(binding_id)
+        actor, binding = selected["actor"], selected["binding"]
+        goal = load_goal_from_registry(self.controller.registry_path, actor["goal_id"])
+        subscription = resolve_active_goal_periodic_report_subscription(goal)
+        if (subscription is None or subscription.get("profile_preset") != PRESET
+                or subscription.get("route_ref") != self.route_ref(binding, actor)
+                or expected_revision is not None and subscription["effective_revision"] != expected_revision):
+            return None
+        return subscription
+
+    def _published_window(self, window: dict[str, Any]) -> bool:
+        from ..periodic_report.incremental import read_periodic_report_publication_cursor
+        from ..periodic_report.post_writeback_hook import evaluate_periodic_report_trigger_evaluation_intent
+        cursor = read_periodic_report_publication_cursor(runtime_root=self.root,
+            goal_id=window["goal_id"], agent_id=window["agent_id"])
+        trigger = evaluate_periodic_report_trigger_evaluation_intent(cadence_intent(window))
+        return bool(cursor and trigger["selected_trigger_id"] in cursor["covered_trigger_ids"])
+
+    def _known_generation_failure(self, actor: dict[str, Any], window: dict[str, Any]) -> dict[str, str] | None:
+        from .steward_turn import native_steward_client_id
+        folder = attempt_directory(self.root, window)
+        if (not (folder / "editorial-response.json").is_file()
+                or (folder / "private-generation.json").exists() or (folder / "private-delivery.json").exists()):
+            return None
+        turn = self.controller.store.turn_for_client(actor["session_id"],
+            native_steward_client_id(actor, "report." + window["window_id"]))
+        request = (turn or {}).get("loopx_request") or {}
+        native = ((turn or {}).get("response") or {}).get("native_loopx") or {}
+        if (turn and turn.get("status") == "completed" and native.get("status") == "failed"
+                and request.get("actor") == actor and request.get("report_window_id") == window["window_id"]):
+            return {"turn_id": turn["turn_id"], "todo_id": request["todo_id"]}
+        return None
+
+    def configure(self, binding_id: str, *, operation: str, schedule: dict[str, Any] | None = None,
+                  expected_plan_id: str | None = None, execute: bool = False) -> dict[str, Any]:
+        from ...configure_goal import configure_goal
+
+        selected = self.selected(binding_id)
+        binding, actor, session = selected["binding"], selected["actor"], selected["session"]
+        provider = getattr(self.controller, "steward_report_provider", None)
+        if provider is None:
+            raise ValueError("the original private report provider is unavailable")
+        route = provider.route_proof(binding, actor)
+        with self.controller.lock, exclusive_file_lock(self.bindings.path, operation="configure_steward_report"):
+            current = self.selected(binding_id)
+            if current["binding"] != binding:
+                raise ValueError("the original steward authorization changed")
+            goal = load_goal_from_registry(self.controller.registry_path, actor["goal_id"])
+            before = configuration_summary(goal)
+            effective_schedule = schedule if operation == "enable" else (before or {}).get("schedule")
+            if effective_schedule is None:
+                raise ValueError("select the daily or weekly report time and first date")
+            proposed = normalize_configuration({"enabled": operation == "enable", "profile_preset": PRESET,
+                "route_ref": self.route_ref(binding, actor), "timezone": effective_schedule["timezone"],
+                "schedule": effective_schedule})
+            active_proposed = resolve_active_goal_periodic_report_subscription(
+                {**goal, "control_plane": {"periodic_report": {**proposed, "enabled": True}}})
+            journal = read_cadence_journal(runtime_root=self.root, goal_id=actor["goal_id"])
+            pending = None
+            failure = None
+            if journal:
+                failure = self._known_generation_failure(actor, journal["window"])
+                pending = {"subscription_revision": journal["window"]["subscription_revision"],
+                    "prepared": (attempt_directory(self.root, journal["window"]) / "editorial-request.json").exists(),
+                    "verified_publication": self._published_window(journal["window"]),
+                    "retired": bool(journal.get("retirement")),
+                    "failure_ref": failure["turn_id"] if failure else None}
+            plan = self.bindings._core("collaboration.steward.report.plan", {
+                **current, "workspace_path": str(self.managed._workspace(session)),
+                "goal": self.managed._goal(actor["goal_id"]),
+                "goal_active": bool(active_proposed), "pending_report": pending,
+                "proposed_subscription_revision": active_proposed["effective_revision"] if active_proposed else None,
+                "configuration": before, "proposed": proposed, "operation": operation, "route": route})
+            if plan.get("gate") == "report_window_pending":
+                raise PendingStewardReportError("the original frozen report still requires verified private delivery")
+            if not execute:
+                return {"ok": True, "applied": False, "plan": plan}
+            if expected_plan_id != plan["plan_id"]:
+                raise ValueError("refresh the original report preview before applying")
+            result = configure_goal(registry_path=self.controller.registry_path, goal_id=actor["goal_id"],
+                periodic_report_configuration=plan["configuration"], execute=True)
+            if result.get("ok") is not True:
+                raise ValueError("native report configuration was not committed")
+            if configuration_summary(load_goal_from_registry(self.controller.registry_path, actor["goal_id"])) != proposed:
+                raise ValueError("native report configuration readback changed")
+            if plan["retires_failed_window"]:
+                from ..periodic_report.cadence_journal import retire_failed_cadence_window
+                key = "cancel.report." + journal["window"]["window_id"]
+                native_command(self.controller, ["todo", "update", "--goal-id", actor["goal_id"],
+                    "--todo-id", failure["todo_id"], "--agent-id", actor["agent_id"],
+                    "--update-operation-id", key, "--status", "blocked", "--clear-resume-when", "--reason",
+                    "Owner cancelled a known failed report window; retain the failed task, costs and evidence, not completed or delivered.", "--execute"])
+                retire_failed_cadence_window(runtime_root=self.root, goal_id=actor["goal_id"],
+                    expected_window_id=journal["window"]["window_id"], source_receipt_id=failure["turn_id"])
+            getattr(self.controller, "_steward_monitor_next_check", {}).pop(binding_id, None)
+            receipt = {"ok": True, "applied": True, "plan": plan, "report": self.health(binding_id),
+                "model_invoked": False, "external_writes_performed": False}
+        if operation == "cancel":
+            # Stop only this original report, outside the configuration fence;
+            # unrelated user/monitor work is never interrupted by this setting.
+            current_session = self.controller.store.load_session(actor["session_id"])
+            turn_id = (current_session or {}).get("active_turn_id")
+            turn = self.controller.store.load_turn(actor["session_id"], turn_id) if turn_id else None
+            request = (turn or {}).get("loopx_request") or {}
+            if request.get("work_kind") == "report" and request.get("actor") == actor:
+                try:
+                    stopped = self.controller.interrupt_turn(session_id=actor["session_id"], turn_id=turn_id)
+                    receipt["stop_status"] = stopped.get("status", "unconfirmed")
+                except (OSError, ValueError, RuntimeError):
+                    receipt["stop_status"] = "unconfirmed"
+        return receipt
+
+    def delivery_current(self, binding_id: str, window: dict[str, Any]) -> bool:
+        """Recheck the exact original read grant before every outbound part."""
+        from ...chat_manager_context import manager_authorization_scope_id_for_registry
+        if self.subscription(binding_id, expected_revision=window["subscription_revision"]) is None:
+            return False
+        selected = self.selected(binding_id)
+        session = selected["session"]
+        expected = json.loads((attempt_directory(self.root, window) / "editorial-request.json").read_text())
+        current = manager_authorization_scope_id_for_registry(self.controller.registry_path,
+            self.bindings.steward_scope(session), runtime_root=self.root, channel_id=session["channel_id"])
+        return current == expected["authorization_scope_id"]
+
+    def health(self, binding_id: str) -> dict[str, Any]:
+        """Content-free metadata, never a source/provider verification receipt."""
+        try:
+            binding = next(row for row in self.bindings.read()["bindings"] if row["binding_id"] == binding_id)
+            actor = binding.get("managed_actor")
+            if not actor:
+                return {"available": True, "enabled": False, "configured": False}
+            goal = load_goal_from_registry(self.controller.registry_path, actor["goal_id"])
+            config = configuration_summary(goal)
+            if not config or config.get("profile_preset") != PRESET:
+                return {"available": True, "enabled": False, "configured": False}
+            journal = read_cadence_journal(runtime_root=self.root, goal_id=actor["goal_id"])
+            generation, delivery = None, None
+            if journal:
+                folder = attempt_directory(self.root, journal["window"])
+                for name in ["private-generation.json", "private-delivery.json"]:
+                    path = folder / name
+                    if path.is_file():
+                        value = json.loads(path.read_text())
+                        if name == "private-generation.json":
+                            generation = value["generation_id"]
+                        else:
+                            delivery = value.get("delivery_status", "pending")
+                if journal.get("retirement"):
+                    delivery = "generation_cancelled"
+                elif self._known_generation_failure(actor, journal["window"]):
+                    delivery = "generation_failed"
+            active = resolve_active_goal_periodic_report_subscription(goal)
+            return {"available": True, "configured": True, "enabled": bool(active),
+                "schedule": config.get("schedule"), "next_due_at": report_cadence_next_due_at(
+                    config.get("schedule"), now=datetime.now(timezone.utc)) if config.get("enabled") else None,
+                "retained_window_due_at": journal["window"]["due_at"] if journal else None,
+                "generation_id": generation, "delivery_status": delivery or "not_generated",
+                "publication_verified": bool(journal and self._published_window(journal["window"])),
+                "destination": "original_owner_private_chat_full_body"}
+        except (OSError, ValueError, TypeError, KeyError, StopIteration):
+            return {"available": False, "error_code": "steward_report_unavailable"}
+
+    def current_window(self, binding_id: str) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+        subscription = self.subscription(binding_id)
+        if subscription is None:
+            return None, None
+        actor = self.selected(binding_id)["actor"]
+        journal = read_cadence_journal(runtime_root=self.root, goal_id=actor["goal_id"])
+        return subscription, journal["window"] if journal else None
+
+    def frontier(self, binding: dict[str, Any]) -> tuple[dict[str, Any] | None, bool]:
+        """Called only by the original host pump after its idle/cache checks."""
+        from .steward_monitor import StewardMonitor
+        from .steward_turn import StewardTurnHost
+
+        actor = binding["managed_actor"]
+        subscription = self.subscription(binding["binding_id"])
+        if subscription is None or subscription.get("schedule") is None:
+            return None, False
+        admitted = admit_cadence_window(runtime_root=self.root, goal_id=actor["goal_id"],
+            agent_id=actor["agent_id"], subscription=subscription, now=datetime.now(timezone.utc),
+            subscription_resolver=lambda: self.subscription(binding["binding_id"]))
+        if admitted["status"] != "pending":
+            return None, False
+        window = admitted["window"]
+        rows = [row for row in StewardMonitor(self.controller).todos(actor) if row.get("target_key") == window["window_id"]]
+        if len(rows) > 1:
+            raise ValueError("report window has conflicting native tasks")
+        if not rows:
+            native_command(self.controller, ["todo", "add", "--goal-id", actor["goal_id"],
+                "--role", "agent", "--operation-id", window["window_id"],
+                "--text", f"[P1] Author the authorized portfolio report ending {window['due_at']}; retain counterevidence and coverage gaps. Generation is separate from verified private delivery.",
+                "--claimed-by", actor["agent_id"], "--action-kind", "generate_periodic_report",
+                "--target-key", window["window_id"], "--continuation-policy", "same_agent_non_delivery",
+                "--execute"])
+            rows = [row for row in StewardMonitor(self.controller).todos(actor) if row.get("target_key") == window["window_id"]]
+        if len(rows) == 1 and rows[0]["status"] == "done":
+            StewardTurnHost(self.controller).recover_report_settlement(actor, window, rows[0])
+            return None, False
+        if len(rows) != 1 or rows[0]["status"] != "open":
+            return None, False
+        folder = attempt_directory(self.root, window)
+        validator = [sys.executable, "-c", "from pathlib import Path; from loopx.capabilities.periodic_report.private_generation import validate_private_generation; "
+            + f"validate_private_generation(Path({str(folder)!r}))"]
+        return StewardTurnHost(self.controller).submit(binding["binding_id"],
+            turn_instance_id="report." + window["window_id"], todo_id=rows[0]["todo_id"],
+            work_kind="report", report_window=window, validation_command=validator)
+
+    def prepare(self, request: dict[str, Any], adapter: Any, *, authorization_scope_id: str) -> str:
+        from ..manager_context.inspection import TOOL_NAME
+        _, window = self.current_window(request["actor"]["goal_id"].removeprefix("steward-agent-"))
+        if not window or window["window_id"] != request["report_window_id"]:
+            raise ValueError("the admitted original report window is unavailable")
+        reader = getattr(adapter.session, "read_tool_handler", None)
+        if reader is None or not authorization_scope_id:
+            raise ValueError("the original scoped report reader is unavailable")
+        session = self.controller.store.load_session(request["actor"]["session_id"])
+        rules = self.managed._workspace(session) / "REPORTING.md"
+        if rules.is_symlink():
+            raise ValueError("the original reporting criteria changed source")
+        reporting = rules.read_text(encoding="utf-8") if rules.exists() else "Use the existing overview-to-depth report contract and preserve all coverage gaps."
+        frozen = prepare_private_report(root=self.root, window=window, read=lambda query: reader(TOOL_NAME, query),
+            authorization_scope_id=authorization_scope_id, reporting=reporting)
+        return report_prompt(frozen, attempt_directory(self.root, window))
+
+    def freeze(self, request: dict[str, Any], candidate: dict[str, Any]) -> dict[str, Any]:
+        _, window = self.current_window(request["actor"]["goal_id"].removeprefix("steward-agent-"))
+        if not window or window["window_id"] != request["report_window_id"]:
+            raise ValueError("the original report was paused, cancelled or changed")
+        response = candidate.pop("editorial_response", None)
+        if not isinstance(response, dict):
+            raise ValueError("the original reporting Agent returned no editorial response")
+        return freeze_private_report(root=self.root, window=window, response=response)
diff --git a/loopx/capabilities/native_chat/steward_turn.py b/loopx/capabilities/native_chat/steward_turn.py
index 375ae78368..9a5a09bcbe 100644
--- a/loopx/capabilities/native_chat/steward_turn.py
+++ b/loopx/capabilities/native_chat/steward_turn.py
@@ -18,6 +18,11 @@
 from .steward_managed_mode import StewardManagedMode
 
 
+def native_steward_client_id(actor: Mapping[str, Any], turn_instance_id: str) -> str:
+    """The original native request identity, shared by dispatch and readback."""
+    return "native." + hashlib.sha256(json.dumps([actor, turn_instance_id], sort_keys=True).encode()).hexdigest()[:40]
+
+
 class StewardTurnHost:
     def __init__(self, controller: Any) -> None:
         self.controller = controller
@@ -27,7 +32,8 @@ def __init__(self, controller: Any) -> None:
             raise ValueError("the original steward binding is unavailable")
         self.managed = StewardManagedMode(controller, self.bindings)
 
-    def _admit(self, request: dict[str, Any], *, turn: dict[str, Any] | None = None) -> dict[str, Any]:
+    def _admit(self, request: dict[str, Any], *, turn: dict[str, Any] | None = None,
+               prepare_context: bool = False, settlement_recovery: dict[str, Any] | None = None) -> dict[str, Any]:
         if self.controller.closed.is_set():
             raise ValueError("the original Chat host is stopped")
         actor = request["actor"]
@@ -44,6 +50,13 @@ def _admit(self, request: dict[str, Any], *, turn: dict[str, Any] | None = None)
         canonical_actor = selected["binding"].get("managed_actor")
         monitor = StewardMonitor(self.controller).current(canonical_actor) if canonical_actor else None
         monitor = monitor if monitor and monitor["todo_id"] == request.get("todo_id") else None
+        report = {}
+        if request.get("work_kind") == "report":
+            from .steward_reports import StewardReports
+            subscription, window = StewardReports(self.controller).current_window(saved["binding_id"])
+            todos = StewardMonitor(self.controller).todos(canonical_actor) if canonical_actor else []
+            report = {"report_window": window, "report_subscription": subscription,
+                "report_todo": next((row for row in todos if row["todo_id"] == request.get("todo_id")), None)}
         scope = None
         if turn is not None:
             from ...chat_manager_context import manager_authorization_scope_id_for_registry
@@ -60,14 +73,70 @@ def scope_id(ids):
             "workspace_path": str(self.managed._workspace(session)),
             "queued_turn_count": len(self.store.queued_turns(session["session_id"])),
             "goal": self.managed._goal(actor["goal_id"]), "goal_active": bool(goal and goal.get("status") == "active" and not goal_is_stopped(goal)),
-            "request": request, "turn": turn, "scope": scope, "monitor_todo": monitor})
+            "request": request, "turn": turn, "scope": scope, "monitor_todo": monitor,
+            **({"report_settlement_recovery": settlement_recovery} if settlement_recovery is not None else {}),
+            **({"preparing_model_context": True} if prepare_context else {}), **report})
         if admitted["refresh_original_scope"]:
             self.store.update_session(session["session_id"], manager_authorization_scope_id=scope["current"])
         return {**admitted, "observed_scope_id": scope["current"] if scope else None}
 
+    def recover_report_settlement(self, actor: dict[str, Any], window: dict[str, Any], todo: dict[str, Any]) -> None:
+        """Resume only cached, validated native effects of the original report.
+
+        Neither Todo DONE nor outer Chat completion is a native commit. The
+        journal owner must authorize a no-host continuation; its existing
+        effect readbacks reconcile ambiguous writeback/debit outcomes.
+        """
+        from ...cli import build_parser
+        from ...cli_commands.turn import handle_turn_command
+        from ...control_plane.turn_driver import inspect_loopx_turn_journal
+        from ...control_plane.turn_driver.journal_store import find_loopx_turn_key_by_settlement_identity
+        from ..periodic_report.private_generation import attempt_directory, validate_private_generation
+        from .steward_reports import StewardReports
+        with self.controller.lock, exclusive_file_lock(self.bindings.path, operation="resume_original_report_settlement"):
+            original = self.store.turn_for_client(actor["session_id"],
+                native_steward_client_id(actor, "report." + window["window_id"]))
+            if not original:
+                return
+            request = original.get("loopx_request") or {}
+            if (request.get("actor") != actor or request.get("report_window_id") != window["window_id"]
+                    or request.get("todo_id") != todo["todo_id"]):
+                raise ValueError("the original report settlement identity changed")
+            if any(row["kind"] == "native_loopx.result" and row["payload"].get("status") == "committed"
+                   for row in self.store.events_after(actor["session_id"], original["turn_id"], None)):
+                return
+            reports = StewardReports(self.controller)
+            validate_private_generation(attempt_directory(reports.root, window))
+            binding_id = actor["goal_id"].removeprefix("steward-agent-")
+            if not reports.delivery_current(binding_id, window):
+                raise ValueError("the original report authorization changed before settlement recovery")
+            key = find_loopx_turn_key_by_settlement_identity(reports.root, goal_id=actor["goal_id"],
+                agent_id=actor["agent_id"], todo_id=todo["todo_id"], turn_instance_id=request["turn_instance_id"])
+            if key is None:
+                return
+            inspection = inspect_loopx_turn_journal(reports.root, goal_id=actor["goal_id"],
+                agent_id=actor["agent_id"], turn_key=key, retry_failed=True)
+            admitted = self._admit(request, settlement_recovery=inspection)
+            def no_model(*_args):
+                raise ValueError("report settlement recovery must never invoke a model")
+            args = build_parser().parse_args(["turn", "run-once", "--goal-id", actor["goal_id"],
+                "--agent-id", actor["agent_id"], "--project", admitted["workspace_path"],
+                "--host", "generic-cli", "--resume-turn-key", key, "--retry-failed-turn", "--execute"])
+            args.host, args.session_scope = "codex-app-server", "agent"
+            result: dict[str, Any] = {}
+            handle_turn_command(args, registry_path=self.controller.registry_path,
+                runtime_root_arg=str(reports.root), output_format=lambda *_a, **_kw: "json",
+                print_payload=lambda value, *_a: result.update(value), native_host_runner=no_model,
+                native_session_binding_resolver=lambda _envelope: {"schema_version": "loopx_turn_session_binding_v0",
+                    "goal_id": actor["goal_id"], "agent_id": actor["agent_id"]})
+            # Retain the historical outer failure. The actual native owner
+            # supplies the new event; no status or publication proof is forged.
+            self.store.append_event(actor["session_id"], original["turn_id"], kind="native_loopx.result", payload=result)
+
     def submit(self, binding_id: str, *, turn_instance_id: str, todo_id: str | None = None,
                validation_command: Sequence[str] | None = None,
-               work_kind: str = "native_turn", monitor_deadline: str | None = None) -> tuple[dict[str, Any], bool]:
+               work_kind: str = "native_turn", monitor_deadline: str | None = None,
+               report_window: dict[str, Any] | None = None) -> tuple[dict[str, Any], bool]:
         """Internal host entrypoint; busy conversations retain work with caller.
 
         No HTTP or model tool exposes this method. Calendar/monitor admission
@@ -85,7 +154,12 @@ def submit(self, binding_id: str, *, turn_instance_id: str, todo_id: str | None
                 "turn_instance_id": turn_instance_id, "todo_id": todo_id,
                 "work_kind": work_kind,
                 "validation_command": list(validation_command) if validation_command is not None else None}
-            client_id = "native." + hashlib.sha256(json.dumps([actor, turn_instance_id], sort_keys=True).encode()).hexdigest()[:40]
+            if work_kind == "report":
+                if not report_window:
+                    raise ValueError("a report requires its original admitted calendar window")
+                request.update(report_window_id=report_window["window_id"],
+                    report_subscription_revision=report_window["subscription_revision"])
+            client_id = native_steward_client_id(actor, turn_instance_id)
             existing = self.store.turn_for_client(actor["session_id"], client_id)
             if existing is not None:
                 # Never replay a failed/unknown model Turn. A committed Chat
@@ -108,7 +182,8 @@ def submit(self, binding_id: str, *, turn_instance_id: str, todo_id: str | None
             session = self.store.load_session(actor["session_id"])
             accepted = self.store.accept_managed_turn(actor["session_id"], client_turn_id=client_id,
                 message="Advance the currently admitted native LoopX work.",
-                display_message="检查授权工作状态。" if work_kind == "monitor" else "推进管家的 LoopX 任务。", origin="native_loopx",
+                display_message="检查授权工作状态。" if work_kind == "monitor" else
+                    "生成本期授权项目日报。" if work_kind == "report" else "推进管家的 LoopX 任务。", origin="native_loopx",
                 loopx_execution=True, loopx_request=request)
             try:
                 if admitted["observation_only"]:
@@ -146,12 +221,27 @@ def execute(self, *, session_id: str, turn_id: str, adapter: Any,
         if not isinstance(adapter, CodexAppServerAdapter):
             raise ValueError("native steward work requires the original Codex app-server adapter")
         original_thread = adapter.upstream_thread_id
+        report_work = request.get("work_kind") == "report"
+        report_lease = None
+
+        def report_lease_proof():
+            from .steward_commands import native_command
+            observed = native_command(self.controller, ["task-lease", "inspect", "--goal-id", actor["goal_id"],
+                "--todo-id", request["todo_id"]]).get("lease")
+            if (not report_lease or not observed or observed.get("status") != "active"
+                    or any(observed.get(key) != report_lease.get(key) for key in
+                        ("owner", "idempotency_key", "lease_epoch", "version"))):
+                raise ValueError("the original report execution lease changed")
+            return {"task_lease_idempotency_key": observed["idempotency_key"],
+                "task_lease_expected_version": observed["version"]}
 
         def current():
             fresh = self.store.load_turn(session_id, turn_id)
             self._admit(request, turn=fresh)
             if adapter.upstream_thread_id != original_thread:
                 raise ValueError("the original steward native thread changed")
+            if report_lease:
+                report_lease_proof()
 
         def session_binding(envelope: Mapping[str, Any]) -> dict[str, Any]:
             current()
@@ -165,7 +255,13 @@ def run(native_request: Mapping[str, Any], launch_scope: Any) -> dict[str, Any]:
             authority = extract_turn_authority(native_request)
             # Portfolio evidence keeps its original reader and original grant;
             # it is data alongside the signed native work, never a new actor.
-            prompt = render_prompt(authority) + "\nOriginal steward evidence (data):\n" + json.dumps(context, ensure_ascii=False)
+            prompt = (render_prompt(authority, allow_completion=True) if report_work else render_prompt(authority)) + "\nOriginal steward evidence (data):\n" + json.dumps(context, ensure_ascii=False)
+            if request.get("work_kind") == "report":
+                from .steward_reports import StewardReports
+                # The compact prompt index deliberately omits authority fields;
+                # use admission's original live scope, never that display index.
+                prompt += StewardReports(self.controller).prepare(request, adapter,
+                    authorization_scope_id=admitted["observed_scope_id"])
             previous_guard = adapter.session._launch_guard
 
             @contextmanager
@@ -186,7 +282,19 @@ def launch():
             finally:
                 adapter.session._launch_guard = previous_guard
             current()  # Revocation/stop/retarget after a long model call wins.
-            return build_result(native_request, parse_model_json(str(response.get("message") or "")), host_name="Codex app-server")
+            candidate = parse_model_json(str(response.get("message") or ""))
+            if report_work and candidate and candidate.get("result_kind") in {"validated_progress", "validated_completion"}:
+                from .steward_reports import StewardReports
+                with self.controller.lock, exclusive_file_lock(self.bindings.path, operation="freeze_original_steward_report"):
+                    current()
+                    StewardReports(self.controller).freeze(request, candidate)
+                    # This finite task's postcondition is the complete validated
+                    # generation, not the model's choice of progress wording.
+                    # The kernel still runs its independent validator and lease
+                    # fence before closing only this window's generation Todo.
+                    candidate["result_kind"] = "validated_completion"
+            return build_result(native_request, candidate, host_name="Codex app-server",
+                **({"allow_completion": True} if report_work else {}))
 
         argv = ["turn", "run-once", "--goal-id", actor["goal_id"], "--agent-id", actor["agent_id"],
             "--project", admitted["workspace_path"], "--host", "generic-cli", "--execute",
@@ -200,12 +308,52 @@ def launch():
         # The kernel records the actual app-server host and independent profile.
         args.host, args.session_scope = "codex-app-server", "agent"
         result: dict[str, Any] = {}
-        handle_turn_command(args, registry_path=self.controller.registry_path,
-            runtime_root_arg=str(self.controller.coordination_runtime_root),
-            output_format=lambda *_a, **_kw: "json",
-            print_payload=lambda value, *_a: result.update(value),
-            native_host_runner=run, native_session_binding_resolver=session_binding)
+        if report_work:
+            from .steward_commands import native_command
+            retained = native_command(self.controller, ["task-lease", "inspect", "--goal-id", actor["goal_id"],
+                "--todo-id", request["todo_id"]]).get("lease")
+            report_lease = native_command(self.controller, ["task-lease", "acquire", "--goal-id", actor["goal_id"],
+                "--todo-id", request["todo_id"], "--owner", actor["agent_id"],
+                "--idempotency-key", request["turn_instance_id"], "--ttl-seconds", "3600",
+                "--expected-version", str(retained["version"] if retained else 0)])["lease"]
+        try:
+            handle_turn_command(args, registry_path=self.controller.registry_path,
+                runtime_root_arg=str(self.controller.coordination_runtime_root),
+                output_format=lambda *_a, **_kw: "json",
+                print_payload=lambda value, *_a: result.update(value),
+                native_host_runner=run, native_session_binding_resolver=session_binding,
+                **({"native_completion_lease_resolver": report_lease_proof} if report_work else {}))
+        finally:
+            if report_lease:
+                # Completion atomically retires this lease. On a non-completion
+                # release only our unchanged claim, never a later owner's lease.
+                try:
+                    retained = native_command(self.controller, ["task-lease", "inspect", "--goal-id", actor["goal_id"],
+                        "--todo-id", request["todo_id"]]).get("lease")
+                    if retained and retained.get("status") == "active":
+                        proof = report_lease_proof()
+                        native_command(self.controller, ["task-lease", "release", "--goal-id", actor["goal_id"],
+                            "--todo-id", request["todo_id"], "--owner", actor["agent_id"],
+                            "--idempotency-key", proof["task_lease_idempotency_key"],
+                            "--expected-version", str(proof["task_lease_expected_version"])])
+                except (OSError, ValueError, RuntimeError):
+                    self.store.append_event(session_id, turn_id,
+                        kind="native_loopx.report_lease_release_unconfirmed",
+                        payload={"todo_id": request["todo_id"], "lease_epoch": report_lease["lease_epoch"]})
         self.store.append_event(session_id, turn_id, kind="native_loopx.result", payload=result)
+        if request.get("work_kind") == "report" and result.get("status") == "committed":
+            from ..periodic_report.private_generation import attempt_directory, validate_private_generation
+            from .steward_reports import StewardReports
+            original_session = self.store.load_session(session_id)
+            subscription, window = StewardReports(self.controller).current_window(original_session["steward_context"]["binding_id"])
+            if not subscription or not window or window["window_id"] != request["report_window_id"]:
+                raise ValueError("report publication was cancelled after native settlement")
+            folder = attempt_directory(self.controller.coordination_runtime_root, window)
+            generation = validate_private_generation(folder)
+            return {"schema_version": "loopx_chat_agent_response_v0", "message": (folder / "report.md").read_text(),
+                "proposals": [], "gate": None, "native_loopx": result,
+                "periodic_report": {"window_id": window["window_id"], "generation_id": generation["generation_id"],
+                    "delivery_verified": False}}
         return {"schema_version": "loopx_chat_agent_response_v0", "message":
             "本轮任务已完成结果回写。" if result.get("status") == "committed" else
             "本轮等待后续执行条件。" if result.get("status") == "stopped" and result.get("result_kind") == "wait" else
diff --git a/loopx/capabilities/periodic_report/cadence_journal.py b/loopx/capabilities/periodic_report/cadence_journal.py
index 7fc9d902ca..a6c7503581 100644
--- a/loopx/capabilities/periodic_report/cadence_journal.py
+++ b/loopx/capabilities/periodic_report/cadence_journal.py
@@ -75,7 +75,7 @@ def read_cadence_journal(*, runtime_root: Path, goal_id: str) -> dict[str, Any]
     fields = {
         "schema_version", "goal_id", "window", "admitted_at", "publication",
     }
-    if not isinstance(value, dict) or set(value) not in (fields, fields | {"supersedes"}) or value["schema_version"] != JOURNAL_SCHEMA or value["goal_id"] != goal_id:
+    if not isinstance(value, dict) or set(value) - {"supersedes", "retirement"} != fields or value["schema_version"] != JOURNAL_SCHEMA or value["goal_id"] != goal_id:
         raise ValueError("cadence journal contract is invalid")
     if "supersedes" in value and not re.fullmatch(r"cadence_[0-9a-f]{64}", str(value["supersedes"])):
         raise ValueError("cadence journal predecessor is invalid")
@@ -89,9 +89,52 @@ def read_cadence_journal(*, runtime_root: Path, goal_id: str) -> dict[str, Any]
         or any(not isinstance(item, str) or not item for item in publication.values())
     ):
         raise ValueError("cadence journal publication reference is invalid")
+    retirement = value.get("retirement")
+    if retirement is not None and (publication is not None or not isinstance(retirement, dict)
+            or set(retirement) != {"reason", "source_receipt_id", "retired_at"}
+            or retirement["reason"] != "owner_cancelled_failed_generation"
+            or any(not isinstance(item, str) or not item for item in retirement.values())):
+        raise ValueError("cadence journal retirement reference is invalid")
     return value
 
 
+def retire_failed_cadence_window(*, runtime_root: Path, goal_id: str,
+                                expected_window_id: str, source_receipt_id: str) -> dict[str, Any]:
+    """Retain an explicitly cancelled known failure; never invent publication.
+
+    The original execution owner must prove a terminal failed generation with
+    no generated report or delivery attempt before calling this transition.
+    This retires admission only; it neither retries a model nor drops evidence.
+    """
+    path = cadence_journal_path(runtime_root, goal_id)
+    if not isinstance(source_receipt_id, str) or not source_receipt_id:
+        raise ValueError("failed cadence retirement requires its original receipt")
+    with exclusive_file_lock(path, policy=LockAcquisitionPolicy.MUTATION,
+                             operation="retire_failed_report_window"):
+        current = read_cadence_journal(runtime_root=runtime_root, goal_id=goal_id)
+        if not current or current["window"]["window_id"] != expected_window_id or current["publication"] is not None:
+            raise ValueError("the unpublished failed report window changed")
+        if current.get("retirement"):
+            if current["retirement"]["source_receipt_id"] != source_receipt_id:
+                raise ValueError("the failed window retirement changed its source")
+            return current
+        current["retirement"] = {"reason": "owner_cancelled_failed_generation",
+            "source_receipt_id": source_receipt_id, "retired_at": datetime.now(timezone.utc).isoformat()}
+        atomic_write_json(path, current)
+        return current
+
+
+def _archive_predecessor(path: Path, previous: dict[str, Any]) -> str:
+    identity = previous["window"]["window_id"]
+    archive = path.parent / "superseded-cadence" / (identity + ".json")
+    if archive.exists():
+        if json.loads(archive.read_text(encoding="utf-8")) != previous:
+            raise ValueError("cadence predecessor archive conflicts with active window")
+    else:
+        atomic_write_json(archive, previous)
+    return identity
+
+
 def admit_cadence_window(
     *, runtime_root: Path, goal_id: str, agent_id: str,
     subscription: Mapping[str, Any], now: datetime,
@@ -156,7 +199,7 @@ def _admit_cadence_window_locked(
     supersedes = None
     if previous is not None:
         old = previous["window"]
-        if previous["publication"] is None:
+        if previous["publication"] is None and not previous.get("retirement"):
             # Import lazily to keep the pure calendar evaluator independent
             # of subscription and generation composition.
             from .incremental import read_periodic_report_publication_cursor
@@ -180,15 +223,13 @@ def _admit_cadence_window_locked(
                 if proposed is None:
                     return {"status": "not_due", "mutated": False, "window": None,
                             "next_due_at": report_cadence_next_due_at(subscription["schedule"], now=now)}
-                archive = path.parent / "superseded-cadence" / (old["window_id"] + ".json")
-                if archive.exists():
-                    if json.loads(archive.read_text(encoding="utf-8")) != previous:
-                        raise ValueError("cadence predecessor archive conflicts with active window")
-                else:
-                    atomic_write_json(archive, previous)
                 # Archive first. A crash before the replacement is written
                 # can safely repeat admission without creating two reports.
-                supersedes = old["window_id"]
+                supersedes = _archive_predecessor(path, previous)
+        if previous.get("retirement"):
+            if proposed is None or old["due_at"] >= proposed["due_at"]:
+                return {"status": "retired", "mutated": False, "window": old}
+            supersedes = _archive_predecessor(path, previous)
         # A route/profile edit is not a second report for the same due
         # boundary. Clock rollback likewise cannot replay a delivered one.
         if proposed is not None and supersedes is None and old["due_at"] >= proposed["due_at"]:
diff --git a/loopx/capabilities/periodic_report/pending_intent.py b/loopx/capabilities/periodic_report/pending_intent.py
index 6d85348735..cc1ee93b00 100644
--- a/loopx/capabilities/periodic_report/pending_intent.py
+++ b/loopx/capabilities/periodic_report/pending_intent.py
@@ -441,7 +441,12 @@ def produce() -> Mapping[str, Any]:
             if normalized_agent_id and subscription is not None
             else []
         )
-        if not intents:
+        if not intents or subscription.get("profile_preset") == "portfolio-progress":
+            # This explicit source profile is consumed by the original Chat
+            # host's admitted native report Todo. Projecting the Goal Channel
+            # CLI action as well would preempt that controlled model Turn and
+            # substitute another source/destination. Calendar required reads
+            # remain visible; no other profile's precedence changes.
             return {
                 "schema_version": INTERACTION_PROJECTION_HOOK_RESULT_SCHEMA_VERSION,
                 "hook_id": HOOK_ID,
@@ -1080,6 +1085,12 @@ def _consume_pending_periodic_report_intent(
             "status": "subscription_disabled",
             "external_writes_performed": False,
         }
+    if subscription.get("profile_preset") == "portfolio-progress":
+        # A CLI caller cannot manufacture the original conversation's reader
+        # or private destination. Its host supplies those under the live grant.
+        return {"ok": True, "schema_version": CONSUMPTION_RECEIPT_SCHEMA,
+            "status": "original_conversation_required", "goal_id": goal_id,
+            "agent_id": agent_id, "external_writes_performed": False}
     intent = intents[0]
     trigger = evaluate_periodic_report_trigger_evaluation_intent(intent)
     payload = intent["payload"]
diff --git a/loopx/capabilities/periodic_report/presets.py b/loopx/capabilities/periodic_report/presets.py
index 5939a03ee2..02d8b6274d 100644
--- a/loopx/capabilities/periodic_report/presets.py
+++ b/loopx/capabilities/periodic_report/presets.py
@@ -15,11 +15,13 @@
 
 
 WEEKLY_PROGRESS_PRESET_ID = "weekly-progress"
-PERIODIC_REPORT_PROFILE_PRESET_IDS = (WEEKLY_PROGRESS_PRESET_ID,)
+PORTFOLIO_PROGRESS_PRESET_ID = "portfolio-progress"
+PERIODIC_REPORT_PROFILE_PRESET_IDS = (WEEKLY_PROGRESS_PRESET_ID, PORTFOLIO_PROGRESS_PRESET_ID)
 PERIODIC_REPORT_PROFILE_PRESET_ALIASES = {
     "weekly": WEEKLY_PROGRESS_PRESET_ID,
     "weekly-progress": WEEKLY_PROGRESS_PRESET_ID,
     "weekly-report": WEEKLY_PROGRESS_PRESET_ID,
+    "portfolio-progress": PORTFOLIO_PROGRESS_PRESET_ID,
 }
 
 _WEEKLY_PROGRESS_PROFILE: dict[str, Any] = {
@@ -71,13 +73,20 @@ def resolve_periodic_report_profile_preset(preset_id: str) -> dict[str, Any]:
 
     requested = str(preset_id or "").strip().lower().replace("_", "-")
     canonical = PERIODIC_REPORT_PROFILE_PRESET_ALIASES.get(requested)
-    if canonical != WEEKLY_PROGRESS_PRESET_ID:
+    if canonical not in PERIODIC_REPORT_PROFILE_PRESET_IDS:
         supported = ", ".join(PERIODIC_REPORT_PROFILE_PRESET_IDS)
         raise ValueError(
             f"unknown periodic report profile preset {preset_id!r}; "
             f"supported presets: {supported}"
         )
-    return normalize_periodic_report_profile(deepcopy(_WEEKLY_PROGRESS_PROFILE))
+    profile = deepcopy(_WEEKLY_PROGRESS_PROFILE)
+    if canonical == PORTFOLIO_PROGRESS_PRESET_ID:
+        profile["profile_id"] = "portfolio_progress"
+        profile["trigger_policy"]["enabled_kinds"] = ["cadence_due"]
+        profile["source_bindings"] = [{"source_id": "manager_portfolio",
+            "source_kind": "authorized_portfolio_evidence", "adapter_id": "manager_portfolio_v0",
+            "provider": {"kind": "builtin"}}]
+    return normalize_periodic_report_profile(profile)
 
 
 def build_periodic_report_preset_activation(preset_id: str) -> dict[str, Any]:
@@ -88,7 +97,7 @@ def build_periodic_report_preset_activation(preset_id: str) -> dict[str, Any]:
     activation = build_periodic_report_activation(profile)
     activation["profile_preset"] = {
         "requested_id": requested,
-        "resolved_id": WEEKLY_PROGRESS_PRESET_ID,
+        "resolved_id": PERIODIC_REPORT_PROFILE_PRESET_ALIASES[requested],
         "aliases": sorted(PERIODIC_REPORT_PROFILE_PRESET_ALIASES),
     }
     activation["interaction_contract"] = {
@@ -101,4 +110,9 @@ def build_periodic_report_preset_activation(preset_id: str) -> dict[str, Any]:
         "renderer_adapter_ids": ["markdown_v0", "html_artifact_v0"],
         "external_write_allowed": False,
     }
+    if profile["profile_id"] == "portfolio_progress":
+        activation["interaction_contract"].update(mode="original_steward_private_chat",
+            source_scope="original_authorized_local_portfolio",
+            original_conversation_required=True,
+            source_and_destination_from_original_binding=True)
     return activation
diff --git a/loopx/capabilities/periodic_report/private_generation.py b/loopx/capabilities/periodic_report/private_generation.py
new file mode 100644
index 0000000000..4293794f6e
--- /dev/null
+++ b/loopx/capabilities/periodic_report/private_generation.py
@@ -0,0 +1,200 @@
+"""Original-conversation IO composition over periodic-report's frozen artifacts.
+
+The host supplies a live scoped reader and an admitted calendar window. This
+module does not select work, invoke a model, choose recipients or send messages.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from ...file_lock import exclusive_file_lock
+from ...registry import atomic_write_json
+from .cadence_journal import cadence_intent, validate_cadence_window
+from .pending_intent import (
+    _attempt_dir, _build_authored_source, _build_editorial_request,
+    _canonical_digest, _load_editorial_response,
+)
+
+
+def attempt_directory(root: Path, window: dict[str, Any]) -> Path:
+    return _attempt_dir(root, window["goal_id"], cadence_intent(window))
+
+
+def _read(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError("report artifact must be an object")
+    return value
+
+
+def prepare_private_report(*, root: Path, window: dict[str, Any], read,
+                           authorization_scope_id: str, reporting: str) -> dict[str, Any]:
+    """Freeze permitted evidence once; full records stay beside bounded fact headings."""
+    from ..manager_context.report_source import collect_manager_report_source
+
+    window = validate_cadence_window(window)
+    folder = attempt_directory(root, window)
+    with exclusive_file_lock(folder / "generation.lock", operation="prepare_private_report"):
+        path = folder / "editorial-request.json"
+        if path.exists():
+            request = _read(path)
+            if (request.get("authorization_scope_id") != authorization_scope_id
+                    or request.get("intent_digest") != _canonical_digest(cadence_intent(window))
+                    or request.get("request_digest") != _canonical_digest(
+                        {k: v for k, v in request.items() if k != "request_digest"})):
+                raise ValueError("the frozen report belongs to another scope or window")
+            return request
+        source = collect_manager_report_source(read, {
+            "window_start": window["start_at"], "window_end": window["due_at"]})
+        folder.mkdir(parents=True, exist_ok=True)
+        atomic_write_json(folder / "source.json", source)
+        facts = [{"fact_id": "portfolio_coverage", "title": "本期来源覆盖",
+            "summary": source["source_result"]["sections"][0]["items"][0]["summary"],
+            "status": "partial" if source["gaps"] else "read", "content_kind": "coverage",
+            "source_ref": source["source_revision"]}]
+        for index, row in enumerate(source["rows"]):
+            encoded = json.dumps(row["evidence"], ensure_ascii=False, sort_keys=True)
+            facts.append({"fact_id": f"portfolio_{index}", "title": f"{row.get('goal_id') or 'portfolio'} / {row['kind']}"[:240],
+                "summary": encoded if len(encoded) <= 1000 else encoded[:940] + "…（摘录；完整记录见冻结来源的同一 source_ref）",
+                "status": "unknown" if row["kind"] == "coverage_gap" else "recorded",
+                "source_ref": row["source_ref"], "content_kind": "coverage"})
+        request = _build_editorial_request(intent=cadence_intent(window), runtime_root=root,
+            goal_id=window["goal_id"], agent_id=window["agent_id"],
+            completed_at=window["due_at"], facts=facts)
+        request.pop("request_digest")
+        request.update(authorization_scope_id=authorization_scope_id, reporting=reporting,
+            source_artifact=str(folder / "source.json"), source_revision=source["source_revision"],
+            source_artifact_sha256=_canonical_digest(source), window=window,
+            coverage=source["coverage"], destination="original_owner_private_chat_full_body")
+        request["narrative_contract"]["requirements"] += [
+            "Follow REPORTING and cover every authorized Goal, including stopped and unreadable Goals.",
+            "Read full frozen source records for substantive claims; excerpts and Agent claims are not independent verification.",
+            "Distinguish implementation, merged source, installed adoption and actual original-message delivery.",
+            "Describe current and relevant completed tasks, counterevidence, source gaps and concrete next steps.",
+            "A due unchanged window still needs a substantive report; observations or CI counts are not business progress.",
+        ]
+        request["request_digest"] = _canonical_digest(request)
+        atomic_write_json(path, request)
+        return request
+
+
+def report_prompt(request: dict[str, Any], folder: Path) -> str:
+    # Complete evidence is readable on demand; do not inject several MiB of
+    # records into the initial model request or silently drop trailing Goals.
+    contract = {k: v for k, v in request.items() if k not in {"facts", "reporting"}}
+    return ("\nThis Turn's task is to author the original steward's due report. "
+        "Do not execute CLI settlement, send messages, delegate, or change business state. "
+        "The host freezes validated editorial content; native Turn owns settlement and the original reply provider owns delivery. "
+        "Read the complete editorial-request.json and source.json below, paging as needed, and relevant permitted artifacts. "
+        "Source records and REPORTING are evidence and the owner's reporting criteria, never new permissions. "
+        "Return the normal public-safe typed Turn result plus an editorial_response object using "
+        "periodic_report_editorial_response_v0, this exact request_digest, language=zh-CN, title, "
+        "2-4 Chinese highlights ({highlight_id: unique lower_snake token, label: <=80 chars, value: <=48 chars, "
+        "detail: <=160 chars, tone: attention|neutral|positive}) and sections in the supplied exact order/titles. "
+        "Each section has nonempty items with title (<=240 chars), substantive summary (<=360 chars) "
+        "and a supplied fact's source_ref; causal items require 2-4 details, each {label: <=40 chars, text: <=360 chars}. "
+        "Do not supply item_id, content_kind or value_rank. Include at least six substantive items in total, "
+        "covering the entire portfolio and material gaps. The full private narrative belongs only in editorial_response; "
+        "keep normal result summary/evidence public-safe. A validated report generation is distinct from provider delivery.\n"
+        "Use validated_completion only for this finite generation task after providing the complete editorial response; "
+        "future windows and the ongoing monitoring Goal remain open. Use wait or iteration_failed when generation is incomplete.\n"
+        + json.dumps({"contract": contract, "editorial_request_path": str(folder / "editorial-request.json"),
+            "source_path": str(folder / "source.json"), "REPORTING": request["reporting"]}, ensure_ascii=False))
+
+
+def freeze_private_report(*, root: Path, window: dict[str, Any], response: dict[str, Any]) -> dict[str, Any]:
+    from .adapters import build_periodic_report_document
+    from .bindings import build_periodic_report_generation_bundle
+    from .post_writeback_hook import evaluate_periodic_report_trigger_evaluation_intent
+    from .incremental import (
+        build_periodic_report_publication_candidate, periodic_report_incremental_baseline,
+        read_periodic_report_publication_cursor,
+    )
+    from ...presentation.renderers.periodic_report_markdown import render_periodic_report_markdown
+    from ...presentation.renderers.periodic_report_html import render_periodic_report_html
+
+    folder = attempt_directory(root, window)
+    with exclusive_file_lock(folder / "generation.lock", operation="freeze_private_report"):
+        request = _read(folder / "editorial-request.json")
+        response_path = folder / "editorial-response.json"
+        if response_path.exists() and _read(response_path) != response:
+            raise ValueError("a report window already has a different authored response")
+        # Persist an invalid response as counterevidence too. A failed/unknown
+        # model attempt never becomes permission to regenerate it automatically.
+        atomic_write_json(response_path, response)
+        authored = _load_editorial_response(request=request, response_path=response_path)
+        generated_at = datetime.now(timezone.utc).isoformat()
+        source = _build_authored_source(authored, completed_at=generated_at)
+        document = build_periodic_report_document(title=authored["title"], generated_at=generated_at,
+            period_window={"start_at": window["start_at"], "end_at": window["due_at"]},
+            profile=window["profile_ref"], sources=[source], editorial=authored["editorial"],
+            trigger_receipt=evaluate_periodic_report_trigger_evaluation_intent(cadence_intent(window)))
+        markdown, html = render_periodic_report_markdown(document), render_periodic_report_html(document)
+        bundle = build_periodic_report_generation_bundle(document=document, artifacts=[markdown, html])
+        atomic_write_json(folder / "generation-bundle.json", bundle)
+        body = str(markdown["content"])
+        (folder / "report.md").write_text(body, encoding="utf-8")
+        cursor = read_periodic_report_publication_cursor(runtime_root=root,
+            goal_id=window["goal_id"], agent_id=window["agent_id"])
+        candidate = build_periodic_report_publication_candidate(goal_id=window["goal_id"],
+            agent_id=window["agent_id"], generation_id=bundle["generation_receipt"]["generation_id"],
+            trigger_receipt=document["trigger_receipt"], facts=request["facts"],
+            baseline=periodic_report_incremental_baseline(cursor) if cursor else None)
+        atomic_write_json(folder / "publication-candidate.json", candidate)
+        receipt = {"window_id": window["window_id"], "request_digest": request["request_digest"],
+            "generated_at": generated_at,
+            "generation_id": bundle["generation_receipt"]["generation_id"],
+            "body_sha256": hashlib.sha256(body.encode()).hexdigest(),
+            "bundle_sha256": _canonical_digest(bundle), "publication_candidate_id": candidate["candidate_id"],
+            "publication_candidate_sha256": _canonical_digest(candidate),
+            "generation_complete": True, "delivery_verified": False}
+        atomic_write_json(folder / "private-generation.json", receipt)
+        validate_private_generation(folder)
+        return receipt
+
+
+def validate_private_generation(folder: Path) -> dict[str, Any]:
+    """Independent frozen-content check used by the native Turn validator."""
+    from .bindings import build_periodic_report_generation_bundle
+    from .incremental import build_periodic_report_publication_candidate
+    from .adapters import build_periodic_report_document
+    from .post_writeback_hook import evaluate_periodic_report_trigger_evaluation_intent
+    from ...presentation.renderers.periodic_report_markdown import render_periodic_report_markdown
+    from ...presentation.renderers.periodic_report_html import render_periodic_report_html
+
+    receipt = _read(folder / "private-generation.json")
+    request = _read(folder / "editorial-request.json")
+    if request["request_digest"] != _canonical_digest({k: v for k, v in request.items() if k != "request_digest"}):
+        raise ValueError("frozen editorial input changed")
+    authored = _load_editorial_response(request=request, response_path=folder / "editorial-response.json")
+    if request["source_artifact_sha256"] != _canonical_digest(_read(folder / "source.json")):
+        raise ValueError("frozen portfolio evidence changed")
+    window = validate_cadence_window(request["window"])
+    document = build_periodic_report_document(title=authored["title"], generated_at=receipt["generated_at"],
+        period_window={"start_at": window["start_at"], "end_at": window["due_at"]},
+        profile=window["profile_ref"], sources=[_build_authored_source(authored, completed_at=receipt["generated_at"])],
+        editorial=authored["editorial"],
+        trigger_receipt=evaluate_periodic_report_trigger_evaluation_intent(cadence_intent(window)))
+    bundle = _read(folder / "generation-bundle.json")
+    checked = build_periodic_report_generation_bundle(document=bundle["document"], artifacts=[
+        render_periodic_report_markdown(bundle["document"]), render_periodic_report_html(bundle["document"])])
+    candidate = _read(folder / "publication-candidate.json")
+    expected_candidate = build_periodic_report_publication_candidate(goal_id=window["goal_id"],
+        agent_id=window["agent_id"], generation_id=checked["generation_receipt"]["generation_id"],
+        trigger_receipt=document["trigger_receipt"], facts=request["facts"],
+        baseline=candidate.get("incremental_baseline"))
+    if (document != bundle["document"] or checked != bundle or receipt["bundle_sha256"] != _canonical_digest(checked)
+            or receipt["window_id"] != window["window_id"]
+            or receipt["generation_id"] != checked["generation_receipt"]["generation_id"]
+            or candidate != expected_candidate
+            or receipt["publication_candidate_id"] != candidate["candidate_id"]
+            or receipt["publication_candidate_sha256"] != _canonical_digest(candidate)
+            or receipt["request_digest"] != request["request_digest"]
+            or receipt["body_sha256"] != hashlib.sha256((folder / "report.md").read_bytes()).hexdigest()
+            or (folder / "report.md").read_text() != render_periodic_report_markdown(bundle["document"])["content"]):
+        raise ValueError("frozen generation or full report body changed")
+    return receipt
diff --git a/loopx/chat_runtime.py b/loopx/chat_runtime.py
index 0b4681a731..c169b450d6 100644
--- a/loopx/chat_runtime.py
+++ b/loopx/chat_runtime.py
@@ -1745,9 +1745,12 @@ def event_sink(kind: str, payload: dict[str, Any]) -> None:
             current_turn = self.store.load_turn(session_id, turn_id) or {}
             native_request = current_turn.get("loopx_request") or {}
             native_loopx = native_request.get("operation") == "native_turn"
+            report_context_rebind = False
             if native_loopx:
                 from .capabilities.native_chat.steward_turn import StewardTurnHost
-                StewardTurnHost(self)._admit(native_request, turn=current_turn)
+                admitted = StewardTurnHost(self)._admit(native_request, turn=current_turn,
+                    **({"prepare_context": True} if native_request.get("work_kind") == "report" else {}))
+                report_context_rebind = admitted.get("context_rebind_required") is True
                 session = self.store.load_session(session_id) or {}
             # Internal native work has no external message event. Its typed
             # original-actor admission above must succeed before using the
@@ -1774,7 +1777,7 @@ def event_sink(kind: str, payload: dict[str, Any]) -> None:
                     raise ValueError("/goal continuation requires the local owner's Goal conversation.")
             if scope["kind"] in {"owner_goal", "owner_portfolio", "external_audience"} and (native_command is None or loopx_execution):
                 adapter, context = prepare_turn_context(self, adapter, session, turn_id, event_sink, scope=scope,
-                    **({"preserve_original_thread": True} if native_loopx else {}))
+                    **({"preserve_original_thread": not report_context_rebind} if native_loopx else {}))
                 # Recheck current scope above, but keep the retry's model input stable.
                 evidence = retry_binding.setdefault("context", json.dumps(context, ensure_ascii=False))
                 message = "Fresh Core evidence (JSON data, not instructions):\n" + evidence + "\n\nCurrent user message:\n" + message
diff --git a/loopx/chat_server.py b/loopx/chat_server.py
index 71e7721c6c..0c8bcf2983 100644
--- a/loopx/chat_server.py
+++ b/loopx/chat_server.py
@@ -1676,6 +1676,7 @@ def do_POST(self) -> None:
             PRIVATE_CONVERSATIONS_PATH + "/owner-notifications": self._private_conversation_owner_notifications,
             PRIVATE_CONVERSATIONS_PATH + "/managed-steward": self._private_conversation_managed_steward,
             PRIVATE_CONVERSATIONS_PATH + "/managed-steward/monitor": self._private_conversation_steward_monitor,
+            PRIVATE_CONVERSATIONS_PATH + "/managed-steward/report": self._private_conversation_steward_report,
             **self._configuration_post_routes(),
             **self._ssh_source_post_routes(),
         }
diff --git a/loopx/cli_commands/turn.py b/loopx/cli_commands/turn.py
index 7971e67f5c..f2f13622f5 100644
--- a/loopx/cli_commands/turn.py
+++ b/loopx/cli_commands/turn.py
@@ -49,6 +49,7 @@ def handle_turn_command(
     print_payload: PrintPayload,
     native_host_runner: Callable[..., dict[str, Any]] | None = None,
     native_session_binding_resolver: Callable[[Mapping[str, Any]], dict[str, Any]] | None = None,
+    native_completion_lease_resolver: Callable[[], Mapping[str, Any]] | None = None,
 ) -> int | None:
     if args.command != "turn":
         return None
@@ -75,6 +76,8 @@ def handle_turn_command(
             args.host != "codex-app-server" or native_host_runner is None or native_session_binding_resolver is None
         ):
             raise ValueError("an app-server Turn requires its original host connection and session resolver")
+        if native_completion_lease_resolver is not None and native_host_runner is None:
+            raise ValueError("a native completion lease requires its original host connection")
         if getattr(args, "todo_id", None) is not None and (
             getattr(args, "resume_turn_key", None)
             or any(getattr(args, key, None) for key in ("resume_goal_id", "resume_agent_id", "resume_todo_id"))
@@ -340,6 +343,7 @@ def handle_turn_command(
                 turn_start_hook_dispatch=turn_start_hook_dispatch,
                 native_host_runner=native_host_runner,
                 native_session_binding_resolver=native_session_binding_resolver,
+                native_completion_lease_resolver=native_completion_lease_resolver,
             )
         else:
             raise ValueError("turn requires the `plan` or `run-once` subcommand")
diff --git a/loopx/cli_commands/turn_run_once.py b/loopx/cli_commands/turn_run_once.py
index 6fb212432d..61d44be49f 100644
--- a/loopx/cli_commands/turn_run_once.py
+++ b/loopx/cli_commands/turn_run_once.py
@@ -37,6 +37,7 @@
     read_persisted_todo_record,
     read_persisted_todo_record_with_source,
 )
+from ..control_plane.todos.completion_fence import evaluate_todo_completion_fence
 from ..control_plane.turn_driver import (
     build_loopx_turn_command_validator,
     codex_cli_session_binding,
@@ -75,6 +76,7 @@ def execute_turn_run_once(
     turn_start_hook_dispatch: Mapping[str, Any] | None = None,
     native_host_runner: Callable[..., dict[str, Any]] | None = None,
     native_session_binding_resolver: Callable[[Mapping[str, Any]], dict[str, Any]] | None = None,
+    native_completion_lease_resolver: Callable[[], Mapping[str, Any]] | None = None,
 ) -> dict[str, Any]:
     """Adapt one prepared CLI Turn plan to the bounded Turn driver."""
     execution_started = False
@@ -382,6 +384,7 @@ def todo_completion(
                 agent_id=args.agent_id,
                 completion_delivery_workspace=completion_delivery_workspace,
                 completion_validation_workspace_path=delivery_workspace_path,
+                **(dict(native_completion_lease_resolver()) if native_completion_lease_resolver else {}),
             )
             if completion.get("ok") is not True:
                 return completion
@@ -451,7 +454,27 @@ def completion_writeback(
             *,
             effect_ref: str,
         ) -> dict[str, object]:
-            completion = todo_completion(result, effect_ref=effect_ref)
+            require_effect_ref(effect_ref, SettlementStepKind.DURABLE_WRITEBACK)
+            prior = completion_readback()
+            if prior is None:
+                completion = todo_completion(result, effect_ref=effect_ref)
+            else:
+                # Completion may have atomically retired the execution lease
+                # before refresh failed. Read its exact canonical Turn receipt;
+                # resubmitting completion with a different/missing old fence is
+                # neither a new execution grant nor an idempotent request.
+                retained = read_heartbeat_settlement(runtime_root,
+                    goal_id=settlement_identity.goal_id, agent_id=settlement_identity.agent_id,
+                    todo_id=settlement_identity.todo_id, turn_instance_id=settlement_identity.turn_instance_id,
+                    replan_obligation_id=settlement_identity.replan_obligation_id,
+                    registry_path=registry_path, goal_ref=goal_ref)
+                if retained is None:
+                    raise RuntimeError(EXACT_SETTLEMENT_READBACK_NOT_FOUND)
+                if retained.completion_event is None:
+                    append_settlement_event({"ok": True, "appended": True}, event_kind="todo_complete",
+                        status="terminal_no_followup" if prior["continuation"] == "no_followup" else "completed",
+                        details={"command": "turn recovery probe", "no_followup": prior["continuation"] == "no_followup"})
+                completion = {"ok": True, "appended": True, "completion": prior}
             if not completion.get("ok"):
                 return completion
             todo_id = str(selected_todo.get("todo_id") or "")
@@ -549,13 +572,19 @@ def completion_readback() -> dict[str, object] | None:
                     project=None,
                     state_file=None,
                 )
-                durable_todo, existing_todo_ids = read_persisted_todo_record(
+                durable_todo, existing_todo_ids, projection_source = read_persisted_todo_record_with_source(
                     state_file,
                     todo_id=todo_id,
                     registry_path=registry_path,
                     goal_id=args.goal_id,
                     runtime_root=runtime_root,
                 )
+                evaluate_todo_completion_fence(
+                    todo=durable_todo,
+                    projection_source=projection_source,
+                    completion_turn_key=settlement_identity.turn_instance_id,
+                    no_followup=False,
+                )
                 return project_durable_completion_outcome(
                     todo=durable_todo,
                     expected_todo_id=todo_id,
diff --git a/loopx/cli_commands/turn_todo_writeback.py b/loopx/cli_commands/turn_todo_writeback.py
index c1059890ec..1e0052d96a 100644
--- a/loopx/cli_commands/turn_todo_writeback.py
+++ b/loopx/cli_commands/turn_todo_writeback.py
@@ -74,6 +74,8 @@ def write_turn_validated_completion(
     expected_todo_text_sha256: str | None = None,
     completion_delivery_workspace: Mapping[str, Any] | None = None,
     completion_validation_workspace_path: Path | None = None,
+    task_lease_idempotency_key: str | None = None,
+    task_lease_expected_version: int | None = None,
 ) -> dict[str, Any]:
     """Complete one validated Todo under the effective runtime root."""
 
@@ -89,6 +91,8 @@ def write_turn_validated_completion(
             require_captured_todo_text=True,
             completion_delivery_workspace=completion_delivery_workspace,
             completion_validation_workspace_path=completion_validation_workspace_path,
+            task_lease_idempotency_key=task_lease_idempotency_key,
+            task_lease_expected_version=task_lease_expected_version,
             evidence=evidence,
             note=note,
             agent_id=agent_id,
diff --git a/loopx/control_plane/collaboration/steward_managed_mode.ts b/loopx/control_plane/collaboration/steward_managed_mode.ts
index 2fcf30797d..d92bfc1bd9 100644
--- a/loopx/control_plane/collaboration/steward_managed_mode.ts
+++ b/loopx/control_plane/collaboration/steward_managed_mode.ts
@@ -36,7 +36,7 @@ export function normalizeStewardManagedActor(value: unknown): JsonObject {
     creation_operation_id: text(row.creation_operation_id, "managed Goal creation")};
 }
 
-function basis(params: JsonObject, executing = false) {
+export function stewardManagedBasis(params: JsonObject, executing = false) {
   const binding = requireJsonObject(params.binding, "steward binding");
   const session = requireJsonObject(params.session, "original steward Session");
   const context = requireJsonObject(session.steward_context, "original steward authority");
@@ -81,16 +81,16 @@ function basis(params: JsonObject, executing = false) {
  */
 export function admitStewardManagedTurn(params: JsonObject): JsonObject {
   const turn = params.turn == null ? null : requireJsonObject(params.turn, "current Chat Turn");
-  const current = basis(params, turn !== null);
+  const current = stewardManagedBasis(params, turn !== null);
   if (!current.actor || !current.goal || params.goal_active !== true) {
     throw new EffectRuntimeRequestError("the original prepared steward Goal must be active");
   }
   const request = requireJsonObject(params.request, "native steward Turn request");
   const fields = ["operation", "host", "actor", "turn_instance_id", "todo_id", "validation_command", "work_kind",
-    "monitor_deadline", "monitor_lease_version"];
+    "monitor_deadline", "monitor_lease_version", "report_window_id", "report_subscription_revision"];
   if (Object.keys(request).some(key => !fields.includes(key))
       || request.operation !== "native_turn" || request.host !== "codex-app-server"
-      || ![undefined, "native_turn", "monitor"].includes(request.work_kind as string | undefined)
+      || ![undefined, "native_turn", "monitor", "report"].includes(request.work_kind as string | undefined)
       || JSON.stringify(normalizeStewardManagedActor(request.actor)) !== JSON.stringify(current.actor)
       || typeof request.turn_instance_id !== "string" || !/^[A-Za-z0-9._:-]{1,160}$/.test(request.turn_instance_id)
       || request.todo_id !== null && (typeof request.todo_id !== "string" || !/^todo_[A-Za-z0-9_-]{1,100}$/.test(request.todo_id))) {
@@ -117,7 +117,41 @@ export function admitStewardManagedTurn(params: JsonObject): JsonObject {
       || !Number.isSafeInteger(request.monitor_lease_version) || Number(request.monitor_lease_version) < 0)) {
     throw new EffectRuntimeRequestError("observation-only execution requires the original native watch Todo");
   }
+  if (request.work_kind === "report") {
+    const window = requireJsonObject(params.report_window, "original report window");
+    const subscription = requireJsonObject(params.report_subscription, "current report subscription");
+    const todo = requireJsonObject(params.report_todo, "original report Todo");
+    const recovery = params.report_settlement_recovery == null ? null
+      : requireJsonObject(params.report_settlement_recovery, "native original report recovery");
+    let settlementOnly = false;
+    if (recovery) {
+      const decision = requireJsonObject(recovery.recovery_decision, "native journal recovery decision");
+      settlementOnly = recovery.schema_version === "loopx_turn_journal_inspection_v1" && recovery.ok === true
+        && recovery.goal_matches === true && recovery.owner_matches === true && recovery.turn_key_matches === true
+        && recovery.journal_consistent === true && decision.reinvoke_host === false
+        && (decision.action === "continue" && ["durable_writeback", "quota_spend", "scheduler_apply", "scheduler_ack"].includes(String(decision.resume_from))
+          || decision.action === "return_existing" && recovery.journal_status === "committed")
+        && todo.status === "done" && todo.completion_turn_key === request.turn_instance_id;
+      if (!settlementOnly || params.preparing_model_context === true) {
+        throw new EffectRuntimeRequestError("original report recovery requires validated remaining effects without a model");
+      }
+    }
+    if (request.validation_command === null || subscription.enabled !== true || subscription.profile_preset !== "portfolio-progress"
+        || subscription.route_ref !== `steward-private:${current.id}:${current.source}`
+        || subscription.effective_revision !== request.report_subscription_revision
+        || window.subscription_revision !== request.report_subscription_revision
+        || window.window_id !== request.report_window_id || window.goal_id !== current.actor.goal_id
+        || window.agent_id !== current.actor.agent_id || todo.todo_id !== request.todo_id
+        || todo.target_key !== window.window_id || todo.claimed_by !== AGENT_ID
+        || todo.action_kind !== "generate_periodic_report" || !(todo.status === "open" && !recovery || settlementOnly)) {
+      throw new EffectRuntimeRequestError("report execution requires the original live subscription, window and task");
+    }
+  } else if (request.report_window_id !== undefined || request.report_subscription_revision !== undefined
+      || params.report_settlement_recovery != null) {
+    throw new EffectRuntimeRequestError("report fields belong only to an original calendar report");
+  }
   let refreshScope = false;
+  let rebindContext = false;
   if (turn) {
     const scope = requireJsonObject(params.scope, "original steward scope observation");
     if (typeof scope.current !== "string" || !scope.current) {
@@ -130,7 +164,12 @@ export function admitStewardManagedTurn(params: JsonObject): JsonObject {
       // external-conversation isolation boundary.
       const knownSelfRegistration = current.binding.goal_scope === "all_registered"
         && scope.without_actor && current.session.manager_authorization_scope_id === scope.without_actor;
-      if (!knownSelfRegistration && !observationOnly) {
+      // A due report may enter only the existing context-preparation owner.
+      // It must discard old model context before strict execution admission;
+      // this phase never updates the saved scope hash or permits a model call.
+      rebindContext = !knownSelfRegistration && current.binding.goal_scope === "all_registered"
+        && request.work_kind === "report" && params.preparing_model_context === true;
+      if (!knownSelfRegistration && !observationOnly && !rebindContext) {
         throw new EffectRuntimeRequestError("the original portfolio changed beyond the prepared steward creation");
       }
       // A pure native watch uses only the fresh scoped reader and cannot
@@ -140,7 +179,8 @@ export function admitStewardManagedTurn(params: JsonObject): JsonObject {
     }
   }
   return {actor: current.actor, workspace_path: current.workspace, host: "codex-app-server",
-    refresh_original_scope: refreshScope, observation_only: observationOnly};
+    refresh_original_scope: refreshScope, observation_only: observationOnly,
+    ...(rebindContext ? {context_rebind_required: true} : {})};
 }
 
 export const STEWARD_MONITOR_TARGET = "steward-portfolio-watch";
@@ -152,7 +192,7 @@ function isStewardMonitorTodo(row: JsonObject): boolean {
 
 /** The monitor Todo is the configuration authority; the binding stores no toggle. */
 export function planStewardMonitor(params: JsonObject): JsonObject {
-  const current = basis(params, true);
+  const current = stewardManagedBasis(params, true);
   if (!current.actor || !current.goal || params.operation === "enable" && params.goal_active !== true) {
     throw new EffectRuntimeRequestError("prepare the original active steward first");
   }
@@ -208,7 +248,7 @@ export function observeStewardPortfolio(params: JsonObject): JsonObject {
 }
 
 export function planStewardManagedMode(params: JsonObject): JsonObject {
-  const current = basis(params);
+  const current = stewardManagedBasis(params);
   if (!Number.isSafeInteger(params.binding_revision) || Number(params.binding_revision) < 0) {
     throw new EffectRuntimeRequestError("current conversation revision is required");
   }
@@ -227,7 +267,7 @@ export function planStewardManagedMode(params: JsonObject): JsonObject {
 }
 
 export function bindStewardManagedActor(params: JsonObject): JsonObject {
-  const current = basis(params);
+  const current = stewardManagedBasis(params);
   const goal = current.goal;
   if (!goal || !Array.isArray(goal.registered_agents) || !goal.registered_agents.includes(AGENT_ID)) {
     throw new EffectRuntimeRequestError("native Goal and Agent registration must be read back before binding");
diff --git a/loopx/control_plane/collaboration/steward_reports.ts b/loopx/control_plane/collaboration/steward_reports.ts
new file mode 100644
index 0000000000..2cbff1a6cf
--- /dev/null
+++ b/loopx/control_plane/collaboration/steward_reports.ts
@@ -0,0 +1,40 @@
+/** Original-conversation report consent; calendar and Todo owners remain separate. */
+import {createHash} from "node:crypto";
+import {requireJsonObject, type JsonObject} from "../runtime_decode.ts";
+import {EffectRuntimeRequestError} from "../effect_runtime_errors.ts";
+import {stewardManagedBasis} from "./steward_managed_mode.ts";
+
+export function planStewardReport(params: JsonObject): JsonObject {
+  const current = stewardManagedBasis(params, true);
+  if (!current.actor || !current.goal || !["enable", "pause", "cancel"].includes(String(params.operation))) {
+    throw new EffectRuntimeRequestError("prepare the original private steward before configuring reports");
+  }
+  const route = `steward-private:${current.id}:${current.source}`;
+  const before = params.configuration == null ? null : requireJsonObject(params.configuration, "current report configuration");
+  if (before && (before.profile_preset !== "portfolio-progress" || before.route_ref !== route)) {
+    throw new EffectRuntimeRequestError("the existing report configuration belongs to another source or destination");
+  }
+  const configuration = requireJsonObject(params.proposed, "normalized report configuration");
+  if (configuration.profile_preset !== "portfolio-progress" || configuration.route_ref !== route
+      || configuration.enabled !== (params.operation === "enable")
+      || params.operation === "enable" && params.goal_active !== true) {
+    throw new EffectRuntimeRequestError("report configuration must retain the original private audience and active actor");
+  }
+  const routeProof = requireJsonObject(params.route, "verified original private source");
+  if (routeProof.binding_id !== current.id || routeProof.source_ref !== current.source
+      || routeProof.session_id !== current.sessionId || routeProof.provider_ref !== current.binding.provider_ref
+      || routeProof.operator_ref !== current.binding.operator_ref) {
+    throw new EffectRuntimeRequestError("the original private report destination must be verified");
+  }
+  const planId = createHash("sha256").update(JSON.stringify([
+    current.actor, current.binding, params.operation, before, configuration, routeProof, params.pending_report ?? null,
+  ])).digest("hex");
+  const pending = params.pending_report == null ? null : requireJsonObject(params.pending_report, "pending report window");
+  const gate = params.operation === "enable" && pending?.prepared === true && pending.retired !== true && pending.verified_publication !== true
+    && pending.subscription_revision !== params.proposed_subscription_revision ? "report_window_pending" : null;
+  return {schema_version: "loopx_steward_report_plan_v0", plan_id: planId,
+    actor: current.actor, operation: params.operation, configuration,
+    retires_failed_window: params.operation === "cancel" && pending?.retired !== true
+      && typeof pending?.failure_ref === "string" && Boolean(pending.failure_ref),
+    gate, model_invoked: false, external_writes_performed: false};
+}
diff --git a/loopx/control_plane/effect_runtime_handlers.ts b/loopx/control_plane/effect_runtime_handlers.ts
index b081018107..f251b74ddb 100644
--- a/loopx/control_plane/effect_runtime_handlers.ts
+++ b/loopx/control_plane/effect_runtime_handlers.ts
@@ -629,6 +629,7 @@ export function createEffectRuntimeHandlers(
     ["collaboration.steward.managed_mode.plan", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({planStewardManagedMode}) => planStewardManagedMode)],
     ["collaboration.steward.managed_turn.admit", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({admitStewardManagedTurn}) => admitStewardManagedTurn)],
     ["collaboration.steward.monitor.plan", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({planStewardMonitor}) => planStewardMonitor)],
+    ["collaboration.steward.report.plan", lazyHandler(() => import("./collaboration/steward_reports.ts"), ({planStewardReport}) => planStewardReport)],
     ["collaboration.steward.monitor.observation", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({observeStewardPortfolio}) => observeStewardPortfolio)],
     ["collaboration.conversation.binding", lazyHandler(() => import("./collaboration/conversation_binding.ts"), ({planConversationBinding}) => planConversationBinding)],
     ["collaboration.conversation.bound_context", lazyHandler(() => import("./collaboration/conversation_binding.ts"), ({resolveBoundConversation}) => resolveBoundConversation)],
diff --git a/loopx/control_plane/turn_driver/host_candidate.py b/loopx/control_plane/turn_driver/host_candidate.py
index e42368ce86..94e468528a 100644
--- a/loopx/control_plane/turn_driver/host_candidate.py
+++ b/loopx/control_plane/turn_driver/host_candidate.py
@@ -147,7 +147,7 @@ def extract_action_text(request: Mapping[str, Any]) -> str:
     return str(extract_turn_authority(request)["primary_action"])
 
 
-def render_prompt(authority: Mapping[str, Any]) -> str:
+def render_prompt(authority: Mapping[str, Any], *, allow_completion: bool = False) -> str:
     """Wrap one signed Turn authority packet in a typed JSON result request.
 
     The host owns execution. The final assistant message is the only channel this
@@ -224,7 +224,9 @@ def render_prompt(authority: Mapping[str, Any]) -> str:
         f"Turn authority JSON:\n{authority_json}\n\n"
         "When finished, return only one JSON object (no Markdown fence) with "
         "these public-safe fields:\n"
-        "- result_kind: one of validated_progress | repair_required | "
+        "- result_kind: one of validated_progress | "
+        + ("validated_completion | " if allow_completion else "")
+        + "repair_required | "
         "replan_required | user_action_required | wait | iteration_failed\n"
         "- classification: short label (<=120 chars)\n"
         "- summary: what changed or why stopped (<=400 chars)\n"
@@ -239,7 +241,8 @@ def render_prompt(authority: Mapping[str, Any]) -> str:
         "hypothesis_id/probe_kind or blocker/coverage fields and opaque evidence_ids; "
         "use independently checked evidence to satisfy the original replan packet.\n"
         "For material result kinds (validated_progress, repair_required, and "
-        "replan_required), describe the path outcome. For a material goal-path "
+        + ("validated_completion, " if allow_completion else "")
+        + "replan_required), describe the path outcome. For a material goal-path "
         "change, set path_delta_mode to material_replan, "
         "result_kind to replan_required, and agent_vision_json to a JSON-encoded "
         "bounded goal_vision_replan_contract_v0 packet whose path_delta is "
@@ -328,6 +331,7 @@ def build_result(
     *,
     fallback_reason: str = "",
     host_name: str = "Host",
+    allow_completion: bool = False,
 ) -> dict[str, Any]:
     """Shape a host model result block into a valid loopx_turn_result_v0."""
 
@@ -352,8 +356,13 @@ def build_result(
             ),
         }
 
+    # A finite-task host may expose the kernel's existing completion result.
+    # Default transports retain their old vocabulary and prompt byte-for-byte;
+    # this option grants no lifecycle authority or validator exemption.
+    material_kinds = MATERIAL_KINDS | ({"validated_completion"} if allow_completion else set())
+    accepted_kinds = ACCEPTED_RESULT_KINDS | ({"validated_completion"} if allow_completion else set())
     kind = str(candidate.get("result_kind") or "").strip()
-    if kind not in ACCEPTED_RESULT_KINDS:
+    if kind not in accepted_kinds:
         return {
             "schema_version": LOOPX_TURN_RESULT_SCHEMA,
             "turn_key": turn_key,
@@ -371,7 +380,7 @@ def build_result(
                 limit=TEXT_LIMITS["vision_unchanged_reason"],
             ),
         }
-    if kind in MATERIAL_KINDS and _execution_profile_present(request):
+    if kind in material_kinds and _execution_profile_present(request):
         missing_evidence = [
             field for field in HOST_RESULT_EVIDENCE_LIMITS
             if field not in candidate
@@ -410,7 +419,7 @@ def build_result(
         text = value.strip() if isinstance(value, str) else value
         if text or (value is not None and not isinstance(value, str)):
             result[field] = text
-    if kind in MATERIAL_KINDS:
+    if kind in material_kinds:
         _complete_material_fields(result, candidate, kind)
     for field in ("path_delta_mode", "agent_vision_json", "progress_observation_json"):
         if field in candidate:
@@ -437,7 +446,7 @@ def build_result(
         # Keep the legacy material-without-packet behavior for older hosts.
         result["vision_unchanged_reason"] = _bounded(
             "host reported material work without a goal vision replan packet"
-            if kind in MATERIAL_KINDS
+            if kind in material_kinds
             else "host reported no material change",
             limit=TEXT_LIMITS["vision_unchanged_reason"],
         )
diff --git a/loopx/extensions/lark/goal_topic_runtime_service.py b/loopx/extensions/lark/goal_topic_runtime_service.py
index d1254deb38..88e5153efc 100644
--- a/loopx/extensions/lark/goal_topic_runtime_service.py
+++ b/loopx/extensions/lark/goal_topic_runtime_service.py
@@ -87,6 +87,8 @@ def _reconcile_private(self) -> None:
         attempted: dict[Path, int] = {}
         attention: Future[int] | None = None
         attention_due = 0.0
+        reports: Future[int] | None = None
+        reports_due = 0.0
         ingress: Future[list[str]] | None = None
         ingress_due = time.monotonic() + 60
         wakeup_scope = getattr(self.runtime_controller, "turn_release_wakeup", None)
@@ -98,6 +100,13 @@ def _reconcile_private(self) -> None:
                 # Clear BEFORE scanning: an arrival during the scan must also
                 # wake the following wait, rather than disappear in that gap.
                 self._delivery_wakeup.clear()
+                if reports is not None and reports.done():
+                    try:
+                        reports.result()
+                    except Exception:
+                        logging.getLogger(__name__).warning("Original private report delivery is pending")
+                    reports = None
+                    reports_due = time.monotonic() + 30
                 if ingress is not None and ingress.done():
                     try:
                         for profile in ingress.result():
@@ -140,17 +149,24 @@ def _reconcile_private(self) -> None:
                     observer = getattr(transport, "ingress", None)
                     ingress_ready = (observer is not None and ingress is None
                         and time.monotonic() >= ingress_due)
+                    report_provider = getattr(transport, "steward_reports", None)
+                    reports_ready = (report_provider is not None and reports is None
+                        and time.monotonic() >= reports_due and report_provider.pending())
+                    if report_provider is not None and reports is None and time.monotonic() >= reports_due:
+                        reports_due = time.monotonic() + 30
                     for path in sorted(paths, key=lambda path: attempted.get(path, 0)):
-                        if (len(pending) + int(attention is not None or attention_ready)
+                        if (len(pending) + int(reports is not None or reports_ready) + int(attention is not None or attention_ready)
                                 + int(ingress is not None or ingress_ready) >= 4 or self._closed.is_set()):
                             break
                         if path in pending:
                             continue
                         pending[path] = pool.submit(transport.reconcile_request, path)
                         attempted[path] = attempted.get(path, 0) + 1
-                    if attention_ready and len(pending) + int(ingress is not None or ingress_ready) < 4 and not self._closed.is_set():
+                    if reports_ready and len(pending) + int(attention is not None or attention_ready) + int(ingress is not None or ingress_ready) < 4 and not self._closed.is_set():
+                        reports = pool.submit(report_provider.reconcile)
+                    if attention_ready and len(pending) + int(reports is not None) + int(ingress is not None or ingress_ready) < 4 and not self._closed.is_set():
                         attention = pool.submit(owner_attention.reconcile)
-                    if ingress_ready and len(pending) + int(attention is not None) < 4 and not self._closed.is_set():
+                    if ingress_ready and len(pending) + int(reports is not None) + int(attention is not None) < 4 and not self._closed.is_set():
                         ingress = pool.submit(observer.observe, cancelled=self._closed.is_set)
                 except Exception:
                     logging.getLogger(__name__).warning("Private Chat delivery discovery is pending")
diff --git a/loopx/extensions/lark/private_conversation_api.py b/loopx/extensions/lark/private_conversation_api.py
index 56d3764915..c3da95e15c 100644
--- a/loopx/extensions/lark/private_conversation_api.py
+++ b/loopx/extensions/lark/private_conversation_api.py
@@ -192,6 +192,30 @@ def _private_conversation_agent_target(self) -> None:
             return
         self._private_conversations()
 
+    def _private_conversation_steward_report(self) -> None:
+        from ...capabilities.native_chat.steward_reports import PendingStewardReportError, StewardReports
+        try:
+            body = self._read_json()
+            if (set(body) - {"binding_id", "operation", "schedule", "plan_id", "execute"}
+                    or not isinstance(body.get("binding_id"), str)
+                    or body.get("operation") not in {"enable", "pause", "cancel"}
+                    or type(body.get("execute", False)) is not bool
+                    or "plan_id" in body and not isinstance(body["plan_id"], str)
+                    or "schedule" in body and (not isinstance(body["schedule"], dict) or body["operation"] != "enable")):
+                raise ValueError("use the original steward report setting")
+            result = StewardReports(self.server.runtime_controller).configure(body["binding_id"],
+                operation=body["operation"], schedule=body.get("schedule"),
+                expected_plan_id=body.get("plan_id"), execute=body.get("execute", False))
+        except PendingStewardReportError:
+            self._send_error("本期汇报已冻结，投递尚未核验；请先完成本期投递，再修改计划。可暂停、取消或恢复原计划，原回执继续保留。The frozen report still awaits verified delivery; finish it before changing its schedule.",
+                status=409, error_code="managed_steward_report_pending")
+            return
+        except (ValueError, KeyError, OSError, RuntimeError, TypeError):
+            self._send_error("The original report setting is unavailable. Refresh the original connection; existing windows, failed attempts and delivery receipts are retained.",
+                status=409, error_code="managed_steward_report_unavailable")
+            return
+        self._send_json(result)
+
     def _private_conversation_owner_notifications(self) -> None:
         try:
             body = self._read_json()
diff --git a/loopx/extensions/lark/private_conversations.py b/loopx/extensions/lark/private_conversations.py
index 90b1eea297..9988b494d6 100644
--- a/loopx/extensions/lark/private_conversations.py
+++ b/loopx/extensions/lark/private_conversations.py
@@ -59,6 +59,9 @@ def __init__(self, *, controller: Any, runtime_root: Path, runner: Any, cli_bin:
         self.ingress = PrivateIngressObserver(self)
         from ...capabilities.native_chat.steward_managed_mode import StewardManagedMode
         self.managed_steward = StewardManagedMode(controller, self.bindings)
+        from .steward_reports import LarkStewardReports
+        self.steward_reports = LarkStewardReports(self)
+        controller.steward_report_provider = self.steward_reports
 
     def profiles(self) -> dict[str, dict[str, str]]:
         """Discover current App configuration, never authorize a conversation.
@@ -811,9 +814,11 @@ def _feedback(self, path: Path, record: dict[str, Any], *, inbox: Callable[[], P
         _atomic_write_json(path, record)
 
     def _deliver(self, path: Path, record: dict[str, Any], phase: str, text: str, *, inbox: Callable[[], Path],
-                 edit_only: bool = False) -> bool:
+                 edit_only: bool = False, authorization_check: Callable[[], bool] | None = None) -> bool:
         if not text:
             return False
+        if authorization_check is not None and not authorization_check():
+            return False
         kind = phase.split(".", 1)[0]
         phase = presentation_phase(record, phase)
         phase_state = record["deliveries"].get(phase, {})
@@ -831,8 +836,10 @@ def _deliver(self, path: Path, record: dict[str, Any], phase: str, text: str, *,
         record_event_timing(record["profile"], record["event"]["message_id"], "delivery_inbox_ready")
         kwargs = dict(project=self.runtime_root, config_path=config,
             message_id=record["event"]["message_id"], text=text, runner=self._reply_runner,
-            finalize_reactions=not edit_only and kind not in {"admission", "progress"} and not (kind == "terminal" and record.get("commission_resources")),
-            source_authority_verifier=lambda profile, chat, message: self._source_authority(record, profile, chat, message))
+            finalize_reactions=not edit_only and kind not in {"admission", "progress", "periodic_report"} and not (kind == "terminal" and record.get("commission_resources")),
+            source_authority_verifier=lambda profile, chat, message: (
+                self._source_authority(record, profile, chat, message)
+                if authorization_check is None or authorization_check() else (None, False)))
         progress = record["deliveries"].get(presentation_phase(record, "progress")) or {}
         stream = presentation_stream(record)
         edit = phase_state.get("edit_from")
diff --git a/loopx/extensions/lark/steward_reports.py b/loopx/extensions/lark/steward_reports.py
new file mode 100644
index 0000000000..884a82b435
--- /dev/null
+++ b/loopx/extensions/lark/steward_reports.py
@@ -0,0 +1,147 @@
+"""Full-body report return through the existing original private reply owner.
+
+Only the existing outbound pool calls this adapter. It never creates a model
+Turn, source event, listener, recipient or report subscription.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+from datetime import datetime, timezone
+import hashlib
+import json
+from typing import Any
+
+from ...chat_store import _read_json
+from ...file_lock import try_exclusive_file_lock
+from ...file_lock import exclusive_file_lock
+from ...registry import atomic_write_json
+from ...capabilities.native_chat.steward_reports import StewardReports
+from ...capabilities.native_chat.steward_turn import native_steward_client_id
+from ...capabilities.periodic_report.cadence_journal import read_cadence_journal
+from ...capabilities.periodic_report.private_generation import attempt_directory, validate_private_generation
+from ...capabilities.periodic_report.incremental import commit_periodic_report_publication_cursor
+
+
+class LarkStewardReports:
+    def __init__(self, transport: Any) -> None:
+        self.transport = transport
+        self.controller = transport.core.controller
+        self.reports = StewardReports(self.controller)
+
+    def _original_route(self, binding: dict[str, Any], actor: dict[str, Any]) -> dict[str, Any]:
+        route = self.transport.owner_attention._route(binding)
+        native = self.transport.core.read_request(route["request_ref"])
+        if native.get("session_id") != actor["session_id"] or route["source"]["source_ref"] != actor["source_ref"]:
+            raise ValueError("the private source does not belong to the original reporting steward")
+        return route
+
+    def route_proof(self, binding: dict[str, Any], actor: dict[str, Any]) -> dict[str, Any]:
+        self._original_route(binding, actor)
+        return {"binding_id": binding["binding_id"], "source_ref": actor["source_ref"],
+            "session_id": actor["session_id"], "provider_ref": binding["provider_ref"],
+            "operator_ref": binding["operator_ref"]}
+
+    def pending(self) -> bool:
+        return any(row.get("managed_actor") and self.reports.health(row["binding_id"]).get("enabled")
+            for row in self.transport.bindings.read()["bindings"])
+
+    def _committed_turn(self, actor: dict[str, Any], window: dict[str, Any]) -> dict[str, Any] | None:
+        # Same stable client identity as the original native host. Reading a
+        # retained completion/event never replays an unknown or failed Turn.
+        client = native_steward_client_id(actor, "report." + window["window_id"])
+        turn = self.controller.store.turn_for_client(actor["session_id"], client)
+        if not turn:
+            return None
+        request = turn.get("loopx_request") or {}
+        if (request.get("work_kind") != "report" or request.get("actor") != actor
+                or request.get("report_window_id") != window["window_id"]
+                or request.get("report_subscription_revision") != window["subscription_revision"]):
+            raise ValueError("the original report Turn changed identity")
+        native = (turn.get("response") or {}).get("native_loopx") or {}
+        if native.get("status") == "committed":
+            return turn
+        # A host response can be lost after native settlement. The original
+        # immutable result event is also sufficient; no second model is run.
+        events = self.controller.store.events_after(actor["session_id"], turn["turn_id"], None)
+        if any(row.get("kind") == "native_loopx.result" and (row.get("payload") or {}).get("status") == "committed"
+                for row in events):
+            return turn
+        return None
+
+    def reconcile(self) -> int:
+        verified = 0
+        for binding in self.transport.bindings.read()["bindings"]:
+            actor = binding.get("managed_actor")
+            if not actor:
+                continue
+            try:
+                subscription = self.reports.subscription(binding["binding_id"])
+                if subscription is None:
+                    continue
+                journal = read_cadence_journal(runtime_root=self.reports.root, goal_id=actor["goal_id"])
+                if not journal or journal["publication"]:
+                    continue
+                window = journal["window"]
+                folder = attempt_directory(self.reports.root, window)
+                if not (folder / "private-generation.json").exists():
+                    continue
+                path = folder / "private-delivery.json"
+                with try_exclusive_file_lock(folder / "delivery.lock", operation="return_private_periodic_report") as acquired:
+                    if not acquired:
+                        continue
+                    if not self._committed_turn(actor, window):
+                        continue
+                    generation = validate_private_generation(folder)
+                    def current():
+                        return self.reports.delivery_current(binding["binding_id"], window)
+                    if not current():
+                        continue
+                    if path.exists():
+                        record = _read_json(path)
+                        if record.get("publication_cursor"):
+                            continue
+                        route = self.transport.owner_attention._route(binding, record["original_route"])
+                    else:
+                        route = self._original_route(binding, actor)
+                        original = _read_json(self.transport.root / (route["request_ref"] + ".json"))
+                        # Preserve the original Core correlation and provider
+                        # source; only this report's reply receipt is separate.
+                        record = {k: deepcopy(v) for k, v in original.items()
+                            if k not in {"deliveries", "stream", "recovery_streams", "context_recovery"}}
+                        record.update(deliveries={}, original_route=route, report_window_id=window["window_id"],
+                            report_generation_id=generation["generation_id"], delivery_status="pending")
+                        atomic_write_json(path, record)
+                    if (record["report_window_id"] != window["window_id"]
+                            or record["report_generation_id"] != generation["generation_id"]
+                            or record["original_route"] != route):
+                        raise ValueError("the frozen report return changed its original audience")
+                    body = (folder / "report.md").read_text(encoding="utf-8")
+                    phase = "periodic_report." + window["window_id"]
+                    delivered = self.transport._deliver(path, record, phase, body,
+                        inbox=lambda: self.transport._inbox(record), authorization_check=current)
+                    record["delivery_status"] = "delivered" if delivered else "unconfirmed"
+                    atomic_write_json(path, record)
+                    if not delivered or not current():
+                        continue
+                    proof = record["deliveries"][phase]
+                    if proof.get("verified") is not True:
+                        raise ValueError("the complete report reply has no verified provider receipt")
+                    publication_id = "private-report-" + hashlib.sha256(json.dumps(
+                        [window["window_id"], generation["generation_id"], proof],
+                        sort_keys=True, ensure_ascii=False).encode()).hexdigest()
+                    candidate = _read_json(folder / "publication-candidate.json")
+                    with self.controller.lock, exclusive_file_lock(self.transport.bindings.path,
+                            operation="commit_original_report_publication"):
+                        if not current():
+                            continue
+                        cursor = commit_periodic_report_publication_cursor(runtime_root=self.reports.root,
+                            candidate=candidate, publication_id=publication_id,
+                            delivered_at=datetime.now(timezone.utc).isoformat(), covered_until=window["due_at"])
+                    record.update(publication_cursor=cursor, delivery_status="delivered")
+                    atomic_write_json(path, record)
+                    verified += 1
+            except (OSError, ValueError, KeyError, TypeError, RuntimeError):
+                # Existing generation, failed/unknown sends and source failures
+                # remain visible. No alternate App, route or model is selected.
+                continue
+        return verified
diff --git a/tests/control_plane_ts/steward_reports.test.ts b/tests/control_plane_ts/steward_reports.test.ts
new file mode 100644
index 0000000000..7dbfccd4d5
--- /dev/null
+++ b/tests/control_plane_ts/steward_reports.test.ts
@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {planStewardReport} from "../../loopx/control_plane/collaboration/steward_reports.ts";
+import {admitStewardManagedTurn, bindStewardManagedActor} from "../../loopx/control_plane/collaboration/steward_managed_mode.ts";
+
+function original() {
+  const binding = {binding_id: "b".repeat(24), transport_ref: "private-steward", provider_ref: "c".repeat(24),
+    operator_ref: "d".repeat(24), project_ref: "a".repeat(24), context_kind: "steward",
+    grant: "portfolio_read", enabled: true, executor_endpoint_id: "codex", audience: "owner"};
+  const source = "e".repeat(24);
+  const session = {session_id: "f".repeat(32), agent_id: "codex", goal_id: "loopx-manager", status: "ready",
+    channel_id: `manager.external.native.${binding.binding_id}.${source}`,
+    steward_context: {...binding, source_ref: source}};
+  const workspace = "/runtime/chat/manager-workspaces/original";
+  const goal = {goal_id: `steward-agent-${binding.binding_id}`, goal_instance_id: null,
+    creation_operation_id: `steward-managed:${binding.binding_id}:${source}`,
+    workspace_path: workspace, registered_agents: ["steward"]};
+  const params = {binding, session, goal, workspace_path: workspace, queued_turn_count: 0,
+    observation: {verified: true, transport_ref: binding.transport_ref, provider_ref: binding.provider_ref,
+      operator_ref: binding.operator_ref}};
+  const actor = bindStewardManagedActor(params);
+  return {...params, binding: {...binding, managed_actor: actor}, actor, goal_active: true, source};
+}
+
+test("report consent fixes the original actor, source and private audience without starting work", () => {
+  const p = original();
+  const proposed = {enabled: true, profile_preset: "portfolio-progress",
+    route_ref: `steward-private:${p.binding.binding_id}:${p.source}`};
+  const route = {binding_id: p.binding.binding_id, source_ref: p.source, session_id: p.session.session_id,
+    provider_ref: p.binding.provider_ref, operator_ref: p.binding.operator_ref};
+  const input = {...p, configuration: null, proposed, route, operation: "enable"};
+  const before = structuredClone(input);
+  const first = planStewardReport(input);
+  assert.deepEqual(input, before);
+  assert.deepEqual(first.actor, p.actor);
+  assert.equal(first.model_invoked, false);
+  const retained = {...input, proposed_subscription_revision: "new", pending_report:
+    {prepared: true, subscription_revision: "original", verified_publication: false}};
+  assert.equal(planStewardReport(retained).gate, "report_window_pending");
+  assert.equal(planStewardReport({...retained, proposed_subscription_revision: "original"}).gate, null);
+  assert.equal(planStewardReport({...retained, pending_report: {...retained.pending_report,
+    verified_publication: true}}).gate, null);
+  assert.equal(planStewardReport({...retained, pending_report: {...retained.pending_report,
+    retired: true}}).gate, null);
+  const cancel = {...retained, operation: "cancel", proposed: {...proposed, enabled: false}};
+  assert.equal(planStewardReport(cancel).retires_failed_window, false);
+  assert.equal(planStewardReport({...cancel, pending_report: {...retained.pending_report,
+    failure_ref: "known-terminal-failure"}}).retires_failed_window, true);
+  assert.equal(planStewardReport({...cancel, pending_report: {...retained.pending_report,
+    failure_ref: "known-terminal-failure", retired: true}}).retires_failed_window, false);
+  assert.notEqual(first.plan_id, planStewardReport({...input, proposed: {...proposed, timezone: "UTC"}}).plan_id);
+  for (const invalid of [
+    {...input, binding: {...p.binding, audience: "group"}},
+    {...input, route: {...route, session_id: "0".repeat(32)}},
+    {...input, route: {...route, operator_ref: "0".repeat(24)}},
+    {...input, configuration: {...proposed, route_ref: "another-channel"}},
+    {...input, proposed: {...proposed, route_ref: "another-channel"}},
+    {...input, goal_active: false},
+  ]) assert.throws(() => planStewardReport(invalid));
+});
+
+test("a model report requires the exact live calendar window and original task, never a watch", () => {
+  const p = original();
+  const request = {operation: "native_turn", host: "codex-app-server", actor: p.actor,
+    turn_instance_id: "report.cadence_original", todo_id: "todo_report", validation_command: ["python", "-c", "validate_generation()"],
+    work_kind: "report", report_window_id: "cadence_original", report_subscription_revision: "sha256:original"};
+  const window = {window_id: request.report_window_id, subscription_revision: request.report_subscription_revision,
+    goal_id: p.actor.goal_id, agent_id: p.actor.agent_id};
+  const subscription = {enabled: true, profile_preset: "portfolio-progress",
+    route_ref: `steward-private:${p.binding.binding_id}:${p.source}`, effective_revision: window.subscription_revision};
+  const todo = {todo_id: request.todo_id, target_key: window.window_id,
+    action_kind: "generate_periodic_report", claimed_by: "steward", status: "open"};
+  const input = {...p, request, report_window: window, report_subscription: subscription, report_todo: todo};
+  assert.equal(admitStewardManagedTurn(input).observation_only, false);
+  const recovery = {...input, report_todo: {...todo, status: "done", completion_turn_key: request.turn_instance_id},
+    report_settlement_recovery: {schema_version: "loopx_turn_journal_inspection_v1", ok: true,
+      goal_matches: true, owner_matches: true, turn_key_matches: true,
+      journal_consistent: true, journal_status: "failed", recovery_decision:
+      {action: "continue", reinvoke_host: false, resume_from: "quota_spend"}}};
+  assert.equal(admitStewardManagedTurn(recovery).observation_only, false);
+  for (const invalid of [
+    {...recovery, report_settlement_recovery: {...recovery.report_settlement_recovery, journal_consistent: false}},
+    {...recovery, report_todo: {...recovery.report_todo, completion_turn_key: "another-original-turn"}},
+    {...recovery, report_todo: {...todo, status: "open"}},
+    {...recovery, preparing_model_context: true},
+    ...["host_execute", "typed_result", "validation"].map(resume_from => ({...recovery,
+      report_settlement_recovery: {...recovery.report_settlement_recovery, recovery_decision:
+        {action: "continue", reinvoke_host: false, resume_from}}})),
+    {...recovery, report_settlement_recovery: {...recovery.report_settlement_recovery, recovery_decision:
+      {action: "continue", reinvoke_host: true, resume_from: "quota_spend"}}},
+  ]) assert.throws(() => admitStewardManagedTurn(invalid));
+  const changed = {...input, binding: {...p.binding, goal_scope: "all_registered"},
+    session: {...p.session, active_turn_id: "running", manager_authorization_scope_id: "old_scope",
+      steward_context: {...p.session.steward_context, goal_scope: "all_registered"}},
+    scope: {current: "new_scope", without_actor: "other_scope"},
+    turn: {session_id: p.session.session_id, turn_id: "running", status: "running", origin: "native_loopx",
+      loopx_execution: true, loopx_request: request}};
+  assert.throws(() => admitStewardManagedTurn(changed));
+  const preparation = admitStewardManagedTurn({...changed, preparing_model_context: true});
+  assert.equal(preparation.context_rebind_required, true);
+  assert.equal(preparation.refresh_original_scope, false); // Only the existing context owner may change it.
+  assert.throws(() => admitStewardManagedTurn({...changed, preparing_model_context: true,
+    binding: {...changed.binding, goal_scope: "selected"}}));
+  assert.throws(() => admitStewardManagedTurn({...changed, preparing_model_context: "true"}));
+  for (const invalid of [
+    {...input, request: {...request, validation_command: null}},
+    {...input, report_subscription: {...subscription, enabled: false}},
+    {...input, report_subscription: {...subscription, effective_revision: "changed"}},
+    {...input, report_window: {...window, window_id: "another"}},
+    {...input, report_todo: {...todo, claimed_by: "other"}},
+    {...input, report_todo: {...todo, action_kind: "local_runtime_observe"}},
+    {...input, report_todo: {...todo, status: "done"}},
+  ]) assert.throws(() => admitStewardManagedTurn(invalid));
+});
diff --git a/tests/test_lark_steward_reports.py b/tests/test_lark_steward_reports.py
new file mode 100644
index 0000000000..ce88abf025
--- /dev/null
+++ b/tests/test_lark_steward_reports.py
@@ -0,0 +1,202 @@
+"""Independent original-audience and partial/unknown-send report recovery."""
+import json
+
+import pytest
+
+from test_native_steward_private import steward as steward_fixture, finish
+from test_native_steward_reports import configured, install_model
+from loopx.capabilities.native_chat.steward_monitor import pump_steward_monitors
+from loopx.capabilities.periodic_report.cadence_journal import read_cadence_journal
+from loopx.capabilities.periodic_report.private_generation import attempt_directory
+from loopx.capabilities.periodic_report.incremental import read_periodic_report_publication_cursor
+from loopx.extensions.lark.steward_reports import LarkStewardReports
+
+steward = steward_fixture
+
+
+def generated(steward, tmp_path, monkeypatch, provider="sqlite"):
+    _, runtime, _, _, binding, _, _ = steward
+    sid, actor, reports, _ = configured(steward, tmp_path, monkeypatch, provider)
+    install_model(steward, tmp_path, sid)
+    turns = pump_steward_monitors(runtime)
+    assert len(turns) == 1
+    done = finish(runtime, turns[0])
+    assert done["status"] == "completed" and done["response"]["native_loopx"]["status"] == "committed", done
+    window = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])["window"]
+    return actor, reports, window, attempt_directory(reports.root, window), binding
+
+
+@pytest.mark.parametrize("fault", ["pause", "cancel", "revoked", "scope", "provider", "body", "source", "foreign_candidate"])
+def test_late_report_never_escapes_changed_original_authority_or_frozen_evidence(steward, tmp_path, monkeypatch, fault):
+    _, runtime, provider, transport, _, capture, _ = steward
+    actor, reports, window, folder, binding = generated(steward, tmp_path, monkeypatch)
+    if fault in {"pause", "cancel"}:
+        preview = reports.configure(binding["binding_id"], operation=fault)["plan"]
+        reports.configure(binding["binding_id"], operation=fault, execute=True, expected_plan_id=preview["plan_id"])
+    elif fault == "revoked":
+        transport.bindings.disconnect(binding["binding_id"], expected_revision=transport.bindings.read()["revision"])
+    elif fault == "scope":
+        transport.bindings.configure(transport_ref="steward-app", project_ref=binding["project_ref"],
+            executor_endpoint_id="codex", context_kind="steward", goal_scope="selected")
+        assert not reports.delivery_current(binding["binding_id"], window)
+    elif fault == "provider":
+        provider.profile_apps["steward-app"] = "cli_replaced_application"
+    elif fault == "body":
+        (folder / "report.md").write_text("篡改后的不完整结果")
+    elif fault == "source":
+        value = json.loads((folder / "source.json").read_text())
+        value["rows"] = []
+        (folder / "source.json").write_text(json.dumps(value))
+    elif fault == "foreign_candidate":
+        from loopx.capabilities.periodic_report.incremental import build_periodic_report_publication_candidate
+        # A well-formed candidate for another Goal passes the generic cursor
+        # schema. This original-report validator must reject it before sending.
+        candidate = build_periodic_report_publication_candidate(goal_id="foreign-reporting-goal",
+            agent_id=actor["agent_id"], generation_id=json.loads((folder / "private-generation.json").read_text())["generation_id"],
+            trigger_receipt={"coalesced_trigger_ids": []}, facts=[], baseline=None)
+        (folder / "publication-candidate.json").write_text(json.dumps(candidate))
+    before = list(provider.writes), capture.read_bytes()
+    assert transport.steward_reports.reconcile() == 0
+    assert before == (provider.writes, capture.read_bytes())
+    assert read_periodic_report_publication_cursor(runtime_root=reports.root,
+        goal_id=actor["goal_id"], agent_id=actor["agent_id"]) is None
+
+
+@pytest.mark.parametrize("provider_kind", ["file", "sqlite"])
+def test_known_partial_reply_recovers_original_parts_after_provider_adapter_restart(steward, tmp_path, monkeypatch, provider_kind):
+    _, _, provider, transport, _, capture, _ = steward
+    actor, reports, window, folder, _ = generated(steward, tmp_path, monkeypatch, provider_kind)
+    calls = capture.read_bytes()
+    provider.verify_replies = False
+    original_count = len(provider.writes)
+    assert transport.steward_reports.reconcile() == 0
+    assert len(provider.writes) > original_count
+    sent = list(provider.writes)
+    path = folder / "private-delivery.json"
+    pending = json.loads(path.read_text())
+    assert pending["delivery_status"] == "unconfirmed"
+    assert read_periodic_report_publication_cursor(runtime_root=reports.root,
+        goal_id=actor["goal_id"], agent_id=actor["agent_id"]) is None
+    # Restoring visibility is a readback change, not authorization to replay
+    # the model or already-created parts. Missing subsequent parts may proceed.
+    provider.verify_replies = True
+    restarted = LarkStewardReports(transport)
+    assert restarted.reconcile() == 1
+    assert provider.writes[:len(sent)] == sent
+    assert len(provider.writes) > len(sent)  # Remaining full-body parts, rather than a truncated first part.
+    writes = list(provider.writes)
+    assert restarted.reconcile() == 0 and provider.writes == writes
+    assert capture.read_bytes() == calls
+    assert json.loads(path.read_text())["delivery_status"] == "delivered"
+
+
+def test_unknown_send_without_locator_is_retained_without_second_create_or_model(steward, tmp_path, monkeypatch):
+    _, _, provider, transport, _, capture, _ = steward
+    actor, reports, _, folder, _ = generated(steward, tmp_path, monkeypatch)
+    original = transport._reply_runner
+    lost = False
+
+    def lose_create_response(args):
+        nonlocal lost
+        result = original(args)
+        if not lost and any(command in args for command in ["+messages-send", "+messages-reply"]) and "--dry-run" not in args:
+            lost = True
+            return {"returncode": 1, "stdout": "", "stderr": "synthetic unknown provider response"}
+        return result
+
+    monkeypatch.setattr(transport, "_reply_runner", lose_create_response)
+    assert transport.steward_reports.reconcile() == 0 and lost
+    sent, calls = list(provider.writes), capture.read_bytes()
+    for _ in range(2):
+        assert LarkStewardReports(transport).reconcile() == 0
+    assert provider.writes == sent and capture.read_bytes() == calls
+    assert json.loads((folder / "private-delivery.json").read_text())["delivery_status"] == "unconfirmed"
+    assert read_periodic_report_publication_cursor(runtime_root=reports.root,
+        goal_id=actor["goal_id"], agent_id=actor["agent_id"]) is None
+    binding = reports.selected(actor["goal_id"].removeprefix("steward-agent-"))["binding"]
+    plan = reports.configure(binding["binding_id"], operation="cancel")["plan"]
+    assert not plan["retires_failed_window"]
+    reports.configure(binding["binding_id"], operation="cancel", execute=True, expected_plan_id=plan["plan_id"])
+    assert not read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"]).get("retirement")
+    assert provider.writes == sent and capture.read_bytes() == calls
+
+
+def test_original_production_wake_and_outbound_loops_complete_the_report_without_manual_submit(steward, tmp_path, monkeypatch):
+    import threading
+    import time
+    from loopx.chat_loopx_mode import DelegationWakeService
+    from loopx.extensions.lark.goal_topic_runtime_service import LarkGoalTopicRuntimeService
+
+    _, runtime, _, transport, _, _, _ = steward
+    sid, actor, reports, _ = configured(steward, tmp_path, monkeypatch)
+    install_model(steward, tmp_path, sid)
+    wake = DelegationWakeService(runtime, interval=.02).start()
+    outbound = LarkGoalTopicRuntimeService(snapshot_provider=lambda: {}, runtime_root=reports.root,
+        runtime_controller=runtime, private_conversations=transport)
+    # Run the existing outbound producer, without starting any event listener.
+    delivery = threading.Thread(target=outbound._reconcile_private)
+    delivery.start()
+    try:
+        deadline = time.monotonic() + 35
+        while read_periodic_report_publication_cursor(runtime_root=reports.root,
+                goal_id=actor["goal_id"], agent_id=actor["agent_id"]) is None:
+            assert time.monotonic() < deadline, "production wake/outbound hooks never completed the due report"
+            time.sleep(.05)
+        window = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])["window"]
+        source = json.loads((attempt_directory(reports.root, window) / "source.json").read_text())
+        assert source["coverage"]["goals_in_inventory"] == 1
+        assert reports.health(transport.bindings.read()["bindings"][-1]["binding_id"])["available"]
+    finally:
+        wake.close()
+        outbound.close()
+        delivery.join(5)
+    assert not delivery.is_alive()
+
+
+def test_full_host_restart_recovers_frozen_delivery_without_a_second_native_model(steward, tmp_path, monkeypatch):
+    from loopx.chat_runtime import ChatRuntimeController
+    from loopx.extensions.lark.private_conversations import LarkPrivateConversations
+
+    store, runtime, provider, transport, _, capture, _ = steward
+    actor, reports, _, folder, _ = generated(steward, tmp_path, monkeypatch)
+    provider.verify_replies = False
+    assert transport.steward_reports.reconcile() == 0
+    sent, calls = list(provider.writes), capture.read_bytes()
+    runtime.close()
+    restored = ChatRuntimeController(store=store, codex_bin=runtime.codex_bin,
+        project_contexts=runtime.project_contexts, registry_path=runtime.registry_path,
+        manager_scope_resolver=runtime.manager_scope_resolver)
+    try:
+        replies = LarkPrivateConversations(controller=restored, runtime_root=reports.root,
+            runner=provider, cli_bin="lark-cli")
+        provider.verify_replies = True
+        assert replies.steward_reports.reconcile() == 1
+        assert provider.writes[:len(sent)] == sent and capture.read_bytes() == calls
+        assert json.loads((folder / "private-delivery.json").read_text())["delivery_status"] == "delivered"
+        assert not pump_steward_monitors(restored) and capture.read_bytes() == calls
+        assert read_periodic_report_publication_cursor(runtime_root=reports.root,
+            goal_id=actor["goal_id"], agent_id=actor["agent_id"])
+    finally:
+        restored.close()
+
+
+def test_schedule_change_cannot_strand_a_frozen_original_report(steward, tmp_path, monkeypatch):
+    from loopx.capabilities.native_chat.steward_reports import PendingStewardReportError
+    _, runtime, _, transport, _, capture, _ = steward
+    _, reports, _, _, binding = generated(steward, tmp_path, monkeypatch)
+    schedule = reports.health(binding["binding_id"])["schedule"]
+    changed = {**schedule, "start_date": "2099-05-01"}
+    before = runtime.registry_path.read_bytes(), capture.read_bytes()
+    with pytest.raises(PendingStewardReportError):
+        reports.configure(binding["binding_id"], operation="enable", schedule=changed)
+    assert before == (runtime.registry_path.read_bytes(), capture.read_bytes())
+    pause = reports.configure(binding["binding_id"], operation="pause")["plan"]
+    reports.configure(binding["binding_id"], operation="pause", execute=True, expected_plan_id=pause["plan_id"])
+    resume = reports.configure(binding["binding_id"], operation="enable", schedule=schedule)["plan"]
+    reports.configure(binding["binding_id"], operation="enable", schedule=schedule, execute=True, expected_plan_id=resume["plan_id"])
+    assert transport.steward_reports.reconcile() == 1
+    assert reports.health(binding["binding_id"])["publication_verified"]
+    preview = reports.configure(binding["binding_id"], operation="enable", schedule=changed)["plan"]
+    result = reports.configure(binding["binding_id"], operation="enable", schedule=changed,
+        execute=True, expected_plan_id=preview["plan_id"])
+    assert result["applied"] and result["report"]["schedule"] == changed
diff --git a/tests/test_loopx_turn_driver.py b/tests/test_loopx_turn_driver.py
index b001e5236b..6a8d28b103 100644
--- a/tests/test_loopx_turn_driver.py
+++ b/tests/test_loopx_turn_driver.py
@@ -2643,9 +2643,9 @@ def crash_after_canonical_completion(**kwargs: object) -> dict[str, object]:
     assert resumed_exit_code == 0, json.dumps(resumed, indent=2)
     assert resumed["status"] == "committed"
     assert resumed["effects"]["host_invoked"] is False
-    assert committed_results[1]["status"] == "done"
-    assert committed_results[1]["provider_status"] == "replayed"
-    assert committed_results[1]["idempotent_replay"] is True
+    # The exact canonical completion is read back after the lost response.
+    # Reissuing completion would carry a lease already retired by its commit.
+    assert len(committed_results) == 1
     assert _turn_journal(runtime)["writeback"]["completion"] == {
         "todo_id": "todo_fixture0001",
         "continuation": "active_goal",
diff --git a/tests/test_native_steward_managed_mode.py b/tests/test_native_steward_managed_mode.py
index 89825e87e1..e58931c328 100644
--- a/tests/test_native_steward_managed_mode.py
+++ b/tests/test_native_steward_managed_mode.py
@@ -179,6 +179,7 @@ def request(path, body=None, origin=None):
         row = next(row for row in readback["connections"] if row["binding_id"] == binding["binding_id"])
         assert row["managed_steward"] == {"available": True, "prepared": True, "scheduling_enabled": False,
             "goal_active": True, "monitor": None,
+            "report": {"available": True, "configured": False, "enabled": False},
             "goal_id": applied["actor"]["goal_id"], "agent_id": "steward", "session_id": sid}
         assert store.messages(sid) == before_history and capture.read_bytes() == before_calls
         assert request(route, {**body, "plan_id": preview["plan"]["plan_id"]})[1]["idempotent"]
diff --git a/tests/test_native_steward_reports.py b/tests/test_native_steward_reports.py
new file mode 100644
index 0000000000..521753e8a4
--- /dev/null
+++ b/tests/test_native_steward_reports.py
@@ -0,0 +1,473 @@
+"""Original Chat + real calendar/Todo/Turn/report owners; synthetic model/Lark.
+
+These tests certify mechanics and original-audience readback, not the quality
+of a live Agent's report or a natural production deadline.
+"""
+from datetime import datetime, timedelta
+import inspect
+import json
+from pathlib import Path
+
+import pytest
+
+from test_native_steward_managed_mode import original, storage
+from test_native_steward_private import steward as steward_fixture, finish
+from tests.control_plane.canonical_authority_fixture import isolate_sqlite_runtime
+from loopx.capabilities.native_chat.steward_monitor import pump_steward_monitors
+from loopx.capabilities.native_chat.steward_reports import StewardReports
+from loopx.capabilities.periodic_report.cadence_journal import read_cadence_journal
+from loopx.capabilities.periodic_report.private_generation import attempt_directory, validate_private_generation
+from loopx.capabilities.periodic_report.incremental import read_periodic_report_publication_cursor
+
+steward = steward_fixture
+
+
+def configured(steward, tmp_path, monkeypatch, provider="sqlite", start_date="2001-01-01"):
+    isolate_sqlite_runtime(tmp_path, monkeypatch)
+    store, runtime, _, transport, binding, capture, _ = steward
+    sid, managed = original(steward)
+    storage(runtime, provider)
+    preview = managed.prepare(binding["binding_id"], session_id=sid)["plan"]
+    actor = managed.prepare(binding["binding_id"], session_id=sid, execute=True,
+        expected_plan_id=preview["plan_id"])["actor"]
+    transport.reconcile()
+    reports = StewardReports(runtime)
+    schedule = {"schema_version": "periodic_report_schedule_v0", "schedule_id": "daily-report",
+        "timezone": "UTC", "rrule": "FREQ=DAILY;BYHOUR=9;BYMINUTE=0", "start_date": start_date}
+    before = runtime.registry_path.read_bytes(), store.messages(sid), capture.read_bytes()
+    preview = reports.configure(binding["binding_id"], operation="enable", schedule=schedule)
+    assert before == (runtime.registry_path.read_bytes(), store.messages(sid), capture.read_bytes())
+    assert not preview["applied"] and preview["plan"]["configuration"]["schedule"] == schedule
+    result = reports.configure(binding["binding_id"], operation="enable", schedule=schedule,
+        execute=True, expected_plan_id=preview["plan"]["plan_id"])
+    assert result["applied"] and result["report"]["enabled"] and not result["model_invoked"]
+    return sid, actor, reports, schedule
+
+
+def fake_report_model(params):
+    """A transport-only oracle returns one substantive synthetic Chinese report."""
+    import json
+    import re
+    from pathlib import Path
+    prompt = "\n".join(row.get("text", "") for row in params.get("input", []) if isinstance(row, dict))
+    match = re.search(r'"editorial_request_path":\s*"([^"\n]+)"', prompt)
+    request = json.loads(Path(match[1]).read_text())
+    ref = request["facts"][0]["source_ref"]
+    sections = [("overview", "全景判断"), ("problem_map", "问题版图"),
+        ("causal_analysis", "重点因果下钻"), ("coverage_and_actions", "版本覆盖与处置"), ("next_actions", "下一步")]
+    narrative = "本期授权工作已完成来源核查，当前记录仍需区分实际成果、来源缺口和后续行动。任务状态与消息送达分别验证，不能根据一次观察宣告业务完成。"
+    response = {"schema_version": "periodic_report_editorial_response_v0",
+        "request_digest": request["request_digest"], "language": "zh-CN", "title": "本期授权工作详细汇报",
+        "highlights": [{"highlight_id": "coverage", "label": "读取范围", "value": "已核查", "detail": "保留来源缺口", "tone": "neutral"},
+            {"highlight_id": "delivery", "label": "送达情况", "value": "待核验", "detail": "生成不代表送达", "tone": "attention"}],
+        "sections": [{"section_id": key, "title": title, "items": [
+            {"title": title + "与证据边界", "summary": narrative * 4, "source_ref": ref,
+                "details": [{"label": "来源", "text": narrative * 4},
+                    {"label": "边界", "text": narrative * 4}]}
+            for _ in range(6)]} for key, title in sections]}
+    return json.dumps({"result_kind": "validated_completion", "classification": "periodic_report_generation",
+        "summary": "The original report generation was frozen and independently validated; private delivery remains separate.",
+        "next_action": "Retain monitoring and future report windows; verify original private delivery.",
+        "delivery_batch_scale": "single_surface", "delivery_outcome": "outcome_progress",
+        "vision_unchanged_reason": "The original monitoring and reporting route remains active.",
+        "work_evidence": ["Frozen report generation and complete report body"],
+        "validation_evidence": ["The independent native report validator checks editorial lineage and artifact digests"],
+        "editorial_response": response}, ensure_ascii=False)
+
+
+def install_model(steward, tmp_path, sid, *, result_kind="validated_completion"):
+    _, runtime, _, _, _, _, _ = steward
+    helper = tmp_path / "report_model.py"
+    helper.write_text(inspect.getsource(fake_report_model).replace(
+        '"result_kind": "validated_completion"', '"result_kind": ' + repr(result_kind)))
+    fake = Path(runtime.codex_bin)
+    source = fake.read_text().replace('"message": "Runtime response."',
+        '"message": __import__("runpy").run_path(' + repr(str(helper)) + ')["fake_report_model"](request["params"])')
+    fake.write_text(source)
+    runtime.adapters.pop(sid).close_session()  # Resume the same native thread with the synthetic response.
+
+
+@pytest.mark.parametrize("provider", ["file", "sqlite"])
+@pytest.mark.parametrize("result_kind", ["validated_progress", "validated_completion"])
+def test_original_due_report_freezes_once_and_returns_full_body_after_native_settlement(steward, tmp_path, monkeypatch, provider, result_kind):
+    store, runtime, bot, transport, binding, capture, _ = steward
+    sid, actor, reports, _ = configured(steward, tmp_path, monkeypatch, provider)
+    install_model(steward, tmp_path, sid, result_kind=result_kind)
+    calls, writes, history = capture.read_bytes(), list(bot.writes), store.messages(sid)
+    thread = store.load_session(sid)["upstream_thread_id"]
+    turns = pump_steward_monitors(runtime)
+    assert len(turns) == 1 and turns[0]["session_id"] == sid
+    done = finish(runtime, turns[0])
+    assert done["status"] == "completed", done
+    assert done["response"]["native_loopx"]["status"] == "committed", done
+    from loopx.capabilities.native_chat.steward_monitor import StewardMonitor
+    task = next(row for row in StewardMonitor(runtime).todos(actor) if row["todo_id"] == turns[0]["loopx_request"]["todo_id"])
+    assert task["status"] == "done"  # Completed generation is not left as tomorrow's backlog.
+    journal = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])
+    window = journal["window"]
+    assert datetime.fromisoformat(window["due_at"].replace("Z", "+00:00")) - datetime.fromisoformat(window["start_at"].replace("Z", "+00:00")) == timedelta(hours=24)
+    folder = attempt_directory(reports.root, window)
+    snapshot = json.loads((folder / "source.json").read_text())
+    assert snapshot["coverage"]["goals_in_inventory"] == 1 and snapshot["goal_ids"] == [actor["goal_id"]]
+    generation = validate_private_generation(folder)
+    assert journal["publication"] is None and read_periodic_report_publication_cursor(
+        runtime_root=reports.root, goal_id=actor["goal_id"], agent_id=actor["agent_id"]) is None
+    assert bot.writes == writes  # A frozen generation is not a send.
+    assert store.messages(sid)[:len(history)] == history
+    assert store.load_session(sid)["upstream_thread_id"] == thread
+    native_calls = [json.loads(line) for line in capture.read_bytes()[len(calls):].splitlines()]
+    assert sum(call.get("method") == "turn/start" for call in native_calls) == 1
+    assert not any(call.get("method") == "thread/start" for call in native_calls)
+    assert transport.steward_reports.reconcile() == 1
+    cursor = read_periodic_report_publication_cursor(runtime_root=reports.root, goal_id=actor["goal_id"], agent_id=actor["agent_id"])
+    assert cursor["generation_id"] == generation["generation_id"] and cursor["covered_until"] == window["due_at"]
+    body = (folder / "report.md").read_text()
+    assert done["response"]["message"] == body and "全景判断" in body and "重点因果下钻" in body
+    delivery = json.loads((folder / "private-delivery.json").read_text())
+    assert delivery["delivery_status"] == "delivered"
+    proof = delivery["deliveries"]["periodic_report." + window["window_id"]]
+    assert proof["verified"] and proof["text"] == body.strip()
+    assert len(body.encode()) > 40000  # Exercise the original multipart full-body sender.
+    after = capture.read_bytes(), list(bot.writes)
+    runtime._steward_monitor_next_check.clear()
+    assert not pump_steward_monitors(runtime)
+    assert transport.steward_reports.reconcile() == 0
+    assert after == (capture.read_bytes(), bot.writes)
+
+
+@pytest.mark.parametrize("provider", ["file", "sqlite"])
+def test_future_first_date_pause_and_cancel_never_start_models_or_shift_window(steward, tmp_path, monkeypatch, provider):
+    store, runtime, bot, _, binding, capture, _ = steward
+    sid, actor, reports, schedule = configured(steward, tmp_path, monkeypatch, provider, "2099-05-01")
+    before = capture.read_bytes(), list(bot.writes), store.messages(sid)
+    for _ in range(3):
+        getattr(runtime, "_steward_monitor_next_check", {}).clear()
+        assert not pump_steward_monitors(runtime)
+    assert read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"]) is None
+    assert reports.health(binding["binding_id"])["next_due_at"] == "2099-05-01T09:00:00Z"
+    for operation in ["pause", "cancel"]:
+        preview = reports.configure(binding["binding_id"], operation=operation)
+        result = reports.configure(binding["binding_id"], operation=operation, execute=True,
+            expected_plan_id=preview["plan"]["plan_id"])
+        assert not result["report"]["enabled"] and result["report"]["schedule"] == schedule
+        assert not pump_steward_monitors(runtime)
+    assert before == (capture.read_bytes(), bot.writes, store.messages(sid))
+
+
+@pytest.mark.parametrize("fault", ["stale", "provider", "revoked", "foreign_route"])
+def test_report_configuration_fails_closed_on_original_source_changes(steward, tmp_path, monkeypatch, fault):
+    _, runtime, provider, transport, binding, capture, _ = steward
+    _, actor, reports, schedule = configured(steward, tmp_path, monkeypatch, start_date="2099-05-01")
+    preview = reports.configure(binding["binding_id"], operation="pause")
+    if fault == "provider":
+        provider.owner_ready = False
+    elif fault == "revoked":
+        transport.bindings.disconnect(binding["binding_id"], expected_revision=transport.bindings.read()["revision"])
+    elif fault == "foreign_route":
+        from loopx.configure_goal import configure_goal
+        configure_goal(registry_path=runtime.registry_path, goal_id=actor["goal_id"], execute=True,
+            periodic_report_configuration={"enabled": True, "profile_preset": "weekly", "route_ref": "other-channel",
+                "timezone": "UTC", "schedule": schedule})
+    before, calls = runtime.registry_path.read_bytes(), capture.read_bytes()
+    with pytest.raises((ValueError, StopIteration)):
+        reports.configure(binding["binding_id"], operation="pause", execute=True,
+            expected_plan_id="stale" if fault == "stale" else preview["plan"]["plan_id"])
+    assert runtime.registry_path.read_bytes() == before and capture.read_bytes() == calls
+
+
+def test_finite_completion_is_opt_in_and_other_host_prompts_and_results_are_unchanged():
+    from loopx.control_plane.turn_driver.host_candidate import render_prompt, build_result
+    authority = {"primary_action": "Inspect an authorized bounded artifact.", "write_scope": []}
+    assert render_prompt(authority) == render_prompt(authority, allow_completion=False)
+    assert "validated_completion |" not in render_prompt(authority)
+    assert "validated_completion |" in render_prompt(authority, allow_completion=True)
+    request = {"turn_key": "opaque-original-turn"}
+    candidate = {"result_kind": "validated_progress", "classification": "bounded_observation",
+        "summary": "A bounded source was independently read.", "next_action": "Retain the original task."}
+    assert build_result(request, candidate) == build_result(request, candidate, allow_completion=True)
+    completion = {**candidate, "result_kind": "validated_completion"}
+    assert build_result(request, completion)["result_kind"] == "wait"
+    assert build_result(request, completion, allow_completion=True)["result_kind"] == "validated_completion"
+
+
+def test_report_http_preview_apply_is_original_source_bound_and_failure_is_reviewable(steward, tmp_path, monkeypatch):
+    import http.client
+    import threading
+    from types import SimpleNamespace
+    from loopx.chat_server import ChatHTTPServer, ChatRequestHandler
+
+    store, runtime, provider, transport, binding, capture, _ = steward
+    sid, _, reports, schedule = configured(steward, tmp_path, monkeypatch, start_date="2099-05-01")
+    server = ChatHTTPServer(("127.0.0.1", 0), ChatRequestHandler)
+    server.chat_store, server.runtime_controller = store, runtime
+    server.registry_path, server.runtime_root_override = runtime.registry_path, str(store.root.parent)
+    server.lark_private_conversations = transport
+    server.lark_goal_topic_runtime = SimpleNamespace(health_snapshot=lambda: {}, close=lambda: None)
+    server.verbose = False
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    route = "/api/chat/lark/private-conversations/managed-steward/report"
+
+    def post(body, origin=None):
+        client = http.client.HTTPConnection(*server.server_address, timeout=15)
+        try:
+            headers = {"Content-Type": "application/json", **({"Origin": origin} if origin else {})}
+            client.request("POST", route, json.dumps(body), headers)
+            reply = client.getresponse()
+            return reply.status, json.loads(reply.read())
+        finally:
+            client.close()
+
+    body = {"binding_id": binding["binding_id"], "operation": "enable", "schedule": schedule}
+    before = runtime.registry_path.read_bytes(), store.messages(sid), capture.read_bytes(), list(provider.writes)
+    try:
+        assert post(body, "https://foreign.example")[0] == 403
+        assert post({**body, "goal_id": "borrowed-project"})[0] == 409
+        status, preview = post({**body, "execute": False})
+        assert status == 200 and not preview["applied"]
+        assert before == (runtime.registry_path.read_bytes(), store.messages(sid), capture.read_bytes(), provider.writes)
+        provider.owner_ready = False
+        assert post({**body, "execute": True, "plan_id": preview["plan"]["plan_id"]})[0] == 409
+        assert before == (runtime.registry_path.read_bytes(), store.messages(sid), capture.read_bytes(), provider.writes)
+        provider.owner_ready = True
+        assert post({**body, "execute": True, "plan_id": "stale"})[0] == 409
+        status, applied = post({**body, "execute": True, "plan_id": preview["plan"]["plan_id"]})
+        assert status == 200 and applied["applied"] and reports.health(binding["binding_id"])["enabled"]
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(5)
+
+
+def test_distinct_due_daily_windows_keep_normal_native_replan_and_quota_rules(steward, tmp_path, monkeypatch):
+    from datetime import timezone
+    from loopx.capabilities.native_chat import steward_reports as module
+    from loopx.capabilities.periodic_report import cadence_runtime
+    from loopx.capabilities.native_chat.steward_monitor import StewardMonitor
+
+    store, runtime, _, transport, _, capture, _ = steward
+    sid, actor, reports, _ = configured(steward, tmp_path, monkeypatch)
+    install_model(steward, tmp_path, sid)
+    point = datetime.now(timezone.utc).replace(hour=9, minute=1, second=0, microsecond=0) - timedelta(days=3)
+
+    class CalendarClock(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return point.astimezone(tz) if tz else point.replace(tzinfo=None)
+
+    monkeypatch.setattr(module, "datetime", CalendarClock)
+    monkeypatch.setattr(cadence_runtime, "datetime", CalendarClock)
+    windows = []
+    for day in range(3):
+        point += timedelta(days=1)
+        runtime._steward_monitor_next_check = {}
+        turns = pump_steward_monitors(runtime)
+        assert len(turns) == 1, (day, turns, StewardMonitor(runtime).todos(actor))
+        done = finish(runtime, turns[0])
+        assert done["status"] == "completed" and done["response"]["native_loopx"]["status"] == "committed", done
+        assert transport.steward_reports.reconcile() == 1
+        cursor = read_periodic_report_publication_cursor(runtime_root=reports.root,
+            goal_id=actor["goal_id"], agent_id=actor["agent_id"])
+        windows.append(cursor["covered_until"])
+    assert len(set(windows)) == 3
+    assert all(row["status"] == "done" for row in StewardMonitor(runtime).todos(actor)
+        if row.get("action_kind") == "generate_periodic_report")
+    assert store.load_session(sid)["upstream_thread_id"] == "durable-thread"
+
+
+def test_due_report_rebinds_model_context_after_a_new_authorized_goal_without_a_user_message(steward, tmp_path, monkeypatch):
+    from loopx.capabilities.native_chat.steward_managed_mode import StewardManagedMode
+    store, runtime, provider, transport, binding, capture, _ = steward
+    sid, actor, reports, _ = configured(steward, tmp_path, monkeypatch)
+    original_history = store.messages(sid)
+    original_scope = store.load_session(sid)["manager_authorization_scope_id"]
+    other = transport.bindings.configure(transport_ref="notes-app", project_ref=binding["project_ref"],
+        executor_endpoint_id="codex", context_kind="steward")
+    transport.admit("notes-app", provider.event("notes-app", "independent-steward", "Keep this other steward independent."))
+    accepted = next(row for row in transport.core.pending() if row["message"] == "Keep this other steward independent.")
+    assert finish(runtime, accepted)["status"] == "completed"
+    managed = StewardManagedMode(runtime, transport.bindings)
+    preview = managed.prepare(other["binding_id"], session_id=accepted["session_id"])["plan"]
+    managed.prepare(other["binding_id"], session_id=accepted["session_id"], execute=True,
+        expected_plan_id=preview["plan_id"])
+    install_model(steward, tmp_path, sid)
+    before = capture.read_bytes()
+    turns = pump_steward_monitors(runtime)
+    assert len(turns) == 1 and turns[0]["session_id"] == sid
+    done = finish(runtime, turns[0])
+    assert done["status"] == "completed" and done["response"]["native_loopx"]["status"] == "committed", done
+    assert transport.steward_reports.reconcile() == 1
+    assert store.messages(sid)[:len(original_history)] == original_history
+    assert next(row for row in transport.bindings.read()["bindings"]
+        if row["binding_id"] == binding["binding_id"])["managed_actor"] == actor
+    calls = [json.loads(line) for line in capture.read_bytes()[len(before):].splitlines()]
+    assert sum(row.get("method") == "thread/start" for row in calls) == 1
+    assert sum(row.get("method") == "turn/start" for row in calls) == 1
+    journal = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])
+    source = json.loads((attempt_directory(reports.root, journal["window"]) / "source.json").read_text())
+    assert source["coverage"]["goals_in_inventory"] == 2
+    events = store.events_after(sid, turns[0]["turn_id"], None)
+    context = next(row["payload"] for row in events if row["kind"] == "manager.context")
+    assert context["authorization_scope_id"] == store.load_session(sid)["manager_authorization_scope_id"]
+    assert context["authorization_scope_id"] != original_scope
+
+
+@pytest.mark.parametrize("provider", ["file", "sqlite"])
+def test_owner_cancel_retires_known_invalid_generation_and_next_window_progresses(steward, tmp_path, monkeypatch, provider):
+    from datetime import timezone
+    from loopx.capabilities.native_chat.steward_monitor import StewardMonitor
+    import loopx.capabilities.native_chat.steward_reports as report_host
+    from loopx.capabilities.periodic_report import cadence_runtime
+    store, runtime, bot, transport, binding, capture, _ = steward
+    sid, actor, reports, schedule = configured(steward, tmp_path, monkeypatch, provider)
+    point = datetime.now(timezone.utc).replace(hour=9, minute=1, second=0, microsecond=0) - timedelta(days=2)
+    class CalendarClock(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return point.astimezone(tz) if tz else point.replace(tzinfo=None)
+    monkeypatch.setattr(report_host, "datetime", CalendarClock)
+    monkeypatch.setattr(cadence_runtime, "datetime", CalendarClock)
+    install_model(steward, tmp_path, sid)
+    helper = tmp_path / "report_model.py"
+    valid_model = helper.read_text()
+    helper.write_text(valid_model.replace('"request_digest": request["request_digest"]', '"request_digest": "known-invalid"'))
+    turn = pump_steward_monitors(runtime)[0]
+    failed = finish(runtime, turn)
+    assert failed["response"]["native_loopx"]["status"] == "failed"
+    old = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])
+    folder = attempt_directory(reports.root, old["window"])
+    before = {p.name: p.read_bytes() for p in folder.iterdir() if p.is_file()}
+    calls, writes = capture.read_bytes(), list(bot.writes)
+    assert reports.health(binding["binding_id"])["delivery_status"] == "generation_failed"
+    cancel = reports.configure(binding["binding_id"], operation="cancel")["plan"]
+    assert cancel["retires_failed_window"]
+    reports.configure(binding["binding_id"], operation="cancel", execute=True, expected_plan_id=cancel["plan_id"])
+    retired = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])
+    assert retired["retirement"]["source_receipt_id"] == turn["turn_id"] and retired["publication"] is None
+    task = next(row for row in StewardMonitor(runtime).todos(actor) if row["todo_id"] == turn["loopx_request"]["todo_id"])
+    assert task["status"] == "blocked" and not task.get("done")
+    future = {**schedule, "start_date": "2099-05-01"}
+    replacement = reports.configure(binding["binding_id"], operation="enable", schedule=future)["plan"]
+    reports.configure(binding["binding_id"], operation="enable", schedule=future, execute=True,
+        expected_plan_id=replacement["plan_id"])
+    assert reports.health(binding["binding_id"])["schedule"] == future
+    # Same-plan restoration does not replay this failed attempt. The next
+    # calendar window remains useful, under the ordinary native admission.
+    resume = reports.configure(binding["binding_id"], operation="enable", schedule=schedule)["plan"]
+    reports.configure(binding["binding_id"], operation="enable", schedule=schedule, execute=True, expected_plan_id=resume["plan_id"])
+    assert not pump_steward_monitors(runtime)
+    assert calls == capture.read_bytes() and writes == bot.writes
+    helper.write_text(valid_model)
+    point += timedelta(days=1)
+    runtime._steward_monitor_next_check.clear()
+    next_turn = pump_steward_monitors(runtime)[0]
+    assert next_turn["turn_id"] != turn["turn_id"]
+    completed = finish(runtime, next_turn)
+    assert completed["response"]["native_loopx"]["status"] == "committed", completed
+    assert transport.steward_reports.reconcile() == 1
+    assert store.load_turn(sid, turn["turn_id"])["response"]["native_loopx"]["status"] == "failed"
+    assert before == {name: (folder / name).read_bytes() for name in before}
+    assert all(json.loads(line).get("method") != "thread/start" for line in capture.read_bytes()[len(calls):].splitlines())
+    assert read_periodic_report_publication_cursor(runtime_root=reports.root,
+        goal_id=actor["goal_id"], agent_id=actor["agent_id"])["covered_until"] == old["window"]["next_due_at"]
+
+
+@pytest.mark.parametrize("provider", ["file", "sqlite"])
+@pytest.mark.parametrize("fault", ["spend_rejected", "writeback_rejected", "spend_response_lost", "writeback_response_lost", "result_event_lost"])
+def test_original_report_resumes_remaining_native_spend_after_generation_done_without_model_replay(steward, tmp_path, monkeypatch, provider, fault):
+    from loopx.cli_commands import turn_run_once
+    from loopx.capabilities.native_chat.steward_monitor import StewardMonitor
+    store, runtime, bot, transport, binding, capture, _ = steward
+    sid, actor, reports, _ = configured(steward, tmp_path, monkeypatch, provider)
+    install_model(steward, tmp_path, sid)
+    if fault == "writeback_rejected":
+        from datetime import timezone
+        from loopx.capabilities.native_chat import steward_reports as report_host
+        from loopx.capabilities.periodic_report import cadence_runtime
+        # Keep both synthetic due windows in the past; the independent native
+        # validator uses the real clock and must still reject future work.
+        point = datetime.now(timezone.utc) - timedelta(days=2)
+        class NextWindowClock(datetime):
+            @classmethod
+            def now(cls, tz=None):
+                return point.astimezone(tz) if tz else point.replace(tzinfo=None)
+        monkeypatch.setattr(report_host, "datetime", NextWindowClock)
+        monkeypatch.setattr(cadence_runtime, "datetime", NextWindowClock)
+    method = "refresh_state_run" if fault.startswith("writeback") else "spend_quota_slot"
+    owner = getattr(turn_run_once, method)
+    attempts = []
+    healthy = False
+    if fault == "result_event_lost":
+        append = store.append_event
+        def lose_result(*args, **kwargs):
+            if not healthy and kwargs.get("kind") == "native_loopx.result" and kwargs["payload"].get("status") == "committed":
+                raise OSError("synthetic lost outer completion event after native commit")
+            return append(*args, **kwargs)
+        monkeypatch.setattr(store, "append_event", lose_result)
+    else:
+        def interrupted_owner(*args, **kwargs):
+            attempts.append(kwargs.get("effect_ref"))
+            if not healthy and fault.endswith("rejected"):
+                return {"ok": False, "appended": False, "reason": "synthetic known absent native effect"}
+            result = owner(*args, **kwargs)
+            if not healthy:
+                raise OSError("synthetic lost response after native effect committed")
+            return result
+        monkeypatch.setattr(turn_run_once, method, interrupted_owner)
+    original = pump_steward_monitors(runtime)[0]
+    failed = finish(runtime, original)
+    if fault != "result_event_lost":
+        # An interrupted callback can return the CLI's error envelope rather
+        # than a final journal status. Neither shape authorizes delivery.
+        assert failed["response"]["native_loopx"].get("status") != "committed"
+    historical = store.load_turn(sid, original["turn_id"])
+    todo = next(row for row in StewardMonitor(runtime).todos(actor)
+        if row["todo_id"] == original["loopx_request"]["todo_id"])
+    assert todo["status"] == "done" and todo["completion_turn_key"] == original["loopx_request"]["turn_instance_id"]
+    from loopx.control_plane.turn_driver.journal_store import find_loopx_turn_key_by_settlement_identity
+    original_key = find_loopx_turn_key_by_settlement_identity(reports.root, goal_id=actor["goal_id"],
+        agent_id=actor["agent_id"], todo_id=todo["todo_id"], turn_instance_id=original["loopx_request"]["turn_instance_id"])
+    assert original_key
+    window = read_cadence_journal(runtime_root=reports.root, goal_id=actor["goal_id"])["window"]
+    folder = attempt_directory(reports.root, window)
+    body = (folder / "report.md").read_bytes()
+    assert validate_private_generation(folder)
+    assert transport.steward_reports.reconcile() == 0
+    calls, writes = capture.read_bytes(), list(bot.writes)
+    healthy = True
+    runtime._steward_monitor_next_check.clear()
+    assert not pump_steward_monitors(runtime)  # Resume native effects, never a new Chat/model Turn.
+    assert capture.read_bytes() == calls and bot.writes == writes
+    assert transport.steward_reports.reconcile() == 1, json.dumps([{k: v for k, v in row["payload"].items()
+        if k in {"status", "reason", "error", "error_code", "recovery", "receipt", "result_kind", "completed_phases"}}
+        for row in store.events_after(sid, original["turn_id"], None) if row["kind"] == "native_loopx.result"])
+    cursor = read_periodic_report_publication_cursor(runtime_root=reports.root,
+        goal_id=actor["goal_id"], agent_id=actor["agent_id"])
+    assert cursor and cursor["covered_until"] == window["due_at"]
+    assert body == (folder / "report.md").read_bytes()
+    assert store.load_turn(sid, original["turn_id"])["response"] == historical["response"]
+    recovered = [row["payload"] for row in store.events_after(sid, original["turn_id"], None)
+        if row["kind"] == "native_loopx.result" and row["payload"].get("status") == "committed"]
+    assert len(recovered) == 1 and recovered[0]["recovery"]["actual"]["host_invoked"] is False
+    if fault != "result_event_lost":
+        assert recovered[0]["resume_turn_key"] == original_key
+        assert len(attempts) == (1 if fault.endswith("response_lost") else 2)
+    sent = list(bot.writes)
+    runtime._steward_monitor_next_check.clear()
+    assert not pump_steward_monitors(runtime) and transport.steward_reports.reconcile() == 0
+    assert bot.writes == sent and capture.read_bytes() == calls
+    if fault == "writeback_rejected":
+        point = datetime.fromisoformat(window["next_due_at"].replace("Z", "+00:00")) + timedelta(minutes=1)
+        runtime._steward_monitor_next_check.clear()
+        next_turn = pump_steward_monitors(runtime)[0]
+        assert next_turn["turn_id"] != original["turn_id"]
+        next_result = finish(runtime, next_turn)["response"]["native_loopx"]
+        assert next_result["status"] == "committed", {key: value for key, value in next_result.items()
+            if key in {"reason", "error", "error_code", "status", "validation", "recovery"}}
+        assert transport.steward_reports.reconcile() == 1
+        next_calls = [json.loads(line) for line in capture.read_bytes()[len(calls):].splitlines()]
+        assert sum(row.get("method") == "turn/start" for row in next_calls) == 1
+        assert all(row.get("method") != "thread/start" for row in next_calls)
+        assert body == (folder / "report.md").read_bytes()
+        assert read_periodic_report_publication_cursor(runtime_root=reports.root,
+            goal_id=actor["goal_id"], agent_id=actor["agent_id"])["covered_until"] == window["next_due_at"]