@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/state-machine.ts

@@ -5,6 +5,7 @@ import type {
   ConditionalNode,
   EdgeType,
   ForkNode,
+  FunctionNode,
   GateNode,
   GraphNode,
   JoinNode,
@@ -83,6 +84,13 @@ const VALID_NODE_TRANSITIONS: Record<NodeType, Set<string>> = {
     toTransitionKey("paused", "running"),
     toTransitionKey("stopped", "running"),
   ]),
+  // Function node transitions (deterministic, no agent loop)
+  function: new Set<string>([
+    toTransitionKey("pending", "running"),
+    toTransitionKey("pending", "skipped"),
+    toTransitionKey("running", "done"),
+    toTransitionKey("running", "failed"),
+  ]),
   // Root node transitions
   root: new Set<string>([
     toTransitionKey("pending", "running"),
@@ -171,6 +179,12 @@ export type JoinNodeTrigger =
   | { type: "EVALUATE"; dependencies: JoinDependencySnapshot[] }
   | { type: "SKIP" };
 
+export type FunctionNodeTrigger =
+  | { type: "START"; depsSatisfied: boolean }
+  | { type: "COMPLETE" }
+  | { type: "FAIL" }
+  | { type: "SKIP" };
+
 export type ConditionalNodeTrigger =
   | { type: "START"; depsSatisfied: boolean }
   | { type: "CONDITION_TRUE" }
@@ -195,6 +209,10 @@ interface JoinMachineContext {
   dependencies: JoinDependencySnapshot[];
 }
 
+interface FunctionMachineContext {
+  node: FunctionNode;
+}
+
 interface ConditionalMachineContext {
   node: ConditionalNode;
 }
@@ -592,6 +610,59 @@ export const conditionalNodeMachine = conditionalNodeSetup.createMachine({
   },
 });
 
+const functionNodeSetup = setup({
+  types: {
+    context: {} as FunctionMachineContext,
+    input: {} as FunctionMachineContext,
+    events: {} as FunctionNodeTrigger,
+  },
+  guards: {
+    depsSatisfied: ({ event }) => event.type === "START" && event.depsSatisfied,
+  },
+  actions: {
+    markRunning: assign(({ context }) => ({ node: { ...context.node, status: "running" } })),
+    markDone: assign(({ context }) => ({ node: { ...context.node, status: "done" } })),
+    markFailed: assign(({ context }) => ({ node: { ...context.node, status: "failed" } })),
+    markSkipped: assign(({ context }) => ({ node: { ...context.node, status: "skipped" } })),
+  },
+});
+
+export const functionNodeMachine = functionNodeSetup.createMachine({
+  id: "function-node",
+  initial: "pending",
+  context: ({ input }) => ({ node: { ...input.node } }),
+  states: {
+    pending: {
+      on: {
+        START: {
+          target: "running",
+          guard: "depsSatisfied",
+          actions: "markRunning",
+        },
+        SKIP: {
+          target: "skipped",
+          actions: "markSkipped",
+        },
+      },
+    },
+    running: {
+      on: {
+        COMPLETE: {
+          target: "done",
+          actions: "markDone",
+        },
+        FAIL: {
+          target: "failed",
+          actions: "markFailed",
+        },
+      },
+    },
+    done: {},
+    failed: {},
+    skipped: {},
+  },
+});
+
 function assertEventSupported(
   machine: { getTransitionData: (...args: any[]) => unknown[] }, // eslint-disable-line
   snapshot: unknown,
@@ -707,10 +778,20 @@ export function transitionConditionalNode(
   };
 }
 
+export function transitionFunctionNode(node: FunctionNode, trigger: FunctionNodeTrigger): FunctionNode {
+  const snapshot = functionNodeMachine.resolveState({ value: resolveStatusValue(node), context: { node: { ...node } } });
+  assertEventSupported(functionNodeMachine, snapshot, trigger, node.type, node.status);
+  const [nextSnapshot] = xstateTransition(functionNodeMachine, snapshot, trigger);
+  const nextNode = nextSnapshot.context.node;
+  assertStatusPair(node.type, node.status, nextNode.status);
+  return nextNode;
+}
+
 export const NODE_STATE_MACHINES = {
   work: workNodeMachine,
   gate: gateNodeMachine,
   fork: forkNodeMachine,
   join: joinNodeMachine,
   conditional: conditionalNodeMachine,
+  function: functionNodeMachine,
 } as const;

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/store.ts

@@ -48,6 +48,7 @@ export interface GraphStructureUpdate {
   edges?: Edge[];
   policy?: ExecutionGraph["policy"];
   doneCriteria?: ExecutionGraph["doneCriteria"];
+  schedule?: ExecutionGraph["schedule"];
 }
 
 export class GraphVersionConflictError extends Error {
@@ -100,6 +101,7 @@ interface ExecutionGraphRow extends QueryResultRow {
   mode: ExecutionGraph["mode"];
   policy: string | ExecutionGraph["policy"] | null;
   done_criteria: string | ExecutionGraph["doneCriteria"] | null;
+  schedule: string | ExecutionGraph["schedule"] | null;
   created_at: string;
   updated_at: string;
 }
@@ -208,11 +210,15 @@ export class GraphStore {
     return getSQLiteDb();
   }
 
-  createGraph(graph: ExecutionGraph): ExecutionGraph {
+  createGraph(graph: ExecutionGraph, opts?: { skipTaskBinding?: boolean }): ExecutionGraph {
     const db = this.getDb();
     const q = makeSQLiteQueryable(db);
 
-    return db.transaction(() => {
+    if (opts?.skipTaskBinding) {
+      db.pragma("foreign_keys = OFF");
+    }
+
+    try { return db.transaction(() => {
       const existingResult = q.query<Pick<ExecutionGraphRow, "id">>(
         `SELECT id FROM execution_graphs WHERE task_id = ? LIMIT 1`,
         [graph.taskId],
@@ -224,19 +230,21 @@ export class GraphStore {
 
       q.query(
         `INSERT INTO execution_graphs
-          (id, task_id, graph_version, mode, policy, done_criteria, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          (id, task_id, graph_version, mode, policy, done_criteria, schedule, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT (id) DO UPDATE SET
            task_id = excluded.task_id,
            graph_version = excluded.graph_version,
            mode = excluded.mode,
            policy = excluded.policy,
            done_criteria = excluded.done_criteria,
+           schedule = excluded.schedule,
            created_at = excluded.created_at,
            updated_at = excluded.updated_at`,
         [
           graph.id, graph.taskId, graph.graphVersion, graph.mode,
           toJson(graph.policy), toJson(graph.doneCriteria),
+          toJson(graph.schedule ?? null),
           graph.createdAt, graph.updatedAt,
         ],
       );
@@ -270,12 +278,18 @@ export class GraphStore {
         this.appendEventInternal(q, graph.id, event);
       }
 
-      q.query("UPDATE tasks SET graph_id = ? WHERE id = ?", [graph.id, graph.taskId]);
+      if (!opts?.skipTaskBinding) {
+        q.query("UPDATE tasks SET graph_id = ? WHERE id = ?", [graph.id, graph.taskId]);
+      }
 
       const persisted = this.getGraphForTask(q, graph.taskId);
       if (!persisted) throw new GraphNotFoundError(graph.id);
       return persisted;
-    })();
+    })(); } finally {
+      if (opts?.skipTaskBinding) {
+        db.pragma("foreign_keys = ON");
+      }
+    }
   }
 
   getGraph(taskId: string): ExecutionGraph | null {
@@ -374,9 +388,9 @@ export class GraphStore {
 
     return db.transaction(() => {
       const graphResult = q.query<
-        Pick<ExecutionGraphRow, "id" | "graph_version" | "mode" | "policy" | "done_criteria">
+        Pick<ExecutionGraphRow, "id" | "graph_version" | "mode" | "policy" | "done_criteria" | "schedule">
       >(
-        `SELECT id, graph_version, mode, policy, done_criteria FROM execution_graphs WHERE id = ?`,
+        `SELECT id, graph_version, mode, policy, done_criteria, schedule FROM execution_graphs WHERE id = ?`,
         [graphId],
       );
       const current = graphResult.rows[0];
@@ -409,13 +423,14 @@ export class GraphStore {
 
       const touchedGraph = q.query<Pick<ExecutionGraphRow, "graph_version" | "updated_at">>(
         `UPDATE execution_graphs
-         SET mode = ?, policy = ?, done_criteria = ?, updated_at = datetime('now')
+         SET mode = ?, policy = ?, done_criteria = ?, schedule = ?, updated_at = datetime('now')
          WHERE id = ?
          RETURNING graph_version, updated_at`,
         [
           update.mode ?? current.mode,
           toJson(update.policy ?? parseJson(current.policy) ?? {}),
           toJson(update.doneCriteria ?? parseJson(current.done_criteria) ?? {}),
+          toJson(update.schedule ?? parseJson(current.schedule) ?? null),
           graphId,
         ],
       );
@@ -434,7 +449,7 @@ export class GraphStore {
 
   private getGraphForTask(client: Queryable, taskId: string): ExecutionGraph | null {
     const graphResult = client.query<ExecutionGraphRow>(
-      `SELECT id, task_id, graph_version, mode, policy, done_criteria, created_at, updated_at
+      `SELECT id, task_id, graph_version, mode, policy, done_criteria, schedule, created_at, updated_at
        FROM execution_graphs WHERE task_id = ? ORDER BY updated_at DESC LIMIT 1`,
       [taskId],
     );
@@ -492,6 +507,7 @@ export class GraphStore {
       edges,
       policy: (parseJson(graphRow.policy) ?? {}) as ExecutionGraph["policy"],
       doneCriteria: (parseJson(graphRow.done_criteria) ?? {}) as ExecutionGraph["doneCriteria"],
+      schedule: (parseJson(graphRow.schedule) ?? undefined) as ExecutionGraph["schedule"] | undefined,
       versionHistory,
       runtimeEvents,
       createdAt: toIsoString(graphRow.created_at),
@@ -514,8 +530,8 @@ export function createGraphStore(): GraphStore {
 
 const defaultGraphStore = new GraphStore();
 
-export function createGraph(graph: ExecutionGraph): ExecutionGraph {
-  return defaultGraphStore.createGraph(graph);
+export function createGraph(graph: ExecutionGraph, opts?: { skipTaskBinding?: boolean }): ExecutionGraph {
+  return defaultGraphStore.createGraph(graph, opts);
 }
 
 export function getGraph(taskId: string): ExecutionGraph | null {
@@ -578,3 +594,64 @@ export function getGraphEvents(
   const result = q.query<GraphEventRow>(sql, params);
   return result.rows.map((row) => normalizeGraphEvent(row));
 }
+
+export function getActiveScheduleForRootMessageId(
+  rootMessageId: string,
+): { graphId: string; taskId: string } | null {
+  const normalized = rootMessageId.trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const db = getSQLiteDb();
+  const row = db
+    .prepare(
+      `SELECT id AS graphId, task_id AS taskId
+       FROM execution_graphs
+       WHERE schedule IS NOT NULL
+         AND json_extract(schedule, '$.rootMessageId') = ?
+         AND json_extract(schedule, '$.state') = 'active'
+       ORDER BY updated_at DESC
+       LIMIT 1`,
+    )
+    .get(normalized) as { graphId: string; taskId: string } | undefined;
+
+  return row ?? null;
+}
+
+/**
+ * Return all rootMessageIds that have an active schedule.
+ */
+export function getActiveScheduleRootMessageIds(): string[] {
+  const db = getSQLiteDb();
+  const rows = db
+    .prepare(
+      `SELECT json_extract(schedule, '$.rootMessageId') AS rootMessageId
+       FROM execution_graphs
+       WHERE schedule IS NOT NULL
+         AND json_extract(schedule, '$.state') = 'active'`,
+    )
+    .all() as { rootMessageId: string }[];
+  return rows.map((r) => r.rootMessageId).filter(Boolean);
+}
+
+export function deactivateSchedulesByRootMessageId(rootMessageId: string): number {
+  const normalized = rootMessageId.trim();
+  if (!normalized) {
+    return 0;
+  }
+
+  const db = getSQLiteDb();
+  const result = db
+    .prepare(
+      `UPDATE execution_graphs
+       SET schedule = json_set(schedule, '$.state', 'stopped', '$.tickInProgress', json('false')),
+           updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
+       WHERE schedule IS NOT NULL
+         AND json_extract(schedule, '$.rootMessageId') = ?
+         AND json_extract(schedule, '$.state') = 'active'`,
+    )
+    .run(normalized);
+
+  return Number(result.changes ?? 0);
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/types.ts

@@ -1,6 +1,6 @@
 export type GraphMode = 'SIMPLE' | 'PROJECT';
 
-export type NodeType = 'work' | 'gate' | 'fork' | 'join' | 'conditional' | 'root';
+export type NodeType = 'work' | 'gate' | 'fork' | 'join' | 'conditional' | 'root' | 'function';
 
 export type NodeStatus =
   | 'pending'
@@ -27,6 +27,10 @@ export type GateType =
   | 'handoff_gate'
   | 'approval_gate';
 
+export type FunctionNodeKind = 'bash' | 'mcp';
+
+export type FunctionNodeStatus = Extract<NodeStatus, 'pending' | 'running' | 'done' | 'failed' | 'skipped'>;
+
 export type WorkNodeStatus = Extract<NodeStatus, 'pending' | 'running' | 'done' | 'failed' | 'blocked' | 'skipped' | 'paused' | 'stopped'>;
 export type GateNodeStatus = Extract<NodeStatus, 'pending' | 'running' | 'awaiting_human' | 'passed' | 'failed' | 'skipped' | 'paused' | 'stopped'>;
 export type ForkNodeStatus = Extract<NodeStatus, 'pending' | 'done' | 'skipped'>;
@@ -94,6 +98,24 @@ export interface WorkNode extends BaseNode {
   output?: Record<string, unknown>;
 }
 
+export interface FunctionNode extends BaseNode {
+  type: 'function';
+  status: FunctionNodeStatus;
+  kind: FunctionNodeKind;
+
+  title: string;
+  description?: string;
+
+  /** For bash: the command string. For mcp: the tool name. */
+  command: string;
+  /** For mcp: tool input parameters. */
+  args?: Record<string, unknown>;
+
+  timeoutMs?: number;
+
+  output?: Record<string, unknown>;
+}
+
 // Root node represents the task objective and creates the graph on first execution
 export interface RootNode extends BaseNode {
   type: 'root';
@@ -170,7 +192,7 @@ export interface ConditionalNode extends BaseNode {
   evaluatedTo?: 'then' | 'else';
 }
 
-export type GraphNode = WorkNode | GateNode | ForkNode | JoinNode | ConditionalNode | RootNode;
+export type GraphNode = WorkNode | GateNode | ForkNode | JoinNode | ConditionalNode | RootNode | FunctionNode;
 
 export type EdgeType = 'hard' | 'soft';
 export type EdgeCondition = 'on_success' | 'on_failure' | 'always';
@@ -300,13 +322,52 @@ export type VersionHistoryEvent = ReplanEvent | RollbackEvent;
 export type RuntimeEvent = GraphCreatedEvent | NodeStatusEvent | GateVerificationEvent | BudgetConsumedEvent;
 export type GraphEvent = VersionHistoryEvent | RuntimeEvent;
 
+export type ScheduleState = 'active' | 'paused' | 'stopped';
+
+export interface GraphSchedule {
+  /** Interval between ticks in milliseconds (used when cronExpr is absent) */
+  intervalMs: number;
+  /** Optional cron expression — takes precedence over intervalMs when present */
+  cronExpr?: string;
+  /** Human-readable cadence label (e.g. "Every 2 hours", "Weekdays at 9 AM") */
+  cadence?: string;
+  /** Current schedule state */
+  state: ScheduleState;
+  /** Node IDs to reset to pending on each tick */
+  resetNodeIds: string[];
+  /** Maximum number of runs (undefined = unlimited) */
+  maxRuns?: number;
+  /** Number of completed runs so far */
+  runCount: number;
+  /** Timestamp of last tick start (epoch ms) */
+  lastTickAt?: number;
+  /** Pre-computed next tick timestamp (epoch ms) — set after each tick or activation */
+  nextTickAt?: number;
+  /** Whether a tick is currently executing (overlap prevention) */
+  tickInProgress: boolean;
+  /** ISO timestamp when schedule was created */
+  createdAt: string;
+  /** Optional timestamp after which schedule should stop running */
+  activeUntil?: string;
+  /** Optional root message id this schedule monitors */
+  rootMessageId?: string;
+  /** Consecutive failure count (for auto-pause) */
+  consecutiveFailures?: number;
+  /** Max consecutive failures before auto-pause (undefined = no limit) */
+  maxConsecutiveFailures?: number;
+  /** Optional display name for the schedule */
+  name?: string;
+  /** Optional description */
+  description?: string;
+}
+
 export interface ExecutionGraph {
   id: string;
   taskId: string;
   graphVersion: number;
 
   mode: GraphMode;
-  
+
   // Execution lifecycle state for the entire task (defaults to 'ready' if not set)
   executionState?: ExecutionLifecycleState;
 
@@ -317,6 +378,9 @@ export interface ExecutionGraph {
 
   doneCriteria: DoneCriteria;
 
+  /** Optional recurrence schedule for autonomous re-execution */
+  schedule?: GraphSchedule;
+
   versionHistory: VersionHistoryEvent[];
   runtimeEvents?: RuntimeEvent[];
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/work-dispatcher.ts

@@ -0,0 +1,174 @@
+/**
+ * Work Dispatcher for schedule-driven work nodes.
+ *
+ * For the thread-monitor steer node:
+ * 1. Reads the thread's conversation state directly from the DB
+ * 2. Calls the provider directly via runCliResponse (same as chat endpoint)
+ * 3. Parses structured output: { isDone: boolean, message: string }
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+import type { WorkNode, ExecutionGraph } from './types';
+import type { WorkDispatchResult } from './executor';
+
+const STEER_SYSTEM_PROMPT = `You are a progress assessor. Review the conversation state below and determine:
+1. Is the work DONE? (all objectives met, code written, tests passing)
+2. If not done, what should the team do next?
+
+You MUST respond with ONLY a JSON object, no markdown fences, no extra text:
+{"isDone": true/false, "message": "your assessment"}
+
+If done, message should confirm what was accomplished.
+If not done, message should be clear next-step instructions.`;
+
+/**
+ * Read agx config to get the default provider name.
+ */
+function getDefaultProvider(): string {
+  try {
+    const configPath = join(homedir(), '.agx', 'config.json');
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    return config.defaultProvider ?? 'claude';
+  } catch {
+    return 'claude';
+  }
+}
+
+/**
+ * Create a dispatchWork implementation for schedule-driven graphs.
+ *
+ * Reads thread status from DB, calls provider directly via runCliResponse, returns structured result.
+ */
+export function createDispatchWork(): (
+  node: WorkNode,
+  graph: ExecutionGraph,
+) => Promise<WorkDispatchResult> {
+  return async (node, graph) => {
+    const rootMessageId = graph.schedule?.rootMessageId;
+    if (!rootMessageId) {
+      return {
+        status: 'failure' as const,
+        message: 'No rootMessageId on graph schedule',
+      };
+    }
+
+    console.log(
+      `[work-dispatch] Dispatching steer node "${node.title}" for graph ${graph.id} (root: ${rootMessageId})`,
+    );
+
+    try {
+      // 1. Read thread status directly from DB
+      const { getMessageThread, getThreadStatusSnapshot, sweepStaleWorkingReactions } =
+        await import('@/lib/history-store');
+
+      const threadRef = await getMessageThread(rootMessageId);
+      if (!threadRef) {
+        return {
+          status: 'failure' as const,
+          message: `Thread not found for rootMessageId: ${rootMessageId}`,
+        };
+      }
+
+      await sweepStaleWorkingReactions(threadRef.threadId);
+      const snapshot = await getThreadStatusSnapshot({
+        threadId: threadRef.threadId,
+        rootMessageId,
+      });
+
+      const activeProcessCount = snapshot.processes.filter(
+        (p: { status: string }) => p.status === 'working',
+      ).length;
+
+      // Build a summary of recent messages for context
+      const recentMessages = (snapshot.messages ?? [])
+        .slice(-10)
+        .map((m: { role?: string; content?: string; participantId?: string | null }) => {
+          const sender = m.participantId ?? m.role ?? '?';
+          const text = (m.content ?? '').slice(0, 300);
+          return `[${sender}]: ${text}`;
+        })
+        .join('\n');
+
+      console.log(`[work-dispatch] Thread: active=${activeProcessCount}, msgs=${snapshot.messages?.length ?? 0}`);
+
+      // 2. Build assessment prompt
+      const assessPrompt = [
+        '--- THREAD STATE ---',
+        `Active agents: ${activeProcessCount}`,
+        `Total messages: ${snapshot.messages?.length ?? 0}`,
+        '',
+        'Recent messages:',
+        recentMessages,
+        '--- END THREAD STATE ---',
+        '',
+        'Assess the progress and respond with the JSON object.',
+      ].join('\n');
+
+      // 3. Call provider directly via runCliResponse (same path as chat endpoint)
+      const { runCliResponse } = await import('@/lib/cli-runner');
+      const provider = getDefaultProvider();
+      console.log(`[work-dispatch] Calling ${provider} via runCliResponse (prompt length: ${assessPrompt.length})...`);
+
+      let fullResponse = '';
+      await runCliResponse({
+        provider: provider as 'claude' | 'gemini' | 'ollama' | 'codex',
+        model: null,
+        prompt: assessPrompt,
+        systemContext: STEER_SYSTEM_PROMPT,
+        onDelta: (chunk: string) => {
+          fullResponse += chunk;
+        },
+        onLog: (stream, line) => {
+          console.log(`[work-dispatch] [${stream}] ${line}`);
+        },
+      });
+
+      console.log(`[work-dispatch] Raw response: ${fullResponse.slice(0, 500)}`);
+
+      // 4. Parse structured output
+      const parsed = parseSteerResponse(fullResponse.trim());
+      console.log(`[work-dispatch] Parsed result:`, parsed);
+
+      return {
+        status: 'success' as const,
+        output: parsed,
+      };
+    } catch (err) {
+      console.error(`[work-dispatch] Steer dispatch failed:`, err);
+      return {
+        status: 'failure' as const,
+        message: err instanceof Error ? err.message : String(err),
+        error: err,
+      };
+    }
+  };
+}
+
+/**
+ * Parse the steer agent's response into { isDone, message }.
+ * Tries JSON parse first, falls back to heuristic detection.
+ */
+function parseSteerResponse(raw: string): { isDone: boolean; message: string } {
+  // Try to extract JSON from the response
+  const jsonMatch = raw.match(/\{[\s\S]*?"isDone"\s*:\s*(true|false)[\s\S]*?\}/);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return {
+        isDone: Boolean(parsed.isDone),
+        message: String(parsed.message ?? ''),
+      };
+    } catch { /* fall through */ }
+  }
+
+  // Fallback: check for [done] marker
+  if (raw.includes('[done]')) {
+    return { isDone: true, message: raw };
+  }
+
+  // Default: not done, use raw output as message
+  return { isDone: false, message: raw };
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/styles/composer-pills.css

@@ -29,6 +29,13 @@
   color: #7c3aed;
 }
 
+/* Project mention (@Project) */
+.composer-pill--project {
+  background-color: #ecfeff;
+  border-color: #a5f3fc;
+  color: #0e7490;
+}
+
 /* File mention (@/path) */
 .composer-pill--file {
   background-color: #f0fdf4;
@@ -43,6 +50,9 @@
   color: #b45309;
 }
 
+/* ─── Tiptap editor container styling ────────────────────────────────────── */
+
+
 /* ─── Tiptap editor container styling ────────────────────────────────────── */
 
 .composer-editor .tiptap {
@@ -59,6 +69,31 @@
   margin: 0;
 }
 
+/* ─── Ship Mode animations ──────────────────────────────────────────────── */
+
+@keyframes shipBgSweep {
+  0%, 100% { background-position: 0% 50%; }
+  50% { background-position: 100% 50%; }
+}
+
+@keyframes shipSpeedLine {
+  0% { transform: translateX(0); opacity: 0; }
+  20% { opacity: 1; }
+  100% { transform: translateX(-120%); opacity: 0; }
+}
+
+@keyframes shipRocketShake {
+  0%, 100% { transform: translate(0, 0) rotate(0deg); }
+  25% { transform: translate(0.5px, -0.5px) rotate(-1deg); }
+  50% { transform: translate(-0.5px, 0.5px) rotate(0.5deg); }
+  75% { transform: translate(0.5px, 0px) rotate(-0.5deg); }
+}
+
+@keyframes shipPulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+
 .composer-editor .tiptap p.is-editor-empty:first-child::before {
   content: attr(data-placeholder);
   float: left;

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/styles/workspaceSidebar.css

@@ -124,7 +124,7 @@
   display: flex;
   align-items: center;
   gap: 0.375rem;
-  margin: 1rem 0 0.5rem;
+  margin-top: 0.5rem;
   padding: 0.25rem 0.75rem;
   font-size: 0.6875rem;
   font-weight: 600;