Merge codex/supervisor-target-memory

# Conflicts:
#	packages/web/src/features/supervisor/views/shared/supervisor-card.tsx

Author: pallyoung

packages/core/src/domain/supervisor.ts

@@ -19,7 +19,52 @@ export type CycleStatus =
 
 export type CycleTrigger = "turn_completed" | "manual" | "scheduled";
 
-export type SupervisorStopReason = "objective_complete" | "max_supervision_count_reached";
+export type SupervisorStopReason =
+  | "objective_complete"
+  | "max_supervision_count_reached"
+  | "supervisor_uncertain"
+  | "needs_user_input";
+
+export type SupervisorPlanStepStatus = "pending" | "in_progress" | "done";
+
+export interface SupervisorPlanStep {
+  id: string;
+  title: string;
+  status: SupervisorPlanStepStatus;
+}
+
+export interface SupervisorTargetMemory {
+  targetId: string;
+  planGenerated: boolean;
+  plan: SupervisorPlanStep[];
+  activeStepId?: string;
+  progressSummary?: string;
+  lastGuidance?: string;
+  stalledCount: number;
+  updatedAt: number;
+}
+
+export interface SupervisorCycleStepUpdate {
+  id: string;
+  status: SupervisorPlanStepStatus;
+}
+
+export interface SupervisorCycleTargetRecord {
+  cycleId: string;
+  targetId: string;
+  startedAt: number;
+  completedAt: number;
+  result: "continue" | "stop" | "error";
+  stopReason?: "objective_complete" | "supervisor_uncertain" | "needs_user_input";
+  reason?: string;
+  guidance?: string;
+  progressSummary?: string;
+  activeStepId?: string;
+  stepUpdates?: SupervisorCycleStepUpdate[];
+  injected?: boolean;
+  attemptCount?: number;
+  errorReason?: string;
+}
 
 export type SupervisorCycleAttemptStatus = "evaluating" | "completed" | "failed" | "cancelled";
 
@@ -65,6 +110,7 @@ export interface Supervisor {
   id: string;
   sessionId: string;
   workspaceId: string;
+  targetId: string;
   state: SupervisorState;
   objective: string;
   evaluatorProviderId: string;
@@ -73,6 +119,8 @@ export interface Supervisor {
   completedSupervisionCount: number;
   scheduledAt?: number;
   stopReason?: SupervisorStopReason;
+  currentTargetMemory?: SupervisorTargetMemory;
+  recentTargetCycles?: SupervisorCycleTargetRecord[];
   cycles: SupervisorCycle[];
   lastCycleAt?: number;
   lastEvaluatedTurnId?: string;

packages/server/src/__tests__/db.test.ts

@@ -8,6 +8,7 @@ import {
   CURRENT_SCHEMA_VERSION,
   IncompatibleSchemaError,
   V1_SCHEMA_SQL,
+  V2_SCHEMA_SQL,
 } from "../storage/schema-version.js";
 
 describe("Database", () => {
@@ -98,7 +99,7 @@ describe("Database", () => {
       expect(tables.map((table) => table.name)).not.toContain("_migrations");
     });
 
-    it("should upgrade a known v1 supervisor schema to v2 when user_version is unset", () => {
+    it("should upgrade a known v1 supervisor schema to v3 when user_version is unset", () => {
       const dbPath = join(tempDir, "v1.db");
       const rawDb = new DatabaseSync(dbPath);
       rawDb.exec("PRAGMA user_version = 0");
@@ -108,13 +109,14 @@ describe("Database", () => {
       db = openDatabase(dbPath);
 
       const userVersion = db.prepare("PRAGMA user_version").get() as { user_version: number };
-      expect(userVersion.user_version).toBe(2);
+      expect(userVersion.user_version).toBe(CURRENT_SCHEMA_VERSION);
 
       const supervisorColumns = db.prepare("PRAGMA table_info(supervisors)").all() as Array<{
         name: string;
       }>;
       expect(supervisorColumns.map((column) => column.name)).toEqual(
         expect.arrayContaining([
+          "target_id",
           "evaluator_model",
           "max_supervision_count",
           "completed_supervision_count",
@@ -138,6 +140,79 @@ describe("Database", () => {
       expect(upgradedIndex?.name).toBe("idx_supervisor_cycle_attempts_cycle");
     });
 
+    it("should upgrade a known v2 supervisor schema to v3 and backfill target ids", () => {
+      const dbPath = join(tempDir, "v2.db");
+      const rawDb = new DatabaseSync(dbPath);
+      rawDb.exec("PRAGMA user_version = 2");
+      rawDb.exec(V2_SCHEMA_SQL);
+      rawDb.exec(`
+        INSERT INTO workspaces (id, path, target_runtime, opened_at, last_active_at, ui_state)
+        VALUES ('ws-1', '/workspace', 'native', 1, 1, '{}');
+      `);
+      rawDb.exec(`
+        INSERT INTO terminals (id, workspace_id, kind, cwd, argv, cols, rows, created_at)
+        VALUES ('term-1', 'ws-1', 'agent', '/workspace', '[]', 120, 30, 1);
+      `);
+      rawDb.exec(`
+        INSERT INTO sessions (
+          id, workspace_id, terminal_id, provider_id, capability, state, started_at, last_active_at
+        ) VALUES ('sess-1', 'ws-1', 'term-1', 'codex', 'full', 'idle', 1, 1);
+      `);
+      rawDb.exec(`
+        INSERT INTO supervisors (
+          id,
+          session_id,
+          workspace_id,
+          state,
+          objective,
+          evaluator_provider_id,
+          evaluator_model,
+          max_supervision_count,
+          completed_supervision_count,
+          scheduled_at,
+          stop_reason,
+          last_cycle_at,
+          last_evaluated_turn_id,
+          error_reason,
+          created_at,
+          updated_at
+        ) VALUES (
+          'sup-legacy',
+          'sess-1',
+          'ws-1',
+          'idle',
+          'Legacy supervisor',
+          'codex',
+          NULL,
+          0,
+          0,
+          NULL,
+          NULL,
+          NULL,
+          NULL,
+          NULL,
+          1,
+          1
+        );
+      `);
+      rawDb.close();
+
+      db = openDatabase(dbPath);
+
+      const userVersion = db.prepare("PRAGMA user_version").get() as { user_version: number };
+      expect(userVersion.user_version).toBe(CURRENT_SCHEMA_VERSION);
+
+      const supervisorColumns = db.prepare("PRAGMA table_info(supervisors)").all() as Array<{
+        name: string;
+      }>;
+      expect(supervisorColumns.map((column) => column.name)).toContain("target_id");
+
+      const upgradedRow = db
+        .prepare("SELECT target_id FROM supervisors WHERE id = ?")
+        .get("sup-legacy") as { target_id: string };
+      expect(upgradedRow.target_id).toBe("legacy_sup-legacy");
+    });
+
     it("should restamp user_version for an already-current schema when it is unset", () => {
       const dbPath = join(tempDir, "current-unstamped.db");
       db = openDatabase(dbPath);

packages/server/src/__tests__/supervisor-integration.test.ts

@@ -3,7 +3,7 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import type { ServerConfig } from "../config.js";
 import { createServer, type Server } from "../server.js";
 import type { SupervisorEvaluationContext } from "../supervisor/context-builder.js";
-import type { SupervisorResult } from "../supervisor/evaluator.js";
+import type { SupervisorEvaluationResult } from "../supervisor/evaluator.js";
 import type { SupervisorManager } from "../supervisor/manager.js";
 import { type CommandContext, dispatch } from "../ws/dispatch.js";
 
@@ -21,7 +21,7 @@ type MutableSupervisorManager = SupervisorManager & {
       supervisor: Supervisor,
       context: SupervisorEvaluationContext,
       options?: { signal?: AbortSignal }
-    ) => Promise<SupervisorResult>;
+    ) => Promise<SupervisorEvaluationResult>;
   };
   logger: unknown;
 };
@@ -103,12 +103,20 @@ describe("Supervisor integration", () => {
         terminalExcerpt: "assistant: built the persistent supervisor repos",
         evidenceSource: "headless_snapshot",
         latestUserInput: "run the tests",
+        targetMemory: {
+          targetId: "tgt-1",
+          planGenerated: false,
+          plan: [],
+          stalledCount: 0,
+          updatedAt: 1,
+        },
       }),
     };
     supervisorManager.evaluator = {
       evaluate: async () => ({
-        message: "",
-        objectiveComplete: false,
+        status: "continue",
+        reason: "Keep going",
+        guidance: "",
       }),
     };
   });