@mndrk/agx 2.4.2 → 2.4.4

package/cloud-runtime/standalone/apps/local/lib/agent-process-registry.ts

@@ -97,12 +97,18 @@ function getDb(): DatabaseSync {
       PRIMARY KEY (thread_id, id)
     )
   `);
-  // Migrate: rename linear_runs → tracker_runs if old table exists
+  // Migrate: rename linear_runs → tracker_runs if old table exists and new one doesn't
   const hasOldTable = (db.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name='linear_runs'"
   ).get() as { name: string } | undefined);
-  if (hasOldTable) {
+  const hasNewTable = (db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='tracker_runs'"
+  ).get() as { name: string } | undefined);
+  if (hasOldTable && !hasNewTable) {
     db.exec("ALTER TABLE linear_runs RENAME TO tracker_runs");
+  } else if (hasOldTable && hasNewTable) {
+    // Both exist (likely a partial prior migration) — drop the stale old table
+    db.exec("DROP TABLE linear_runs");
   }
   db.exec(`
     CREATE TABLE IF NOT EXISTS tracker_runs (

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/jira/adapter.tsx

@@ -43,6 +43,7 @@ export function JiraIcon({ className }: { className?: string }) {
 export class JiraAdapter implements TrackerAdapter {
   type = "jira" as const;
   displayName = "Jira Cloud";
+  groupLabel = "Sprint";
   icon = JiraIcon;
 
   getAuthUrl(projectId: string): string {

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/jira/issues.ts

@@ -113,6 +113,7 @@ function mapJiraIssueToCacheInput(
     priority: fields.priority?.name ?? null,
     labels: fields.labels ?? [],
     url: `${siteUrl}/browse/${issue.key}`,
+    createdAt: fields.created ?? null,
     updatedAt: fields.updated,
   };
 }

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/linear/adapter.tsx

@@ -77,6 +77,7 @@ function cycleToGroup(cycle: LinearCycle): TrackerGroup {
 export class LinearAdapter implements TrackerAdapter {
   type = "linear" as const;
   displayName = "Linear";
+  groupLabel = "Cycle";
   icon = LinearIcon;
 
   getAuthUrl(projectId: string): string {

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/linear/client.ts

@@ -98,6 +98,7 @@ interface RawLinearIssueNode {
   title: string;
   description: string | null;
   url: string | null;
+  createdAt: string;
   updatedAt: string;
   state: LinearIssueState | null;
   assignee: LinearIssueAssignee | null;
@@ -184,6 +185,7 @@ export interface LinearIssueNode {
   title: string;
   description: string | null;
   url: string | null;
+  createdAt: string;
   updatedAt: string;
   state: Promise<LinearIssueState | null>;
   assignee: Promise<LinearIssueAssignee | null>;
@@ -490,6 +492,7 @@ export class LinearClient {
             title
             description
             url
+            createdAt
             updatedAt
             state { name }
             assignee { id name email }
@@ -516,6 +519,7 @@ export class LinearClient {
         title: issue.title,
         description: issue.description,
         url: issue.url,
+        createdAt: issue.createdAt,
         updatedAt: issue.updatedAt,
         state: Promise.resolve(issue.state),
         assignee: Promise.resolve(issue.assignee),
@@ -581,6 +585,7 @@ export class LinearClient {
             title
             description
             url
+            createdAt
             updatedAt
             state { name }
             assignee { id name email }

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/linear/issues.ts

@@ -279,6 +279,7 @@ export async function pullLinearIssues(input: {
           cycleId: cycle?.id ?? null,
           cycleName: cycle?.name ?? null,
           cycleNumber: cycle?.number ?? null,
+          createdAt: issue.createdAt,
           updatedAt: issue.updatedAt,
         } satisfies CachedLinearIssueInput;
       })

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

@@ -18,50 +18,81 @@ function ensureDir(filePath: string): void {
   }
 }
 
-export function listTrackerConnections(projectId: string): TrackerConnection[] {
-  if (!projectId) return [];
+function readConnectionsFile(projectId: string): { connections: TrackerConnection[]; defaultTracker?: string } {
+  if (!projectId) return { connections: [] };
   const filePath = getConnectionsPath(projectId);
   try {
     const raw = readFileSync(filePath, "utf8");
     const data = JSON.parse(raw);
-    return Array.isArray(data.connections) ? data.connections : [];
+    return {
+      connections: Array.isArray(data.connections) ? data.connections : [],
+      defaultTracker: typeof data.defaultTracker === "string" ? data.defaultTracker : undefined,
+    };
   } catch {
-    return [];
+    return { connections: [] };
   }
 }
 
+function writeConnectionsFile(
+  projectId: string,
+  connections: TrackerConnection[],
+  defaultTracker: string | undefined
+): void {
+  const filePath = getConnectionsPath(projectId);
+  ensureDir(filePath);
+  const payload: { connections: TrackerConnection[]; defaultTracker?: string } = { connections };
+  if (defaultTracker) payload.defaultTracker = defaultTracker;
+  writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+}
+
+export function listTrackerConnections(projectId: string): TrackerConnection[] {
+  return readConnectionsFile(projectId).connections;
+}
+
+export function getDefaultTrackerType(projectId: string): string | null {
+  const data = readConnectionsFile(projectId);
+  const typeExists = (t: string) => data.connections.some((c) => c.type === t);
+  if (data.defaultTracker && typeExists(data.defaultTracker)) return data.defaultTracker;
+  // Fall back to the only connected tracker, if exactly one is configured.
+  return data.connections.length === 1 ? data.connections[0].type : null;
+}
+
+export function setDefaultTrackerType(projectId: string, trackerType: string | null): void {
+  if (!projectId) return;
+  const data = readConnectionsFile(projectId);
+  const next = trackerType && data.connections.some((c) => c.type === trackerType) ? trackerType : undefined;
+  writeConnectionsFile(projectId, data.connections, next);
+}
+
 export function addTrackerConnection(
   projectId: string,
   connection: TrackerConnection
 ): void {
   if (!projectId) return;
-  const filePath = getConnectionsPath(projectId);
-  ensureDir(filePath);
-  const connections = listTrackerConnections(projectId);
-  // Prevent duplicates — update existing connection of same type
+  const data = readConnectionsFile(projectId);
+  const connections = data.connections.slice();
   const existing = connections.findIndex((c) => c.type === connection.type);
   if (existing >= 0) {
     connections[existing] = connection;
   } else {
     connections.push(connection);
   }
-  writeFileSync(filePath, JSON.stringify({ connections }, null, 2), "utf8");
+  writeConnectionsFile(projectId, connections, data.defaultTracker);
 }
 
 export function removeTrackerConnection(projectId: string, trackerType: string): void {
   if (!projectId) return;
-  const filePath = getConnectionsPath(projectId);
-  const connections = listTrackerConnections(projectId).filter(
-    (c) => c.type !== trackerType
-  );
+  const data = readConnectionsFile(projectId);
+  const connections = data.connections.filter((c) => c.type !== trackerType);
+  const nextDefault = data.defaultTracker === trackerType ? undefined : data.defaultTracker;
   if (connections.length === 0) {
+    const filePath = getConnectionsPath(projectId);
     try {
       unlinkSync(filePath);
     } catch {
       // already gone
     }
   } else {
-    ensureDir(filePath);
-    writeFileSync(filePath, JSON.stringify({ connections }, null, 2), "utf8");
+    writeConnectionsFile(projectId, connections, nextDefault);
   }
 }

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

@@ -29,6 +29,8 @@ export interface TrackerAdapter {
   type: string;
   /** Human-readable name, e.g. 'Linear' or 'Jira Cloud' */
   displayName: string;
+  /** Label for the group filter, e.g. 'Cycle' (Linear), 'Sprint' (Jira) */
+  groupLabel?: string;
   /** Icon component to render in the sidebar and headers */
   icon: ComponentType<{ className?: string }>;
 

package/cloud-runtime/standalone/apps/local/lib/tracker/tracker-item-metadata-store.ts

@@ -0,0 +1,262 @@
+import "server-only";
+
+import type { DatabaseSync } from "node:sqlite";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pragmaSet, transaction } from "../sqlite-compat";
+
+const TRACKER_DIR =
+  process.env.AGX_TRACKER_DIR?.trim() ||
+  path.join(process.env.AGX_DATA_DIR || path.join(os.homedir(), ".agx"), "tracker");
+const DB_PATH = path.join(TRACKER_DIR, "items.sqlite");
+
+const FIBONACCI = [1, 2, 3, 5, 8, 13, 21] as const;
+export type FibonacciEstimate = (typeof FIBONACCI)[number];
+export const FIBONACCI_VALUES: readonly number[] = FIBONACCI;
+
+export interface ItemMetadata {
+  labels: string[];
+  estimate: number | null;
+}
+
+export interface LabelDefinition {
+  id: string;
+  name: string;
+  color: string | null;
+}
+
+async function withDb<T>(run: (db: DatabaseSync) => T): Promise<T> {
+  await fs.mkdir(TRACKER_DIR, { recursive: true });
+  const db = new (process.getBuiltinModule("node:sqlite") as typeof import("node:sqlite")).DatabaseSync(DB_PATH);
+  pragmaSet(db, "journal_mode = WAL");
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS tracker_item_metadata (
+        issue_id TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        labels_json TEXT NOT NULL DEFAULT '[]',
+        estimate INTEGER,
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (issue_id, project_id)
+      );
+      CREATE TABLE IF NOT EXISTS tracker_label_definitions (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        color TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(project_id, name)
+      );
+    `);
+    return run(db);
+  } finally {
+    db.close();
+  }
+}
+
+function parseLabels(json: string | null): string[] {
+  if (!json) return [];
+  try {
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed.filter((l: unknown) => typeof l === "string" && l.trim()) : [];
+  } catch {
+    return [];
+  }
+}
+
+export async function getItemMetadata(projectId: string, issueId: string): Promise<ItemMetadata> {
+  return withDb((db) => {
+    const row = db.prepare(
+      "SELECT labels_json, estimate FROM tracker_item_metadata WHERE project_id = ? AND issue_id = ?"
+    ).get(projectId, issueId) as { labels_json: string; estimate: number | null } | undefined;
+    if (!row) return { labels: [], estimate: null };
+    return { labels: parseLabels(row.labels_json), estimate: row.estimate };
+  });
+}
+
+export async function setItemMetadata(
+  projectId: string,
+  issueId: string,
+  update: { labels?: string[]; estimate?: number | null }
+): Promise<ItemMetadata> {
+  return withDb((db) => {
+    const existing = db.prepare(
+      "SELECT labels_json, estimate FROM tracker_item_metadata WHERE project_id = ? AND issue_id = ?"
+    ).get(projectId, issueId) as { labels_json: string; estimate: number | null } | undefined;
+
+    const labels = update.labels ?? parseLabels(existing?.labels_json ?? null);
+    const estimate = update.estimate !== undefined ? update.estimate : (existing?.estimate ?? null);
+
+    db.prepare(`
+      INSERT INTO tracker_item_metadata (issue_id, project_id, labels_json, estimate, updated_at)
+      VALUES (?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(issue_id, project_id) DO UPDATE SET
+        labels_json = excluded.labels_json,
+        estimate = excluded.estimate,
+        updated_at = excluded.updated_at
+    `).run(issueId, projectId, JSON.stringify(labels), estimate);
+
+    return { labels, estimate };
+  });
+}
+
+export async function bulkGetItemMetadata(
+  projectId: string,
+  issueIds: string[]
+): Promise<Map<string, ItemMetadata>> {
+  if (issueIds.length === 0) return new Map();
+  return withDb((db) => {
+    const placeholders = issueIds.map(() => "?").join(", ");
+    const rows = db.prepare(
+      `SELECT issue_id, labels_json, estimate FROM tracker_item_metadata
+       WHERE project_id = ? AND issue_id IN (${placeholders})`
+    ).all(projectId, ...issueIds) as Array<{ issue_id: string; labels_json: string; estimate: number | null }>;
+
+    const result = new Map<string, ItemMetadata>();
+    for (const row of rows) {
+      result.set(row.issue_id, { labels: parseLabels(row.labels_json), estimate: row.estimate });
+    }
+    return result;
+  });
+}
+
+export async function bulkSetEstimate(
+  projectId: string,
+  issueIds: string[],
+  estimate: number | null
+): Promise<void> {
+  if (issueIds.length === 0) return;
+  return withDb((db) => {
+    transaction(db, () => {
+      const stmt = db.prepare(`
+        INSERT INTO tracker_item_metadata (issue_id, project_id, estimate, updated_at)
+        VALUES (?, ?, ?, datetime('now'))
+        ON CONFLICT(issue_id, project_id) DO UPDATE SET
+          estimate = excluded.estimate,
+          updated_at = excluded.updated_at
+      `);
+      for (const issueId of issueIds) {
+        stmt.run(issueId, projectId, estimate);
+      }
+    });
+  });
+}
+
+export async function bulkAddLabels(
+  projectId: string,
+  issueIds: string[],
+  labelsToAdd: string[]
+): Promise<void> {
+  if (issueIds.length === 0 || labelsToAdd.length === 0) return;
+  return withDb((db) => {
+    transaction(db, () => {
+      for (const issueId of issueIds) {
+        const row = db.prepare(
+          "SELECT labels_json FROM tracker_item_metadata WHERE project_id = ? AND issue_id = ?"
+        ).get(projectId, issueId) as { labels_json: string } | undefined;
+
+        const existing = parseLabels(row?.labels_json ?? null);
+        const merged = Array.from(new Set([...existing, ...labelsToAdd]));
+
+        db.prepare(`
+          INSERT INTO tracker_item_metadata (issue_id, project_id, labels_json, updated_at)
+          VALUES (?, ?, ?, datetime('now'))
+          ON CONFLICT(issue_id, project_id) DO UPDATE SET
+            labels_json = excluded.labels_json,
+            updated_at = excluded.updated_at
+        `).run(issueId, projectId, JSON.stringify(merged));
+      }
+    });
+  });
+}
+
+export async function bulkRemoveLabel(
+  projectId: string,
+  issueIds: string[],
+  label: string
+): Promise<void> {
+  if (issueIds.length === 0 || !label.trim()) return;
+  return withDb((db) => {
+    transaction(db, () => {
+      for (const issueId of issueIds) {
+        const row = db.prepare(
+          "SELECT labels_json FROM tracker_item_metadata WHERE project_id = ? AND issue_id = ?"
+        ).get(projectId, issueId) as { labels_json: string } | undefined;
+
+        if (!row) continue;
+        const existing = parseLabels(row.labels_json);
+        const filtered = existing.filter((l) => l !== label);
+
+        db.prepare(
+          "UPDATE tracker_item_metadata SET labels_json = ?, updated_at = datetime('now') WHERE project_id = ? AND issue_id = ?"
+        ).run(JSON.stringify(filtered), projectId, issueId);
+      }
+    });
+  });
+}
+
+export async function listLabelDefinitions(projectId: string): Promise<LabelDefinition[]> {
+  return withDb((db) => {
+    const rows = db.prepare(
+      "SELECT id, name, color FROM tracker_label_definitions WHERE project_id = ? ORDER BY name ASC"
+    ).all(projectId) as Array<{ id: string; name: string; color: string | null }>;
+    return rows;
+  });
+}
+
+export async function createLabelDefinition(
+  projectId: string,
+  name: string,
+  color?: string | null
+): Promise<LabelDefinition> {
+  const id = globalThis.crypto?.randomUUID?.() ?? `label-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const trimmedName = name.trim();
+  if (!trimmedName) throw new Error("Label name is required");
+
+  return withDb((db) => {
+    db.prepare(
+      "INSERT INTO tracker_label_definitions (id, project_id, name, color) VALUES (?, ?, ?, ?)"
+    ).run(id, projectId, trimmedName, color?.trim() || null);
+    return { id, name: trimmedName, color: color?.trim() || null };
+  });
+}
+
+export async function deleteLabelDefinition(projectId: string, id: string): Promise<void> {
+  return withDb((db) => {
+    db.prepare(
+      "DELETE FROM tracker_label_definitions WHERE id = ? AND project_id = ?"
+    ).run(id, projectId);
+  });
+}
+
+export async function listAllLabels(projectId: string): Promise<Array<{ name: string; color: string | null; defined: boolean }>> {
+  return withDb((db) => {
+    const definitions = db.prepare(
+      "SELECT name, color FROM tracker_label_definitions WHERE project_id = ? ORDER BY name ASC"
+    ).all(projectId) as Array<{ name: string; color: string | null }>;
+
+    const metadataRows = db.prepare(
+      "SELECT labels_json FROM tracker_item_metadata WHERE project_id = ?"
+    ).all(projectId) as Array<{ labels_json: string }>;
+
+    const definedNames = new Set(definitions.map((d) => d.name));
+    const allUsed = new Set<string>();
+    for (const row of metadataRows) {
+      for (const label of parseLabels(row.labels_json)) {
+        allUsed.add(label);
+      }
+    }
+
+    const result: Array<{ name: string; color: string | null; defined: boolean }> = [];
+    for (const def of definitions) {
+      result.push({ name: def.name, color: def.color, defined: true });
+    }
+    for (const name of allUsed) {
+      if (!definedNames.has(name)) {
+        result.push({ name, color: null, defined: false });
+      }
+    }
+    return result;
+  });
+}

package/cloud-runtime/standalone/apps/local/lib/tracker/tracker-item-store.ts

@@ -40,6 +40,7 @@ interface TrackerItemRow {
   cycle_number: number | null;
   priority: string | null;
   metadata_json: string | null;
+  created_at: string | null;
   updated_at: string;
   pulled_at: number;
 }
@@ -75,6 +76,7 @@ export interface CachedTrackerItemRecord {
   cycleNumber: number | null;
   priority: string | null;
   metadata: Record<string, unknown>;
+  createdAt: string | null;
   updatedAt: string;
   pulledAt: string;
 }
@@ -102,6 +104,7 @@ export interface CachedTrackerItemInput {
   cycleNumber?: number | null;
   priority?: string | null;
   metadata?: Record<string, unknown>;
+  createdAt?: string | null;
   updatedAt: string;
 }
 
@@ -211,6 +214,7 @@ function mapRow(row: TrackerItemRow): CachedTrackerItemRecord {
     cycleNumber: row.cycle_number,
     priority: row.priority,
     metadata: row.metadata_json ? JSON.parse(row.metadata_json) : {},
+    createdAt: row.created_at,
     updatedAt: row.updated_at,
     pulledAt: toIso(row.pulled_at),
   };
@@ -384,6 +388,7 @@ async function withTrackerItemDatabase<T>(run: (db: DatabaseSync) => T): Promise
     ensureColumn(db, "tracker_items", "status_category", "status_category TEXT NOT NULL DEFAULT 'todo'");
     ensureColumn(db, "tracker_items", "priority", "priority TEXT");
     ensureColumn(db, "tracker_items", "metadata_json", "metadata_json TEXT");
+    ensureColumn(db, "tracker_items", "created_at", "created_at TEXT");
 
     return run(db);
   } finally {
@@ -411,8 +416,8 @@ export async function replaceCachedTrackerItems(input: {
           labels_json, url, status, status_category,
           assignee_id, assignee_name, assignee_email, is_assigned_to_me,
           team_id, team_name, team_key, cycle_id, cycle_name, cycle_number,
-          priority, metadata_json, updated_at, pulled_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          priority, metadata_json, created_at, updated_at, pulled_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(issue_id) DO UPDATE SET
           tracker_type = excluded.tracker_type,
           tracker_id = excluded.tracker_id,
@@ -435,6 +440,7 @@ export async function replaceCachedTrackerItems(input: {
           cycle_number = excluded.cycle_number,
           priority = excluded.priority,
           metadata_json = excluded.metadata_json,
+          created_at = excluded.created_at,
           updated_at = excluded.updated_at,
           pulled_at = excluded.pulled_at
       `);
@@ -464,6 +470,7 @@ export async function replaceCachedTrackerItems(input: {
           toOptionalNumber(issue.cycleNumber ?? null),
           toOptionalString(issue.priority ?? null),
           issue.metadata ? JSON.stringify(issue.metadata) : null,
+          toOptionalString(issue.createdAt ?? null),
           issue.updatedAt.trim(),
           pulledAtMs
         );
@@ -693,7 +700,7 @@ export async function listCachedTrackerItems(
         orderClause = `ORDER BY LOWER(status) ${dirSql}, identifier ASC`;
         break;
       case "created":
-        orderClause = `ORDER BY pulled_at ${dirSql}, identifier ASC`;
+        orderClause = `ORDER BY COALESCE(created_at, updated_at) ${dirSql}, identifier ASC`;
         break;
       default:
         orderClause = `ORDER BY updated_at ${dirSql}, identifier ASC`;

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

@@ -510,6 +510,48 @@ export async function getIssueActivityMap(
   });
 }
 
+export interface IssueStats {
+  issueId: string;
+  sessions: number;
+  messages: number;
+}
+
+export async function getIssueStats(
+  projectId?: string | null
+): Promise<IssueStats[]> {
+  return withTrackerRunDatabase((db) => {
+    const hasProject = projectId?.trim();
+    const sql = hasProject
+      ? `SELECT tr.issue_id,
+                COUNT(DISTINCT tr.id) AS sessions,
+                COALESCE(SUM(mc.cnt), 0) AS messages
+         FROM tracker_runs tr
+         LEFT JOIN (
+           SELECT thread_id, COUNT(*) AS cnt FROM messages GROUP BY thread_id
+         ) mc ON mc.thread_id = tr.thread_id
+         WHERE tr.project_id = ?
+         GROUP BY tr.issue_id`
+      : `SELECT tr.issue_id,
+                COUNT(DISTINCT tr.id) AS sessions,
+                COALESCE(SUM(mc.cnt), 0) AS messages
+         FROM tracker_runs tr
+         LEFT JOIN (
+           SELECT thread_id, COUNT(*) AS cnt FROM messages GROUP BY thread_id
+         ) mc ON mc.thread_id = tr.thread_id
+         GROUP BY tr.issue_id`;
+
+    const rows = hasProject
+      ? (db.prepare(sql).all(projectId!.trim()) as unknown as Array<{ issue_id: string; sessions: number; messages: number }>)
+      : (db.prepare(sql).all() as unknown as Array<{ issue_id: string; sessions: number; messages: number }>);
+
+    return rows.map((row) => ({
+      issueId: row.issue_id,
+      sessions: row.sessions,
+      messages: row.messages,
+    }));
+  });
+}
+
 export interface IssueActiveAgent {
   issueId: string;
   agentId: string;

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

@@ -379,6 +379,13 @@ export async function executeObjectiveWorker(opts: {
         ? (parsed.decision as string).trim().toLowerCase()
         : '';
     const action = rawAction === 'work' ? 'work_ticket' : rawAction;
+    if (!action) {
+      const raw = controllerResult.output ?? '';
+      console.warn(
+        `[objective-worker] empty action from controller (job=${opts.job.id}, outputLen=${raw.length}, parsed=${parsed ? 'object' : 'null'}):`,
+        raw.slice(0, 500),
+      );
+    }
     const reason = typeof parsed?.reason === 'string' ? parsed.reason.trim() : '';
     const objectiveProgress = normalizeAssessmentProgress(parsed?.objectiveProgress);
     const objectiveStatus = normalizeAssessmentStatus(parsed?.objectiveStatus);

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

@@ -336,6 +336,13 @@ export async function executeTaskWorker(opts: {
         ? (parsed.decision as string).trim().toLowerCase()
         : '';
     const action = rawAction === 'work' ? 'work_ticket' : rawAction;
+    if (!action) {
+      const raw = controllerResult.output ?? '';
+      console.warn(
+        `[task-worker] empty action from controller (job=${opts.job.id}, outputLen=${raw.length}, parsed=${parsed ? 'object' : 'null'}):`,
+        raw.slice(0, 500),
+      );
+    }
     const reason = typeof parsed?.reason === 'string' ? parsed.reason.trim() : '';
 
     // Phase 4: Act - dispatch action

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

@@ -5,6 +5,7 @@ export interface TrackerBoardFilters {
   assigneeIds: string[];
   statusCategories: string[];
   groupIds: string[];
+  labelNames: string[];
   sortBy: "activity" | "identifier" | "status" | "created";
   sortDir: "asc" | "desc";
   hasActivity: boolean;
@@ -15,6 +16,7 @@ const DEFAULT_TRACKER_BOARD_FILTERS: TrackerBoardFilters = {
   assigneeIds: [],
   statusCategories: [],
   groupIds: [],
+  labelNames: [],
   sortBy: "activity",
   sortDir: "desc",
   hasActivity: false,
@@ -69,6 +71,7 @@ export function loadTrackerBoardFilters(
       assigneeIds: normalizeStringArray(parsed.assigneeIds),
       statusCategories: normalizeStringArray(parsed.statusCategories),
       groupIds: normalizeStringArray(parsed.groupIds),
+      labelNames: normalizeStringArray(parsed.labelNames),
       sortBy: ["activity", "identifier", "status", "created"].includes(parsed.sortBy as string)
         ? (parsed.sortBy as TrackerBoardFilters["sortBy"])
         : DEFAULT_TRACKER_BOARD_FILTERS.sortBy,
@@ -101,6 +104,7 @@ export function persistTrackerBoardFilters(
         assigneeIds: normalizeStringArray(filters.assigneeIds),
         statusCategories: normalizeStringArray(filters.statusCategories),
         groupIds: normalizeStringArray(filters.groupIds),
+        labelNames: normalizeStringArray(filters.labelNames),
         sortBy: filters.sortBy || "activity",
         sortDir: filters.sortDir || "desc",
         hasActivity: !!filters.hasActivity,

package/cloud-runtime/standalone/apps/local/worker/index.js

@@ -11199,8 +11199,13 @@ function getDb2() {
   const hasOldTable = db2.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name='linear_runs'"
   ).get();
-  if (hasOldTable) {
+  const hasNewTable = db2.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='tracker_runs'"
+  ).get();
+  if (hasOldTable && !hasNewTable) {
     db2.exec("ALTER TABLE linear_runs RENAME TO tracker_runs");
+  } else if (hasOldTable && hasNewTable) {
+    db2.exec("DROP TABLE linear_runs");
   }
   db2.exec(`
     CREATE TABLE IF NOT EXISTS tracker_runs (
@@ -24121,7 +24126,6 @@ function parseNaturalSchedule(input) {
 var PATTERNS;
 var init_nl_schedule = __esm({
   "apps/local/src/graph/nl-schedule.ts"() {
-    "use strict";
     PATTERNS = [
       // "every N seconds" → intervalMs only (sub-minute)
       {