@mndrk/agx 2.3.3 → 2.4.1

package/cloud-runtime/standalone/apps/local/lib/tracker-run-status.ts

@@ -0,0 +1,88 @@
+import type { TrackerRunRecord } from "@/lib/tracker/tracker-run-store";
+
+export type RunDisplayTone = TrackerRunRecord["status"] | "ready";
+
+export function formatRunStatus(status: TrackerRunRecord["status"]): string {
+  switch (status) {
+    case "queued":
+      return "queued";
+    case "running":
+      return "running";
+    case "success":
+      return "success";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return status;
+  }
+}
+
+export function getRunDisplayState(run: TrackerRunRecord): {
+  label: string;
+  tone: RunDisplayTone;
+} {
+  if (run.mode === "chat") {
+    switch (run.status) {
+      case "queued":
+        return { label: "starting", tone: "queued" };
+      case "running":
+        return { label: "thinking", tone: "running" };
+      case "success":
+        return { label: "ready", tone: "ready" };
+      case "failed":
+        return { label: "error", tone: "failed" };
+      case "cancelled":
+        return { label: "stopped", tone: "cancelled" };
+      default:
+        return { label: formatRunStatus(run.status), tone: run.status };
+    }
+  }
+
+  return { label: formatRunStatus(run.status), tone: run.status };
+}
+
+export function getRunTitle(run: TrackerRunRecord): string {
+  const title = run.sessionTitle?.trim();
+  if (title) {
+    return title;
+  }
+  return run.mode === "scripted" ? "Scripted session" : "Chat session";
+}
+
+export const STATUS_LABELS: Record<string, string> = {
+  "In Progress": "In Prog",
+  "In Review": "Review",
+  Backlog: "Backlog",
+  Todo: "Todo",
+  Done: "Done",
+  Cancelled: "Cancl.",
+};
+
+export const STATUS_BADGE_STYLES: Record<RunDisplayTone, string> = {
+  queued: "bg-amber-500/10 border-amber-500/20 text-amber-400",
+  running: "bg-yellow-500/10 border-yellow-500/20 text-yellow-400",
+  ready: "bg-sky-500/10 border-sky-500/20 text-sky-400",
+  success: "bg-emerald-500/10 border-emerald-500/20 text-emerald-400",
+  failed: "bg-red-500/10 border-red-500/20 text-red-400",
+  cancelled: "bg-zinc-500/10 border-zinc-500/20 text-zinc-400",
+};
+
+export const STATUS_DOT_COLORS: Record<RunDisplayTone, string> = {
+  queued: "bg-amber-400",
+  running: "bg-yellow-400",
+  ready: "bg-sky-400",
+  success: "bg-emerald-400",
+  failed: "bg-red-400",
+  cancelled: "bg-zinc-400",
+};
+
+export const STATUS_TEXT_COLORS: Record<RunDisplayTone, string> = {
+  queued: "text-amber-500",
+  running: "text-yellow-500",
+  ready: "text-sky-500",
+  success: "text-green-500",
+  failed: "text-red-500",
+  cancelled: "text-[var(--muted-foreground)]",
+};

package/cloud-runtime/standalone/apps/local/lib/types.ts

@@ -103,6 +103,7 @@ export type ChatEvent =
   | { type: "participant-thinking"; participantId: string }
   | { type: "participant-start"; participantId: string }
   | { type: "text-delta"; participantId: string; delta: string }
+  | { type: "participant-thought"; participantId: string; content: string }
   | { type: "participant-error"; participantId: string; error: string }
   | { type: "message-reactions"; messageId: string; reactions: MessageReaction[] }
   | { type: "participant-end"; participantId: string; messageId?: string; content?: string }

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/objective-worker.ts

@@ -1,9 +1,9 @@
 import { getPromptJobStore } from './get-store';
 import {
-  listObjectiveLinearIssues,
-  filterObjectiveLinearIssuesForAction,
-  isObjectiveLinearTerminalStatus,
-} from '@/lib/objective-linear-issues';
+  listObjectiveTrackerIssues as listObjectiveLinearIssues,
+  filterObjectiveTrackerIssuesForAction as filterObjectiveLinearIssuesForAction,
+  isObjectiveTrackerTerminalStatus as isObjectiveLinearTerminalStatus,
+} from '@/lib/objective-tracker-issues';
 import { getIssueActiveAgents, type IssueActiveAgent } from '@/lib/linear-run-store';
 import { getActivityRepository } from '@/src/objectives/activities/repository';
 import { getNoteRepository } from '@/src/objectives/notes';

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/processor.ts

@@ -8,10 +8,10 @@ import { getAgent, getAgentSkills, getProjectAgents, getTeamAgents } from '@/lib
 import { LOCAL_USER } from '@/lib/auth-mode';
 import { loadDbParticipants } from '@/lib/agent-participants';
 import { runCliResponse, buildCliAttempts, CliRunError } from '@/lib/cli-runner';
-import { startScriptedLinearSession } from '@/lib/linear-scripted-session';
+import { startScriptedTrackerSession } from '@/lib/tracker/scripted-session';
 import {
-  isObjectiveLinearTerminalStatus,
-} from '@/lib/objective-linear-issues';
+  isObjectiveTrackerTerminalStatus as isObjectiveLinearTerminalStatus,
+} from '@/lib/objective-tracker-issues';
 import {
   loadProjectObjectiveContext,
 } from '@/lib/project-objective-context';
@@ -380,7 +380,8 @@ export async function dispatchObjectiveAction(opts: {
       };
     }
 
-    const launch = await startScriptedLinearSession({
+    const launch = await startScriptedTrackerSession({
+      trackerType: 'linear',
       projectId: opts.objectiveContext.project.id,
       projectSlug: opts.objectiveContext.project.slug,
       issue: {
@@ -456,8 +457,8 @@ async function executeJobAction(
     });
   }
 
-  if (job.executionMode === 'linear_worker') {
-    const { executeLinearWorker } = await import('./linear-worker');
+  if (job.executionMode === 'linear_worker' || job.executionMode === 'task_worker') {
+    const { executeLinearWorker } = await import('./task-worker');
     const sessionAgent = await resolveLinearWorkerAgent(job);
     const controllerContext = await resolveJobContextForAgent(job, sessionAgent.id);
     return executeLinearWorker({

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/{linear-worker-constants.ts → task-worker-constants.ts}

@@ -1,15 +1,15 @@
-// TODO(multi-tracker): These constants are Linear-specific. When adding Jira or other trackers:
-//   - Add parallel JIRA_WORKER_* constants (or make a factory that accepts trackerType).
-//   - The DEFAULT_PROMPT and DEFAULT_SCRIPT_PROMPT reference "Linear MCP" — update those
-//     references to use the configured tracker's MCP name dynamically.
-//   - LINEAR_WORKER_DEFAULT_CADENCE can stay shared; it's tracker-agnostic.
-export const LINEAR_WORKER_JOB_NAME = 'Linear worker';
-export const LINEAR_WORKER_DEFAULT_CADENCE = 'every 30 minutes';
+// Task worker constants — tracker-agnostic replacement for linear-worker-constants.
+// Phase 1: These mirror the Linear constants with updated naming.
+// Phase 2: When Jira/GitHub adapters are added, the prompt text will become
+//   tracker-aware (e.g., referencing "the issue tracker MCP" instead of "Linear MCP").
+
+export const TASK_WORKER_JOB_NAME = "Task worker";
+export const TASK_WORKER_DEFAULT_CADENCE = "every 30 minutes";
 
 /**
  * Default selection prompt — guides the controller LLM when picking which ticket to work on.
  */
-export const LINEAR_WORKER_DEFAULT_PROMPT = `Pick the highest-priority actionable ticket. Prefer tickets that:
+export const TASK_WORKER_DEFAULT_PROMPT = `Pick the highest-priority actionable ticket. Prefer tickets that:
 1. Are already started (existing branches, PRs, or prior comments) — continue where you left off.
 2. Are assigned to you or unassigned.
 3. Have the most urgent priority or earliest due date.
@@ -18,12 +18,12 @@ Skip tickets with the \`active-session\` label — another agent is already work
 
 /**
  * Default execution prompt — injected into the agent chat session when working a selected ticket.
- * When empty, the system falls back to the built-in linear execution prompt (buildLinearExecutionPrompt).
+ * When empty, the system falls back to the built-in execution prompt (buildTrackerExecutionPrompt).
  * Supports template variables: {{ticket.identifier}}, {{ticket.title}}, {{ticket.status}},
  * {{ticket.assignee}}, {{project.name}}, {{project.slug}}, {{knowledge_base.root}},
  * {{knowledge_base.issue_path}}, {{worktree.path}}.
  */
-export const LINEAR_WORKER_DEFAULT_SCRIPT_PROMPT = `Work on {{ticket.identifier}}: {{ticket.title}}
+export const TASK_WORKER_DEFAULT_SCRIPT_PROMPT = `Work on {{ticket.identifier}}: {{ticket.title}}
 
 ## Workflow
 
@@ -40,4 +40,4 @@ export const LINEAR_WORKER_DEFAULT_SCRIPT_PROMPT = `Work on {{ticket.identifier}
 - Keep the issue tracker accurate: update status, post comments, link PRs.
 - Add the \`active-session\` label when starting. Remove it when done.
 - Leave everything in a resumable state. Clean up worktrees when finished.
-- One ticket per session.`;
+- One ticket per session.`;

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/task-worker-job.ts

@@ -0,0 +1,49 @@
+// Task worker job helpers — tracker-agnostic replacement for linear-worker-job.
+// Uses executionMode: 'task_worker' instead of 'linear_worker'.
+import { getPromptJobStore } from "./get-store";
+import type { PromptJob } from "./types";
+export {
+  TASK_WORKER_JOB_NAME,
+  TASK_WORKER_DEFAULT_CADENCE,
+  TASK_WORKER_DEFAULT_PROMPT,
+} from "./task-worker-constants";
+import {
+  TASK_WORKER_JOB_NAME,
+  TASK_WORKER_DEFAULT_CADENCE,
+  TASK_WORKER_DEFAULT_PROMPT,
+} from "./task-worker-constants";
+
+export function findTaskWorkerJob(
+  projectId?: string
+): PromptJob | null {
+  const store = getPromptJobStore();
+  const jobs = store.listJobs(projectId ? { projectId } : undefined);
+  return jobs.find((job) => job.executionMode === "task_worker") ?? null;
+}
+
+export function ensureTaskWorkerJob(input: {
+  projectId?: string;
+  prompt?: string;
+  cadence?: string;
+  agentId?: string;
+  provider?: string;
+  model?: string;
+}): PromptJob {
+  const existing = findTaskWorkerJob(input.projectId);
+  if (existing) {
+    return existing;
+  }
+
+  const store = getPromptJobStore();
+  return store.createJob({
+    name: TASK_WORKER_JOB_NAME,
+    prompt: input.prompt || TASK_WORKER_DEFAULT_PROMPT,
+    executionMode: "task_worker",
+    projectId: input.projectId,
+    builtIn: true,
+    cadence: input.cadence || TASK_WORKER_DEFAULT_CADENCE,
+    provider: input.provider ?? "claude",
+    model: input.model,
+    agentId: input.agentId,
+  });
+}

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/{linear-worker.ts → task-worker.ts}

@@ -1,14 +1,20 @@
+// Task worker — tracker-agnostic worker that observes a workspace and decides what to work on.
+// Inlined from the deleted linear-worker.ts with updated imports pointing to
+// tracker-agnostic modules.
+
 import { getPromptJobStore } from './get-store';
 import {
   ensureLinearIssueCache,
   listLinearIssueSummaries,
 } from '@/lib/linear-issues';
 import { getIssueActiveAgents, type IssueActiveAgent } from '@/lib/linear-run-store';
-import { isObjectiveLinearTerminalStatus } from '@/lib/objective-linear-issues';
+import { isObjectiveTrackerTerminalStatus } from '@/lib/objective-tracker-issues';
 import { getDefaultRunner } from '@/src/linear-recap/runner';
 import { readLatestRecap } from '@/src/linear-recap/storage';
 import { runCliResponse } from '@/lib/cli-runner';
-import { startScriptedLinearSession } from '@/lib/linear-scripted-session';
+import {
+  startScriptedTrackerSession,
+} from '@/lib/tracker/scripted-session';
 import type { ChatProvider } from '@/lib/types';
 import type { LinearIssueSummary } from '@/lib/linear-issues';
 import type { Participant } from '@/lib/types';
@@ -18,9 +24,9 @@ import type { PromptJob, ActionReceipt } from './types';
 // System context for the controller LLM
 // ---------------------------------------------------------------------------
 
-const LINEAR_WORKER_SYSTEM_CONTEXT = [
-  'You are deciding what action a Linear workspace worker should take next.',
-  'You are observing the FULL Linear workspace — all teams, all issues.',
+const TASK_WORKER_SYSTEM_CONTEXT = [
+  'You are deciding what action a workspace worker should take next.',
+  'You are observing the FULL workspace — all teams, all issues.',
   'Use the GUIDING PROMPT to prioritize and decide what matters most.',
   'Return ONLY raw JSON with no markdown fences or commentary.',
   'Valid responses:',
@@ -101,7 +107,7 @@ async function sweepStaleRecaps(issues: LinearIssueSummary[]): Promise<void> {
   const runner = getDefaultRunner();
   const now = Date.now();
   for (const issue of issues) {
-    if (isObjectiveLinearTerminalStatus(issue.status ?? '')) continue;
+    if (isObjectiveTrackerTerminalStatus(issue.status ?? '')) continue;
     const latest = await readLatestRecap(issue.id);
     const isStale =
       !latest || now - latest.generatedAt.getTime() > RECAP_STALENESS_MS;
@@ -126,21 +132,24 @@ function formatIssueLine(issue: LinearIssueSummary): string {
 }
 
 // ---------------------------------------------------------------------------
-// buildLinearWorkerObservation
+// buildTaskWorkerObservation (was buildLinearWorkerObservation)
 // ---------------------------------------------------------------------------
 
-export interface LinearWorkerObservation {
+export interface TaskWorkerObservation {
   prompt: string;
   issues: LinearIssueSummary[];
   eligibleIssues: LinearIssueSummary[];
   activeIssueAgents: IssueActiveAgent[];
 }
 
-export async function buildLinearWorkerObservation(opts: {
+// Keep the old name as an alias for backward compat within this file
+export type LinearWorkerObservation = TaskWorkerObservation;
+
+export async function buildTaskWorkerObservation(opts: {
   job: PromptJob;
   projectId: string;
   projectSlug?: string;
-}): Promise<LinearWorkerObservation> {
+}): Promise<TaskWorkerObservation> {
   const { job, projectId, projectSlug } = opts;
 
   // Refresh the cache and fetch all issues
@@ -164,17 +173,17 @@ export async function buildLinearWorkerObservation(opts: {
   const activeIssueIds = new Set(activeIssueAgents.map((a) => a.issueId));
   const eligibleIssues = issues.filter(
     (issue) =>
-      !isObjectiveLinearTerminalStatus(issue.status) &&
+      !isObjectiveTrackerTerminalStatus(issue.status) &&
       !activeIssueIds.has(issue.id),
   );
 
-  // Gather scheduled tasks (linear worker jobs, excluding current)
+  // Gather scheduled tasks (task worker jobs, excluding current)
   const store = getPromptJobStore();
   const allJobs = store.listJobs(
     opts.projectId ? { projectId: opts.projectId } : undefined,
   );
   const scheduledTasks = allJobs.filter(
-    (j) => j.id !== job.id && j.executionMode === 'linear_worker',
+    (j) => j.id !== job.id && (j.executionMode === 'linear_worker' || j.executionMode === 'task_worker'),
   );
 
   // Assemble the prompt sections
@@ -200,11 +209,11 @@ export async function buildLinearWorkerObservation(opts: {
   if (issues.length > 0) {
     sections.push(
       '',
-      'ALL LINEAR TICKETS',
+      'ALL TICKETS',
       issues.map((issue) => formatIssueLine(issue)).join('\n\n'),
     );
   } else {
-    sections.push('', 'ALL LINEAR TICKETS', '- None.');
+    sections.push('', 'ALL TICKETS', '- None.');
   }
 
   // ACTIVE SESSIONS
@@ -218,11 +227,11 @@ export async function buildLinearWorkerObservation(opts: {
     );
   }
 
-  // OTHER LINEAR WORKERS
+  // OTHER WORKERS
   if (scheduledTasks.length > 0) {
     sections.push(
       '',
-      'OTHER LINEAR WORKERS',
+      'OTHER WORKERS',
       ...scheduledTasks.map(
         (t) =>
           `- ${t.name} | state: ${t.state} | last outcome: ${t.lastOutcome ?? 'none'}`,
@@ -261,11 +270,14 @@ export async function buildLinearWorkerObservation(opts: {
   };
 }
 
+// Backward-compatible alias
+export const buildLinearWorkerObservation = buildTaskWorkerObservation;
+
 // ---------------------------------------------------------------------------
-// executeLinearWorker — the observe -> decide -> act pipeline
+// executeTaskWorker (was executeLinearWorker) — the observe -> decide -> act pipeline
 // ---------------------------------------------------------------------------
 
-export async function executeLinearWorker(opts: {
+export async function executeTaskWorker(opts: {
   job: PromptJob;
   controllerContext: {
     provider: ChatProvider;
@@ -284,14 +296,14 @@ export async function executeLinearWorker(opts: {
     if (!opts.job.projectId) {
       return {
         output: '',
-        error: 'Linear worker job missing projectId',
+        error: 'Task worker job missing projectId',
         durationMs: Date.now() - startMs,
         status: 'failed',
       };
     }
 
     // Phase 1: Observe - gather full workspace state
-    const observation = await buildLinearWorkerObservation({
+    const observation = await buildTaskWorkerObservation({
       job: opts.job,
       projectId: opts.job.projectId,
       projectSlug: undefined,
@@ -304,7 +316,7 @@ export async function executeLinearWorker(opts: {
     const controllerResult = await executePrompt({
       ...opts.controllerContext,
       prompt: observation.prompt,
-      systemContext: LINEAR_WORKER_SYSTEM_CONTEXT,
+      systemContext: TASK_WORKER_SYSTEM_CONTEXT,
       cliArgs: opts.cliArgs,
       onSpawn: opts.onSpawn,
     });
@@ -312,7 +324,7 @@ export async function executeLinearWorker(opts: {
     if (controllerResult.status !== 'success') {
       return {
         ...controllerResult,
-        output: controllerResult.output || 'Linear worker controller failed before selecting an action.',
+        output: controllerResult.output || 'Task worker controller failed before selecting an action.',
       };
     }
 
@@ -327,7 +339,7 @@ export async function executeLinearWorker(opts: {
     const reason = typeof parsed?.reason === 'string' ? parsed.reason.trim() : '';
 
     // Phase 4: Act - dispatch action
-    const receipt = await dispatchLinearWorkerAction({
+    const receipt = await dispatchTaskWorkerAction({
       action,
       parsed,
       reason,
@@ -357,11 +369,14 @@ export async function executeLinearWorker(opts: {
   }
 }
 
+// Backward-compatible alias
+export const executeLinearWorker = executeTaskWorker;
+
 // ---------------------------------------------------------------------------
-// dispatchLinearWorkerAction
+// dispatchTaskWorkerAction (was dispatchLinearWorkerAction)
 // ---------------------------------------------------------------------------
 
-async function dispatchLinearWorkerAction(opts: {
+async function dispatchTaskWorkerAction(opts: {
   action: string;
   parsed: Record<string, unknown> | null;
   reason: string;
@@ -384,11 +399,11 @@ async function dispatchLinearWorkerAction(opts: {
 
   if (action === 'stop') {
     const hasNonTerminalIssues = opts.issues.some(
-      (issue) => !isObjectiveLinearTerminalStatus(issue.status),
+      (issue) => !isObjectiveTrackerTerminalStatus(issue.status),
     );
     const fallbackReason =
       opts.issues.length === 0
-        ? 'No Linear tickets were found in the workspace.'
+        ? 'No tickets were found in the workspace.'
         : opts.eligibleIssues.length === 0
           ? hasNonTerminalIssues
             ? 'All actionable tickets already have active sessions.'
@@ -459,13 +474,14 @@ async function dispatchLinearWorkerAction(opts: {
         action: 'work_ticket',
         jobName: opts.job.name,
         reason,
-        result: 'Linear worker requires a project context to start a scripted session.',
+        result: 'Task worker requires a project context to start a scripted session.',
         durationMs: Date.now() - opts.startMs,
         status: 'failed',
       };
     }
 
-    const launch = await startScriptedLinearSession({
+    const launch = await startScriptedTrackerSession({
+      trackerType: 'linear',
       projectId: opts.job.projectId,
       projectSlug: opts.job.projectId,
       issue: {
@@ -490,7 +506,7 @@ async function dispatchLinearWorkerAction(opts: {
       result: [
         `Started work on ${issueLink}: ${selectedIssue.title}`,
         reason ? `Reason: ${reason}` : null,
-        `Linear run: ${launch.run.id}`,
+        `Run: ${launch.run.id}`,
       ]
         .filter((line): line is string => Boolean(line))
         .join('\n\n'),

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/types.ts

@@ -3,7 +3,7 @@ export type OverlapPolicy = 'skip' | 'queue' | 'allow';
 export type CatchUpPolicy = 'fire_once' | 'replay_all' | 'skip';
 export type RunStatus = 'queued' | 'running' | 'success' | 'failed' | 'cancelled';
 export type TriggerType = 'scheduled' | 'condition';
-export type PromptJobExecutionMode = 'prompt' | 'objective_worker' | 'linear_worker';
+export type PromptJobExecutionMode = 'prompt' | 'objective_worker' | 'linear_worker' | 'task_worker';
 
 export type ObjectiveActionType = 'work_ticket' | 'run_prompt' | 'stop';
 
@@ -43,10 +43,12 @@ export interface PromptJob {
   catchUpPolicy: CatchUpPolicy;
   cancelCheckSec: number;
   executionMode: PromptJobExecutionMode;
-  /** For linear_worker: the prompt injected into the agent chat session when working a ticket. */
+  /** For linear_worker/task_worker: the prompt injected into the agent chat session when working a ticket. */
   scriptPrompt: string;
-  /** For linear_worker: the team whose agents participate in the linear chat session. */
+  /** For linear_worker/task_worker: the team whose agents participate in the chat session. */
   teamId: string;
+  /** For task_worker: which tracker adapter to use (e.g. 'linear', 'jira'). Defaults to 'linear'. */
+  trackerType?: string;
   /** True for system-managed jobs that cannot be deleted by users */
   builtIn?: boolean;
   condition: string;

package/cloud-runtime/standalone/apps/local/state/lastSession.test.ts

@@ -0,0 +1,83 @@
+import {
+  loadLastRunForIssue,
+  persistLastRunForIssue,
+  loadLastSessionForEntity,
+  persistLastSessionForEntity,
+} from "./lastSession";
+
+type Storage = Record<string, string>;
+
+function withFakeLocalStorage<T>(callback: (storage: Storage) => T): T {
+  const originalWindow = globalThis.window;
+  const storage: Storage = {};
+  const fakeLocalStorage = {
+    getItem(key: string) { return storage[key] ?? null; },
+    setItem(key: string, value: string) { storage[key] = value; },
+    removeItem(key: string) { delete storage[key]; },
+  };
+  globalThis.window = { localStorage: fakeLocalStorage } as unknown as Window;
+  try {
+    return callback(storage);
+  } finally {
+    globalThis.window = originalWindow;
+  }
+}
+
+describe("lastSession", () => {
+  describe("run storage", () => {
+    test("returns null when no run stored for issue", () => {
+      withFakeLocalStorage(() => {
+        expect(loadLastRunForIssue("issue-1")).toBeNull();
+      });
+    });
+
+    test("persists and loads run for issue", () => {
+      withFakeLocalStorage(() => {
+        persistLastRunForIssue("issue-1", "run-abc");
+        expect(loadLastRunForIssue("issue-1")).toBe("run-abc");
+      });
+    });
+
+    test("overwriting persists the latest run", () => {
+      withFakeLocalStorage(() => {
+        persistLastRunForIssue("issue-1", "run-abc");
+        persistLastRunForIssue("issue-1", "run-xyz");
+        expect(loadLastRunForIssue("issue-1")).toBe("run-xyz");
+      });
+    });
+
+    test("stores runs for multiple issues independently", () => {
+      withFakeLocalStorage(() => {
+        persistLastRunForIssue("issue-1", "run-a");
+        persistLastRunForIssue("issue-2", "run-b");
+        expect(loadLastRunForIssue("issue-1")).toBe("run-a");
+        expect(loadLastRunForIssue("issue-2")).toBe("run-b");
+      });
+    });
+  });
+
+  describe("session storage", () => {
+    test("returns null when no session stored for entity", () => {
+      withFakeLocalStorage(() => {
+        expect(loadLastSessionForEntity("obj-1")).toBeNull();
+      });
+    });
+
+    test("persists and loads session for entity", () => {
+      withFakeLocalStorage(() => {
+        persistLastSessionForEntity("obj-1", "session-abc");
+        expect(loadLastSessionForEntity("obj-1")).toBe("session-abc");
+      });
+    });
+
+    test("run and session maps are stored independently", () => {
+      withFakeLocalStorage(() => {
+        persistLastRunForIssue("issue-1", "run-a");
+        persistLastSessionForEntity("obj-1", "session-b");
+        expect(loadLastRunForIssue("issue-1")).toBe("run-a");
+        expect(loadLastSessionForEntity("obj-1")).toBe("session-b");
+      });
+    });
+  });
+
+});

package/cloud-runtime/standalone/apps/local/state/lastSession.ts

@@ -0,0 +1,46 @@
+const LAST_RUN_KEY = "agx:lastRun";
+const LAST_SESSION_KEY = "agx:lastSession";
+
+function isStorageAvailable(): boolean {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+
+function loadMap(key: string): Record<string, string> {
+  if (!isStorageAvailable()) return {};
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return {};
+    return JSON.parse(raw) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
+function saveMap(key: string, map: Record<string, string>): void {
+  if (!isStorageAvailable()) return;
+  try {
+    window.localStorage.setItem(key, JSON.stringify(map));
+  } catch {
+    // ignore quota errors
+  }
+}
+
+export function loadLastRunForIssue(issueId: string): string | null {
+  return loadMap(LAST_RUN_KEY)[issueId] ?? null;
+}
+
+export function persistLastRunForIssue(issueId: string, runId: string): void {
+  const map = loadMap(LAST_RUN_KEY);
+  map[issueId] = runId;
+  saveMap(LAST_RUN_KEY, map);
+}
+
+export function loadLastSessionForEntity(entityId: string): string | null {
+  return loadMap(LAST_SESSION_KEY)[entityId] ?? null;
+}
+
+export function persistLastSessionForEntity(entityId: string, sessionId: string): void {
+  const map = loadMap(LAST_SESSION_KEY);
+  map[entityId] = sessionId;
+  saveMap(LAST_SESSION_KEY, map);
+}