diff --git a/apps/presentation/dashboard/src/data/action-source-basis.ts b/apps/presentation/dashboard/src/data/action-source-basis.ts
index 622cc311b7..1f2baff596 100644
--- a/apps/presentation/dashboard/src/data/action-source-basis.ts
+++ b/apps/presentation/dashboard/src/data/action-source-basis.ts
@@ -9,8 +9,10 @@ const todoBasis = {
 
 // Decode existing backend contracts; effect authority and stale-source checks
 // remain in ChatActionService and the owning Todo/Goal services.
+export const todoUpdateSourceBasisSchema = z.object({ schema_version: z.literal("loopx_chat_canonical_update_basis_v0"), ...todoBasis });
+export type TodoUpdateSourceBasis = z.infer<typeof todoUpdateSourceBasisSchema>;
 export const actionSourceBasisSchema = z.discriminatedUnion("schema_version", [
-  z.object({ schema_version: z.literal("loopx_chat_canonical_update_basis_v0"), ...todoBasis }),
+  todoUpdateSourceBasisSchema,
   z.object({ schema_version: z.literal("loopx_chat_canonical_terminal_basis_v0"), ...todoBasis }),
   z.object({
     schema_version: z.literal("loopx_goal_lifecycle_source_basis_v1"),
diff --git a/apps/presentation/dashboard/src/data/chat.ts b/apps/presentation/dashboard/src/data/chat.ts
index 62fd4f375e..62fd631c53 100644
--- a/apps/presentation/dashboard/src/data/chat.ts
+++ b/apps/presentation/dashboard/src/data/chat.ts
@@ -3,7 +3,7 @@ import { HANDOFF_MODES, EXECUTION_HANDOFF_MODES, type ExecutionHandoffMode } fro
 import { normalizeGoalDraft } from "../../../../../loopx/control_plane/collaboration/goal_draft.js";
 import { parseTurnStep, type TurnStep } from "./turn-steps.js";
 import { z } from "zod";
-import { actionSourceBasisSchema } from "./action-source-basis.js";
+import { actionSourceBasisSchema, todoUpdateSourceBasisSchema } from "./action-source-basis.js";
 
 import {
   todoApplyResultMatchesRequest,
@@ -651,6 +651,7 @@ export async function readTodoRequest(goalId: string, todoId: string, signal: Ab
   const result = z.object({
     ok: z.literal(true), goal_id: z.string(), todo_id: z.string(), text: z.string(),
     status: z.string(), archive_state: z.string(), updated_at: z.string().nullable(),
+    review_basis: todoUpdateSourceBasisSchema.optional(),
   }).parse(await requestJson<unknown>(`/api/chat/todo/detail?${query}`, {signal}));
   if (result.goal_id !== goalId || result.todo_id !== todoId) throw new Error("Task source changed");
   return result;
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/context-drawer.tsx b/apps/presentation/dashboard/src/features/personal-workspace/context-drawer.tsx
index 4da8669fcf..566c20213c 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/context-drawer.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/context-drawer.tsx
@@ -651,7 +651,8 @@ export function ContextDrawer({ agents, attentionHistory = [], onSelectAttention
                 {selection.item.priority ? <span>{selection.item.priority}</span> : null}
                 <span>{selection.item.taskClass === "advancement_task" ? t("drawer.taskAdvancement") : selection.item.taskClass ?? t("drawer.taskOrdinary")}</span>
               </div>
-              <TaskRequest todo={selection.item} local={!readOnly} />
+              <TaskRequest key={`${selection.item.goalId}:${selection.item.todoId}`} todo={selection.item} local={!readOnly}
+                onSave={!todoCompleted ? callbacks.onSaveTodoRequirements : undefined} />
               {selection.item.status === "blocked" ? <section aria-label={t("drawer.blockedReason")} className="personal-task-blocked-reason" data-recorded={selection.item.blockedReason ? "true" : "false"}>
                 <h4><AlertCircle size={14} />{t("drawer.blockedReason")}</h4>
                 <p>{selection.item.blockedReason ?? t("drawer.blockedReasonMissing")}</p>
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/i18n.tsx b/apps/presentation/dashboard/src/features/personal-workspace/i18n.tsx
index 07e6c6acfc..7dc173ee70 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/i18n.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/i18n.tsx
@@ -524,6 +524,17 @@ const en = {
   "drawer.taskDeferUntil": "Defer until",
   "drawer.taskDetails": "Todo details",
   "drawer.taskInfo": "Task information",
+  "drawer.requirementsEdit": "Edit requirements",
+  "drawer.requirementsLabel": "Complete task requirements",
+  "drawer.requirementsSave": "Save requirements",
+  "drawer.requirementsSaving": "Saving…",
+  "drawer.requirementsReadback": "Retry readback",
+  "drawer.requirementsEffect": "Update this task only. Existing acceptance may become stale; this does not start or stop a process or grant execution permission.",
+  "drawer.requirementsNotSaved": "The requirements were not verified as saved. Your draft is retained.",
+  "drawer.requirementsReadbackChanged": "The saved requirements could not be confirmed. Read the current source before editing again.",
+  "drawer.requirementsTooLong": "The action journal supports up to 8,000 characters. The original requirements are retained in full.",
+  "drawer.requirementsReload": "Read current requirements and retain draft",
+  "drawer.requirementsSaved": "Requirements saved and read back. Work was not started.",
   "drawer.requestLoading": "Showing the summary while the full request loads…",
   "drawer.requestError": "Only the summary is available. The full request could not be read.",
   "drawer.requestLocalOnly": "This source provides a summary. Open its local workspace to read the full request.",
@@ -2082,6 +2093,17 @@ const zhCN: Record<WorkspaceMessageKey, string> = {
   "drawer.taskDeferUntil": "暂缓至",
   "drawer.taskDetails": "Todo 详情",
   "drawer.taskInfo": "任务信息",
+  "drawer.requirementsEdit": "修改要求",
+  "drawer.requirementsLabel": "完整任务要求",
+  "drawer.requirementsSave": "保存要求",
+  "drawer.requirementsSaving": "正在保存…",
+  "drawer.requirementsReadback": "重试读回",
+  "drawer.requirementsEffect": "只修改此任务。已有验收可能失效；不会启动或停止进程，也不授予执行权限。",
+  "drawer.requirementsNotSaved": "尚未核实保存成功，草稿已保留。",
+  "drawer.requirementsReadbackChanged": "未能核实保存后的要求，请读取当前来源后再修改。",
+  "drawer.requirementsTooLong": "操作记录最多支持 8,000 字符，原始要求仍完整保留。",
+  "drawer.requirementsReload": "读取当前要求并保留草稿",
+  "drawer.requirementsSaved": "要求已保存并读回，未启动工作。",
   "drawer.requestLoading": "正在读取完整要求，暂时显示摘要…",
   "drawer.requestError": "当前仅有摘要，完整要求读取失败。",
   "drawer.requestLocalOnly": "此来源提供摘要，请在它的本机工作区读取完整要求。",
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-model.ts b/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-model.ts
index d8eaf2c340..e80db3bcca 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-model.ts
+++ b/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-model.ts
@@ -7,6 +7,7 @@ import type { GoalAcceptanceObservation } from "../../data/goal-acceptance-obser
 import type { AttentionDetails } from "./attention-details";
 import type { WorkspaceLoadError, WorkspaceReadScope } from "../../data/workspace-progressive-status";
 import type { TodoItem } from "../../data/status";
+import type { TodoUpdateSourceBasis } from "../../data/action-source-basis";
 import { goalWorkKind, type GoalHostThreadActivity, type WorkspaceGoalExecution } from "./goal-activity";
 import { receiptRetryReadback } from "./monitor-readback";
 import type { DigestAttentionSummary } from "../../../../../../loopx/control_plane/presentation/goal_workspace_digest.js";
@@ -530,6 +531,7 @@ export type WorkspaceGoalArchiveLoadState =
   | { phase: "error"; error: string };
 
 export type PersonalWorkspaceCallbacks = {
+  onSaveTodoRequirements?: (todo: WorkspaceTodo, text: string, basis: TodoUpdateSourceBasis, retry?: WorkspaceActionPreview) => Promise<WorkspaceActionPreview>;
   onApplyProposal?: (proposal: WorkspaceActionPreview) => void | Promise<void>;
   onApplyAttention?: (attention: WorkspaceAttention) => void;
   onCancelProposal?: (proposal: WorkspaceActionPreview) => void;
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-page.tsx b/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-page.tsx
index 689ee4db52..3b08b0d718 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-page.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-page.tsx
@@ -27,6 +27,7 @@ import {
   fetchGoalChannelTargets,
   fetchLarkConnections,
   fetchLoopXMode,
+  loadTypedAction,
   previewTypedAction,
   setupGoalChannel,
   stewardPrompts,
@@ -1840,13 +1841,17 @@ export function PersonalWorkspacePage({
     options: {
       keepGoalSelected?: boolean;
       lifecycleProjection?: GoalLifecycleProjection;
-      presentation?: "drawer" | "feedback";
+      presentation?: "drawer" | "feedback" | "inline";
     } = {},
   ) {
-    if (proposal.reviewPlan && !proposal.reviewPlan.canApply) return;
+    if (proposal.reviewPlan && !proposal.reviewPlan.canApply) return proposal;
     if (proposal.actionKind === "team.plan" && proposal.status === "error"
-      && !proposal.reviewPlan?.retryOriginal) return;
-    const showDrawer = options.presentation !== "feedback";
+      && !proposal.reviewPlan?.retryOriginal) return proposal;
+    const matchesTodoTarget = (observed: TypedActionProposal) => proposal.actionKind !== "todo.update" || (
+      observed.normalized_parameters.goal_id === proposal.goalId
+      && (!proposal.sourceRequest || observed.normalized_parameters.todo_id === proposal.sourceRequest.normalizedParameters.todo_id)
+    );
+    const showDrawer = options.presentation !== "feedback" && options.presentation !== "inline";
     const inferredLifecycleChange = proposal.actionKind === "goal.lifecycle"
       && proposal.goalId
       && (proposal.lifecycleOperation === "stop" || proposal.lifecycleOperation === "resume")
@@ -1885,11 +1890,12 @@ export function PersonalWorkspacePage({
         if (proposal.actionKind === "todo.update") {
           void reconcileStatus(proposal.goalId ? [proposal.goalId] : undefined);
         }
-        return;
+        return applied;
       }
       const result = await applyTypedAction(proposal.previewId);
       if (result.proposal.proposal_id !== proposal.previewId
         || result.proposal.action_kind !== proposal.actionKind
+        || !matchesTodoTarget(result.proposal)
         || (proposal.actionKind === "goal.lifecycle" && (
           result.proposal.normalized_parameters.goal_id !== proposal.goalId
           || lifecycleOperationFor(result.proposal) !== proposal.lifecycleOperation
@@ -1904,7 +1910,7 @@ export function PersonalWorkspacePage({
         if (lifecycleChange) {
           callbacks.onGoalActivationStateChange?.(lifecycleChange.goalId, lifecycleChange.previous);
         }
-        setSelection({ item: applied, kind: "proposal" });
+        if (options.presentation !== "inline") setSelection({ item: applied, kind: "proposal" });
         setActionFeedback(
           result.proposal.status === "stale"
             ? t("feedback.stale")
@@ -1912,7 +1918,7 @@ export function PersonalWorkspacePage({
               ? t("proposal.teamPlan.retryUnavailable")
             : t(`actionReview.${applied.reviewPlan!.reason}`),
         );
-        return;
+        return applied;
       }
       setActionFeedback(t("feedback.completed", { title: applied.title }));
       // Keep the success receipt visible for reviewed actions. Direct actions
@@ -1929,6 +1935,7 @@ export function PersonalWorkspacePage({
       if (applied.actionKind === "goal.lifecycle" || applied.actionKind === "gate.resolve" || applied.actionKind === "todo.update") {
         void reconcileStatus(applied.goalId ? [applied.goalId] : undefined);
       }
+      return applied;
     } catch (error) {
       if (lifecycleChange) {
         callbacks.onGoalActivationStateChange?.(lifecycleChange.goalId, lifecycleChange.previous);
@@ -1955,13 +1962,13 @@ export function PersonalWorkspacePage({
         setProposals((current) => ({ ...current, [proposal.previewId]: gated }));
         // A newly discovered authority gate always deserves review, including
         // when the action started on the direct path.
-        setSelection({ item: gated, kind: "proposal" });
+        if (options.presentation !== "inline") setSelection({ item: gated, kind: "proposal" });
         setActionFeedback(t("feedback.gateRequired", { summary: gated.gate.summary }));
         if (proposal.actionKind === "goal.create" && proposal.goalId) {
           callbacks.onRefresh?.();
           selectGoal(proposal.goalId);
         }
-        return;
+        return gated;
       }
       const stale = error instanceof ChatApiError && isStaleActionFailure(error.payload);
       const readbackMismatch = error instanceof ChatApiError && error.payload.error_code === "action_response_mismatch";
@@ -1970,24 +1977,25 @@ export function PersonalWorkspacePage({
       const returned = error instanceof ChatApiError
         ? typedActionProposalSchema.safeParse(error.payload.proposal) : null;
       let stored = returned?.success ? returned.data : undefined;
-      if (!stored && ["team.plan", "goal.create"].includes(proposal.actionKind) && !readbackMismatch) {
+      if (!stored && ["team.plan", "goal.create", "todo.update"].includes(proposal.actionKind) && !readbackMismatch) {
         const readback = await actionReadback.refetch();
         // Query errors retain cached data; it cannot certify this attempt.
         if (readback.isSuccess) stored = readback.data?.find(item => item.proposal_id === proposal.previewId);
       }
       if (stored?.proposal_id === proposal.previewId && stored.action_kind === proposal.actionKind
-        && (!["team.plan", "goal.create"].includes(proposal.actionKind) || stored.normalized_parameters.goal_id === proposal.goalId)) {
+        && matchesTodoTarget(stored)
+        && (!["team.plan", "goal.create", "todo.update"].includes(proposal.actionKind) || stored.normalized_parameters.goal_id === proposal.goalId)) {
         await actionReadback.acceptProposal(stored);
         const observed = workspaceProposal(stored, t);
         const reconciled = { ...observed, errorMessage: observed.status === "error"
           ? error instanceof Error ? error.message : String(error) : undefined };
         setProposals(current => ({ ...current, [proposal.previewId]: reconciled }));
-        setSelection({ item: reconciled, kind: "proposal" });
+        if (options.presentation !== "inline") setSelection({ item: reconciled, kind: "proposal" });
         if (observed.reviewPlan?.creationProgress?.goalId) void callbacks.onRefresh?.();
         setActionFeedback(stored.status === "stale" ? t("feedback.stale")
           : observed.reviewPlan?.interaction === "completed" ? t("feedback.completed", { title: observed.title })
           : t("feedback.executionFailed", { error: error instanceof Error ? error.message : String(error) }));
-        return;
+        return reconciled;
       }
       const failed = {
         ...proposal,
@@ -1998,8 +2006,9 @@ export function PersonalWorkspacePage({
         status: (stale ? "stale" : "error") as "stale" | "error",
       };
       setProposals((current) => ({ ...current, [proposal.previewId]: failed }));
-      setSelection({ item: failed, kind: "proposal" });
+      if (options.presentation !== "inline") setSelection({ item: failed, kind: "proposal" });
       setActionFeedback(t("feedback.executionFailed", { error: failed.errorMessage }));
+      return failed;
     }
   }
 
@@ -2036,7 +2045,30 @@ export function PersonalWorkspacePage({
       else setSelectedGoalTab("files");
       callbacks.onOpenOutput?.(output);
     },
-    onApplyProposal: applyProposal,
+    onApplyProposal: async proposal => { await applyProposal(proposal); },
+    onSaveTodoRequirements: async (todo, text, basis, retry) => {
+      if (retry?.status === "applied") return retry;
+      let original = retry;
+      if (retry) {
+        const stored = await loadTypedAction(retry.previewId);
+        if (stored.action_kind !== "todo.update" || stored.normalized_parameters.goal_id !== todo.goalId
+          || stored.normalized_parameters.todo_id !== (todo.sourceTodoId ?? todo.todoId)
+          || stored.normalized_parameters.text !== text) {
+          throw new ChatApiError(t("actionReview.targetChanged"), {error_code: "action_response_mismatch"});
+        }
+        await actionReadback.acceptProposal(stored);
+        original = {...workspaceProposal(stored, t), sourceRequest: retry.sourceRequest};
+        if (original.status === "applied") return original;
+      }
+      const proposal = original ?? await createPreview({actionKind: "todo.update",
+        context: {goal_id: todo.goalId, kind: "todo", todo_id: todo.sourceTodoId ?? todo.todoId},
+        idempotencyKey: `workspace-todo-requirements-${todo.todoId}-${Date.now().toString(36)}`,
+        normalizedParameters: {goal_id: todo.goalId, todo_id: todo.sourceTodoId ?? todo.todoId,
+          ...(todo.claimedBy ? {agent_id: todo.claimedBy} : {}), operation: "edit", text, review_basis: basis},
+        summary: t("drawer.requirementsSave"),
+      }, {select: false});
+      return applyProposal(proposal, {presentation: "inline"});
+    },
     onExplainDecision: callbacks.onExplainDecision ?? ((attention) => draftAttentionMessage(attention, "explain")),
     onReplyToAttention: callbacks.onReplyToAttention ?? draftAttentionMessage,
     onCancelProposal: async (proposal) => {
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace.css b/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace.css
index a48aa2b6ec..0a2c4d4138 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace.css
+++ b/apps/presentation/dashboard/src/features/personal-workspace/personal-workspace.css
@@ -1235,6 +1235,14 @@ button.personal-execution-chip:focus-visible { outline: 2px solid #0070f3; outli
 .personal-context-drawer[data-context-kind="todo"] .personal-drawer-body { padding: 0; }
 .personal-task-inspector-summary { padding: 24px 24px 20px; border-bottom: 1px solid var(--pw-line); background: #fff; }
 .personal-task-inspector-summary h3 { margin: 14px 0 0; font-size: var(--text-heading); font-weight: 600; letter-spacing: -.015em; line-height: var(--leading-heading); overflow-wrap: anywhere; }
+.personal-task-requirements-editor { display: grid; gap: 12px; margin-top: 16px; }
+.personal-task-requirements-editor label { display: grid; gap: 8px; font-weight: 500; }
+.personal-task-requirements-editor textarea { box-sizing: border-box; width: 100%; min-width: 0; padding: 12px; border: 1px solid var(--pw-line-strong); border-radius: 6px; color: var(--pw-text); background: var(--pw-card); font: inherit; line-height: var(--leading-prose); resize: vertical; }
+.personal-task-requirements-editor p { margin: 0; color: var(--pw-muted); font-size: var(--text-caption); }
+.personal-task-requirements-editor > div { display: flex; flex-wrap: wrap; gap: 8px; }
+.personal-task-requirements-editor [role="alert"] { display: grid; }
+.personal-task-requirements-editor [role="alert"] p { color: var(--pw-red); }
+.personal-drawer-body:has(.personal-task-requirements-editor) > .personal-task-inspector-actions { display: none; }
 .personal-task-inspector-status { display: flex; align-items: center; gap: 7px; flex-wrap: wrap; }
 .personal-task-inspector-status > span { display: inline-flex; align-items: center; gap: 6px; min-height: 24px; padding: 2px 8px; border-radius: 6px; background: #f1f2f5; color: #62697a; font-size: var(--text-caption); line-height: var(--leading-caption); font-weight: 600; }
 .personal-task-inspector-status > span:first-child { padding-left: 7px; }
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/task-request.tsx b/apps/presentation/dashboard/src/features/personal-workspace/task-request.tsx
index bec4c37ee6..7812e5b482 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/task-request.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/task-request.tsx
@@ -1,39 +1,101 @@
-import {useEffect, useState} from "react";
+import {useEffect, useRef, useState} from "react";
 import {readTodoRequest} from "../../data/chat";
+import type {TodoUpdateSourceBasis} from "../../data/action-source-basis";
 import {useWorkspaceI18n} from "./i18n";
 import {MarkdownText} from "./markdown";
-import type {WorkspaceTodo} from "./personal-workspace-model";
+import type {PersonalWorkspaceCallbacks, WorkspaceActionPreview, WorkspaceTodo} from "./personal-workspace-model";
 
-// Per-open read state, never a second Task store. A different selection or
-// source invalidates both the in-flight read and its earlier successful body.
+// Per-open read/draft state, never a second Task or execution owner.
 type RequestRead = {identity: string} & (
-  | {phase: "loading" | "error"; text?: never}
-  | {phase: "ready"; text: string}
+  | {phase: "loading" | "error"; detail?: never}
+  | {phase: "ready"; detail: Awaited<ReturnType<typeof readTodoRequest>>}
 );
 
-export function TaskRequest({todo, local}: {todo: WorkspaceTodo; local: boolean}) {
+export function TaskRequest({todo, local, onSave}: {todo: WorkspaceTodo; local: boolean;
+  onSave?: PersonalWorkspaceCallbacks["onSaveTodoRequirements"]}) {
   const {t} = useWorkspaceI18n();
   const sourceId = todo.sourceTodoId;
   const identity = JSON.stringify([local, todo.goalId, sourceId, todo.requestText, todo.status]);
   const [read, setRead] = useState<RequestRead | null>(null);
   const [retry, setRetry] = useState(0);
+  const [draft, setDraft] = useState<{text: string; basis: TodoUpdateSourceBasis} | null>(null);
+  const [pending, setPending] = useState<WorkspaceActionPreview | null>(null);
+  const [saving, setSaving] = useState(false);
+  const [failure, setFailure] = useState<string | null>(null);
+  const [saved, setSaved] = useState(false);
+  const savingRef = useRef(false);
+  const rebaseRef = useRef(false);
+  const mounted = useRef(true);
+  useEffect(() => { mounted.current = true; return () => { mounted.current = false; }; }, []);
   useEffect(() => {
     if (!local || !sourceId) return;
     const controller = new AbortController();
     setRead({identity, phase: "loading"});
-    void readTodoRequest(todo.goalId, sourceId, controller.signal).then(result => {
-      if (!controller.signal.aborted) setRead({identity, phase: "ready", text: result.text});
+    void readTodoRequest(todo.goalId, sourceId, controller.signal).then(detail => {
+      if (controller.signal.aborted) return;
+      setRead({identity, phase: "ready", detail});
+      if (rebaseRef.current && detail.review_basis) {
+        const basis = detail.review_basis;
+        setDraft(previous => previous ? {...previous, basis} : null);
+        setPending(null);
+        setFailure(null);
+      }
+      rebaseRef.current = false;
     }).catch(() => {
       if (!controller.signal.aborted) setRead({identity, phase: "error"});
     });
     return () => controller.abort();
   }, [identity, local, retry, todo.goalId, sourceId]);
   const current = local && read?.identity === identity ? read : null;
+  const detail = current?.phase === "ready" ? current.detail : null;
+  const editable = local && onSave && todo.claimedBy && sourceId && detail?.review_basis
+    && detail.archive_state === "active" && detail.status !== "done";
+  async function save() {
+    if (!onSave || !draft || !sourceId || savingRef.current) return;
+    savingRef.current = true;
+    setSaving(true); setFailure(null); setSaved(false);
+    try {
+      const text = draft.text.replace(/\s+/gu, " ").trim();
+      const proposal = await onSave(todo, text, draft.basis, pending ?? undefined);
+      if (!mounted.current) return;
+      setPending(proposal);
+      if (proposal.status !== "applied" || proposal.reviewPlan?.interaction !== "completed") {
+        throw new Error(proposal.errorMessage ?? proposal.gate?.summary
+          ?? (proposal.reviewPlan ? t(`actionReview.${proposal.reviewPlan.reason}`) : t("drawer.requirementsNotSaved")));
+      }
+      const observed = await readTodoRequest(todo.goalId, sourceId, new AbortController().signal);
+      if (!mounted.current) return;
+      setRead({identity, phase: "ready", detail: observed});
+      if (observed.text !== text) throw new Error(t("drawer.requirementsReadbackChanged"));
+      setDraft(null); setPending(null); setSaved(true);
+    } catch (error) {
+      if (mounted.current) setFailure(error instanceof Error ? error.message : String(error));
+    } finally {
+      savingRef.current = false;
+      if (mounted.current) setSaving(false);
+    }
+  }
   return <div className="personal-task-request">
-    <MarkdownText text={current?.phase === "ready" ? current.text : todo.requestText ?? todo.text} />
+    {!draft ? <MarkdownText text={detail?.text ?? todo.requestText ?? todo.text} /> : null}
     {current?.phase !== "ready" ? <div className="personal-proposal-explainer" role={current?.phase === "error" ? "alert" : "status"}>
       <span>{t(!local ? "drawer.requestLocalOnly" : !sourceId ? "drawer.requestUnidentified" : current?.phase === "error" ? "drawer.requestError" : "drawer.requestLoading")}</span>
       {current?.phase === "error" ? <button className="personal-secondary-action" type="button" onClick={() => setRetry(value => value + 1)}>{t("drawer.requestRetry")}</button> : null}
     </div> : null}
+    {editable && !draft ? <button className="personal-secondary-action" type="button" onClick={() => {
+      setDraft({text: detail.text, basis: detail.review_basis!}); setFailure(null); setSaved(false);
+    }}>{t("drawer.requirementsEdit")}</button> : null}
+    {draft ? <form className="personal-task-requirements-editor" onSubmit={event => {event.preventDefault(); void save();}}>
+      <label>{t("drawer.requirementsLabel")}<textarea autoFocus rows={8} value={draft.text} disabled={saving}
+        onChange={event => {setDraft({...draft, text: event.target.value}); setPending(null); setSaved(false);}} /></label>
+      <p>{t("drawer.requirementsEffect")}</p>
+      <div><button className="personal-primary-action" type="submit" disabled={saving || !editable || !draft.text.trim() || draft.text.length > 8000}>
+        {t(saving ? "drawer.requirementsSaving" : pending?.status === "applied" || pending?.status === "error" ? "drawer.requirementsReadback" : "drawer.requirementsSave")}</button>
+        <button className="personal-secondary-action" type="button" disabled={saving} onClick={() => {setDraft(null); setPending(null); setFailure(null);}}>{t("common.cancel")}</button></div>
+      {draft.text.length > 8000 ? <p role="alert">{t("drawer.requirementsTooLong")}</p> : null}
+      {failure ? <div role="alert"><p>{failure}</p><button className="personal-secondary-action" type="button" disabled={saving} onClick={() => {
+        rebaseRef.current = true; setRetry(value => value + 1);
+      }}>{t("drawer.requirementsReload")}</button></div> : null}
+    </form> : null}
+    {saved ? <p role="status">{t("drawer.requirementsSaved")}</p> : null}
   </div>;
 }
diff --git a/docs/reference/canonical-lease-renew.md b/docs/reference/canonical-lease-renew.md
index 8e9b427abe..e823d26941 100644
--- a/docs/reference/canonical-lease-renew.md
+++ b/docs/reference/canonical-lease-renew.md
@@ -51,7 +51,9 @@ can freeze the current Todo identity. Malformed frozen identities fail closed.
 Renewal, transfer and release preserve the frozen value and historical receipts.
 Current execution proof, acquire replay and inspection reject known repository
 drift with `lease_repository_divergence`; cleanup still uses exact owner/key/version.
-Changing retained work requirements is not a metadata-edit shortcut.
+Changing retained work requirements is not a metadata-edit shortcut: the
+[owner revision lifecycle](#revising-declared-work-requirements) retires the old
+grant atomically and requires a fresh acquisition for subsequent execution.
 
 JSON inspection exposes `lease.write_repository`; Markdown lease readback also
 shows the identity or `unknown (conservative overlap)`. This is a Goal-local,
@@ -461,6 +463,62 @@ provider revision 暂停并清除等待；读回后再用
 新 revision 明确重新打开，最后领取新租约。不能附带旧 proof、任务正文、归属或工作要求修改，
 也不能把暂停或重新打开当作执行授权；每步可原子附带备注和证据。
 
+### Revising declared work requirements
+
+In canonical **hard-lease** mode, the registered current Todo owner can revise
+the existing work-requirement fields through one `todo update`. The same provider
+transaction updates the declaration and releases the owner's active or expired
+lease. Absent or already released history needs no acquire/release preparation.
+The retained key, generation, repository and scopes remain historical facts;
+the update grants no execution and does not terminate a running process.
+
+```bash
+loopx todo update --goal-id example-goal --todo-id todo_work --agent-id owner \
+  --required-write-scope 'src/**' --required-write-scope 'tests/**' \
+  --required-capability filesystem_write --reason 'Include regression coverage' \
+  --update-operation-id revise-work
+loopx todo list --goal-id example-goal --todo-id todo_work
+loopx task-lease inspect --goal-id example-goal --todo-id todo_work
+```
+
+`work_requirements_transition` reports changed fields, lease retirement and
+`execution_authority_granted=false` in the preview, committed result and replay.
+Unchanged declarations preserve the current grant. After an actual revision,
+acquire a fresh generation with a new idempotency key and explicitly requested
+scopes before executing. Acquisition still checks the current Todo, repository,
+workspace, Goal policy and competing holders. Repository revisions preserve the
+old grant's frozen repository; the next grant binds the revised identity.
+That released history does not block the same claim owner's subsequent notes,
+pause/resume or further requirement/repository corrections without execution
+proof. These operations retain the entire old grant unchanged. An unreleased
+divergent grant, foreign retained holder, malformed repository or explicit old
+proof still rejects; the exception never applies to execution admission.
+
+This corrects the former default rejection of every retained requirement edit;
+it is limited to the existing hard-lease owner update path. Foreign retained
+holders, actor exclusions/bindings, archived/completed tasks and provider or
+registry conflicts remain fenced. Supplied proof must match one current active
+generation: stale, partial, expired or released proof is rejected and never
+silently replaced. Status, ownership, validation and dependency transitions
+cannot be bundled into this revision. Optional task copy, note, priority,
+reason and evidence may accompany it. Soft-claim behavior is unchanged.
+
+在 canonical **hard-lease** 模式中，当前已注册的 Todo owner 可通过一次既有
+`todo update` 修订工作要求。同一 provider 事务更新声明并释放本人有效或过期的
+旧租约；没有租约或已经释放时，无需先领取或再次释放。旧 key、代际、仓库和
+写入范围作为历史保留，修改不授予执行权，也不声称终止运行中的进程。
+预览、提交和重放的 `work_requirements_transition` 显示修改字段与租约结果；
+相同声明不会结束现有授权。真正修改后，必须用新幂等 key、明确写入范围重新
+申请租约；仓库修订只影响下一次授权，不改写旧授权的仓库身份。
+已释放的旧仓库历史不再阻断同一 claim owner 不带执行 proof 的后续备注、暂停/恢复、
+范围修订及再次纠正仓库；这些操作完整保留旧授权。未释放但仓库不符的授权、他人保留
+的租约、损坏仓库与显式旧 proof 仍被拒绝，此例外不用于执行准入。
+他人保留的租约、排除/绑定限制、归档/完成、provider 与 registry 冲突仍被拒绝；
+显式 proof 必须精确对应当前有效代际，陈旧、不完整、过期或已释放 proof 不会
+被自动替换。状态、归属、验证和依赖转换不能混在本次修订里；可附带普通正文、
+备注、优先级、原因及证据。此处明确改变的是 hard-lease owner 工作要求编辑的
+默认拒绝行为，soft-claim 规则保持原样。
+
 A successful readback is still a point-in-time proof, not a lock over subsequent
 external effects. Execution must retain its existing mutation fences; this
 change does not close the remaining external-effect fencing work.
@@ -646,3 +704,40 @@ shadow outbox，并保留租约版本、generation、scope 及幂等回执；陈
 移除配置不会退役活跃 binding：启用 capture 及已有 binding 的恢复仍须持久准备
 并送达。本项只移除默认关闭时无用途的依赖，不改变 provider 默认值、不迁移 Goal、
 不删除受支持的 Markdown writer，也不授予删除 capture 历史和待处理 outbox 的权限。
+
+## Edit complete task requirements in the workbench
+
+For a local canonical Task with a recorded Agent owner, open its existing Task
+inspector and choose **Edit requirements**. The editor reads the entire original
+request, including text omitted from list previews. **Save requirements** is the
+owner's single write decision: the existing typed action prepares and applies
+the edit internally, then reads the exact Task back. It does not start or stop a
+process or grant execution authority. Existing completion and protected actions
+retain their separate review paths.
+
+This edits the Task's requirements prose. It preserves the admitted lease;
+repository, write-scope and capability declarations still use the separate
+work-requirement revision lifecycle above.
+
+The exact read supplies the existing canonical update basis (provider revision
+and registry fingerprint). A changed source refuses a new edit before writing;
+an intervening write after preparation still fails the native CAS. The draft is
+retained so the user can read current requirements, compare and save again. A
+lost successful response is reconciled through the original action journal, not
+by issuing another write. Readback failure stays unverified until the original
+result and exact source can be read.
+
+This local transport extends `todo.update` with an optional `review_basis` echo
+of `loopx_chat_canonical_update_basis_v0`. It is observation, not a lease or a new
+permission. The canonical Todo owner continues to decide actor, claim, lease,
+CAS and execution eligibility. Source-bound text uses the action journal's
+existing 8,000-character envelope; quick actions without the basis retain their
+400-character bound. Oversized requests remain readable and are never truncated
+into an edit. Legacy, remote, unidentified, unassigned and unavailable sources
+retain the read-only path. CLI behavior and Lark actions are unchanged.
+
+中文：在本机 canonical Task 的原详情中“修改要求”，完整原文直接进入编辑器，
+一次“保存要求”沿既有 typed action 内部准备、提交并精确读回；不要求填写租约或
+版本字段，也不新增确认页。要求改变可能使既有验收失效，不会启动或停止进程。
+来源变化时拒绝覆盖、保留草稿，可读取当前要求核对后再保存；响应丢失先对账原
+操作。只在完整来源和已记录负责人均可核实的任务开放编辑，其他来源仍可阅读。
diff --git a/examples/personal-workspace-browser/assets/task-requirements-desktop.png b/examples/personal-workspace-browser/assets/task-requirements-desktop.png
new file mode 100644
index 0000000000..5f3de26795
Binary files /dev/null and b/examples/personal-workspace-browser/assets/task-requirements-desktop.png differ
diff --git a/examples/personal-workspace-browser/assets/task-requirements-mobile-conflict.png b/examples/personal-workspace-browser/assets/task-requirements-mobile-conflict.png
new file mode 100644
index 0000000000..c529f0ea2f
Binary files /dev/null and b/examples/personal-workspace-browser/assets/task-requirements-mobile-conflict.png differ
diff --git a/examples/personal-workspace-browser/goal-workspace-todo-backend.py b/examples/personal-workspace-browser/goal-workspace-todo-backend.py
index b1b351fc42..224bf62866 100644
--- a/examples/personal-workspace-browser/goal-workspace-todo-backend.py
+++ b/examples/personal-workspace-browser/goal-workspace-todo-backend.py
@@ -24,6 +24,9 @@
 data = json.loads(registry.read_text())
 data["goals"][0].update(id="progress-projection", display_name="Synthetic workspace")
 data["goals"][0]["coordination"]["handoff_mode"] = "soft_claim"
+editing = len(sys.argv) > 2 and sys.argv[2] == "requirements"
+if editing:
+    data["goals"][0]["coordination"]["registered_agents"] = ["agent-a"]
 registry.write_text(json.dumps(data), encoding="utf-8")
 runtime = Path(data["common_runtime_root"])
 canonical_fixtures = runpy.run_path(
@@ -35,7 +38,21 @@
     build_todo_runtime_shadow_projection(
         goal_id="progress-projection",
         handoff_mode="soft_claim",
-        todos=[],
+        todos=([{"schema_version": "todo_item_v0", "todo_id": "todo_requirements_source", "index": 1,
+            "role": "agent", "status": "open", "done": False, "archive_state": "active",
+            "source_section": "Agent Todo", "task_class": "advancement_task", "claimed_by": "agent-a",
+            "text": "数据导出交付要求：保留原始研究记录、来源和版本，生成可复查的导出文件。 "
+                + "一、输入必须来自声明的研究记录，不得把缺失、失败或尚未验证的结果填成零。保留原始标识和引用；明确时间窗口，注明采集时刻与执行时刻的区别。 "
+                + "二、导出必须覆盖全部已选记录，按稳定顺序分页，重试不得重复或漏掉记录。长内容完整保留，列表摘要不能替代正文。 "
+                + "三、每项效果判断都带理由与来源，观察、解释和实际采用分别展示。没有证据的关系保持未知，不从相邻时间或任务数量推断收益。 "
+                + "四、修改任务要求时保存当前版本，原有验收过期后应明确显示；不因保存要求而启动新任务、接管其它工作或自动增加资源。 "
+                + "五、暂时断线、响应丢失和并发修改必须保留草稿和原操作身份。失败时说明是否已经提交，优先读回原结果，不能通过重复执行消除不确定性。 "
+                + "六、文件读回包含可用内容、原来源及适用版本。真实工作、测试样例、历史缓存和未完成验证要有明确边界。 "
+                + "七、普通用户只需表达修改并保存，不填写内部版本、租约键或协议字段。仅在出现真实冲突或缺少必要身份时请求额外决定。 "
+                + "八、在桌面、窄屏与键盘路径验证相同的任务，错误信息无需横向滚动；返回原任务后仍能看到完整要求与实际保存结果。 "
+                + "九、所有原生状态以权威来源读回为准，页面存在、测试通过和提交记录不能代表已安装或完成全部目标。 "
+                + "十、交付说明保留未完成事项和下一负责人，沿原任务推进，避免为了制造进度而复制分支、任务或相同资料。 "
+                + "FINAL_ACCEPTANCE: preserve every requirement and verify the exact stored source."}] if editing else []),
     ),
     state_path=state,
     provider="file",
diff --git a/examples/personal-workspace-browser/task-inspector-return.mjs b/examples/personal-workspace-browser/task-inspector-return.mjs
index 897327be36..d11e87a1a7 100644
--- a/examples/personal-workspace-browser/task-inspector-return.mjs
+++ b/examples/personal-workspace-browser/task-inspector-return.mjs
@@ -1,7 +1,12 @@
 import assert from "node:assert/strict";
 import { resolve } from "node:path";
-import { outputDir } from "./fixture.mjs";
-import { openWorkspacePage } from "./scenario-context.mjs";
+import { outputDir, repoRoot } from "./fixture.mjs";
+import {spawn, execFile} from "node:child_process";
+import {mkdtemp, rm} from "node:fs/promises";
+import {tmpdir} from "node:os";
+import {promisify} from "node:util";
+import {resolveTestPython} from "../../scripts/test-python.mjs";
+import { openWorkspacePage, fetchWorkspaceBackend } from "./scenario-context.mjs";
 
 export const taskInspectorReturnScenario = {
   id: "task-inspector-return",
@@ -130,6 +135,135 @@ export const taskInspectorReturnScenario = {
         coverageEntries.push(...await context.close());
       }
     }
-    return { coverageEntries, note: "The 988-character source survives a bounded 500-character status; failed/mismatched reads, retry and late selection responses are explicit on packaged desktop/390px. Pointer/Escape/Enter/close/More retain the opener with reduced motion; no authority or model write. Backend authority is qualified separately by the real File/SQLite HTTP+CLI tests." };
+    // Shipped editing reaches the same real source and typed write owner.
+    const root = await mkdtemp(resolve(tmpdir(), "loopx-task-editor-"));
+    const python = await resolveTestPython();
+    const backend = spawn(python, ["-u", resolve(repoRoot, "examples/personal-workspace-browser/goal-workspace-todo-backend.py"), root, "requirements"], {cwd: repoRoot, stdio: ["ignore", "pipe", "pipe"]});
+    let backendError = "";
+    backend.stderr.on("data", bytes => { backendError += bytes; });
+    let editing;
+    try {
+      const info = await new Promise((resolveInfo, reject) => {
+        let data = "";
+        backend.stdout.on("data", bytes => {
+          data += bytes;
+          if (data.includes("\n")) { try {resolveInfo(JSON.parse(data.split("\n")[0]));} catch(error) {reject(error);} }
+        });
+        backend.once("exit", code => reject(new Error(`Task backend exited ${code}: ${backendError}`)));
+        backend.once("error", reject);
+      });
+      const endpoint = `http://127.0.0.1:${info.port}`;
+      let applyCount = 0;
+      editing = await openWorkspacePage(browser, url, {collectCoverage, beforeGoto: async (api, page) => {
+        api.transformStatus = payload => {
+          const queue = payload.attention_queue.items.find(item => item.goal_id === "progress-projection");
+          for (const source of [queue?.agent_todos, queue?.project_asset?.agent_todos]) {
+            for (const item of source?.items ?? []) if (item.todo_id === "todo-progress-full") { item.claimed_by = "agent-a"; item.todo_id = "todo_requirements_source"; }
+          }
+        };
+        await page.route("**/api/chat/todo/detail?*", async route => route.fulfill({response: await fetchWorkspaceBackend(route, endpoint)}));
+        await page.route("**/api/actions**", async route => {
+          if (new URL(route.request().url()).pathname.endsWith("/apply")) applyCount++;
+          await route.fulfill({response: await fetchWorkspaceBackend(route, endpoint)});
+        });
+      }});
+      const {page} = editing;
+      await page.emulateMedia({reducedMotion: "reduce"});
+      await page.locator(".personal-goal-link", {hasText: "Progress Projection"}).click();
+      await page.getByRole("navigation", {name: "Goal 视图"}).getByRole("button", {name: /^(Tasks|任务)$/}).click();
+      await page.locator(".personal-task-card", {hasText: "Full queue follow-up"}).locator(":scope > button").click();
+      const drawer = page.getByRole("dialog", {name: "Todo 详情"});
+      const read = async () => (await (await page.request.get(`${endpoint}/api/chat/todo/detail?goal_id=progress-projection&todo_id=todo_requirements_source`)).json());
+      const initial = await read();
+      assert.ok(initial.text?.indexOf("FINAL_ACCEPTANCE") > 500 && initial.review_basis, JSON.stringify(initial));
+      await drawer.getByRole("button", {name: "修改要求", exact: true}).click();
+      const field = drawer.getByRole("textbox", {name: "完整任务要求"});
+      assert.equal(await field.inputValue(), initial.text, "Editing must start from the exact source, never the 500-character list");
+      await drawer.getByRole("button", {name:"标记完成",exact:true}).waitFor({state:"hidden"});
+      const next = initial.text + " Keep the additional delivery condition.";
+      await field.fill(next);
+      await page.screenshot({path: resolve(outputDir, "task-requirements-edit-desktop.png"), animations: "disabled"});
+      await field.press("Tab");
+      await page.keyboard.press("Enter");
+      await drawer.getByRole("status").filter({hasText: "要求已保存并读回"}).waitFor();
+      await drawer.getByRole("button", {name:"标记完成",exact:true}).waitFor({state:"visible"});
+      assert.equal(applyCount, 1, "One save decision invokes the existing native action once");
+      assert.equal((await read()).text, next);
+      assert.equal(await page.locator('.personal-context-drawer[data-context-kind="proposal"]').count(), 0, "An ordinary edit must not require another approval form");
+      await page.setViewportSize({width:390,height:844});
+      await drawer.getByRole("button", {name: "修改要求", exact: true}).click();
+      assert.equal(await field.inputValue(), next);
+      await field.fill(next + " Preserve this draft after a concurrent update.");
+      // Same real CLI and canonical writer, an independent intervening write.
+      const changed = await promisify(execFile)(python, ["-m", "loopx.cli", "--registry", info.registry,
+        "--format", "json", "todo", "update", "--goal-id", "progress-projection", "--todo-id", "todo_requirements_source",
+        "--agent-id", "agent-a", "--note", "Concurrent progress"], {cwd: repoRoot});
+      assert.equal(JSON.parse(changed.stdout).ok, true);
+      await drawer.getByRole("button", {name:"保存要求",exact:true}).click();
+      await drawer.getByRole("alert").filter({hasText:"Task source changed"}).waitFor();
+      await page.screenshot({path: resolve(outputDir, "task-requirements-edit-mobile-conflict.png"), animations: "disabled"});
+      assert.equal(applyCount, 1, "A stale source must fail before apply");
+      assert.equal((await read()).text, next);
+      assert.match(await field.inputValue(), /Preserve this draft/);
+      await drawer.getByRole("button", {name:"读取当前要求并保留草稿",exact:true}).click();
+      await drawer.getByRole("alert").waitFor({state:"hidden"});
+      await drawer.getByRole("button", {name:"保存要求",exact:true}).click();
+      await drawer.getByRole("status").filter({hasText: "要求已保存并读回"}).waitFor();
+      assert.equal(applyCount, 2);
+      assert.equal((await read()).text, next + " Preserve this draft after a concurrent update.");
+      const afterConflict = (await read()).text;
+      await drawer.getByRole("button", {name:"修改要求",exact:true}).click();
+      await field.fill(afterConflict + " Recover the original committed response.");
+      let loseResponse = true;
+      await page.route("**/api/actions/*/apply", async route => {
+        if (!loseResponse) return route.fallback();
+        loseResponse = false;
+        applyCount++;
+        const committed = await fetchWorkspaceBackend(route, endpoint);
+        assert.equal(committed.ok(), true);
+        await route.abort("failed");
+      });
+      await drawer.getByRole("button", {name:"保存要求",exact:true}).click();
+      await drawer.getByRole("status").filter({hasText:"要求已保存并读回"}).waitFor();
+      assert.equal(applyCount, 3, "A lost successful reply is reconciled from the original journal without a second apply");
+      assert.equal((await read()).text, afterConflict + " Recover the original committed response.");
+
+      // If both the apply reply and journal read are lost, retain the original
+      // proposal. Retrying during the outage must never create/apply anew.
+      const beforeOutage = (await read()).text;
+      await drawer.getByRole("button", {name:"修改要求",exact:true}).click();
+      const outageDraft = beforeOutage + " Retain the operation throughout an outage.";
+      await field.fill(outageDraft);
+      loseResponse = true;
+      let journalUnavailable = true;
+      await page.route("**/api/actions**", async route => {
+        if (journalUnavailable && route.request().method() === "GET") return route.abort("failed");
+        return route.fallback();
+      });
+      await drawer.getByRole("button", {name:"保存要求",exact:true}).click();
+      await drawer.getByRole("alert").waitFor();
+      assert.equal(applyCount, 4);
+      assert.equal((await read()).text, outageDraft);
+      await drawer.getByRole("button", {name:"重试读回",exact:true}).click();
+      await drawer.getByRole("button", {name:"重试读回",exact:true}).waitFor({state:"visible"});
+      assert.equal(await field.inputValue(), outageDraft);
+      assert.equal(applyCount, 4, "An unavailable original journal must not trigger another apply");
+      journalUnavailable = false;
+      await drawer.getByRole("button", {name:"重试读回",exact:true}).click();
+      await drawer.getByRole("status").filter({hasText:"要求已保存并读回"}).waitFor();
+      assert.equal(applyCount, 4, "Reconnect reads the original committed receipt without a new operation");
+
+      assert.equal(await page.evaluate(() => document.documentElement.scrollWidth > innerWidth + 1), false);
+      assert.equal(editing.api.turnRequests.length, 0);
+      assert.ok(editing.errors.every(error => /status of 400|net::ERR_FAILED/.test(error)), editing.errors.join(" | "));
+      await page.screenshot({path: resolve(outputDir, "task-requirements-edit-mobile.png"), animations: "disabled"});
+    } finally {
+      if (editing) coverageEntries.push(...await editing.close());
+      const exited = new Promise(resolveExit => backend.once("exit", resolveExit));
+      backend.kill("SIGTERM");
+      await exited;
+      await rm(root, {recursive:true,force:true});
+    }
+    return { coverageEntries, note: "The 988-character source survives a bounded 500-character status; failed/mismatched reads, retry and late selection responses are explicit on packaged desktop/390px. Pointer/Escape/Enter/close/More retain the opener with reduced motion. Editing uses a disposable real File authority and Chat HTTP owner: one save, retained concurrent-conflict draft and lost successful response recovery without another apply. Workspace navigation/status is synthetic. File/SQLite hard-lease semantics are qualified separately by HTTP+CLI tests; no active Goal or model execution." };
   },
 };
diff --git a/loopx/chat_action_normalization.py b/loopx/chat_action_normalization.py
index 043afb8065..dc9fce5aa7 100644
--- a/loopx/chat_action_normalization.py
+++ b/loopx/chat_action_normalization.py
@@ -411,6 +411,7 @@ def _normalize(
                     "no_followup",
                     "task_lease_idempotency_key",
                     "task_lease_expected_version",
+                    "review_basis",
                 },
             )
             goal_id = _opaque(values.get("goal_id"), field="goal_id")
@@ -432,8 +433,19 @@ def _normalize(
                     "todo.update operation must be edit, reassign, block, defer, complete, or successor"
                 )
             result["operation"] = operation
+            if "review_basis" in values:
+                basis = values["review_basis"]
+                if (operation != "edit" or not values.get("text") or not isinstance(basis, dict)
+                        or set(basis) != {"schema_version", "provider_revision", "source_authority", "registry_sha256"}
+                        or basis.get("schema_version") != "loopx_chat_canonical_update_basis_v0"
+                        or any(not isinstance(x, str) or not x for x in basis.values())
+                        or not BARE_SHA256_PATTERN.fullmatch(basis["registry_sha256"])):
+                    raise ValueError("Task edit requires its complete current source basis")
+                result["review_basis"] = dict(basis)
             if values.get("text"):
-                result["text"] = _text(values["text"], field="text", limit=400)
+                # Source-bound requirements use the existing journal's 8,000
+                # character envelope, never the 400-character quick-action copy.
+                result["text"] = _text(values["text"], field="text", limit=8000 if "review_basis" in result else 400)
             if values.get("status"):
                 status = str(values["status"]).strip().lower()
                 if status not in {"open", "blocked", "deferred"}:
diff --git a/loopx/chat_todo_actions.py b/loopx/chat_todo_actions.py
index 42efe19416..97ada532cb 100644
--- a/loopx/chat_todo_actions.py
+++ b/loopx/chat_todo_actions.py
@@ -30,6 +30,8 @@ def _run_todo_update(
     ) -> dict[str, Any]:
         goal_id = str(parameters["goal_id"])
         operation = str(parameters.get("operation") or "edit")
+        if parameters.get("review_basis") is not None and parameters["review_basis"] != basis:
+            raise ValueError("The Task source changed. Reload its complete requirements before saving.")
         # Transport only caller-supplied proof. The terminal owner revalidates
         # the execution; a lease read or a Todo claim is never substitute proof.
         proof = {key: parameters[key] for key in (
diff --git a/loopx/chat_todo_detail.py b/loopx/chat_todo_detail.py
index 1f2215003e..12b1363da2 100644
--- a/loopx/chat_todo_detail.py
+++ b/loopx/chat_todo_detail.py
@@ -1,5 +1,6 @@
 """Loopback-only exact Task request reads over the existing Todo owner."""
 
+import hashlib
 from urllib.parse import parse_qs, urlparse
 
 from .status_server import is_loopback_host
@@ -21,6 +22,7 @@ def _todo_detail(self) -> None:
         try:
             if not self.server.registry_path.is_file():
                 raise OSError("Task registry is unavailable")
+            registry_digest = hashlib.sha256(self.server.registry_path.read_bytes()).hexdigest()
             self._registry_and_goal(goal_id)
             payload = list_goal_todos(
                 registry_path=self.server.registry_path, goal_id=goal_id,
@@ -34,11 +36,22 @@ def _todo_detail(self) -> None:
             if item is None:
                 self._send_error("The Task is no longer available in this Goal.", status=404)
                 return
+            if hashlib.sha256(self.server.registry_path.read_bytes()).hexdigest() != registry_digest:
+                raise OSError("Task registration changed during the read")
+            authority = payload.get("authority_read") or {}
+            # Echo the same canonical CAS used by the existing Chat edit owner.
+            # Legacy display reads deliberately cannot authorize inline edits.
+            basis = ({"schema_version": "loopx_chat_canonical_update_basis_v0",
+                "provider_revision": authority["provider_revision"],
+                "source_authority": authority["source_authority"],
+                "registry_sha256": registry_digest}
+                if authority.get("decision_read_from_provider") is True else None)
             self._send_json({
                 "ok": True, "goal_id": goal_id, "todo_id": item["todo_id"],
                 "text": item["text"], "status": item["status"],
                 "archive_state": item.get("archive_state", "active"),
                 "updated_at": item.get("updated_at"),
+                **({"review_basis": basis} if basis is not None else {}),
             })
         except ValueError:
             self._send_error("The Goal or Task source could not be verified.", status=400)
diff --git a/loopx/control_plane/coordination/task_lease_proof.ts b/loopx/control_plane/coordination/task_lease_proof.ts
index b52003fda3..00aca6e9ce 100644
--- a/loopx/control_plane/coordination/task_lease_proof.ts
+++ b/loopx/control_plane/coordination/task_lease_proof.ts
@@ -14,6 +14,7 @@ import type {CoordinationTodoUpdateInput} from "./todo_update_intent.ts";
 import {deferredReopenRejection, isDeferredReopen, isOwnerDeferral} from "./todo_deferred_lifecycle.ts";
 import {blockedLifecycleRejection, isBlockedLifecycleTransition} from "./todo_blocked_lifecycle.ts";
 import {TODO_WORK_REQUIREMENT_FIELDS} from "../todos/work_requirements.ts";
+import {isOwnerWorkRequirementsRevision} from "./todo_work_requirements_lifecycle.ts";
 import {acceptanceWorkGuard} from "../goals/acceptance_contract.ts";
 import {leaseEpoch} from "../work_items/task_lease_acquire.ts";
 import {leaseRepositoryRejection} from "../work_items/task_lease_repository.ts";
@@ -163,6 +164,15 @@ export function todoUpdateLeaseRecovery(head: JsonObject, input: CoordinationTod
     execution_authority_granted: false,
   };
   const intent = input.planning_intent ?? {};
+  if (mode === "hard_lease" && isOwnerWorkRequirementsRevision(todo, input) &&
+      (input.lease_idempotency_key != null || input.lease_expected_version != null)) {
+    return {...base, action: "inspect_current_proof",
+      reason: "The explicit proof did not qualify. Inspect the current generation; do not replace its key/version or silently retry without proof. A separately reviewed proof-free requirement revision retires only the actor's own current grant and grants no execution."};
+  }
+  if (mode === "hard_lease" && isOwnerWorkRequirementsRevision(todo, input) && lease !== null && !sameOwner) {
+    return {...base, action: "reconcile_lease_owner",
+      reason: "This Todo retains another holder's execution history. Inspect that holder and reconcile the ownership through its lifecycle before preparing a requirement revision; this request cannot retire foreign history, borrow proof or acquire on the holder's behalf."};
+  }
   if ((intent.status === "blocked" || intent.status === "deferred") &&
       (input.lease_idempotency_key != null || input.lease_expected_version != null)) {
     return {...base, action: "inspect_current_proof", reason: "This lifecycle request supplied execution proof that did not qualify. Inspect the current lease and review the intended operation; do not silently replace its key or version. A proof-free administrative pause is a new, explicit request, not a retry of the stale execution."};
diff --git a/loopx/control_plane/coordination/todo_update.ts b/loopx/control_plane/coordination/todo_update.ts
index e988d37b71..89810da0c0 100644
--- a/loopx/control_plane/coordination/todo_update.ts
+++ b/loopx/control_plane/coordination/todo_update.ts
@@ -18,6 +18,7 @@ import {
 import {planMonitorCycleTransition} from "./todo_monitor_cycle.ts";
 import {isDeferredReopen, isOwnerDeferral, planDeferredLifecycle} from "./todo_deferred_lifecycle.ts";
 import {isBlockedLifecycleTransition, planBlockedLifecycleTransition} from "./todo_blocked_lifecycle.ts";
+import {isOwnerWorkRequirementsRevision, planWorkRequirementsRevision} from "./todo_work_requirements_lifecycle.ts";
 import {todoUpdateAdmissionRejection} from "./todo_update_admission.ts";
 import { CoordinationCommandReceipt } from "./command_receipt.ts";
 import {canonicalTodoRecord} from "./todo_presentation.ts";
@@ -97,7 +98,9 @@ function updateReceipt(input: CoordinationTodoUpdateInput, requestSha: string) {
         ...(original.deferred_resume_transition === undefined ? {} : {deferred_resume_transition:
           canonicalAuthorityObject(original.deferred_resume_transition, "Deferred resume receipt transition")}),
         ...(original.blocked_lifecycle_transition === undefined ? {} : {blocked_lifecycle_transition:
-          canonicalAuthorityObject(original.blocked_lifecycle_transition, "Blocked lifecycle receipt transition")})}, changed: original.changed};
+          canonicalAuthorityObject(original.blocked_lifecycle_transition, "Blocked lifecycle receipt transition")}),
+        ...(original.work_requirements_transition === undefined ? {} : {work_requirements_transition:
+          canonicalAuthorityObject(original.work_requirements_transition, "Work requirements receipt transition")})}, changed: original.changed};
     }});
 }
 
@@ -261,6 +264,7 @@ export async function executeCoordinationTodoUpdate(
   let cycle: ReturnType<typeof planMonitorCycleTransition>;
   let deferredCycle: ReturnType<typeof planDeferredLifecycle> | null = null;
   let blockedCycle: ReturnType<typeof planBlockedLifecycleTransition> | null = null;
+  let workRequirements: ReturnType<typeof planWorkRequirementsRevision> | null = null;
   try {
     cycle = planMonitorCycleTransition({goal_id: input.goal_id, before: target.todo, after: next,
       lease: target.leases.get(input.todo_id), handoff_mode: head.head.handoff_mode, now: input.now});
@@ -274,6 +278,10 @@ export async function executeCoordinationTodoUpdate(
       blockedCycle = planBlockedLifecycleTransition({goal_id: input.goal_id, before: target.todo, after: next,
         lease: target.leases.get(input.todo_id), now: input.now});
     }
+    if (head.head.handoff_mode === "hard_lease" && isOwnerWorkRequirementsRevision(target.todo, normalizedInput)) {
+      workRequirements = planWorkRequirementsRevision({goal_id: input.goal_id, before: target.todo, after: next,
+        lease: target.leases.get(input.todo_id), now: input.now});
+    }
   } catch (error) {
     return failure(
       "invalid_coordination_projection",
@@ -288,11 +296,15 @@ export async function executeCoordinationTodoUpdate(
       ? "deferred_transition"
       : "deferred_resume_transition"]: deferredCycle.transition,
   };
+  const workRequirementsTransition = workRequirements?.transition == null ? {} : {
+    work_requirements_transition: workRequirements.transition,
+  };
   const commit: AuthorityStoreCommit = changed ? prepareCoordinationProjectionCommit({
     goal_id: input.goal_id, operation_id: input.operation_id,
     expected_provider_revision: head.provider_revision, projection: head.head,
     mutations: [{kind: "todo_upsert", todo: next, clear_fields: clearFields},
-      ...cycle.mutations, ...(deferredCycle?.mutations ?? []), ...(blockedCycle?.mutations ?? [])],
+      ...cycle.mutations, ...(deferredCycle?.mutations ?? []), ...(blockedCycle?.mutations ?? []),
+      ...(workRequirements?.mutations ?? [])],
   }) : {operation_id: input.operation_id,
     expected_provider_revision: head.provider_revision, next_projection: head.head,
     events: [], receipts: []};
@@ -316,6 +328,7 @@ export async function executeCoordinationTodoUpdate(
       {completion_validation_revision: completionValidationRevisionReceipt}),
     ...(cycle.transition === null ? {} : {monitor_lifecycle_transition: cycle.transition}),
     ...deferredTransition,
+    ...workRequirementsTransition,
     ...(blockedCycle?.transition == null ? {} : {blocked_lifecycle_transition: blockedCycle.transition})};
   commit.receipts = [{schema_version: COORDINATION_TODO_UPDATE_RECEIPT_SCHEMA,
     operation_id: input.operation_id, goal_id: input.goal_id,
@@ -325,6 +338,7 @@ export async function executeCoordinationTodoUpdate(
       {completion_validation_revision: completionValidationRevisionReceipt}),
     ...(cycle.transition === null ? {} : {monitor_lifecycle_transition: cycle.transition}),
     ...deferredTransition,
+    ...workRequirementsTransition,
     ...(blockedCycle?.transition == null ? {} : {blocked_lifecycle_transition: blockedCycle.transition})}];
   return receipt.commit(store, commit);
 }
diff --git a/loopx/control_plane/coordination/todo_update_admission.ts b/loopx/control_plane/coordination/todo_update_admission.ts
index 712b66695c..c874c4117e 100644
--- a/loopx/control_plane/coordination/todo_update_admission.ts
+++ b/loopx/control_plane/coordination/todo_update_admission.ts
@@ -2,7 +2,7 @@
  * Grants may cross a claim owner;
  * exclusions, bindings and execution lineage remain independent restrictions. */
 import {retiredHandoffModeRejection, HANDOFF_MODE_RETIRED_REASON} from "./handoff_mode_policy.ts";
-import {leaseRepositoryRejection} from "../work_items/task_lease_repository.ts";
+import {leaseRepositoryRejection, ownerAdministrativeRepositoryRejection} from "../work_items/task_lease_repository.ts";
 import {isExploreReferenceAppend} from "../todos/field_update.ts";
 import {acceptanceRestoration} from "./todo_acceptance_restoration.ts";
 import {monitorMutationRejection} from "./todo_monitor_cycle.ts";
@@ -15,6 +15,7 @@ import {evaluateCoordinationTodoMutationDecision,
 import {decodeTaskLeaseProof, evaluateCanonicalTaskLeaseProof, todoUpdateLeaseRecovery, leasedTodoEditRejection, isBoundUserActionMetadataUpdate, isSoftClaimReleasedCopyUpdate, isOwnerAdministrativeCopyUpdate} from "./task_lease_proof.ts";
 import {deferredReopenRejection, isDeferredReopen, isOwnerDeferral} from "./todo_deferred_lifecycle.ts";
 import {blockedLifecycleRejection, isBlockedLifecycleTransition} from "./todo_blocked_lifecycle.ts";
+import {isOwnerWorkRequirementsRevision, workRequirementsRevisionRejection} from "./todo_work_requirements_lifecycle.ts";
 import {indexCoordinationProjection} from "./coordination_projection.ts";
 import {canonicalTaskLease} from "./task_lease_state.ts";
 import {leaseIsActive} from "../work_items/task_lease_acquire.ts";
@@ -133,6 +134,23 @@ export function todoUpdateAdmissionRejection(
     }
     return null;
   }
+  if (mode === "hard_lease" && isOwnerWorkRequirementsRevision(todo, input)) {
+    try {
+      // Supplied proof pins one live generation. Never turn stale/partial proof
+      // into a proof-free administrative request by looking up another lease.
+      if (hasProof) {
+        const fence = evaluateCanonicalTaskLeaseProof({todo, lease, handoff_mode: mode,
+          registered_agents: input.registered_agents, actor_agent_id: input.actor_agent_id,
+          lease_idempotency_key: input.lease_idempotency_key ?? null,
+          lease_expected_version: input.lease_expected_version ?? null, now: input.now});
+        if (fence.outcome !== "apply") return withRecovery(reject(String(fence.code),
+          "Explicit execution proof is stale or unavailable; inspect this Todo before retrying"));
+      }
+      return withRecovery(workRequirementsRevisionRejection(todo, input, lease));
+    } catch (error) {
+      return reject("invalid_coordination_projection", error instanceof Error ? error.message : "invalid retained lease");
+    }
+  }
   if (mode === "hard_lease" && isBlockedLifecycleTransition(input, todo)) {
     try {
       // Proof, if supplied, is an explicit generation constraint. Never replace
@@ -145,7 +163,8 @@ export function todoUpdateAdmissionRejection(
         if (fence.outcome !== "apply") return withRecovery(reject(String(fence.code), "Explicit execution proof is stale or unavailable; inspect this Todo before retrying"));
       }
       if (lease !== undefined) {
-        const repository = leaseRepositoryRejection(todo, canonicalTaskLease(lease, input.goal_id, input.todo_id));
+        const repository = ownerAdministrativeRepositoryRejection(todo,
+          canonicalTaskLease(lease, input.goal_id, input.todo_id), input.actor_agent_id);
         if (repository !== null) return withRecovery(reject(repository, "Lifecycle change must preserve the execution repository"));
       }
       return withRecovery(blockedLifecycleRejection({goal_id: input.goal_id, todo_id: input.todo_id,
@@ -178,7 +197,7 @@ export function todoUpdateAdmissionRejection(
       if (lease !== undefined) {
         const current = canonicalTaskLease(lease, input.goal_id, input.todo_id);
         leaseIsActive(current, input.now); // Validate the retained clock as well.
-        const repository = leaseRepositoryRejection(todo, current);
+        const repository = ownerAdministrativeRepositoryRejection(todo, current, input.actor_agent_id);
         if (repository !== null) return withRecovery(reject(repository, "Administrative edit must preserve the execution repository"));
         if (current.owner !== input.actor_agent_id) return withRecovery(reject("lease_owner_mismatch",
           "This Todo retains another holder's execution; reconcile that holder before editing"));
diff --git a/loopx/control_plane/coordination/todo_work_requirements_lifecycle.ts b/loopx/control_plane/coordination/todo_work_requirements_lifecycle.ts
new file mode 100644
index 0000000000..fa49f26ca5
--- /dev/null
+++ b/loopx/control_plane/coordination/todo_work_requirements_lifecycle.ts
@@ -0,0 +1,65 @@
+/** Declared work may change; an old execution grant must not change with it.
+ * Admission and Todo/lease retirement share the update owner's provider CAS. */
+import type {JsonObject} from "../effect_program.ts";
+import {TODO_WORK_REQUIREMENT_FIELDS} from "../todos/work_requirements.ts";
+import {leaseIsActive, leaseVersion, leaseEpoch} from "../work_items/task_lease_acquire.ts";
+import {releasedTaskLeaseRecord} from "../work_items/task_lease_lifecycle_decision.ts";
+import {ownerAdministrativeRepositoryRejection} from "../work_items/task_lease_repository.ts";
+import {canonicalAuthoritySha256} from "./authority_store_codec.ts";
+import type {CoordinationProjectionMutation} from "./coordination_projection.ts";
+import {canonicalTaskLease} from "./task_lease_state.ts";
+import type {CoordinationTodoUpdateInput} from "./todo_update_intent.ts";
+
+/** Local classification of the existing update intent, not an execution grant.
+ * Status, ownership, dependencies and validation changes keep their own owners. */
+export function isOwnerWorkRequirementsRevision(todo: JsonObject, input: CoordinationTodoUpdateInput): boolean {
+  const intent = input.planning_intent ?? {};
+  return todo.role === "agent" && ["open", "blocked", "deferred"].includes(String(todo.status)) &&
+    input.actor_agent_id !== null && (todo.claimed_by == null || todo.claimed_by === input.actor_agent_id) &&
+    input.completion === undefined && input.completion_validation_revision === undefined &&
+    input.monitor_observation === undefined &&
+    TODO_WORK_REQUIREMENT_FIELDS.some(field => Object.hasOwn(intent, field)) &&
+    Object.keys(input.patch).every(field => field === "text" || field === "note") &&
+    input.clear_fields.every(field => field === "note") &&
+    Object.entries(intent).every(([field, value]) =>
+      TODO_WORK_REQUIREMENT_FIELDS.some(requirement => requirement === field) ||
+      ["evidence", "reason", "priority", "clear_priority"].includes(field) ||
+      (field === "status" && value === todo.status));
+}
+
+/** Shared actor/claim/binding admission and optional explicit proof run first.
+ * An inactive foreign generation is still someone else's retained authority. */
+export function workRequirementsRevisionRejection(todo: JsonObject, input: CoordinationTodoUpdateInput,
+  retained: JsonObject | undefined): {code: string; reason: string} | null {
+  if (retained === undefined) return null;
+  const lease = canonicalTaskLease(retained, input.goal_id, input.todo_id);
+  leaseIsActive(lease, input.now); // Validate the stored clock even for administrative intent.
+  const repository = ownerAdministrativeRepositoryRejection(todo, lease, input.actor_agent_id);
+  if (repository !== null) return {code: repository, reason: "Inspect the divergent execution repository before revising work"};
+  if (lease.owner !== input.actor_agent_id) return {code: "lease_owner_mismatch",
+    reason: "Only the current owner may retire its retained execution while revising work requirements"};
+  if (todo.claimed_by !== input.actor_agent_id) return {code: "update_owner_mismatch",
+    reason: "Requirement revision must retain the execution holder's current Todo claim"};
+  return null;
+}
+
+/** Called only after admission and normalization. Freeze history unchanged;
+ * any later execution is separately admitted with a new acquire identity. */
+export function planWorkRequirementsRevision(input: {
+  goal_id: string; before: JsonObject; after: JsonObject; lease: JsonObject | undefined; now: Date;
+}): {mutations: CoordinationProjectionMutation[]; transition: JsonObject | null} {
+  const changed = TODO_WORK_REQUIREMENT_FIELDS.filter(field =>
+    canonicalAuthoritySha256({value: input.before[field] ?? null}) !==
+    canonicalAuthoritySha256({value: input.after[field] ?? null}));
+  if (changed.length === 0) return {mutations: [], transition: null};
+  const lease = input.lease === undefined ? null :
+    canonicalTaskLease(input.lease, input.goal_id, String(input.before.todo_id));
+  const retiring = lease !== null && lease.status !== "released";
+  return {
+    mutations: retiring ? [{kind: "lease_upsert", lease: releasedTaskLeaseRecord(lease, input.now)}] : [],
+    transition: {changed_fields: changed, execution_authority_granted: false,
+      lease_retirement: lease === null ? "absent" : retiring ? "released" : "already_released",
+      next_execution: "acquire_fresh_lease",
+      ...(lease === null ? {} : {retired_lease_version: leaseVersion(lease), retired_lease_epoch: leaseEpoch(lease)})},
+  };
+}
diff --git a/loopx/control_plane/work_items/task_lease_repository.ts b/loopx/control_plane/work_items/task_lease_repository.ts
index 591216ca3e..92195586d3 100644
--- a/loopx/control_plane/work_items/task_lease_repository.ts
+++ b/loopx/control_plane/work_items/task_lease_repository.ts
@@ -26,3 +26,16 @@ export function leaseRepositoryRejection(todo: {task_repository?: unknown} | nul
   return current !== null && frozen.toLowerCase() === current.toLowerCase()
     ? null : "lease_repository_divergence";
 }
+
+/** A released owner's grant is immutable history during inert administration.
+ * Actor/claim admission and any explicit execution proof are checked by the
+ * caller. Execution, foreign history and unreleased drift keep the strict fence. */
+export function ownerAdministrativeRepositoryRejection(
+  todo: {task_repository?: unknown; claimed_by?: unknown},
+  lease: {write_repository?: unknown; status?: unknown; owner?: unknown},
+  actorAgentId: string | null,
+): string | null {
+  const rejection = leaseRepositoryRejection(todo, lease); // Validate history before any exception.
+  return rejection !== null && lease.status === "released" && actorAgentId !== null &&
+    lease.owner === actorAgentId && todo.claimed_by === actorAgentId ? null : rejection;
+}
diff --git a/tests/control_plane/test_todo_administrative_journey.py b/tests/control_plane/test_todo_administrative_journey.py
index e0e2428a32..6f344f216e 100644
--- a/tests/control_plane/test_todo_administrative_journey.py
+++ b/tests/control_plane/test_todo_administrative_journey.py
@@ -80,7 +80,9 @@ def test_cli_copy_pause_resume_defer_without_lease_bookkeeping(journey):
 
 def test_chat_uses_same_atomic_owner_and_refuses_changed_review_basis(journey, tmp_path):
     cli, todo_id, registry, runtime = journey
+    cli("todo", "update", "--agent-id", "agent-a", "--task-repository", "git:github.com/example/original")
     cli("task-lease", "acquire", "--owner", "agent-a", "--idempotency-key", "chat-execution")
+    cli("todo", "update", "--agent-id", "agent-a", "--task-repository", "git:github.com/example/revised")
     cli("todo", "update", "--agent-id", "agent-a", "--note", "Original task context")
     service = ChatActionService(store=ChatActionStore(tmp_path / "actions"), registry_path=registry,
         runtime_root_override=str(runtime))
@@ -106,3 +108,84 @@ def preview(key, **parameters):
     cli("todo", "update", "--agent-id", "agent-a", "--note", "Intervening task change")
     assert service.apply(priority["proposal_id"])["proposal"]["status"] == "stale"
     assert cli("todo", "list")["todo"].get("priority") != "P2"
+
+
+def test_source_bound_chat_text_edit_preserves_its_original_lease(journey, tmp_path):
+    cli, todo_id, registry, runtime = journey
+    lease = cli("task-lease", "acquire", "--owner", "agent-a", "--idempotency-key", "original-editor-lease")["lease"]
+    service = ChatActionService(store=ChatActionStore(tmp_path / "actions"), registry_path=registry,
+        runtime_root_override=str(runtime))
+    text = "[P1] Preserve the full requirements. " + "A" * 900 + " FINAL_ACCEPTANCE: exact source."
+    proposal = service.preview({"action_kind": "todo.update", "summary": "Save complete requirements",
+        "idempotency_key": "source-bound-edit", "context": {"kind": "todo", "goal_id": "goal-a", "todo_id": todo_id},
+        "normalized_parameters": {"goal_id": "goal-a", "todo_id": todo_id, "agent_id": "agent-a",
+            "operation": "edit", "text": text, "review_basis": service._canonical_update_basis("goal-a")}})
+    assert cli("task-lease", "inspect")["lease"] == lease
+    assert service.apply(proposal["proposal_id"])["proposal"]["status"] == "applied"
+    # Requirements prose is the existing administrative copy edit. It must not
+    # impersonate a scope/repository revision or retire an admitted execution.
+    after = cli("task-lease", "inspect")
+    assert after["active"] and after["lease"] == lease
+    assert cli("todo", "list")["todo"]["text"] == text
+    service.apply(proposal["proposal_id"])
+    assert cli("task-lease", "inspect") == after
+
+
+@pytest.mark.parametrize("retained", ["active", "released"])
+def test_cli_revises_requirements_without_a_release_acquire_dead_end(journey, retained):
+    cli, _, _, _ = journey
+    lease = cli("task-lease", "acquire", "--owner", "agent-a", "--idempotency-key", "original")["lease"]
+    if retained == "released":
+        cli("task-lease", "release", "--owner", "agent-a", "--idempotency-key", "original",
+            "--expected-version", str(lease["version"]))
+    revision = ("todo", "update", "--agent-id", "agent-a", "--required-write-scope", "src/**",
+        "--required-capability", "filesystem_write", "--update-operation-id", "revise-once")
+    if retained == "active":
+        revision += ("--task-lease-idempotency-key", "original", "--task-lease-expected-version", str(lease["version"]))
+    before = cli("task-lease", "inspect")["lease"]
+    assert cli(*revision, "--dry-run")["status"] == "planned"
+    assert cli("task-lease", "inspect")["lease"] == before
+    applied = cli(*revision)
+    assert applied["work_requirements_transition"]["execution_authority_granted"] is False
+    assert cli(*revision)["status"] == "replayed"
+    todo = cli("todo", "list")["todo"]
+    assert todo["required_write_scopes"] == ["src/**"]
+    assert todo["required_capabilities"] == ["filesystem_write"]
+    retired = cli("task-lease", "inspect")["lease"]
+    assert retired["status"] == "released" and retired["version"] == lease["version"]
+    stale = cli("todo", "update", "--agent-id", "agent-a", "--note", "Old execution proof",
+        "--task-lease-idempotency-key", "original", "--task-lease-expected-version", str(lease["version"]), ok=False)
+    assert stale["ok"] is False
+    fresh = cli("task-lease", "acquire", "--owner", "agent-a", "--idempotency-key", "revised",
+        "--write-scope", "src/**")["lease"]
+    assert fresh["version"] == lease["version"] + 1
+    assert fresh["write_scopes"] == ["src/**"]
+
+
+def test_cli_repository_revision_preserves_frozen_history_and_acquires_the_new_identity(journey):
+    cli, _, _, _ = journey
+    cli("todo", "update", "--agent-id", "agent-a", "--task-repository", "git:github.com/example/original")
+    lease = cli("task-lease", "acquire", "--owner", "agent-a", "--idempotency-key", "original")["lease"]
+    cli("todo", "update", "--agent-id", "agent-a", "--task-repository", "git:github.com/example/revised")
+    retained = cli("task-lease", "inspect")["lease"]
+    assert retained["status"] == "released" and retained["write_repository"] == "git:github.com/example/original"
+    # Correcting a declaration must leave ordinary task management usable.
+    # None of these operations starts a new execution or rewrites its history.
+    for args in [
+        ("--note", "Continue after the repository correction"),
+        ("--required-write-scope", "tests/**"),
+        ("--status", "blocked", "--reason", "Owner paused"),
+        ("--status", "open", "--reason", "Owner resumed"),
+        ("--status", "deferred", "--reason", "Wait", "--resume-when", "resume_at:2099-01-01T00:00:00Z"),
+        ("--status", "open", "--reason", "Resume deferred work"),
+        ("--task-repository", "git:github.com/example/corrected"),
+    ]:
+        assert cli("todo", "update", "--agent-id", "agent-a", *args)["ok"]
+        assert cli("task-lease", "inspect")["lease"] == retained
+    refused = cli("todo", "update", "--agent-id", "agent-a", "--note", "Old proof cannot execute",
+        "--task-lease-idempotency-key", "original", "--task-lease-expected-version", str(lease["version"]), ok=False)
+    assert refused["ok"] is False
+    assert cli("task-lease", "inspect")["lease"] == retained
+    fresh = cli("task-lease", "acquire", "--owner", "agent-a", "--idempotency-key", "revised")["lease"]
+    assert fresh["version"] == lease["version"] + 1
+    assert fresh["write_repository"] == "git:github.com/example/corrected"
diff --git a/tests/control_plane_ts/native_planning_update_conformance.ts b/tests/control_plane_ts/native_planning_update_conformance.ts
index 548788a187..ff00adaf51 100644
--- a/tests/control_plane_ts/native_planning_update_conformance.ts
+++ b/tests/control_plane_ts/native_planning_update_conformance.ts
@@ -192,7 +192,7 @@ export function registerNativePlanningUpdateConformance(provider: string, factor
     });
   }
 
-  test(`${provider}: production-scale planning edit preserves unrelated state and active lease`, async t => {
+  test(`${provider}: production-scale copy preserves execution; requirement revision retires only its own lease`, async t => {
     const {store} = await factory(t);
     const fixture = productionScaleCoordinationFixture("planning-scale");
     assert.equal((await store.commitAuthority({operation_id: "seed", expected_provider_revision: null,
@@ -218,7 +218,6 @@ export function registerNativePlanningUpdateConformance(provider: string, factor
     for (const [operation_id, change] of [
       ["partial-proof", {lease_idempotency_key: null}],
       ["status-change", {planning_intent: {status: "deferred", resume_when: "pr_merged:#123"}}],
-      ["requirements-change", {planning_intent: {required_write_scopes: ["new/**"]}}],
       ["wrong-owner", {actor_agent_id: "agent-b"}],
     ] as const) {
       const result = await executeCoordinationTodoUpdate(store, {...request, operation_id, ...change});
@@ -227,6 +226,17 @@ export function registerNativePlanningUpdateConformance(provider: string, factor
       assert.deepEqual(await head(store), after);
       assert.equal((await store.readReceipt(operation_id)).status, "missing");
     }
+    const revised = await executeCoordinationTodoUpdate(store, {...request, operation_id: "requirements-change",
+      planning_intent: {required_write_scopes: ["new/**"]}});
+    assert.equal(revised.status, "applied", JSON.stringify(revised));
+    assert.equal((revised.work_requirements_transition as JsonObject).execution_authority_granted, false);
+    const final = await head(store);
+    assert.deepEqual((final.head.todos as JsonObject[]).filter(todo => todo.todo_id !== request.todo_id),
+      records.filter(todo => todo.todo_id !== request.todo_id));
+    const leases = final.head.leases as JsonObject[];
+    assert.equal(leases.find(lease => lease.todo_id === request.todo_id)!.status, "released");
+    assert.deepEqual(leases.filter(lease => lease.todo_id !== request.todo_id),
+      (after.head.leases as JsonObject[]).filter(lease => lease.todo_id !== request.todo_id));
   });
 
   for (const native of [false, true]) test(`${provider}: update intent matrix preserves compatibility clears and user scope`, async t => {
diff --git a/tests/control_plane_ts/todo_administrative_edits.test.ts b/tests/control_plane_ts/todo_administrative_edits.test.ts
index 52a90949e9..2a638837ef 100644
--- a/tests/control_plane_ts/todo_administrative_edits.test.ts
+++ b/tests/control_plane_ts/todo_administrative_edits.test.ts
@@ -37,6 +37,7 @@ async function fixture(t: test.TestContext, provider: "file" | "sqlite" | "postg
     task_class: "advancement_task", task_repository: "git:github.com/example/project", required_write_scopes: ["src/**"], completion_validation_required: true};
   const lease = {schema_version: "task_lease_v0", goal_id: GOAL, todo_id: "todo_work", owner: "agent-a",
     idempotency_key: "execution", version: 7, lease_epoch: 3, write_scopes: ["src/**"],
+    write_repository: todo.task_repository,
     status: leaseState === "released" ? "released" : "active",
     expires_at: leaseState === "active" ? "2026-09-25T07:00:00Z" : "2026-09-25T05:00:00Z"};
   const seeded = await store.commitAuthority({operation_id: "seed", expected_provider_revision: null,
@@ -104,7 +105,6 @@ for (const provider of ["file", "sqlite", "postgresql"] as const) {
       {...input, expected_provider_revision: "stale:revision"},
       {...input, actor_agent_id: "agent-b"},
       {...input, actor_agent_id: "unknown"},
-      {...input, planning_intent: {required_write_scopes: ["other/**"]}},
     ]) {
       assert.equal((await executeCoordinationTodoUpdate(store, request)).status, "failed");
       assert.deepEqual(await head(store), before);
@@ -121,4 +121,187 @@ for (const provider of ["file", "sqlite", "postgresql"] as const) {
       {...input, operation_id, patch: {note: operation_id}, expected_provider_revision: before.provider_revision})));
     assert.equal(outcomes.filter(result => result.status === "applied").length, 1);
   });
+  for (const state of [null, "active", "expired", "released"]) test(`${provider}: requirement revision retires old execution in the same commit (${state})`, options, async t => {
+    const {store, input, lease, todo} = await fixture(t, provider, state);
+    const revision = {...input, planning_intent: {required_write_scopes: ["src/**", "tests/**"],
+      required_capabilities: ["filesystem_write"], reason: "Include regression coverage"}};
+    const before = await head(store);
+    const planned = await executeCoordinationTodoUpdate(store, {...revision, dry_run: true});
+    assert.equal(planned.status, "planned", JSON.stringify(planned));
+    assert.deepEqual(await head(store), before);
+    const result = await executeCoordinationTodoUpdate(store, revision);
+    assert.equal(result.status, "applied", JSON.stringify(result));
+    const transition = result.work_requirements_transition as JsonObject;
+    assert.equal(transition.execution_authority_granted, false);
+    assert.equal(transition.next_execution, "acquire_fresh_lease");
+    assert.equal(transition.lease_retirement, state === null ? "absent" : state === "released" ? "already_released" : "released");
+    const after = await head(store);
+    const updated = (after.head.todos as JsonObject[])[0]!;
+    assert.deepEqual(updated.required_write_scopes, ["src/**", "tests/**"]);
+    assert.deepEqual(updated.required_capabilities, ["filesystem_write"]);
+    assert.equal(updated.text, todo.text);
+    assert.equal(updated.claimed_by, todo.claimed_by);
+    assert.equal(updated.status, "open");
+    assert.equal(updated.completion_validation_required, true);
+    const retained = (after.head.leases as JsonObject[])[0];
+    if (state === null) assert.equal(retained, undefined);
+    else {
+      assert.equal(retained!.status, "released");
+      for (const field of ["version", "lease_epoch", "idempotency_key", "write_scopes", "write_repository"] as const)
+        assert.deepEqual(retained![field], lease[field]);
+    }
+    const replay = await executeCoordinationTodoUpdate(store, revision);
+    assert.equal(replay.status, "replayed");
+    assert.deepEqual(replay.work_requirements_transition, transition);
+    assert.deepEqual(await head(store), after);
+    assert.equal((await executeCoordinationTodoUpdate(store, {...revision,
+      planning_intent: {required_write_scopes: ["changed/**"]}})).reason_code, "coordination_operation_identity_mismatch");
+    assert.deepEqual(await head(store), after);
+  });
+  test(`${provider}: identical requirements preserve the current grant; explicit valid proof may revise it`, options, async t => {
+    const {store, input} = await fixture(t, provider);
+    const same = {...input, planning_intent: {required_write_scopes: ["src/**"]}};
+    const before = await head(store);
+    const result = await executeCoordinationTodoUpdate(store, same);
+    assert.equal(result.status, "applied", JSON.stringify(result));
+    assert.equal(result.work_requirements_transition, undefined);
+    assert.deepEqual((await head(store)).head.leases, before.head.leases);
+    const changed = await executeCoordinationTodoUpdate(store, {...input, operation_id: "exact-proof",
+      planning_intent: {required_capabilities: ["filesystem_write"]},
+      lease_idempotency_key: "execution", lease_expected_version: 7});
+    assert.equal(changed.status, "applied", JSON.stringify(changed));
+    assert.equal(((await head(store)).head.leases as JsonObject[])[0]!.status, "released");
+  });
+  test(`${provider}: repository correction preserves history and subsequent owner administration`, options, async t => {
+    const {store, input, lease} = await fixture(t, provider);
+    const correction = {...input, operation_id: "repository-correction", patch: {},
+      planning_intent: {task_repository: "git:github.com/example/revised"}};
+    assert.equal((await executeCoordinationTodoUpdate(store, correction)).status, "applied");
+    const retired = (await head(store)).head.leases;
+    assert.deepEqual((retired as JsonObject[])[0], {...lease, status: "released",
+      released_at: NOW.toISOString().replace(".000Z", "Z"), updated_at: NOW.toISOString().replace(".000Z", "Z")});
+    const steps = [
+      {patch: {note: "Continue administration"}, planning_intent: {}},
+      {patch: {}, planning_intent: {required_write_scopes: ["tests/**"]}},
+      {patch: {}, planning_intent: {status: "blocked", reason: "Pause"}},
+      {patch: {}, planning_intent: {status: "open", reason: "Resume"}},
+      {patch: {}, planning_intent: {status: "deferred", reason: "Wait", resume_when: "resume_at:2099-01-01T00:00:00Z"}},
+      {patch: {}, planning_intent: {status: "open", reason: "Resume deferred work"}},
+      {patch: {}, planning_intent: {task_repository: "git:github.com/example/corrected"}},
+    ];
+    for (const [index, step] of steps.entries()) {
+      const request = {...input, ...step, operation_id: `continue-${index}`};
+      const before = await head(store);
+      assert.equal((await executeCoordinationTodoUpdate(store, {...request, dry_run: true})).status, "planned");
+      assert.deepEqual(await head(store), before);
+      const result = await executeCoordinationTodoUpdate(store, request);
+      assert.equal(result.status, "applied", JSON.stringify(result));
+      const after = await head(store);
+      assert.deepEqual(after.head.leases, retired);
+      assert.equal((await executeCoordinationTodoUpdate(store, request)).status, "replayed");
+      assert.deepEqual(await head(store), after);
+      for (const proof of [
+        {lease_idempotency_key: "execution", lease_expected_version: 7},
+        {lease_idempotency_key: "execution"},
+      ]) {
+        const refused = await executeCoordinationTodoUpdate(store, {...request, ...proof, operation_id: `old-proof-${index}`});
+        assert.equal(refused.status, "failed", JSON.stringify(refused));
+        assert.deepEqual(await head(store), after);
+      }
+    }
+    const final = (await head(store)).head.todos as JsonObject[];
+    assert.equal(final[0]!.task_repository, "git:github.com/example/corrected");
+    assert.equal(final[0]!.status, "open");
+    assert.equal(final[0]!.claimed_by, "agent-a");
+    assert.equal(final[0]!.completion_validation_required, true);
+    // Retrying the original correction reports history without undoing later work.
+    const beforeReplay = await head(store);
+    assert.equal((await executeCoordinationTodoUpdate(store, correction)).status, "replayed");
+    assert.deepEqual(await head(store), beforeReplay);
+  });
+  for (const boundary of ["active", "expired", "foreign", "corrupt", "excluded", "bound"] as const) {
+    test(`${provider}: released-history recovery cannot hide ${boundary} repository constraints`, options, async t => {
+      const {store, input, todo} = await fixture(t, provider,
+        boundary === "active" || boundary === "expired" ? boundary : "released");
+      const seeded = await head(store);
+      const current = {...todo, task_repository: "git:github.com/example/revised",
+        ...(boundary === "excluded" ? {excluded_agents: ["agent-a"]} : {}),
+        ...(boundary === "bound" ? {bound_agent: "agent-b"} : {})};
+      const leases = (seeded.head.leases as JsonObject[]).map(lease => ({...lease,
+        ...(boundary === "foreign" ? {owner: "agent-b"} : {}),
+        ...(boundary === "corrupt" ? {write_repository: "https://github.com/example/project.git"} : {})}));
+      assert.equal((await store.commitAuthority({operation_id: "retained-repository-state",
+        expected_provider_revision: seeded.provider_revision, events: [], receipts: [],
+        next_projection: {...seeded.head, todos: [current], leases,
+          todo_read_model: coordinationTodoReadModel([current], TODO_DOMAIN_READ_RECORD_SCHEMA)}})).status, "applied");
+      const before = await head(store);
+      for (const [index, step] of [
+        {patch: {note: "Cannot bypass holder"}, planning_intent: {}},
+        {patch: {}, planning_intent: {required_write_scopes: ["tests/**"]}},
+        {patch: {}, planning_intent: {status: "blocked", reason: "Pause"}},
+        {patch: {}, planning_intent: {status: "deferred", reason: "Wait", resume_when: "resume_at:2099-01-01T00:00:00Z"}},
+      ].entries()) {
+        const request = {...input, ...step, operation_id: `refuse-${index}`};
+        assert.equal((await executeCoordinationTodoUpdate(store, request)).status, "failed");
+        assert.deepEqual(await head(store), before);
+        assert.equal((await store.readReceipt(request.operation_id)).status, "missing");
+      }
+    });
+  }
+  test(`${provider}: requirement edits cannot heal stale proof, combine status/ownership, or bypass CAS`, options, async t => {
+    const {store, input} = await fixture(t, provider);
+    const revision = {...input, planning_intent: {required_capabilities: ["filesystem_write"]}};
+    const before = await head(store);
+    for (const request of [
+      {...revision, lease_idempotency_key: "stale", lease_expected_version: 7},
+      {...revision, lease_idempotency_key: "execution", lease_expected_version: 6},
+      {...revision, lease_idempotency_key: "execution"},
+      {...revision, lease_expected_version: 7},
+      {...revision, actor_agent_id: "agent-b"},
+      {...revision, actor_agent_id: "unknown"},
+      {...revision, planning_intent: {...revision.planning_intent, status: "blocked", reason: "Bundle"}},
+      {...revision, planning_intent: {...revision.planning_intent, claimed_by: "agent-b"}},
+      {...revision, expected_provider_revision: "stale:revision"},
+    ]) {
+      assert.equal((await executeCoordinationTodoUpdate(store, request)).status, "failed");
+      assert.deepEqual(await head(store), before);
+    }
+    const outcomes = await Promise.all(["one", "two"].map(operation_id => executeCoordinationTodoUpdate(store,
+      {...revision, operation_id, expected_provider_revision: before.provider_revision})));
+    assert.equal(outcomes.filter(result => result.status === "applied").length, 1);
+  });
+  for (const state of ["expired", "released"]) test(`${provider}: explicit ${state} proof is not converted into an administrative revision`, options, async t => {
+    const {store, input} = await fixture(t, provider, state);
+    const before = await head(store);
+    const result = await executeCoordinationTodoUpdate(store, {...input,
+      planning_intent: {required_capabilities: ["filesystem_write"]},
+      lease_idempotency_key: "execution", lease_expected_version: 7});
+    assert.equal(result.status, "failed", JSON.stringify(result));
+    assert.equal((result.recovery as JsonObject).action, "inspect_current_proof");
+    assert.deepEqual(await head(store), before);
+  });
+  test(`${provider}: registry revocation cannot leave revised work or a retired lease`, options, async t => {
+    const {store, input} = await fixture(t, provider);
+    const before = await head(store);
+    let reads = 0;
+    const result = await executeCoordinationTodoUpdate(store, {...input,
+      planning_intent: {required_write_scopes: ["other/**"]}}, async () => ++reads === 1);
+    assert.equal(result.reason_code, "authority_source_changed");
+    assert.deepEqual(await head(store), before);
+    assert.equal((await store.readReceipt(input.operation_id)).status, "missing");
+  });
+  for (const state of ["active", "expired", "released"]) test(`${provider}: a foreign ${state} holder cannot be retired by requirement editing`, options, async t => {
+    const {store, input} = await fixture(t, provider, state);
+    const seeded = await head(store);
+    await store.commitAuthority({operation_id: "foreign-holder", expected_provider_revision: seeded.provider_revision,
+      next_projection: {...seeded.head, leases: (seeded.head.leases as JsonObject[]).map(lease => ({...lease, owner: "agent-b"}))},
+      events: [], receipts: []});
+    const before = await head(store);
+    const result = await executeCoordinationTodoUpdate(store, {...input,
+      planning_intent: {required_write_scopes: ["other/**"]}});
+    assert.equal(result.reason_code, "lease_owner_mismatch", JSON.stringify(result));
+    assert.equal((result.recovery as JsonObject).owner_relation, "foreign_owner");
+    assert.equal((result.recovery as JsonObject).action, "reconcile_lease_owner");
+    assert.deepEqual(await head(store), before);
+  });
 }
diff --git a/tests/control_plane_ts/todo_update.test.ts b/tests/control_plane_ts/todo_update.test.ts
index 29f82123e4..6c4624d343 100644
--- a/tests/control_plane_ts/todo_update.test.ts
+++ b/tests/control_plane_ts/todo_update.test.ts
@@ -1082,11 +1082,10 @@ test("recovery preserves stale-proof rejection and never offers foreign proof",
   assert.deepEqual(await store.loadAuthority(), before);
 });
 
-test("inactive history does not invent an executable lease acquisition", async () => {
+test("inactive history keeps unsupported lifecycle edits fenced without inventing acquisition", async () => {
   for (const [overrides, intent, mode, expected] of [
     [{status: "blocked"}, {unblocks_todo_id: "todo_other"}, "hard_lease", "resolve_acquire_rejection"],
     [{claimed_by: null}, {unblocks_todo_id: "todo_other"}, "hard_lease", "reconcile_lease_owner"],
-    [{}, {required_capabilities: ["code_review"]}, "hard_lease", "resolve_lifecycle_edit"],
     [{}, {status: "blocked"}, "hard_lease", "resolve_lifecycle_edit"],
     [{status: "blocked"}, {}, "soft_claim", "resolve_acquire_rejection"],
   ] as const) {
diff --git a/tests/test_chat_todo_detail.py b/tests/test_chat_todo_detail.py
index c11d0fbfc2..dfe68a3d61 100644
--- a/tests/test_chat_todo_detail.py
+++ b/tests/test_chat_todo_detail.py
@@ -31,13 +31,14 @@ def test_exact_task_cli_http_preserve_full_current_and_retained_request(tmp_path
         "claimed_by": "agent-a", "task_class": "advancement_task", "priority": "P0",
     } for index, (todo_id, archived) in enumerate([("todo_current", False), ("todo_retained", True)])]
     state, runtime, registry = tmp_path / "state.md", tmp_path / "runtime", tmp_path / "registry.json"
-    state.write_text("# Synthetic Goal\n\n## Agent Todo\n")
+    state.write_text("# Synthetic Goal\n\n## User Todo / Owner Review Reading Queue\n\n## Agent Todo\n\n## Completed Work Archive\n")
     projection = build_todo_runtime_shadow_projection(goal_id="reading-goal", todos=records, handoff_mode="soft_claim")
     initialize_canonical_authority(runtime, "reading-goal", projection, state_path=state, provider=provider)
     # The authoritative reader must work without a stale display file.
     state.unlink()
     registry.write_text(json.dumps({"common_runtime_root": str(runtime), "goals": [
-        {"id": "reading-goal", "repo": str(tmp_path), "state_file": "state.md"}]}))
+        {"id": "reading-goal", "repo": str(tmp_path), "state_file": "state.md",
+         "coordination": {"registered_agents": ["agent-a"], "agent_model": "peer_v1"}}]}))
     before = read_canonical_todos_if_promoted(runtime_root=runtime, goal_id="reading-goal")
 
     def cli(*args, expected_code=0):
@@ -72,6 +73,7 @@ def cli(*args, expected_code=0):
             assert detail["goal_id"] == "reading-goal" and detail["todo_id"] == todo_id
             assert detail["text"] == text and detail["archive_state"] == ("archive" if archived else "active")
             assert "state_file" not in detail and "required_capabilities" not in detail and "authority_read" not in detail
+            assert detail["review_basis"]["provider_revision"] == before["provider_revision"]
         for query, expected in [("goal_id=other-goal&todo_id=todo_current", 400),
                                 ("goal_id=reading-goal&todo_id=todo_missing", 404),
                                 ("goal_id=reading-goal&todo_id=../state.md", 400),
@@ -93,6 +95,77 @@ def cli(*args, expected_code=0):
         after = read_canonical_todos_if_promoted(runtime_root=runtime, goal_id="reading-goal")
         assert after["provider_revision"] == before["provider_revision"] and after["todos"] == before["todos"]
         assert not state.exists()
+
+    finally:
+        server.shutdown()
+        server.server_close()
+        worker.join()
+
+
+@pytest.mark.parametrize("provider", ["file", "sqlite"])
+def test_source_bound_requirements_use_real_canonical_writer(tmp_path, monkeypatch, provider):
+    monkeypatch.syspath_prepend(str(Path(__file__).parent / "control_plane"))
+    from canonical_authority_fixture import promoted_create_fixture, isolate_sqlite_runtime
+    from loopx.chat_action_store import ChatActionStore
+    from loopx.chat_actions import ChatActionService
+    from loopx.todos import add_goal_todo
+    isolate_sqlite_runtime(tmp_path, monkeypatch)
+    registry, runtime, state = promoted_create_fixture(tmp_path, provider=provider, goal_id="reading-goal")
+    tail = " FINAL_ACCEPTANCE: preserve every original requirement."
+    text = "[P1] Complete current requirements. " + "A" * 900 + tail
+    todo_id = add_goal_todo(registry_path=registry, goal_id="reading-goal", role="agent",
+        text=text, claimed_by="agent-a", agent_id="agent-a", task_class="advancement_task")["todo_id"]
+    before = read_canonical_todos_if_promoted(runtime_root=runtime, goal_id="reading-goal")
+    server = ChatHTTPServer(("127.0.0.1", 0), ChatRequestHandler)
+    server.action_service = ChatActionService(store=ChatActionStore(runtime / "chat/actions"), registry_path=registry, runtime_root_override=str(runtime))
+    server.registry_path, server.runtime_root_override, server.verbose = registry, str(runtime), False
+    worker = threading.Thread(target=server.serve_forever, daemon=True)
+    worker.start()
+    base = f"http://127.0.0.1:{server.server_port}/api/chat/todo/detail"
+    try:
+        # The source read, not the bounded list, supplies both text and CAS.
+        with urlopen(f"{base}?goal_id=reading-goal&todo_id={todo_id}") as response:
+            detail = json.load(response)
+        updated_text = text + " Preserve this additional acceptance requirement."
+        service = server.action_service
+        request = {"action_kind": "todo.update", "summary": "Save task requirements",
+            "context": {"kind": "todo", "goal_id": "reading-goal", "todo_id": todo_id},
+            "idempotency_key": "save-requirements", "normalized_parameters": {
+                "goal_id": "reading-goal", "todo_id": todo_id, "agent_id": "agent-a",
+                "operation": "edit", "text": updated_text, "review_basis": detail["review_basis"]}}
+        proposal = service.preview(request)
+        assert read_canonical_todos_if_promoted(runtime_root=runtime, goal_id="reading-goal")["provider_revision"] == before["provider_revision"]
+        applied = service.apply(proposal["proposal_id"])["proposal"]
+        assert applied["status"] == "applied", json.dumps(applied, ensure_ascii=False)
+        with urlopen(f"{base}?goal_id=reading-goal&todo_id={todo_id}") as response:
+            saved = json.load(response)
+        assert saved["text"] == updated_text and tail in saved["text"]
+        assert service.apply(proposal["proposal_id"])["proposal"] == applied
+        assert read_canonical_todos_if_promoted(runtime_root=runtime, goal_id="reading-goal")["provider_revision"] == saved["review_basis"]["provider_revision"]
+        with pytest.raises(ValueError, match="changed"):
+            service.preview({**request, "idempotency_key": "stale-source"})
+        with pytest.raises(ValueError, match="complete current source basis"):
+            service.preview({**request, "idempotency_key": "partial-basis",
+                "normalized_parameters": {**request["normalized_parameters"], "review_basis": {"provider_revision": "unknown"}}})
+        with pytest.raises(ValueError, match="bounded visible text"):
+            service.preview({**request, "idempotency_key": "old-quick-edit-bound",
+                "normalized_parameters": {key: value for key, value in request["normalized_parameters"].items() if key != "review_basis"}})
+        with pytest.raises(ValueError, match="bounded visible text"):
+            service.preview({**request, "idempotency_key": "no-source-truncation",
+                "normalized_parameters": {**request["normalized_parameters"],
+                    "review_basis": saved["review_basis"], "text": "A" * 8001}})
+        current_request = {**request, "idempotency_key": "intervening-writer",
+            "normalized_parameters": {**request["normalized_parameters"], "text": updated_text + " A new intent.",
+                "review_basis": saved["review_basis"]}}
+        pending = service.preview(current_request)
+        from loopx.todos import update_goal_todo
+        update_goal_todo(registry_path=registry, goal_id="reading-goal", todo_id=todo_id,
+            agent_id="agent-a", note="Independent progress")
+        assert service.apply(pending["proposal_id"])["proposal"]["status"] == "stale"
+        assert service.apply(proposal["proposal_id"])["proposal"] == applied
+
+        with urlopen(f"{base}?goal_id=reading-goal&todo_id={todo_id}") as response:
+            assert json.load(response)["text"] == updated_text
     finally:
         server.shutdown()
         server.server_close()