@mndrk/agx 2.0.55 → 2.1.0

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

@@ -161,10 +161,12 @@ interface PromptJobListFilter {
 }
 
 function rowToJob(row: PromptJobRow): PromptJob {
-  const executionMode =
-    row.execution_mode === "objective_linear_ticket"
-      ? "objective_linear_ticket"
-      : DEFAULT_PROMPT_JOB_EXECUTION_MODE;
+  const executionMode: PromptJobExecutionMode =
+    row.execution_mode === "objective_linear_ticket" || row.execution_mode === "objective_worker"
+      ? "objective_worker"
+      : row.execution_mode === "linear_worker"
+        ? "linear_worker"
+        : DEFAULT_PROMPT_JOB_EXECUTION_MODE;
   return {
     id: row.id,
     name: row.name,
@@ -183,6 +185,9 @@ function rowToJob(row: PromptJobRow): PromptJob {
     catchUpPolicy: (row.catch_up_policy || "fire_once") as PromptJob["catchUpPolicy"],
     cancelCheckSec: row.cancel_check_sec,
     executionMode,
+    scriptPrompt: "",
+    teamId: "",
+    builtIn: executionMode === "objective_worker" || executionMode === "linear_worker",
     condition: row.condition || "",
     nextRunAt: row.next_run_at,
     lastRunAt: row.last_run_at,
@@ -316,6 +321,7 @@ export class PromptJobStore {
       },
       target: {
         type: "prompt_job",
+        ...(input.builtIn ? { builtIn: true } : {}),
         ...(input.agentId ? { agentId: input.agentId } : {}),
         ...(input.objectiveId ? { objectiveId: input.objectiveId } : {}),
         ...(input.objectiveKey ? { objectiveKey: input.objectiveKey } : {}),
@@ -325,6 +331,8 @@ export class PromptJobStore {
         ...(input.provider ? { provider: input.provider } : {}),
         ...(input.model ? { model: input.model } : {}),
         ...(input.cliArgs !== undefined ? { cliArgs: input.cliArgs } : {}),
+        ...(input.scriptPrompt ? { scriptPrompt: input.scriptPrompt } : {}),
+        ...(input.teamId ? { teamId: input.teamId } : {}),
       },
       createdAt,
       body: input.prompt,
@@ -430,6 +438,11 @@ export class PromptJobStore {
   }
 
   deleteJob(id: string): void {
+    const job = this.getJob(id);
+    if (job?.builtIn) {
+      throw new Error('Cannot delete built-in job. Use pause instead.');
+    }
+
     if (isAutomationFrontmatterEnabled()) {
       const archived = this.getAutomationRepo().archiveAutomation(id);
       if (!archived) {
@@ -755,6 +768,8 @@ export class PromptJobStore {
     if (updates.provider !== undefined) targetPatch.provider = updates.provider || undefined;
     if (updates.model !== undefined) targetPatch.model = updates.model || undefined;
     if (updates.cliArgs !== undefined) targetPatch.cliArgs = updates.cliArgs;
+    if (updates.scriptPrompt !== undefined) targetPatch.scriptPrompt = updates.scriptPrompt || undefined;
+    if (updates.teamId !== undefined) targetPatch.teamId = updates.teamId || undefined;
 
     return {
       ...(Object.keys(patch).length > 0 ? patch : {}),

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

@@ -3,16 +3,27 @@ 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_linear_ticket';
+export type PromptJobExecutionMode = 'prompt' | 'objective_worker' | 'linear_worker';
+
+export type ObjectiveActionType = 'work_ticket' | 'run_prompt' | 'stop';
+
+export type ObjectiveAction =
+  | { action: 'work_ticket'; ticketId: string; reason: string }
+  | { action: 'run_prompt'; prompt: string; reason: string }
+  | { action: 'stop'; reason: string };
+
+export interface ActionReceipt {
+  action: string;
+  jobName: string;
+  reason: string;
+  result: string;
+  linearRunId?: string;
+  chatRunId?: string;
+  durationMs: number;
+  status: 'success' | 'failed';
+}
 
 export const DEFAULT_PROMPT_JOB_EXECUTION_MODE: PromptJobExecutionMode = 'prompt';
-export const DEFAULT_OBJECTIVE_LINEAR_WORKER_NAME = 'Work objective Linear tickets';
-export const DEFAULT_OBJECTIVE_LINEAR_WORKER_PROMPT = [
-  'Review the outstanding Linear tickets for this objective and decide whether one should be worked now.',
-  'Prefer the single next concrete ticket that most advances the objective.',
-  'Prefer tickets already in progress or otherwise clearly actionable.',
-  'Do not start a session when there is no useful work to do right now.',
-].join('\n');
 
 export interface PromptJob {
   id: string;
@@ -32,9 +43,17 @@ export interface PromptJob {
   catchUpPolicy: CatchUpPolicy;
   cancelCheckSec: number;
   executionMode: PromptJobExecutionMode;
+  /** For linear_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. */
+  teamId: string;
+  /** True for system-managed jobs that cannot be deleted by users */
+  builtIn?: boolean;
   condition: string;
   nextRunAt: number | null;
   lastRunAt: number | null;
+  /** Computed: previous cron occurrence (not persisted) */
+  prevScheduledAt?: number | null;
   lastOutcome: RunStatus | null;
   createdAt: string;
   updatedAt: string;
@@ -71,6 +90,9 @@ export interface CreatePromptJobInput {
   catchUpPolicy?: CatchUpPolicy;
   cancelCheckSec?: number;
   executionMode?: PromptJobExecutionMode;
+  scriptPrompt?: string;
+  teamId?: string;
+  builtIn?: boolean;
   // Legacy compatibility only. New callers should always send cadence.
   triggerType?: TriggerType;
   condition?: string;
@@ -80,6 +102,8 @@ export interface CreatePromptJobInput {
 export interface UpdatePromptJobInput {
   name?: string;
   prompt?: string;
+  scriptPrompt?: string;
+  teamId?: string;
   agentId?: string;
   projectId?: string;
   objectiveId?: string | null;

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

@@ -6,30 +6,37 @@ import type {
   TerminalStatus,
 } from "@/lib/terminal-types";
 
-export interface TerminalTabsState {
-  sessions: TerminalSession[];
+const DEFAULT_PROJECT_KEY = "__global__";
 
-  createSession: (cwd?: string) => string;
-  closeSession: (id: string) => void;
-  renameSession: (id: string, title: string) => void;
-  addTerminal: (sessionId: string, cwd?: string) => string | null;
-  closeTerminal: (sessionId: string, terminalId: string) => void;
+export interface TerminalTabsState {
+  sessions: Record<string, TerminalSession[]>;
+
+  getProjectSessions: (projectId: string) => TerminalSession[];
+  createSession: (projectId: string, cwd?: string) => string;
+  closeSession: (projectId: string, id: string) => void;
+  renameSession: (projectId: string, id: string, title: string) => void;
+  addTerminal: (projectId: string, sessionId: string, cwd?: string) => string | null;
+  closeTerminal: (projectId: string, sessionId: string, terminalId: string) => void;
   renameTerminal: (
+    projectId: string,
     sessionId: string,
     terminalId: string,
     title: string,
   ) => void;
   updateTerminalLayout: (
+    projectId: string,
     sessionId: string,
     terminalId: string,
     layout: { colSpan?: number; rowSpan?: number },
   ) => void;
   setTerminalSessionId: (
+    projectId: string,
     sessionId: string,
     terminalId: string,
     backendSessionId: string,
   ) => void;
   updateTerminalStatus: (
+    projectId: string,
     sessionId: string,
     terminalId: string,
     status: TerminalStatus,
@@ -154,14 +161,66 @@ export function normalizePersistedSessions(
   });
 }
 
+/**
+ * Migrate legacy persisted state where sessions was a flat array
+ * to the new project-keyed Record shape.
+ */
+function migratePersistedSessions(
+  raw: unknown,
+): Record<string, TerminalSession[]> {
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    // Already in Record shape — normalize each project's sessions
+    const result: Record<string, TerminalSession[]> = {};
+    for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+      result[key] = normalizePersistedSessions(
+        Array.isArray(value) ? (value as Array<Partial<TerminalSession>>) : [],
+      );
+    }
+    return result;
+  }
+
+  if (Array.isArray(raw)) {
+    // Legacy flat array — migrate to default project key
+    return {
+      [DEFAULT_PROJECT_KEY]: normalizePersistedSessions(
+        raw as Array<Partial<TerminalSession>>,
+      ),
+    };
+  }
+
+  return {};
+}
+
+function getProjectSessionsList(
+  sessions: Record<string, TerminalSession[]>,
+  projectId: string,
+): TerminalSession[] {
+  return sessions[projectId] ?? [];
+}
+
+function updateProjectSessions(
+  sessions: Record<string, TerminalSession[]>,
+  projectId: string,
+  updater: (projectSessions: TerminalSession[]) => TerminalSession[],
+): Record<string, TerminalSession[]> {
+  const current = sessions[projectId] ?? [];
+  const updated = updater(current);
+  return { ...sessions, [projectId]: updated };
+}
+
 export const useTerminalTabsStore = create<TerminalTabsState>()(
   persist(
     (set, get) => ({
-      sessions: [],
+      sessions: {},
 
-      createSession(cwd?: string): string {
+      getProjectSessions(projectId: string): TerminalSession[] {
+        return getProjectSessionsList(get().sessions, projectId);
+      },
+
+      createSession(projectId: string, cwd?: string): string {
         const id = crypto.randomUUID();
-        const title = nextTitle(get().sessions);
+        const projectSessions = getProjectSessionsList(get().sessions, projectId);
+        const title = nextTitle(projectSessions);
         const session: TerminalSession = {
           id,
           title,
@@ -170,153 +229,174 @@ export const useTerminalTabsStore = create<TerminalTabsState>()(
         };
 
         set((state) => ({
-          sessions: [...state.sessions, session],
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) => [
+            ...ps,
+            session,
+          ]),
         }));
 
         return id;
       },
 
-      closeSession(id: string): void {
+      closeSession(projectId: string, id: string): void {
         set((state) => ({
-          sessions: state.sessions.filter((session) => session.id !== id),
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.filter((session) => session.id !== id),
+          ),
         }));
       },
 
-      renameSession(id: string, title: string): void {
+      renameSession(projectId: string, id: string, title: string): void {
         set((state) => ({
-          sessions: state.sessions.map((session) =>
-            session.id === id ? { ...session, title } : session,
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.map((session) =>
+              session.id === id ? { ...session, title } : session,
+            ),
           ),
         }));
       },
 
-      addTerminal(sessionId: string, cwd?: string): string | null {
+      addTerminal(projectId: string, sessionId: string, cwd?: string): string | null {
         const terminalId = crypto.randomUUID();
         let added = false;
 
         set((state) => ({
-          sessions: state.sessions.map((session) => {
-            if (session.id !== sessionId) {
-              return session;
-            }
-
-            added = true;
-            return {
-              ...session,
-              terminals: [
-                ...session.terminals,
-                createTerminal(session.terminals, cwd, terminalId),
-              ],
-            };
-          }),
-        }));
-
-        return added ? terminalId : null;
-      },
-
-      closeTerminal(sessionId: string, terminalId: string): void {
-        set((state) => ({
-          sessions: state.sessions
-            .map((session) => {
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.map((session) => {
               if (session.id !== sessionId) {
                 return session;
               }
 
+              added = true;
               return {
                 ...session,
-                terminals: session.terminals.filter(
-                  (terminal) => terminal.id !== terminalId,
-                ),
+                terminals: [
+                  ...session.terminals,
+                  createTerminal(session.terminals, cwd, terminalId),
+                ],
               };
-            })
-            .filter((session) => session.terminals.length > 0),
+            }),
+          ),
         }));
+
+        return added ? terminalId : null;
       },
 
-      renameTerminal(sessionId: string, terminalId: string, title: string): void {
+      closeTerminal(projectId: string, sessionId: string, terminalId: string): void {
         set((state) => ({
-          sessions: state.sessions.map((session) =>
-            session.id === sessionId
-              ? {
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps
+              .map((session) => {
+                if (session.id !== sessionId) {
+                  return session;
+                }
+
+                return {
                   ...session,
-                  terminals: session.terminals.map((terminal) =>
-                    terminal.id === terminalId
-                      ? { ...terminal, title }
-                      : terminal,
+                  terminals: session.terminals.filter(
+                    (terminal) => terminal.id !== terminalId,
                   ),
-                }
-              : session,
+                };
+              })
+              .filter((session) => session.terminals.length > 0),
           ),
         }));
       },
 
-      updateTerminalLayout(sessionId: string, terminalId: string, layout): void {
+      renameTerminal(projectId: string, sessionId: string, terminalId: string, title: string): void {
         set((state) => ({
-          sessions: state.sessions.map((session) =>
-            session.id === sessionId
-              ? {
-                  ...session,
-                  terminals: session.terminals.map((terminal) =>
-                    terminal.id === terminalId
-                      ? {
-                          ...terminal,
-                          colSpan: clamp(
-                            layout.colSpan ?? terminal.colSpan,
-                            1,
-                            2,
-                          ),
-                          rowSpan: clamp(
-                            layout.rowSpan ?? terminal.rowSpan,
-                            1,
-                            4,
-                          ),
-                        }
-                      : terminal,
-                  ),
-                }
-              : session,
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.map((session) =>
+              session.id === sessionId
+                ? {
+                    ...session,
+                    terminals: session.terminals.map((terminal) =>
+                      terminal.id === terminalId
+                        ? { ...terminal, title }
+                        : terminal,
+                    ),
+                  }
+                : session,
+            ),
+          ),
+        }));
+      },
+
+      updateTerminalLayout(projectId: string, sessionId: string, terminalId: string, layout): void {
+        set((state) => ({
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.map((session) =>
+              session.id === sessionId
+                ? {
+                    ...session,
+                    terminals: session.terminals.map((terminal) =>
+                      terminal.id === terminalId
+                        ? {
+                            ...terminal,
+                            colSpan: clamp(
+                              layout.colSpan ?? terminal.colSpan,
+                              1,
+                              2,
+                            ),
+                            rowSpan: clamp(
+                              layout.rowSpan ?? terminal.rowSpan,
+                              1,
+                              4,
+                            ),
+                          }
+                        : terminal,
+                    ),
+                  }
+                : session,
+            ),
           ),
         }));
       },
 
       setTerminalSessionId(
+        projectId: string,
         sessionId: string,
         terminalId: string,
         backendSessionId: string,
       ): void {
         set((state) => ({
-          sessions: state.sessions.map((session) =>
-            session.id === sessionId
-              ? {
-                  ...session,
-                  terminals: session.terminals.map((terminal) =>
-                    terminal.id === terminalId
-                      ? { ...terminal, sessionId: backendSessionId }
-                      : terminal,
-                  ),
-                }
-              : session,
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.map((session) =>
+              session.id === sessionId
+                ? {
+                    ...session,
+                    terminals: session.terminals.map((terminal) =>
+                      terminal.id === terminalId
+                        ? { ...terminal, sessionId: backendSessionId }
+                        : terminal,
+                    ),
+                  }
+                : session,
+            ),
           ),
         }));
       },
 
       updateTerminalStatus(
+        projectId: string,
         sessionId: string,
         terminalId: string,
         status: TerminalStatus,
       ): void {
         set((state) => ({
-          sessions: state.sessions.map((session) =>
-            session.id === sessionId
-              ? {
-                  ...session,
-                  terminals: session.terminals.map((terminal) =>
-                    terminal.id === terminalId
-                      ? { ...terminal, status }
-                      : terminal,
-                  ),
-                }
-              : session,
+          sessions: updateProjectSessions(state.sessions, projectId, (ps) =>
+            ps.map((session) =>
+              session.id === sessionId
+                ? {
+                    ...session,
+                    terminals: session.terminals.map((terminal) =>
+                      terminal.id === terminalId
+                        ? { ...terminal, status }
+                        : terminal,
+                    ),
+                  }
+                : session,
+            ),
           ),
         }));
       },
@@ -329,11 +409,7 @@ export const useTerminalTabsStore = create<TerminalTabsState>()(
         return {
           ...currentState,
           ...persisted,
-          sessions: normalizePersistedSessions(
-            Array.isArray(persisted.sessions)
-              ? (persisted.sessions as Array<Partial<TerminalSession>>)
-              : currentState.sessions,
-          ),
+          sessions: migratePersistedSessions(persisted.sessions),
         };
       },
     },

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

@@ -21,6 +21,7 @@ export interface SidebarState {
   linearTicketPanelWidth: number;
   linearRunsPanelWidth: number;
   objectiveChatPanelWidth: number;
+  objectiveListPanelWidth: number;
 }
 
 export interface ScrollState {
@@ -42,6 +43,7 @@ const DEFAULT_SIDEBAR: SidebarState = {
   linearTicketPanelWidth: 576,
   linearRunsPanelWidth: 224,
   objectiveChatPanelWidth: 440,
+  objectiveListPanelWidth: 320,
 };
 
 const DEFAULT_SCROLL: ScrollState = {
@@ -203,6 +205,15 @@ export function persistObjectiveChatPanelWidth(width: number): void {
   persistSidebarState({ objectiveChatPanelWidth: width });
 }
 
+// Objective list panel width
+export function loadObjectiveListPanelWidth(): number {
+  return loadSidebarState().objectiveListPanelWidth;
+}
+
+export function persistObjectiveListPanelWidth(width: number): void {
+  persistSidebarState({ objectiveListPanelWidth: width });
+}
+
 // Clear all window state (for logout/reset)
 export function clearWindowState(): void {
   if (!isStorageAvailable()) return;

package/cloud-runtime/standalone/apps/local/styles/workspaceSidebar.css

@@ -17,6 +17,32 @@
   overflow: hidden;
 }
 
+.workspace-sidebar__backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 54;
+  border: 0;
+  background: rgba(15, 23, 42, 0.48);
+  padding: 0;
+  margin: 0;
+}
+
+.workspace-sidebar--drawer {
+  position: fixed;
+  left: 0;
+  top: 0;
+  z-index: 55;
+  width: min(360px, 80vw);
+  min-width: min(360px, 80vw);
+  height: 100dvh;
+  box-shadow: 0 18px 48px rgba(15, 23, 42, 0.28);
+}
+
+.workspace-sidebar--drawer-phone {
+  width: min(100vw, 26rem);
+  min-width: min(100vw, 26rem);
+}
+
 .workspace-sidebar--collapsed {
   width: 3.5rem;
   min-width: 3.5rem;
@@ -562,3 +588,42 @@
   background: var(--app-shell-subtle);
   color: var(--foreground);
 }
+
+@media (hover: none), (pointer: coarse) {
+  .workspace-sidebar__nav-item,
+  .workspace-sidebar__section-link,
+  .workspace-sidebar__settings-button,
+  .workspace-sidebar__action,
+  .workspace-sidebar__workspace-action {
+    min-height: 2.75rem;
+  }
+
+  .workspace-sidebar__brand {
+    padding-top: calc(0.75rem + env(safe-area-inset-top));
+  }
+
+  .workspace-sidebar__content {
+    padding-bottom: calc(1rem + env(safe-area-inset-bottom));
+  }
+
+  .workspace-sidebar__workspace-nav-item {
+    padding-right: 5.5rem;
+  }
+
+  .workspace-sidebar__workspace-actions {
+    opacity: 1;
+    gap: 0.35rem;
+    right: 0.5rem;
+  }
+
+  .workspace-sidebar__workspace-action {
+    width: 2rem;
+    height: 2rem;
+    border-color: var(--app-shell-border);
+  }
+
+  .workspace-sidebar__action {
+    width: 2.25rem;
+    height: 2.25rem;
+  }
+}