fix(app): keep a host claim out of the running brief and lane

A Goal whose only execution fact is an attached host claim was still counted
as "Running now" in the manager brief and as "执行中" in the home lane, so the
first screen implied work was already advancing.

Move the claim/execution decision into one shared read-model helper and route
every consumer through it: the brief renders a claim-only Goal in its own
"宿主已领取" tile, the home board gives it a matching lane, and timeline run
rows no longer spin for a claim. The claim-only Goal keeps a clickable entry
point with its claim time instead of borrowing execution.

The browser scenario now asserts the four mixtures (attached-only, queued
without a claim, stale managed with a fresh claim, fresh managed with an old
claim) in Chinese and English, plus the tile and lane counts and widths.

Signed-off-by: huangruiteng <14976749+huangruiteng@users.noreply.github.com>

Author: huangruiteng

apps/presentation/dashboard/src/features/personal-workspace/goal-activity.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { goalExecution, presentGoalActivity } from "../../../node_modules/.cache/loopx-goal-activity/goal-activity.js";
+import { goalExecution, goalWorkKind, presentGoalActivity } from "../../../node_modules/.cache/loopx-goal-activity/goal-activity.js";
 
 // One Goal's session facts, mixed by mode. `updated_at` stands for the time the
 // owner last recorded anything for that session.
@@ -97,4 +97,18 @@ for (const completeness of ["incomplete", undefined]) {
   assert.equal(partialIdle.alsoKey, "activity.inHost", "an incomplete sample never proves all threads idle");
 }
 
+// `goalWorkKind` is the single rule the brief and the home lanes share: a claim
+// is never execution, and only a managed turn counts as executing.
+assert.equal(goalWorkKind({ execution: managed }), "executing", "A managed turn executes");
+assert.equal(goalWorkKind({ execution: quiet }), "executing", "A silent managed turn is still executing, not claimed");
+assert.equal(goalWorkKind({ execution: claim }), "claimed", "An attached-only claim is a claim, not execution");
+assert.equal(goalWorkKind({ execution: silentWithFreshClaim }), "executing", "A fresh claim never downgrades a managed turn");
+assert.equal(goalWorkKind({ execution: recentWithOldClaim }), "executing", "A stale claim never downgrades a managed turn");
+assert.equal(goalWorkKind({ execution: hostWithClaim }), "executing", "An observed host thread turn is execution, not a bare claim");
+assert.equal(goalWorkKind({ execution: { kind: "idle", hostSurfaces: [] } }), "none", "An idle Goal carries no unfinished turn");
+assert.equal(goalWorkKind({ execution: { kind: "unknown" } }), "none", "Unreadable execution is not unfinished work");
+assert.equal(goalWorkKind({}), "none", "A Goal without an execution fact carries no work kind");
+assert.equal(presentGoalActivity({ activationState: "active", execution: claim, state: "推进" }).labelKey, "activity.hostClaimed", "The chip names the claim");
+assert.equal(presentGoalActivity({ activationState: "active", execution: managed, state: "推进" }).labelKey, "activity.running", "The chip names managed execution");
+
 console.log("Goal execution read-model invariants passed");

apps/presentation/dashboard/src/features/personal-workspace/goal-activity.ts

@@ -142,15 +142,29 @@ type GoalActivityInput = {
   state: string;
 };
 
+/**
+ * The unfinished-work fact a Goal carries, in the vocabulary its chip and lane
+ * already show. `executing` needs a managed turn's own activity; an attached
+ * host claim alone is `claimed` and is never counted as execution.
+ */
+export type GoalWorkKind = "executing" | "claimed" | "none";
+
+/** `none` covers an idle, unreadable or absent execution, so only a live turn is actionable work. */
+export function goalWorkKind(goal: Pick<GoalActivityInput, "execution">): GoalWorkKind {
+  if (goal.execution?.kind !== "running") return "none";
+  return goal.execution.hostClaimed ? "claimed" : "executing";
+}
+
 export function presentGoalActivity(goal: GoalActivityInput): GoalActivity {
-  const execution = goal.activationState === "active" && goal.execution?.kind === "running" ? goal.execution : null;
-  const running = execution !== null;
-  const live = execution !== null && !execution.quiet && !execution.hostClaimed;
+  const work = goal.activationState === "active" ? goalWorkKind(goal) : "none";
+  const execution = work === "none" ? null : goal.execution as Extract<WorkspaceGoalExecution, { kind: "running" }>;
+  const running = work !== "none";
+  const live = work === "executing" && execution !== null && !execution.quiet;
   if (goal.activationState === "stopped" || goal.state === "已停止") return { labelKey: "state.stopped", tone: "stopped", live: false, alsoKey: null };
   if (goal.state === "等你" || goal.needsYou) return { labelKey: "state.needsYou", tone: "attention", live, alsoKey: running ? "activity.alsoRunning" : null };
   if (goal.state === "需修复") return { labelKey: "state.needsRepair", tone: "danger", live, alsoKey: running ? "activity.alsoRunning" : null };
-  if (execution?.hostClaimed) return { labelKey: "activity.hostClaimed", tone: "running", live: false, alsoKey: null };
-  if (running) return { labelKey: "activity.running", tone: live ? "running" : "attention", live, alsoKey: null };
+  if (work === "claimed") return { labelKey: "activity.hostClaimed", tone: "running", live: false, alsoKey: null };
+  if (work === "executing") return { labelKey: "activity.running", tone: live ? "running" : "attention", live, alsoKey: null };
   if (goal.state === "等待条件") return { labelKey: "state.waiting", tone: "waiting", live: false, alsoKey: null };
   if (goal.state === "已安排") {
     const hostThreads = goal.hostThreadActivity?.threads ?? [];

apps/presentation/dashboard/src/features/personal-workspace/i18n.tsx

@@ -468,6 +468,8 @@ const en = {
   "home.lane.observingDescription": "Monitoring continuously and notifying you when something changes",
   "home.lane.running": "Running",
   "home.lane.runningDescription": "Agents are making progress and reporting back",
+  "home.lane.claimed": "Claimed by host",
+  "home.lane.claimedDescription": "A host took this work and LoopX is waiting for it to continue",
   "home.lane.scheduled": "Scheduled",
   "home.lane.scheduledDescription": "Queued until its time or prerequisite arrives",
   "home.noActivity": "No activity yet",
@@ -1093,6 +1095,8 @@ const en = {
   "brief.runningEmptyQueued": "No Agent is running · {count} queued",
   "brief.runningReading": "Reading run state…",
   "brief.alsoQueued": "{count} more queued",
+  "brief.claimed": "Claimed by host",
+  "brief.claimedEmpty": "No work is with a host",
   "brief.completed": "Recently completed",
   "brief.completedEmpty": "No completed work yet",
   "brief.completedTotal": "{count} completed in total",
@@ -1615,6 +1619,8 @@ const zhCN: Record<WorkspaceMessageKey, string> = {
   "home.lane.observingDescription": "持续监控，出现变化时再提醒你",
   "home.lane.running": "执行中",
   "home.lane.runningDescription": "Agent 正在推进并持续回传进展",
+  "home.lane.claimed": "宿主已领取",
+  "home.lane.claimedDescription": "宿主已取走工作，LoopX 等待其接续",
   "home.lane.scheduled": "已安排",
   "home.lane.scheduledDescription": "已经安排，等待时间或前置条件",
   "home.noActivity": "尚无活动",
@@ -2240,6 +2246,8 @@ const zhCN: Record<WorkspaceMessageKey, string> = {
   "brief.runningEmptyQueued": "现在没有 Agent 在执行 · {count} 个已安排",
   "brief.runningReading": "正在读取执行状态…",
   "brief.alsoQueued": "另有 {count} 个已安排",
+  "brief.claimed": "宿主已领取",
+  "brief.claimedEmpty": "没有交给宿主的工作",
   "brief.completed": "最近完成",
   "brief.completedEmpty": "还没有完成的工作",
   "brief.completedTotal": "累计完成 {count} 项",

apps/presentation/dashboard/src/features/personal-workspace/manager-brief.tsx

@@ -3,7 +3,7 @@ import { ArrowRight, Check } from "lucide-react";
 import { useWorkspaceI18n } from "./i18n";
 import type { WorkspaceGoal } from "./personal-workspace-model";
 import { workspaceHomeLaneForGoal } from "./personal-workspace-model";
-import { presentGoalActivity } from "./goal-activity";
+import { goalWorkKind, presentGoalActivity } from "./goal-activity";
 import { GoalIdentityMark, useExecutionDetail } from "./goal-activity-view";
 
 const briefRowLimit = 3;
@@ -17,7 +17,7 @@ function RunningMeta({ goal }: { goal: WorkspaceGoal }) {
 function BriefTile({ count, empty, kind, live = false, onSelectGoal, rows, title, total }: {
   count: number;
   empty: string;
-  kind: "needs" | "running" | "completed";
+  kind: "needs" | "running" | "claimed" | "completed";
   live?: boolean;
   onSelectGoal: (goalId: string) => void;
   rows: BriefRow[];
@@ -45,8 +45,9 @@ export function ManagerBrief({ goals, onSelectGoal }: { goals: WorkspaceGoal[];
   const { t } = useWorkspaceI18n();
   const active = goals.filter((goal) => goal.activationState === "active" && !goal.loadState);
   const needs = active.filter((goal) => workspaceHomeLaneForGoal(goal) === "needs_you");
-  const running = active.filter((goal) => goal.execution?.kind === "running");
-  const queued = active.filter((goal) => goal.state === "已安排" && goal.execution?.kind !== "running").length;
+  const running = active.filter((goal) => goalWorkKind(goal) === "executing");
+  const claimed = active.filter((goal) => goalWorkKind(goal) === "claimed");
+  const queued = active.filter((goal) => goal.state === "已安排" && goalWorkKind(goal) === "none").length;
   const executionRead = active.some((goal) => goal.execution && goal.execution.kind !== "unknown");
   const executionPending = active.some((goal) => !goal.execution);
   const completed = active.flatMap((goal) => goal.agentTodos
@@ -64,6 +65,9 @@ export function ManagerBrief({ goals, onSelectGoal }: { goals: WorkspaceGoal[];
       <BriefTile count={running.length} empty={runningEmpty} kind="running" live={running.some((goal) => presentGoalActivity(goal).live)} onSelectGoal={onSelectGoal}
         rows={running.map((goal) => ({ goal, key: goal.goalId, meta: <RunningMeta goal={goal} />, text: goal.title }))}
         title={t("brief.running")} total={running.length && queued ? t("brief.alsoQueued", { count: queued }) : null} />
+      {claimed.length ? <BriefTile count={claimed.length} empty={t("brief.claimedEmpty")} kind="claimed" onSelectGoal={onSelectGoal}
+        rows={claimed.map((goal) => ({ goal, key: goal.goalId, meta: <RunningMeta goal={goal} />, text: goal.title }))}
+        title={t("brief.claimed")} /> : null}
       <BriefTile count={completed.length} empty={t("brief.completedEmpty")} kind="completed" onSelectGoal={onSelectGoal}
         rows={completed} title={t("brief.completed")}
         total={completedTotal > completed.length ? t("brief.completedTotal", { count: completedTotal }) : null} />

apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-contract.test.mjs

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 const source = (name) => readFileSync(new URL(name, import.meta.url), "utf8");
 const answerText = source("./answer-text.ts");
 const model = source("./personal-workspace-model.ts");
+const activity = source("./goal-activity.ts");
 const drawer = source("./context-drawer.tsx");
 const header = source("./channel-header.tsx");
 const sidebar = source("./goal-sidebar.tsx");
@@ -266,16 +267,18 @@ assert.match(chatData, /codexHostCapacitySchema/, "Codex host-capacity receipts
 assert.match(drawer, /subagentHostCapacityRaise/, "Goal sub-agent preview discloses a required Codex capacity raise");
 assert.match(drawer, /subagentAppliedRestart/, "Applied host capacity tells the operator that a new Session is required");
 
-for (const lane of ["needs_you", "running", "observing", "scheduled", "history"]) {
+for (const lane of ["needs_you", "running", "claimed", "observing", "scheduled", "history"]) {
   assert.match(model, new RegExp(`"${lane}"`), `Manager home models the ${lane} lane`);
 }
 assert.match(model, /function workspaceHomeLaneForGoal/, "Manager lane projection is centralized and testable");
-assert.match(model, /goal\.execution\?\.kind === "running" \|\| goal\.state === "需修复"/, "Only an observed active turn or agent-owned repair work enters the running lane");
-for (const key of ["needsYou", "running", "observing", "scheduled"]) {
+assert.match(activity, /const work = goal\.activationState === "active" \? goalWorkKind\(goal\) : "none"/, "The claim/execution rule lives in one shared read-model helper");
+assert.match(model, /work === "executing"\) return "running"/, "Only a managed turn enters the running lane");
+assert.match(model, /work === "claimed"\) return "claimed"/, "A host claim gets its own lane instead of the running lane");
+for (const key of ["needsYou", "running", "claimed", "observing", "scheduled"]) {
   assert.match(page, new RegExp(`home\\.lane\\.${key}`), `Manager home renders localized ${key} lane copy`);
 }
 assert.match(page, /home\.history/, "Manager home renders localized history copy");
-assert.match(page, /personal-home-board/, "Manager home uses the four-lane workspace board");
+assert.match(page, /personal-home-board/, "Manager home uses the populated-lane workspace board");
 assert.doesNotMatch(page, /personal-worker-strip/, "Manager home omits the redundant Agent worker strip");
 assert.doesNotMatch(header, /切换到野兽主题|切换到默认主题/, "Workspace header does not expose theme switching");
 assert.match(workspaceTheme, /workspaceThemeStorageKey = "loopx-pw-theme"/, "Theme preference persists across reloads");

apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-model.ts

@@ -4,7 +4,7 @@ import type { ActionReviewPlan } from "../../../../../../loopx/control_plane/pre
 import type { GoalAcceptanceObservation } from "../../data/goal-acceptance-observation";
 import type { AttentionDetails } from "./attention-details";
 import type { WorkspaceLoadError } from "../../data/workspace-progressive-status";
-import type { GoalHostThreadActivity, WorkspaceGoalExecution } from "./goal-activity";
+import { goalWorkKind, type GoalHostThreadActivity, type WorkspaceGoalExecution } from "./goal-activity";
 export type WorkspaceGoalState =
   | "需修复"
   | "等你"
@@ -17,6 +17,7 @@ export type WorkspaceGoalState =
 export type WorkspaceHomeLane =
   | "needs_you"
   | "running"
+  | "claimed"
   | "observing"
   | "scheduled"
   | "history"
@@ -506,14 +507,19 @@ export function goalHasExecutionSummary(goal: Pick<WorkspaceGoal, "state">): boo
 }
 
 /**
- * Project the detailed Goal lifecycle onto the five manager-home buckets.
- * The home shows populated active lanes and collapses terminal work into history.
+ * Project the detailed Goal lifecycle onto the manager-home buckets. Execution
+ * is read through the shared claim/execution rule, so a host claim gets its own
+ * lane instead of borrowing the running one. The home shows populated active
+ * lanes and collapses terminal work into history.
  */
 export function workspaceHomeLaneForGoal(goal: WorkspaceGoal): WorkspaceHomeLane {
   if (goal.activationState === "stopped" || goal.state === "已停止") return "stopped";
   if (goal.state === "已完成") return "history";
   if (goal.needsYou || goal.state === "等你") return "needs_you";
-  if (goal.execution?.kind === "running" || goal.state === "需修复") return "running";
+  if (goal.state === "需修复") return "running";
+  const work = goalWorkKind(goal);
+  if (work === "executing") return "running";
+  if (work === "claimed") return "claimed";
   if (goal.state === "安静运行") return "observing";
   return "scheduled";
 }

apps/presentation/dashboard/src/features/personal-workspace/personal-workspace-page.tsx

@@ -60,6 +60,7 @@ import type {
   WorkspaceTodo,
 } from "./personal-workspace-model";
 import { goalHasExecutionSummary, goalTitleFor, workspaceHomeLaneForGoal } from "./personal-workspace-model";
+import { goalWorkKind } from "./goal-activity";
 import { WorkspaceActionForm, type WorkspaceActionDraft } from "./workspace-action-form";
 import { GoalActivityChip, GoalIdentityMark } from "./goal-activity-view";
 import { ManagerBrief } from "./manager-brief";
@@ -111,6 +112,7 @@ function ManagerHomeBoard({
   const activeHomeLanes = [
     { key: "needs_you", label: t("home.lane.needsYou") },
     { key: "running", label: t("home.lane.running") },
+    { key: "claimed", label: t("home.lane.claimed") },
     { key: "observing", label: t("home.lane.observing") },
     { key: "scheduled", label: t("home.lane.scheduled") },
   ] as const;
@@ -373,7 +375,7 @@ function defaultTimeline(model: WorkspaceModel, selectedGoalId: string | null, t
         goalTitle: goal.title,
         latestActivity: goal.agentSentence,
         runId: `goal:${goal.goalId}`,
-        status: goal.execution?.kind === "running" ? "running" : "failed",
+        status: goalWorkKind(goal) === "executing" ? "running" : "failed",
         title: goal.nextSentence,
         totalSteps: Math.max(
           (goal.doneTodoCount ?? 0) + goal.agentTodos.filter((todo) => !todo.done).length,
@@ -410,7 +412,7 @@ function defaultTimeline(model: WorkspaceModel, selectedGoalId: string | null, t
       goalTitle: goal.title,
       latestActivity: goal.agentSentence,
       runId: `goal:${goal.goalId}`,
-      status: goal.execution?.kind === "running" ? "running" : goal.state === "需修复" ? "failed" : goal.state === "已安排" ? "queued" : "waiting",
+      status: goalWorkKind(goal) === "executing" ? "running" : goal.state === "需修复" ? "failed" : goal.state === "已安排" ? "queued" : "waiting",
       title: goal.nextSentence,
       totalSteps: Math.max(
         (goal.doneTodoCount ?? 0) + goal.agentTodos.filter((todo) => !todo.done).length,