@mndrk/agx 2.0.46 → 2.0.48

package/cloud-runtime/standalone/lib/cli-runner.ts

@@ -5,6 +5,7 @@ import type { ChatProvider } from "./types";
 import { createCliChunkSanitizer } from "./sanitize";
 import { writeDebugLog } from "./debug-log";
 import { buildSpawnEnv, commandExists } from "./shell-env";
+import { buildScheduledTaskSkillPromptContext } from "./scheduled-task-skill";
 
 const isNonEmptyString = (value: unknown): value is string =>
   typeof value === "string" && value.trim().length > 0;
@@ -711,12 +712,12 @@ export async function runCliResponse({
     if (cleaned) onDelta(cleaned);
   };
 
-  const systemParts: string[] = [];
-  if (systemContext) systemParts.push(systemContext);
-  if (identity) systemParts.push(`<identity>\n${identity}\n</identity>`);
-  if (self) systemParts.push(`<self>\n${self}\n</self>`);
-  if (skills) systemParts.push(`<skills>\n${skills}\n</skills>`);
-  const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
+  const systemPrompt = buildCliSystemPrompt({
+    identity,
+    self,
+    skills,
+    systemContext,
+  });
   const attempts = buildCliAttempts({
     provider,
     model,
@@ -789,3 +790,23 @@ export async function runCliResponse({
 
   throw lastError || new Error("CLI execution failed.");
 }
+
+export function buildCliSystemPrompt({
+  identity,
+  self,
+  skills,
+  systemContext,
+}: {
+  identity?: string;
+  self?: string;
+  skills?: string;
+  systemContext?: string;
+}): string | undefined {
+  const systemParts: string[] = [];
+  if (systemContext) systemParts.push(systemContext);
+  systemParts.push(buildScheduledTaskSkillPromptContext());
+  if (identity) systemParts.push(`<identity>\n${identity}\n</identity>`);
+  if (self) systemParts.push(`<self>\n${self}\n</self>`);
+  if (skills) systemParts.push(`<skills>\n${skills}\n</skills>`);
+  return systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
+}

package/cloud-runtime/standalone/lib/linear-client.ts

@@ -1,9 +1,12 @@
 import "server-only";
 
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import path from "node:path";
 
-const TOKEN_PATH = ".linear-token.json";
+const AGX_DIR = path.join(homedir(), ".agx");
+const TOKEN_FILENAME = "linear-token.json";
+const LEGACY_TOKEN_PATH = ".linear-token.json";
 const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
 
 interface LinearToken {
@@ -127,19 +130,40 @@ interface LinearIssueConnection {
 }
 
 function getTokenPath(): string {
-  return path.join(process.cwd(), TOKEN_PATH);
+  return path.join(AGX_DIR, TOKEN_FILENAME);
+}
+
+function getLegacyTokenPath(): string {
+  return path.join(process.cwd(), LEGACY_TOKEN_PATH);
 }
 
 export function getLinearToken(): LinearToken | null {
+  // Try the canonical path first
   try {
     const raw = readFileSync(getTokenPath(), "utf8");
     return JSON.parse(raw) as LinearToken;
+  } catch {
+    // fall through
+  }
+
+  // Migrate from legacy cwd-relative path
+  try {
+    const legacyPath = getLegacyTokenPath();
+    const raw = readFileSync(legacyPath, "utf8");
+    const token = JSON.parse(raw) as LinearToken;
+    // Save to new location and clean up old file
+    saveLinearToken(token);
+    try { unlinkSync(legacyPath); } catch { /* ignore */ }
+    return token;
   } catch {
     return null;
   }
 }
 
 export function saveLinearToken(token: LinearToken): void {
+  if (!existsSync(AGX_DIR)) {
+    mkdirSync(AGX_DIR, { recursive: true });
+  }
   writeFileSync(getTokenPath(), JSON.stringify(token, null, 2));
 }
 
@@ -149,6 +173,12 @@ export function deleteLinearToken(): void {
   } catch {
     // already gone
   }
+  // Also clean up legacy location
+  try {
+    unlinkSync(getLegacyTokenPath());
+  } catch {
+    // already gone
+  }
 }
 
 function serializeGraphQLValue(value: unknown): string {

package/cloud-runtime/standalone/lib/linear-execution-prompt.ts

@@ -29,6 +29,26 @@ export interface LinearExecutionPromptInput {
   runtime?: LinearExecutionRuntimeContext | null;
 }
 
+export interface ResolvedLinearExecutionContext {
+  issue: {
+    identifier: string;
+    title: string;
+    status: string;
+    assignee: string;
+  };
+  project: {
+    name: string;
+    slug: string;
+    label: string;
+    repos: LinearExecutionProjectRepoContext[];
+  };
+  runtime: {
+    knowledgeBaseRoot: string;
+    issueKnowledgePath: string;
+    isolatedWorktreePath: string;
+  };
+}
+
 function slugifySegment(value: string, fallback: string): string {
   const slug = value
     .trim()
@@ -95,19 +115,14 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
   prompt: string;
   promptPrefix: string;
 } {
-  const issueIdentifier = input.issue.identifier.trim() || "TICKET-ID";
-  const issueTitle = input.issue.title.trim() || "Untitled ticket";
-  const issueStatus = String(input.issue.status ?? "").trim() || "Unknown";
-  const issueAssignee = String(input.issue.assignee ?? "").trim() || "Unassigned";
-  const projectSlug = toProjectSlug(input.project);
-  const knowledgeBaseRoot =
-    String(input.runtime?.knowledgeBaseRoot ?? "").trim() || `~/.agx/vault/${projectSlug}`;
-  const issueKnowledgePath =
-    String(input.runtime?.issueKnowledgePath ?? "").trim() ||
-    `${knowledgeBaseRoot}/issues/${issueIdentifier}/`;
-  const isolatedWorktreePath =
-    String(input.runtime?.isolatedWorktreePath ?? "").trim() ||
-    `/tmp/agx-${slugifySegment(issueIdentifier, "ticket")}`;
+  const context = resolveLinearExecutionContext(input);
+  const issueIdentifier = context.issue.identifier;
+  const issueTitle = context.issue.title;
+  const issueStatus = context.issue.status;
+  const issueAssignee = context.issue.assignee;
+  const knowledgeBaseRoot = context.runtime.knowledgeBaseRoot;
+  const issueKnowledgePath = context.runtime.issueKnowledgePath;
+  const isolatedWorktreePath = context.runtime.isolatedWorktreePath;
 
   const promptPrefix = [
     "LINEAR TASK EXECUTION",
@@ -118,13 +133,13 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
       `- Title: ${issueTitle}`,
       `- Current status: ${issueStatus}`,
       `- Current assignee: ${issueAssignee}`,
-      `- Project: ${toProjectLabel(input.project)}`,
+      `- Project: ${context.project.label}`,
       `- Knowledge base root: ${knowledgeBaseRoot}`,
       `- Issue knowledge path: ${issueKnowledgePath}`,
       `- Suggested isolated worktree: ${isolatedWorktreePath}`,
       "- Additional project resources such as repo knowledge, project memory, and project variables are injected separately by the active project context.",
     ].join("\n"),
-    `SOURCE REPOSITORIES\n${formatRepositories(input.project?.repos)}`,
+    `SOURCE REPOSITORIES\n${formatRepositories(context.project.repos)}`,
     [
       "WORKFLOW",
       "1. Read the full Linear issue and comment thread before acting. Use Linear MCP for issue details, comments, state changes, and follow-up.",
@@ -151,3 +166,65 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
     promptPrefix,
   };
 }
+
+export function resolveLinearExecutionContext(
+  input: LinearExecutionPromptInput
+): ResolvedLinearExecutionContext {
+  const issueIdentifier = input.issue.identifier.trim() || "TICKET-ID";
+  const issueTitle = input.issue.title.trim() || "Untitled ticket";
+  const issueStatus = String(input.issue.status ?? "").trim() || "Unknown";
+  const issueAssignee = String(input.issue.assignee ?? "").trim() || "Unassigned";
+  const projectSlug = toProjectSlug(input.project);
+  const projectName = String(input.project?.name ?? "").trim() || projectSlug;
+  const knowledgeBaseRoot =
+    String(input.runtime?.knowledgeBaseRoot ?? "").trim() || `~/.agx/vault/${projectSlug}`;
+  const issueKnowledgePath =
+    String(input.runtime?.issueKnowledgePath ?? "").trim() ||
+    `${knowledgeBaseRoot}/issues/${issueIdentifier}/`;
+  const isolatedWorktreePath =
+    String(input.runtime?.isolatedWorktreePath ?? "").trim() ||
+    `/tmp/agx-${slugifySegment(issueIdentifier, "ticket")}`;
+
+  return {
+    issue: {
+      identifier: issueIdentifier,
+      title: issueTitle,
+      status: issueStatus,
+      assignee: issueAssignee,
+    },
+    project: {
+      name: projectName,
+      slug: projectSlug,
+      label: toProjectLabel(input.project),
+      repos: input.project?.repos ? [...input.project.repos] : [],
+    },
+    runtime: {
+      knowledgeBaseRoot,
+      issueKnowledgePath,
+      isolatedWorktreePath,
+    },
+  };
+}
+
+export function renderLinearExecutionPromptTemplate(
+  template: string,
+  input: LinearExecutionPromptInput
+): string {
+  const context = resolveLinearExecutionContext(input);
+  const values: Record<string, string> = {
+    "ticket.identifier": context.issue.identifier,
+    "ticket.title": context.issue.title,
+    "ticket.status": context.issue.status,
+    "ticket.assignee": context.issue.assignee,
+    "project.name": context.project.name,
+    "project.slug": context.project.slug,
+    "project.label": context.project.label,
+    "knowledge_base.root": context.runtime.knowledgeBaseRoot,
+    "knowledge_base.issue_path": context.runtime.issueKnowledgePath,
+    "worktree.path": context.runtime.isolatedWorktreePath,
+  };
+
+  return template.replace(/\{\{\s*([a-zA-Z0-9._-]+)\s*\}\}/g, (_match, key: string) => {
+    return values[key] ?? "";
+  });
+}

package/cloud-runtime/standalone/lib/linear-issue-store.ts

@@ -87,7 +87,7 @@ export interface LinearIssueSyncState {
 
 export interface ListCachedLinearIssuesInput {
   search?: string;
-  status?: string;
+  statuses?: string[];
   assigneeIds?: string[];
   assignedToMe?: boolean;
   teamId?: string;
@@ -104,6 +104,10 @@ export interface ListCachedLinearIssuesResult {
   };
 }
 
+interface LinearIssueStatusRow {
+  status: string;
+}
+
 function toOptionalString(value: string | null | undefined): string | null {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
@@ -343,10 +347,17 @@ export async function listCachedLinearIssues(
       params.push(pattern, pattern, pattern);
     }
 
-    const status = toOptionalString(input.status ?? null);
-    if (status) {
-      clauses.push("LOWER(status) = ?");
-      params.push(status.toLowerCase());
+    const statuses = Array.from(
+      new Set(
+        (input.statuses ?? [])
+          .map((status) => toOptionalString(status))
+          .filter((status): status is string => Boolean(status))
+          .map((status) => status.toLowerCase())
+      )
+    );
+    if (statuses.length > 0) {
+      clauses.push(`LOWER(status) IN (${statuses.map(() => "?").join(", ")})`);
+      params.push(...statuses);
     }
 
     const assigneeIds = Array.from(
@@ -402,6 +413,23 @@ export async function listCachedLinearIssues(
   });
 }
 
+export async function listCachedLinearIssueStatuses(): Promise<string[]> {
+  return withLinearIssueDatabase((db) => {
+    const rows = db
+      .prepare(
+        `SELECT DISTINCT status
+         FROM linear_issues
+         WHERE TRIM(status) <> ''
+         ORDER BY LOWER(status) ASC`
+      )
+      .all() as unknown as LinearIssueStatusRow[];
+
+    return rows
+      .map((row) => row.status.trim())
+      .filter(Boolean);
+  });
+}
+
 export async function getCachedLinearIssueContexts(issueIds: string[]): Promise<CachedLinearIssueRecord[]> {
   const normalizedIds = Array.from(
     new Set(

package/cloud-runtime/standalone/lib/scheduled-task-skill.ts

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const SCHEDULED_TASK_SKILL_ID = "scheduled-task-manager";
+
+type ScheduledTaskSkillOptions = {
+  agxDataDir?: string;
+  workspaceRoot?: string;
+};
+
+function toDisplayPath(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+function resolveAgxDataDir(explicitDir?: string): string {
+  const trimmed = explicitDir?.trim();
+  if (trimmed) return trimmed;
+  const configured = process.env.AGX_DATA_DIR?.trim();
+  if (configured) return configured;
+  return path.join(os.homedir(), ".agx");
+}
+
+function resolveWorkspaceRoot(explicitRoot?: string): string {
+  const trimmed = explicitRoot?.trim();
+  if (trimmed) return trimmed;
+  return process.cwd();
+}
+
+export function getScheduledTaskSkillPath(options: ScheduledTaskSkillOptions = {}): string {
+  return path.join(
+    resolveAgxDataDir(options.agxDataDir),
+    "skills",
+    SCHEDULED_TASK_SKILL_ID,
+    "SKILL.md",
+  );
+}
+
+export function buildScheduledTaskSkillContent(options: ScheduledTaskSkillOptions = {}): string {
+  const workspaceRoot = resolveWorkspaceRoot(options.workspaceRoot);
+  const specPath = toDisplayPath(path.join(workspaceRoot, "planning", "automation-frontmatter-migration-spec.md"));
+  const automationsDir = toDisplayPath(path.join(workspaceRoot, "src", "automations"));
+  const promptSchedulerDir = toDisplayPath(path.join(workspaceRoot, "src", "prompt-scheduler"));
+  const graphScheduleRunnerPath = toDisplayPath(path.join(workspaceRoot, "src", "graph", "schedule-runner.ts"));
+  const graphStorePath = toDisplayPath(path.join(workspaceRoot, "src", "graph", "store.ts"));
+  const automationsRoutePath = toDisplayPath(path.join(workspaceRoot, "app", "api", "automations", "route.ts"));
+  const promptJobsRoutePath = toDisplayPath(path.join(workspaceRoot, "app", "api", "prompt-jobs", "route.ts"));
+
+  return `---
+name: scheduled-task-manager
+description: Use when creating, editing, migrating, debugging, or reviewing AGX scheduled tasks, automations, prompt jobs, execution graph schedules, or frontmatter-backed automation definitions.
+---
+
+# Scheduled Task Manager
+
+Use this skill whenever the task touches scheduled tasks, automations, prompt jobs, execution graph schedules, or automation frontmatter.
+
+## Read First
+
+- [automation-frontmatter-migration-spec](${specPath})
+- Shared automation model lives in [src/automations](${automationsDir})
+- Prompt-job scheduling lives in [src/prompt-scheduler](${promptSchedulerDir})
+- Execution-graph scheduling flows through [schedule-runner.ts](${graphScheduleRunnerPath}) and [store.ts](${graphStorePath})
+- API entry points are [app/api/automations/route.ts](${automationsRoutePath}) and [app/api/prompt-jobs/route.ts](${promptJobsRoutePath})
+
+## Guardrails
+
+- Reject malformed frontmatter. Do not coerce invalid enum values into defaults.
+- Preserve stable automation ids. Renaming a task must not create a new id.
+- Keep runtime state such as last run, next run, and archival flags out of frontmatter unless the spec explicitly says otherwise.
+- Preserve sub-minute scheduled cadences when they are represented as \`intervalMs\`.
+- For \`execution_graph\` targets, keep \`graphId\` and \`taskId\` resolution correct. Do not assume \`definition.id === taskId\`.
+- Updating an automation definition should advance user-visible \`updatedAt\`.
+- Avoid eager file-backed repository initialization on request paths that should stay lazy or rollout-gated.
+- Keep parser and serializer behavior round-trippable unless the spec explicitly requires normalization.
+
+## Working Pattern
+
+1. Read the migration spec before changing storage, rollout, or validation behavior.
+2. Trace the full path: parser -> validation -> repository -> scheduler -> API.
+3. Add or update regression tests for parsing, serialization, due selection, and the affected API or runtime path.
+4. Prefer small fixes in the shared automation layer over duplicating logic in adapters.
+
+## Validation Checklist
+
+- Scheduled triggers keep \`cronExpr\`, \`cadence\`, and sub-minute \`intervalMs\` semantics intact.
+- Condition triggers validate required fields and reject unsupported polling intervals.
+- Target-specific required fields are enforced.
+- Invalid definitions fail closed and are excluded instead of silently rewritten.
+- Prompt-job and execution-graph adapters preserve the same runtime meaning before and after frontmatter serialization.
+`;
+}
+
+export function ensureScheduledTaskSkillInstalled(options: ScheduledTaskSkillOptions = {}): string {
+  const skillPath = getScheduledTaskSkillPath(options);
+  const skillContent = buildScheduledTaskSkillContent(options);
+
+  try {
+    fs.mkdirSync(path.dirname(skillPath), { recursive: true });
+    const existing = fs.existsSync(skillPath) ? fs.readFileSync(skillPath, "utf8") : null;
+    if (existing !== skillContent) {
+      fs.writeFileSync(skillPath, skillContent, "utf8");
+    }
+  } catch (error) {
+    console.warn("[scheduled-task-skill] Failed to install skill:", error);
+  }
+
+  return skillPath;
+}
+
+export function buildScheduledTaskSkillPromptContext(options: ScheduledTaskSkillOptions = {}): string {
+  const skillPath = ensureScheduledTaskSkillInstalled(options);
+  return [
+    "<scheduled-task-skill>",
+    `Path: ${toDisplayPath(skillPath)}`,
+    "Read this skill whenever the task involves scheduled tasks, automations, prompt jobs, execution graph schedules, or frontmatter-backed automation definitions.",
+    "</scheduled-task-skill>",
+  ].join("\n");
+}

package/cloud-runtime/standalone/state/automations/.state/c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc.json

@@ -0,0 +1,8 @@
+{
+  "scheduleHash": "218b10daaa347ad14c3a8fbaabee0cff119839d6f5b6c5c3aaf7ed2eac4484f1",
+  "nextRunAt": 1775643300000,
+  "lastRunAt": null,
+  "lastOutcome": null,
+  "lastError": null,
+  "updatedAt": "2026-04-08T09:50:53.809Z"
+}

package/cloud-runtime/standalone/state/automations/active/c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc.md

@@ -0,0 +1,15 @@
+---
+id: c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc
+name: 'Agx Agent: Work On Linear Tickets'
+projectId: f354bbf2-cfed-473f-890c-e592209313da
+state: active
+trigger:
+  type: scheduled
+  cadence: 15 * * * *
+  cronExpr: 15 * * * *
+target:
+  type: prompt_job
+  provider: claude
+createdAt: '2026-04-08T09:50:53.793Z'
+---
+Execute `/Users/mendrika/Projects/Agents/agx-game-vault/agx-game-vault/scheduled-tasks/work-linear-tickets.md`

package/cloud-runtime/standalone/state/linearBoardFilters.ts

@@ -0,0 +1,90 @@
+const LINEAR_BOARD_FILTERS_STORAGE_PREFIX = "agx-linear:boardFilters";
+
+export interface LinearBoardFilters {
+  search: string;
+  assigneeIds: string[];
+  statuses: string[];
+  teamId: string;
+  cycleId: string;
+}
+
+const DEFAULT_LINEAR_BOARD_FILTERS: LinearBoardFilters = {
+  search: "",
+  assigneeIds: [],
+  statuses: [],
+  teamId: "",
+  cycleId: "",
+};
+
+function isStorageAvailable(): boolean {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+
+function normalizeStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return Array.from(
+    new Set(
+      value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter(Boolean)
+    )
+  );
+}
+
+export function getLinearBoardFiltersStorageKey(projectSlug?: string | null): string {
+  const normalizedProjectSlug = String(projectSlug ?? "").trim().toLowerCase();
+  return normalizedProjectSlug
+    ? `${LINEAR_BOARD_FILTERS_STORAGE_PREFIX}:${normalizedProjectSlug}`
+    : `${LINEAR_BOARD_FILTERS_STORAGE_PREFIX}:global`;
+}
+
+export function loadLinearBoardFilters(projectSlug?: string | null): LinearBoardFilters {
+  if (!isStorageAvailable()) {
+    return { ...DEFAULT_LINEAR_BOARD_FILTERS };
+  }
+
+  const raw = window.localStorage.getItem(getLinearBoardFiltersStorageKey(projectSlug));
+  if (!raw) {
+    return { ...DEFAULT_LINEAR_BOARD_FILTERS };
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<LinearBoardFilters>;
+    return {
+      search: typeof parsed.search === "string" ? parsed.search : DEFAULT_LINEAR_BOARD_FILTERS.search,
+      assigneeIds: normalizeStringArray(parsed.assigneeIds),
+      statuses: normalizeStringArray(parsed.statuses),
+      teamId: typeof parsed.teamId === "string" ? parsed.teamId : DEFAULT_LINEAR_BOARD_FILTERS.teamId,
+      cycleId: typeof parsed.cycleId === "string" ? parsed.cycleId : DEFAULT_LINEAR_BOARD_FILTERS.cycleId,
+    };
+  } catch {
+    return { ...DEFAULT_LINEAR_BOARD_FILTERS };
+  }
+}
+
+export function persistLinearBoardFilters(
+  projectSlug: string | null | undefined,
+  filters: LinearBoardFilters
+): void {
+  if (!isStorageAvailable()) {
+    return;
+  }
+
+  try {
+    window.localStorage.setItem(
+      getLinearBoardFiltersStorageKey(projectSlug),
+      JSON.stringify({
+        search: filters.search,
+        assigneeIds: normalizeStringArray(filters.assigneeIds),
+        statuses: normalizeStringArray(filters.statuses),
+        teamId: String(filters.teamId || ""),
+        cycleId: String(filters.cycleId || ""),
+      })
+    );
+  } catch {
+    // ignore storage errors
+  }
+}

package/cloud-runtime/standalone/state/linearRunScripts.test.ts

@@ -0,0 +1,99 @@
+import {
+  getLinearRunScriptsStorageKey,
+  loadLinearRunScripts,
+  persistLinearRunScripts,
+} from "./linearRunScripts";
+
+type LocalStorageMap = Record<string, string>;
+
+function withFakeLocalStorage<T>(callback: (storage: LocalStorageMap) => T): T {
+  const originalWindow = globalThis.window;
+  const storage: LocalStorageMap = {};
+  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("linearRunScripts", () => {
+  test("persists and restores scripts per project slug", () => {
+    withFakeLocalStorage((storage) => {
+      const key = getLinearRunScriptsStorageKey("agx-cloud");
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: null,
+        scripts: [],
+      });
+
+      persistLinearRunScripts("agx-cloud", {
+        activeScriptId: "script-1",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Investigation",
+            prompt: "Read {{ticket.identifier}} first.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+
+      expect(storage[key]).toContain("Investigation");
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: "script-1",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Investigation",
+            prompt: "Read {{ticket.identifier}} first.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+
+  test("clears invalid active script ids while preserving valid scripts", () => {
+    withFakeLocalStorage((storage) => {
+      storage[getLinearRunScriptsStorageKey("agx-cloud")] = JSON.stringify({
+        activeScriptId: "missing-script",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Implementation",
+            prompt: "Implement carefully.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: null,
+        scripts: [
+          {
+            id: "script-1",
+            name: "Implementation",
+            prompt: "Implement carefully.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+});