feat(web-shell): add a workspace Goals page, and stop losing /goal on daemon resume

.qwen/skills/autofix/SKILL.md

@@ -68,6 +68,7 @@ owns the model-driven decisions, code changes, and pre-commit verification.
   Keep `failure.md` and `handoff.md` English-only WITHOUT a details block:
   handoff comments embed a byte-truncated excerpt of them, and a severed
   `<details>` tag would swallow the rest of the comment when rendered.
+
 - Never ask the user a question in this headless workflow. If blocked, write
   `<workdir>/failure.md` with what you learned and stop.
 

integration-tests/cli/qwen-serve-routes.test.ts

@@ -743,6 +743,46 @@ describe('qwen serve — cancel + list', () => {
   });
 });
 
+describe('qwen serve — GET /goals', () => {
+  const getGoals = async () => {
+    const res = await fetch(`${base}/goals`, {
+      headers: { Authorization: `Bearer ${TOKEN}` },
+    });
+    return { status: res.status, body: await res.json() };
+  };
+
+  it('returns an empty, versioned list when no session has a goal', async () => {
+    const { status, body } = await getGoals();
+    expect(status).toBe(200);
+    expect(body).toEqual({ v: 1, goals: [], droppedCount: 0 });
+  });
+
+  it('probes each live session over the bridge without reporting a goal', async () => {
+    // The real round trip: serve -> bridge -> `sessionGoalGet` ext method in
+    // the `qwen --acp` child -> back. A live session with no `/goal` must come
+    // back as "no goal" rather than an error or a phantom entry.
+    const session = await client.createOrAttachSession({
+      workspaceCwd: REPO_ROOT,
+      sessionScope: 'thread',
+    });
+    try {
+      const { status, body } = await getGoals();
+      expect(status).toBe(200);
+      // `droppedCount: 0` is the load-bearing half: it proves the ext-method
+      // probe actually reached the child. A dropped probe would also yield an
+      // empty `goals`, so that alone cannot tell success from a silent failure.
+      expect(body).toEqual({ v: 1, goals: [], droppedCount: 0 });
+    } finally {
+      await client.closeSession(session.sessionId);
+    }
+  });
+
+  it('requires the bearer token', async () => {
+    const res = await fetch(`${base}/goals`);
+    expect(res.status).toBe(401);
+  });
+});
+
 describe('qwen serve — DELETE /session/:id', () => {
   it('204 on explicit close', async () => {
     const session = await client.createOrAttachSession({

packages/acp-bridge/src/bridge.ts

@@ -96,6 +96,7 @@ import type {
   BridgeRestoreSessionRequest,
   BridgeSessionState,
   BridgeRestoredSession,
+  BridgeSessionGoal,
   BridgeSessionSummary,
   BridgePendingInteraction,
   BridgeClientRequestContext,
@@ -6146,6 +6147,13 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
       );
     },
 
+    async getSessionGoal(sessionId) {
+      return requestSessionStatus<BridgeSessionGoal>(
+        sessionId,
+        SERVE_CONTROL_EXT_METHODS.sessionGoalGet,
+      );
+    },
+
     async continueSession(sessionId, context) {
       // Validate the originator up-front, mirroring POST /session/:id/prompt, so
       // an unknown client id (or a session that vanished) surfaces as an error

packages/acp-bridge/src/bridgeTypes.ts

@@ -373,6 +373,24 @@ export interface BridgeSessionSummary {
   color?: SessionGroupPresetColor | null;
 }
 
+/**
+ * A session's live `/goal` state, as reported by the `qwen --acp` child.
+ *
+ * Only the active goal crosses the bridge. The child also caches the most
+ * recent goal that ended on its own, but nothing on this side reads it, so it
+ * is not part of the wire shape — add it back alongside the first consumer.
+ */
+export interface BridgeSessionGoal {
+  active: {
+    condition: string;
+    /** Judge turns completed so far; 0 before the first stop-hook evaluation. */
+    iterations: number;
+    setAt: number;
+    /** The judge's verdict on the most recent turn, when it has run. */
+    lastReason?: string;
+  } | null;
+}
+
 export interface SessionMetadataUpdate {
   displayName?: string;
 }
@@ -971,6 +989,13 @@ export interface AcpSessionBridge {
     sessionId: string,
   ): Promise<{ cleared: boolean; condition?: string }>;
 
+  /**
+   * Read a live session's goal state. Throws `SessionNotFoundError` when the
+   * session is not resident — goals live in the child's memory, so a
+   * non-resident session has no goal to report.
+   */
+  getSessionGoal(sessionId: string): Promise<BridgeSessionGoal>;
+
   /**
    * Resume a live session's unfinished previous turn — an interrupted prompt
    * (model never answered) or a turn left with dangling tool calls — without

packages/acp-bridge/src/status.ts

@@ -157,6 +157,13 @@ export const SERVE_CONTROL_EXT_METHODS = {
   // Runtime MCP server mutation ext-methods
   sessionTaskCancel: 'qwen/control/session/task/cancel',
   sessionGoalClear: 'qwen/control/session/goal/clear',
+  /**
+   * Read a live session's `/goal` state. The active goal lives only in the
+   * child's in-memory store, so this is the sole authoritative source for the
+   * condition, its running turn count and the judge's last verdict. Params:
+   * `{ sessionId }`; result: `{ active: ActiveGoalView | null }`.
+   */
+  sessionGoalGet: 'qwen/control/session/goal/get',
   workspaceMcpRuntimeAdd: 'qwen/control/workspace/mcp/runtime-add',
   workspaceMcpRuntimeRemove: 'qwen/control/workspace/mcp/runtime-remove',
   workspaceReload: 'qwen/control/workspace/reload',