@@ -146,6 +146,12 @@ check(managedFrame?.kind === "pending" && managedFrame.executionState === "manag
 check(managedFrame?.content.fields.some(field => field.value.includes("test-model@xhigh")) === true,
   "The shared managed profile survives the frontend schema transport");
 check(compileActionReviewPlan(managedPending).canApply === false, "Managed approval exposes no local execute control");
+const startedManaged = typedActionProposalSchema.parse({...managedPending,
+  operation: {...managedPending.operation, host_start: {schema_version: "loopx_operation_host_start_v0", host_turn_id: "native-turn"}}});
+const startedFrame = compileActionReviewPlan(startedManaged).operationFrame;
+check(startedFrame?.kind === "pending" && startedFrame.executionState === "managed_turn_started",
+  "Native accepted start survives schema transport without claiming consumption or execution");
+check(compileActionReviewPlan(startedManaged).canApply === false, "Accepted native start grants no apply control");
 check(compileActionReviewPlan(unknownAgentResult).interaction === "repair", "Delivered unknown submission is not completion");
 const reconciledAgentResult = typedActionProposalSchema.parse({...unknownAgentResult,
   operation: {...unknownAgentResult.operation, reconciliation: {outcome: "not_executed", simulation: false}}});
 
@@ -121,10 +121,12 @@ export function ChannelTimeline({
     }
     if (item.kind === "proposal") {
       const appliedTeamPlan = item.proposal.actionKind === "team.plan" && item.proposal.status === "applied";
+      const pendingOperation = item.proposal.reviewPlan?.operationFrame?.kind === "pending";
       return (
         <Fragment key={item.id}><button className={`personal-proposal-row is-${item.proposal.status}`} data-action-kind={item.proposal.actionKind} onClick={() => onSelect({ item: item.proposal, kind: "proposal" })} type="button">
           <span><Sparkles size={17} /></span>
-          <span><small>{appliedTeamPlan ? (locale === "zh-CN" ? "团队分配 · 已记录" : "Team assignment · Recorded")
+          <span><small>{pendingOperation ? t(`proposal.kind.${item.proposal.actionKind}`)
+            : appliedTeamPlan ? (locale === "zh-CN" ? "团队分配 · 已记录" : "Team assignment · Recorded")
             : `${t(`proposal.kind.${item.proposal.actionKind}`)} · ${t(`proposal.status.${item.proposal.status}`)}`}</small><strong>{item.proposal.title}</strong>{item.proposal.impact ? <p>{item.proposal.impact}</p> : null}</span>
           <b>{item.proposal.status === "gated" && item.proposal.actionKind !== "operation.execute" ? t("timeline.review") : item.proposal.primaryLabel ?? t("timeline.reviewAndConfirm")}</b>
         </button>{showManagerTeamResults && onOpenGoalEvidence && appliedTeamPlan
 
@@ -1102,7 +1102,9 @@ export function ContextDrawer({ agents, attentionHistory = [], onSelectAttention
         {selection.kind === "proposal" ? (
           <>
             {selection.item.actionKind === "team.plan" && selection.item.status === "applied" ? <TeamPlanResult proposal={selection.item} t={t} /> : <section className="personal-proposal-card">
-              <small>{selection.item.actionKind} · {selection.item.status}</small>
+              <small>{selection.item.reviewPlan?.operationFrame?.kind === "pending"
+                ? t(`proposal.kind.${selection.item.actionKind}`)
+                : `${selection.item.actionKind} · ${selection.item.status}`}</small>
               <h3>{selection.item.title}</h3>
               {selection.item.impact ? <p>{selection.item.impact}</p> : null}
               {selection.item.reviewPlan && !selection.item.reviewPlan.retryOriginal && selection.item.actionKind !== "team.plan" ? <p className="personal-proposal-explainer" data-action-review={selection.item.reviewPlan.interaction}>{operationUnknown
 
@@ -684,6 +684,7 @@ const en = {
   "proposal.field.operationState": "Operation state",
   "proposal.operationState.host_authentication_required": "Confirmed; original-host authentication unavailable",
   "proposal.operationState.managed_turn_pending": "Confirmed; waiting for the bound managed Turn",
+  "proposal.operationState.managed_turn_started": "Native continuation accepted; authorization not yet consumed",
   "proposal.operationState.consumed_outcome_pending": "Authorization consumed; waiting for the real result",
   "proposal.operationState.submission_unknown": "Result unknown; reconcile the original operation, do not resubmit",
   "proposal.field.resultDelivery": "Result delivery",
@@ -730,6 +731,7 @@ const en = {
   "proposal.impact.operation": "The exact terms are read-only here. Confirm or reject the same immutable request in the bound Feishu group; confirmation consumes one canonical claim.",
   "proposal.impact.operationAuthorized": "Human confirmation is recorded, but the original host's authenticated tool transport is not connected. Thread flags or environment ids cannot authorize execution. No external result is recorded yet.",
   "proposal.impact.operationManagedPending": "Confirmation is bound to the selected managed session and execution profile, not the source conversation. The admitted Turn must consume it once through its owned tool connection. No execution or external result is established yet.",
+  "proposal.impact.operationManagedStarted": "The bound native host accepted a continuation containing this confirmed operation. This first-start receipt is not proof that the Turn is still running, that authorization was consumed, or that an external effect occurred.",
   "proposal.impact.operationConsumed": "The authorization has been consumed. Wait for original external evidence; a retry or lost response must not grant another submission.",
   "proposal.impact.operationUnknown": "Submission may have had an external effect. Reconcile the original operation using its evidence; do not resubmit or treat card delivery as execution completion.",
   "proposal.primary.apply": "Confirm and apply",
@@ -1882,6 +1884,7 @@ const zhCN: Record<WorkspaceMessageKey, string> = {
   "proposal.field.operationState": "操作状态",
   "proposal.operationState.host_authentication_required": "已确认，原宿主身份认证尚未接通",
   "proposal.operationState.managed_turn_pending": "已确认，等待绑定的受管回合",
+  "proposal.operationState.managed_turn_started": "原生续接已接受，授权尚未消费",
   "proposal.operationState.consumed_outcome_pending": "授权已消费，等待真实结果",
   "proposal.operationState.submission_unknown": "结果未知；核对原操作，不可重复提交",
   "proposal.field.resultDelivery": "结果回传",
@@ -1928,6 +1931,7 @@ const zhCN: Record<WorkspaceMessageKey, string> = {
   "proposal.impact.operation": "这里仅展示同一份不可变条款。请在已绑定的飞书群确认或拒绝；确认只会消费一个规范 claim。",
   "proposal.impact.operationAuthorized": "用户确认已记录，但原宿主的认证工具通道尚未接通。线程参数或环境变量不能授权执行；目前尚无外部执行结果。",
   "proposal.impact.operationManagedPending": "批准绑定选定的受管会话和执行配置，不绑定来源对话。通过准入的回合须在自有工具通道上消费一次；目前不代表已执行，也没有外部结果。",
+  "proposal.impact.operationManagedStarted": "绑定的原生宿主已接受包含本确认请求的续接。首次启动回执不证明回合仍在运行、授权已消费或已有外部效果。",
   "proposal.impact.operationConsumed": "授权已消费。等待原始外部证据；重试或响应丢失均不得重新授予提交许可。",
   "proposal.impact.operationUnknown": "提交可能已产生外部副作用。须以原始证据核对原操作，不可重提，也不能把卡片投递当作执行完成。",
   "proposal.primary.apply": "确认并应用",
 
@@ -659,7 +659,8 @@ function workspaceProposal(proposal: TypedActionProposal, t: WorkspaceTranslate)
       ? operationFrame?.kind === "pending" && operationFrame.executionState
         ? t(operationFrame.executionState === "consumed_outcome_pending"
           ? "proposal.impact.operationConsumed" : operationFrame.executionState === "managed_turn_pending"
-          ? "proposal.impact.operationManagedPending" : "proposal.impact.operationAuthorized")
+          ? "proposal.impact.operationManagedPending" : operationFrame.executionState === "managed_turn_started"
+          ? "proposal.impact.operationManagedStarted" : "proposal.impact.operationAuthorized")
         : operationFrame?.kind === "result" && operationFrame.resultKind === "unknown"
         ? t("proposal.impact.operationUnknown") : t("proposal.impact.operation")
       : proposal.action_kind === "team.plan"
 
@@ -445,10 +445,23 @@ remain fail-closed before private reads or writes, even with matching
 `CODEX_THREAD_ID`, route flags, self-signed proof or an older runtime's actor
 success. No proof-import shortcut is exposed.
 
-Immediate confirmation-triggered host wakeup is not implemented:
-`host_delivery: "not_attempted"` remains truthful. Continue through the
-existing admitted Turn/delegation route; later durable wakeup must reuse its
-original scheduling/session owner, not start a parallel resumed executor.
+An admitted operation-enabled Turn now automatically includes canonical
+confirmed-operation locators for its exact Goal/Agent/Todo/session/profile,
+filtered before inbox pagination. After the native `turn/start` response is
+accepted, the existing action store records immutable first-start evidence:
+confirmation event/time, claim, LoopX Turn key, native Turn and acceptance time.
+`host_delivery: "native_start_accepted"` means that observation only; it grants
+no consumption or effect authority and does not claim the Turn is still live.
+Receipt failure aborts before operation-tool dispatch; later Turns preserve the
+first observation. CLI/Inbox, Dashboard and Lark distinguish accepted native
+continuation from consumed authorization and an actual outcome.
+
+Immediate confirmation-triggered wakeup is still not implemented. The first
+observation is from the existing admitted Turn/delegation route, not proof of
+an immediate callback-triggered wake. Before it exists, `host_delivery` remains
+`"not_attempted"`. Durable wakeup must reuse the original scheduling/session
+owner, not start a parallel resumed executor. Outcome return to the original
+source audience remains a separate delivery obligation.
 Before claiming the investment minimum loop, still prove installation,
 genuine human approval, bound native consumption, domain preflight and
 original-system evidence, accepted result and original-card/audience readback.
 
@@ -348,8 +348,16 @@ context 调用，结果均由既有 typed result validator 接受）、规范
 私有读写前拒绝，即使 `CODEX_THREAD_ID`、路由、自签 proof 完全匹配或旧运行时
 意外返回 actor 成功，也没有 proof-import 捷径。
 
-本切片不实现确认后的即时宿主唤醒，`host_delivery: "not_attempted"` 保持真实。
-沿既有已准入 Turn/delegation 续接；后续持久唤醒复用其调度/session owner，
-不启动平行 resumed 执行者。宣称投研最小闭环前，仍须证明安装、真实用户批准、
+启用 operation 的已准入 Turn 自动携带其精确 Goal/Agent/Todo/session/profile 的
+规范确认请求定位信息，并在 Inbox 分页前过滤范围。仅在原生 `turn/start` 返回接受后，
+既有 action store 才记录不可覆盖的首次启动证据：确认事件/时间、claim、LoopX Turn key、
+原生 Turn 和接受时间。`host_delivery: "native_start_accepted"` 只证明该观察，
+不授予消费或外部效果权限，也不声称回合仍在运行。回执失败时先停止、不分发 operation 工具；
+后续回合保留首次观察。CLI/Inbox、Dashboard 和 Lark 区分原生续接接受、授权消费和真实结果。
+
+确认后的即时唤醒仍未实现。首次观察来自既有已准入 Turn/delegation，不能冒充
+即时 callback 触发；未观察前 `host_delivery: "not_attempted"` 保持真实。
+后续持久唤醒复用原调度/session owner，不启动平行 resumed 执行者；
+向原来源受众返回结果仍是独立交付义务。宣称投研最小闭环前，仍须证明安装、真实用户批准、
 绑定原生消费、垂域提交前检查与原系统证据、结果验收及原卡/受众读回。
 Core PR 仍须 owner review，不在合并前自行安装。
@@ -1068,6 +1068,29 @@ def _agent_operation_plan(
         except EffectRuntimeRemoteError as exc:
             raise ActionConflictError(str(exc)) from exc
 
+    def record_agent_operation_host_start(
+        self, proposal_id: str, *, actor: Mapping[str, Any],
+        binding_current: bool, turn_key: str,
+    ) -> dict[str, Any]:
+        """Internal native transport observation; never a caller proof or permit."""
+        token = _opaque_id(proposal_id, field="proposal_id")
+        with exclusive_file_lock(self.path, operation="observe_operation_host_start"):
+            payload = self._read()
+            proposal = payload["proposals"].get(token)
+            if not isinstance(proposal, dict):
+                raise KeyError("typed operation was not found")
+            plan = self._agent_operation_plan(
+                proposal, action="observe_host_start", actor=dict(actor),
+                binding_current=binding_current, turn_key=turn_key,
+            )
+            receipt = plan.pop("write_host_start", None)
+            if receipt is not None:
+                proposal["operation"]["host_start"] = receipt
+                proposal["updated_at"] = _utc_now()
+                self._write(payload)
+                plan.update(host_start=receipt, host_delivery="native_start_accepted")
+            return plan
+
     def consume_agent_operation(
         self,
         proposal_id: str,
 
@@ -79,6 +79,7 @@ def pending_operation_handoffs(
     scope: CollaborationGoalScope | None = None,
     cursor: str | None = None,
     cursor_scope: str,
+    executor_route: Mapping[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Project canonical tickets into the existing Inbox; do not copy authority."""
     store = (
@@ -155,6 +156,7 @@ def pending_operation_handoffs(
                     "items": result,
                     "cursor": cursor,
                     "cursor_scope": cursor_scope,
+                    "executor_route": dict(executor_route) if executor_route is not None else None,
                 },
             )
         )
@@ -171,6 +173,7 @@ def agent_operation_action(
     action: str,
     consumption_id: str | None = None,
     outcome: Mapping[str, Any] | None = None,
+    turn_key: str | None = None,
 ) -> dict[str, Any]:
     """Internal locked IO seam, not a public caller-authentication endpoint.
 
@@ -194,12 +197,12 @@ def agent_operation_action(
         goal_id=actor["goal_id"],
         agents=(actor["agent_id"],),
         caller_goal_ref=parameters.get("origin_goal_ref"),
-        require_active=action == "consume",
+        require_active=action in {"consume", "observe_host_start"},
         # Recovery-owner binding must stay valid through evidence commit too.
         # Use the same Goal -> registry -> action-store ordering as consumption.
         lock_registry=True,
     ) as scope:
-        if action == "consume":
+        if action in {"consume", "observe_host_start"}:
             decide_collaboration_lifecycle(scope, operation="request_create")
             if goal_is_stopped(scope.goal):
                 raise ActionConflictError("confirmed operation Goal is stopped")
@@ -258,6 +261,7 @@ def agent_operation_action(
                 action,
                 consumption_id,
                 outcome,
+                turn_key,
             )
 
 
@@ -272,6 +276,7 @@ def _commit_agent_operation(
     action: str,
     consumption_id: str | None,
     outcome: Mapping[str, Any] | None,
+    turn_key: str | None,
 ) -> dict[str, Any]:
     current = _binding(registry_path, parameters, runtime_root)
     actor_executor = (
@@ -313,6 +318,10 @@ def _commit_agent_operation(
             "outcome_report": proposal["operation"].get("outcome_report"),
             "reconciliation_report": proposal["operation"].get("reconciliation_report"),
         }
+    if action == "observe_host_start":
+        return store.record_agent_operation_host_start(
+            proposal_id, actor=actor, binding_current=current, turn_key=str(turn_key or ""),
+        )
     if action == "consume":
         return store.consume_agent_operation(
             proposal_id,
 
@@ -42,7 +42,7 @@ export type OperationReviewFrame = OperationReviewFrameBase & (
       kind: "pending";
       attentionKind: "progress";
       interactionMode: "inform";
-      executionState?: "host_authentication_required" | "managed_turn_pending" | "consumed_outcome_pending";
+      executionState?: "host_authentication_required" | "managed_turn_pending" | "managed_turn_started" | "consumed_outcome_pending";
     }
   | {
       kind: "result";
@@ -332,7 +332,10 @@ export function compileOperationReviewFrame(proposalValue: unknown): OperationRe
       interactionMode: "inform",
       ...(["agent_session", "managed_turn"].includes(String(objectValue(parameters.executor)?.kind))
         ? {executionState: objectValue(operation.agent_handoff) ? "consumed_outcome_pending" as const
-          : objectValue(parameters.executor)?.kind === "managed_turn" ? "managed_turn_pending" as const : "host_authentication_required" as const}
+          : objectValue(parameters.executor)?.kind === "managed_turn"
+          ? objectValue(operation.host_start)?.schema_version === "loopx_operation_host_start_v0"
+            ? "managed_turn_started" as const : "managed_turn_pending" as const
+          : "host_authentication_required" as const}
         : {}),
     };
   }