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

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

@@ -533,6 +533,43 @@ 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: [] });
+  });
+
+  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);
+      expect(body).toEqual({ v: 1, goals: [] });
+    } 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

@@ -86,6 +86,7 @@ import type {
   BridgeRestoreSessionRequest,
   BridgeSessionState,
   BridgeRestoredSession,
+  BridgeSessionGoal,
   BridgeSessionSummary,
   BridgeClientRequestContext,
   CloseSessionOpts,
@@ -5009,6 +5010,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

@@ -224,6 +224,30 @@ export interface BridgeSessionSummary {
   color?: SessionGroupColor | null;
 }
 
+/** A session's live `/goal` state, as reported by the `qwen --acp` child. */
+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;
+  /**
+   * The most recent goal that ended on its own (`achieved` / `failed` /
+   * `aborted`). A user-driven `/goal clear` does not populate this.
+   */
+  lastTerminal: {
+    kind: 'achieved' | 'aborted' | 'failed';
+    condition: string;
+    iterations: number;
+    durationMs: number;
+    lastReason?: string;
+    systemMessage?: string;
+  } | null;
+}
+
 export interface SessionMetadataUpdate {
   displayName?: string;
 }
@@ -766,6 +790,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

@@ -149,6 +149,14 @@ 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, lastTerminal:
+   * GoalTerminalView | 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',