@mndrk/agx 2.0.45 → 2.0.47

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

@@ -87,8 +87,8 @@ export interface LinearIssueSyncState {
 
 export interface ListCachedLinearIssuesInput {
   search?: string;
-  status?: string;
-  assigneeId?: string;
+  statuses?: string[];
+  assigneeIds?: string[];
   assignedToMe?: boolean;
   teamId?: string;
   cycleId?: 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,16 +347,29 @@ 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 assigneeId = toOptionalString(input.assigneeId ?? null);
-    if (assigneeId) {
-      clauses.push("assignee_id = ?");
-      params.push(assigneeId);
+    const assigneeIds = Array.from(
+      new Set(
+        (input.assigneeIds ?? [])
+          .map((assigneeId) => toOptionalString(assigneeId))
+          .filter((assigneeId): assigneeId is string => Boolean(assigneeId))
+      )
+    );
+    if (assigneeIds.length > 0) {
+      clauses.push(`assignee_id IN (${assigneeIds.map(() => "?").join(", ")})`);
+      params.push(...assigneeIds);
     }
 
     if (input.assignedToMe) {
@@ -396,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/24a6a5db-3b14-49c4-841f-29f10f015fbb.json

@@ -1,8 +1,8 @@
 {
   "scheduleHash": "c2ceb4716d31708534c3ced330caffb304cc5e0713572bfdb0893feffd9ddb61",
-  "nextRunAt": 1775620397853,
-  "lastRunAt": 1775616817898,
+  "nextRunAt": 1775642967540,
+  "lastRunAt": 1775639392247,
   "lastOutcome": "success",
   "lastError": null,
-  "updatedAt": "2026-04-08T02:53:37.898Z"
+  "updatedAt": "2026-04-08T09:09:52.248Z"
 }

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/worker/index.js

@@ -287,9 +287,9 @@ function reflectionStatePath(agentId) {
   return (0, import_path5.join)(AGENTS_DIR2, agentId, "reflection-state.json");
 }
 function readSelf(agentId) {
-  const path12 = selfPath(agentId);
-  if (!(0, import_fs5.existsSync)(path12)) return null;
-  const raw = (0, import_fs5.readFileSync)(path12, "utf-8");
+  const path13 = selfPath(agentId);
+  if (!(0, import_fs5.existsSync)(path13)) return null;
+  const raw = (0, import_fs5.readFileSync)(path13, "utf-8");
   if (!raw.trim()) return null;
   const lines = raw.split("\n");
   let version = 0;
@@ -330,10 +330,10 @@ ${content}
   logActivity(agentId, "self-updated", { meta: { version } });
 }
 function readReflectionState(agentId) {
-  const path12 = reflectionStatePath(agentId);
-  if (!(0, import_fs5.existsSync)(path12)) return null;
+  const path13 = reflectionStatePath(agentId);
+  if (!(0, import_fs5.existsSync)(path13)) return null;
   try {
-    const parsed = JSON.parse((0, import_fs5.readFileSync)(path12, "utf-8"));
+    const parsed = JSON.parse((0, import_fs5.readFileSync)(path13, "utf-8"));
     const lastProcessedJournalId = typeof parsed?.lastProcessedJournalId === "string" && parsed.lastProcessedJournalId.trim() ? parsed.lastProcessedJournalId.trim() : null;
     const updatedAt = typeof parsed?.updatedAt === "string" && parsed.updatedAt.trim() ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
     return { lastProcessedJournalId, updatedAt };
@@ -451,9 +451,9 @@ function ensureAgentDir(agentId) {
   }
 }
 function readJournalLines(agentId) {
-  const path12 = journalPath(agentId);
-  if (!(0, import_fs6.existsSync)(path12)) return [];
-  return (0, import_fs6.readFileSync)(path12, "utf-8").split("\n").filter((l) => l.trim());
+  const path13 = journalPath(agentId);
+  if (!(0, import_fs6.existsSync)(path13)) return [];
+  return (0, import_fs6.readFileSync)(path13, "utf-8").split("\n").filter((l) => l.trim());
 }
 function parseMaxSeq(agentId, lines) {
   let maxSeq = 0;
@@ -564,10 +564,10 @@ I am ${agentId}. ${seed}
   }
 }
 function readIdentity(agentId) {
-  const path12 = (0, import_path7.join)(AGENTS_DIR4, agentId, "identity.json");
-  if (!(0, import_fs7.existsSync)(path12)) return null;
+  const path13 = (0, import_path7.join)(AGENTS_DIR4, agentId, "identity.json");
+  if (!(0, import_fs7.existsSync)(path13)) return null;
   try {
-    return JSON.parse((0, import_fs7.readFileSync)(path12, "utf-8"));
+    return JSON.parse((0, import_fs7.readFileSync)(path13, "utf-8"));
   } catch {
     return null;
   }
@@ -8971,6 +8971,111 @@ function commandExists(bin) {
   }
 }
 
+// ../agx-cloud/lib/scheduled-task-skill.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+var SCHEDULED_TASK_SKILL_ID = "scheduled-task-manager";
+function toDisplayPath(value) {
+  return value.replace(/\\/g, "/");
+}
+function resolveAgxDataDir(explicitDir) {
+  const trimmed = explicitDir?.trim();
+  if (trimmed) return trimmed;
+  const configured = process.env.AGX_DATA_DIR?.trim();
+  if (configured) return configured;
+  return import_node_path2.default.join(import_node_os2.default.homedir(), ".agx");
+}
+function resolveWorkspaceRoot(explicitRoot) {
+  const trimmed = explicitRoot?.trim();
+  if (trimmed) return trimmed;
+  return process.cwd();
+}
+function getScheduledTaskSkillPath(options = {}) {
+  return import_node_path2.default.join(
+    resolveAgxDataDir(options.agxDataDir),
+    "skills",
+    SCHEDULED_TASK_SKILL_ID,
+    "SKILL.md"
+  );
+}
+function buildScheduledTaskSkillContent(options = {}) {
+  const workspaceRoot = resolveWorkspaceRoot(options.workspaceRoot);
+  const specPath = toDisplayPath(import_node_path2.default.join(workspaceRoot, "planning", "automation-frontmatter-migration-spec.md"));
+  const automationsDir = toDisplayPath(import_node_path2.default.join(workspaceRoot, "src", "automations"));
+  const promptSchedulerDir = toDisplayPath(import_node_path2.default.join(workspaceRoot, "src", "prompt-scheduler"));
+  const graphScheduleRunnerPath = toDisplayPath(import_node_path2.default.join(workspaceRoot, "src", "graph", "schedule-runner.ts"));
+  const graphStorePath = toDisplayPath(import_node_path2.default.join(workspaceRoot, "src", "graph", "store.ts"));
+  const automationsRoutePath = toDisplayPath(import_node_path2.default.join(workspaceRoot, "app", "api", "automations", "route.ts"));
+  const promptJobsRoutePath = toDisplayPath(import_node_path2.default.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.
+`;
+}
+function ensureScheduledTaskSkillInstalled(options = {}) {
+  const skillPath = getScheduledTaskSkillPath(options);
+  const skillContent = buildScheduledTaskSkillContent(options);
+  try {
+    import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(skillPath), { recursive: true });
+    const existing = import_node_fs2.default.existsSync(skillPath) ? import_node_fs2.default.readFileSync(skillPath, "utf8") : null;
+    if (existing !== skillContent) {
+      import_node_fs2.default.writeFileSync(skillPath, skillContent, "utf8");
+    }
+  } catch (error) {
+    console.warn("[scheduled-task-skill] Failed to install skill:", error);
+  }
+  return skillPath;
+}
+function buildScheduledTaskSkillPromptContext(options = {}) {
+  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");
+}
+
 // ../agx-cloud/lib/cli-runner.ts
 var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
 var createRawParser = (onDelta) => ({
@@ -9505,18 +9610,12 @@ async function runCliResponse({
     const cleaned = sanitize(chunk);
     if (cleaned) onDelta(cleaned);
   };
-  const systemParts = [];
-  if (systemContext) systemParts.push(systemContext);
-  if (identity) systemParts.push(`<identity>
-${identity}
-</identity>`);
-  if (self) systemParts.push(`<self>
-${self}
-</self>`);
-  if (skills) systemParts.push(`<skills>
-${skills}
-</skills>`);
-  const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
+  const systemPrompt = buildCliSystemPrompt({
+    identity,
+    self,
+    skills,
+    systemContext
+  });
   const attempts = buildCliAttempts({
     provider,
     model,
@@ -9576,6 +9675,26 @@ ${skills}
   }
   throw lastError || new Error("CLI execution failed.");
 }
+function buildCliSystemPrompt({
+  identity,
+  self,
+  skills,
+  systemContext
+}) {
+  const systemParts = [];
+  if (systemContext) systemParts.push(systemContext);
+  systemParts.push(buildScheduledTaskSkillPromptContext());
+  if (identity) systemParts.push(`<identity>
+${identity}
+</identity>`);
+  if (self) systemParts.push(`<self>
+${self}
+</self>`);
+  if (skills) systemParts.push(`<skills>
+${skills}
+</skills>`);
+  return systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
+}
 
 // ../agx-cloud/lib/memory-extractor.ts
 init_sqlite_query_adapter();
@@ -11325,11 +11444,11 @@ function appendReaction(agentId, targetEntry, type) {
 init_activity();
 
 // ../agx-cloud/lib/agent-skill-bindings.ts
-var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_fs3 = __toESM(require("node:fs"));
 init_sqlite_query_adapter();
 
 // ../agx-cloud/lib/skills-library.ts
-var import_node_path2 = __toESM(require("node:path"));
+var import_node_path3 = __toESM(require("node:path"));
 var import_node_child_process = require("node:child_process");
 init_sqlite_query_adapter();
 var SKILLS_CACHE_TTL = 60 * 60 * 1e3;
@@ -11351,7 +11470,7 @@ function skillAgentName(provider) {
   return null;
 }
 function installedSkillPath(skillId) {
-  return import_node_path2.default.join(process.cwd(), ".agents", "skills", skillId, "SKILL.md");
+  return import_node_path3.default.join(process.cwd(), ".agents", "skills", skillId, "SKILL.md");
 }
 function recordSkillHistory(input) {
   const db2 = getSQLiteDb();
@@ -11477,7 +11596,7 @@ function resolveBoundSkillFiles(bindings, prompt, provider) {
   for (const binding of bindings) {
     if (!isBindingRelevant(binding, prompt)) continue;
     const file = installedSkillPath(binding.skillId);
-    if (!import_node_fs2.default.existsSync(file)) {
+    if (!import_node_fs3.default.existsSync(file)) {
       const installResult = installSkill({
         repo: binding.repo,
         skillId: binding.skillId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mndrk/agx",
-  "version": "2.0.45",
+  "version": "2.0.47",
   "description": "Autonomous AI Agent Orchestrator for Claude, Gemini, and Ollama",
   "engines": {
     "node": ">=22.16.0"

package/cloud-runtime/standalone/.linear-token.json

@@ -1,4 +0,0 @@
-{
-  "accessToken": "lin_oauth_57e29621e622de9a7e82341db1318204ad38b149f7502a3f20d972b9bb709db7",
-  "expiresAt": 1775703197030
-}