@mndrk/agx 2.4.5 → 2.4.7

package/cloud-runtime/standalone/apps/local/lib/workspace-yaml.ts

@@ -0,0 +1,164 @@
+import { dump, load } from "js-yaml";
+import type { WorkspaceEntry } from "./db";
+import { listWorkspaceCategories } from "./workspace-categories";
+
+export interface WorkspaceYamlCategory {
+  id: string;
+  label: string;
+}
+
+export interface WorkspaceYamlEntry {
+  category: string;
+  name: string;
+  purpose: string | null;
+}
+
+export interface WorkspaceYamlDocument {
+  version: 1;
+  categories: WorkspaceYamlCategory[];
+  entries: WorkspaceYamlEntry[];
+}
+
+const knownCategoryLabels = new Map<string, string>(
+  listWorkspaceCategories().map((category) => [category.id, category.label]),
+);
+
+function normalizeRequiredString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid or missing '${field}'`);
+  }
+
+  return value.trim();
+}
+
+function normalizeOptionalPurpose(value: unknown, field: string): string | null {
+  if (value === undefined || value === null) {
+    return null;
+  }
+
+  if (typeof value !== "string") {
+    throw new Error(`Invalid '${field}'`);
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function fallbackCategoryLabel(categoryId: string): string {
+  return categoryId
+    .split(/[_-]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ") || categoryId;
+}
+
+function categoryKey(category: string, name: string): string {
+  return `${category}\u0000${name}`;
+}
+
+export function serializeWorkspace(entries: WorkspaceEntry[]): string {
+  const sortedEntries = [...entries].sort((a, b) => {
+    if (a.category !== b.category) return a.category.localeCompare(b.category);
+    if (a.sort_order !== b.sort_order) return a.sort_order - b.sort_order;
+    return a.name.localeCompare(b.name);
+  });
+
+  const categories = new Map<string, WorkspaceYamlCategory>();
+  for (const entry of sortedEntries) {
+    if (!categories.has(entry.category)) {
+      categories.set(entry.category, {
+        id: entry.category,
+        label: knownCategoryLabels.get(entry.category) ?? fallbackCategoryLabel(entry.category),
+      });
+    }
+  }
+
+  const doc: WorkspaceYamlDocument = {
+    version: 1,
+    categories: Array.from(categories.values()),
+    entries: sortedEntries.map((entry) => ({
+      category: entry.category,
+      name: entry.name,
+      purpose: entry.purpose ?? null,
+    })),
+  };
+
+  return dump(doc, {
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false,
+  });
+}
+
+export function deserializeWorkspace(yaml: string): WorkspaceYamlDocument {
+  const parsed = load(yaml);
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Invalid YAML: expected an object at the root level");
+  }
+
+  const doc = parsed as Record<string, unknown>;
+  if (doc.version !== 1) {
+    throw new Error(`Unsupported version: ${doc.version ?? "missing"}. Only version 1 is supported.`);
+  }
+  if (!Array.isArray(doc.categories)) {
+    throw new Error("Invalid YAML: missing or invalid 'categories' array");
+  }
+  if (!Array.isArray(doc.entries)) {
+    throw new Error("Invalid YAML: missing or invalid 'entries' array");
+  }
+
+  const seenCategories = new Set<string>();
+  const categories = doc.categories.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Invalid category entry at index ${index}`);
+    }
+
+    const category = entry as Record<string, unknown>;
+    const id = normalizeRequiredString(category.id, `categories[${index}].id`);
+    const label = normalizeRequiredString(category.label, `categories[${index}].label`);
+
+    if (seenCategories.has(id)) {
+      throw new Error(`Duplicate category id '${id}'`);
+    }
+    seenCategories.add(id);
+
+    return { id, label };
+  });
+
+  const categoryIds = new Set(categories.map((category) => category.id));
+  const seenEntries = new Set<string>();
+
+  const entries = doc.entries.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Invalid workspace entry at index ${index}`);
+    }
+
+    const workspaceEntry = entry as Record<string, unknown>;
+    if ("path" in workspaceEntry) {
+      throw new Error(`Invalid workspace entry at index ${index}: 'path' is not allowed`);
+    }
+
+    const category = normalizeRequiredString(workspaceEntry.category, `entries[${index}].category`);
+    const name = normalizeRequiredString(workspaceEntry.name, `entries[${index}].name`);
+    const purpose = normalizeOptionalPurpose(workspaceEntry.purpose, `entries[${index}].purpose`);
+
+    if (!categoryIds.has(category)) {
+      throw new Error(`Entry '${name}' references unknown category '${category}'`);
+    }
+
+    const key = categoryKey(category, name);
+    if (seenEntries.has(key)) {
+      throw new Error(`Duplicate workspace entry '${category}/${name}'`);
+    }
+    seenEntries.add(key);
+
+    return { category, name, purpose };
+  });
+
+  return {
+    version: 1,
+    categories,
+    entries,
+  };
+}

package/cloud-runtime/standalone/apps/local/src/objectives/program/index.ts

@@ -0,0 +1,7 @@
+export {
+  PROGRAM_FILENAME,
+  getProgramPath,
+  readProgram,
+  writeProgram,
+} from "./repository";
+export type { ObjectiveProgram } from "./repository";

package/cloud-runtime/standalone/apps/local/src/objectives/program/repository.ts

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+import { homedir } from "os";
+
+export const PROGRAM_FILENAME = "program.md";
+
+function resolveAgxDataDir(): string {
+  const configured = process.env.AGX_DATA_DIR?.trim();
+  if (configured) return path.resolve(configured);
+  return path.join(homedir(), ".agx");
+}
+
+export function getProgramPath(projectSlug: string, objectiveKey: string): string {
+  return path.join(
+    resolveAgxDataDir(),
+    "projects",
+    projectSlug,
+    "objectives",
+    objectiveKey,
+    PROGRAM_FILENAME,
+  );
+}
+
+export interface ObjectiveProgram {
+  path: string;
+  content: string | null;
+  updatedAt: string | null;
+}
+
+export function readProgram(projectSlug: string, objectiveKey: string): ObjectiveProgram {
+  const filePath = getProgramPath(projectSlug, objectiveKey);
+  if (!fs.existsSync(filePath)) {
+    return { path: filePath, content: null, updatedAt: null };
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const stat = fs.statSync(filePath);
+    return { path: filePath, content, updatedAt: stat.mtime.toISOString() };
+  } catch {
+    return { path: filePath, content: null, updatedAt: null };
+  }
+}
+
+export function writeProgram(
+  projectSlug: string,
+  objectiveKey: string,
+  content: string,
+): ObjectiveProgram {
+  const filePath = getProgramPath(projectSlug, objectiveKey);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const trimmed = content.replace(/\s+$/g, "");
+  if (trimmed.length === 0) {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    return { path: filePath, content: null, updatedAt: null };
+  }
+  const body = trimmed + "\n";
+  fs.writeFileSync(filePath, body, "utf8");
+  const stat = fs.statSync(filePath);
+  return { path: filePath, content: body, updatedAt: stat.mtime.toISOString() };
+}

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

@@ -7,6 +7,7 @@ import {
 import { getIssueActiveAgents, type IssueActiveAgent } from '@/lib/linear-run-store';
 import { getActivityRepository } from '@/src/objectives/activities/repository';
 import { getNoteRepository } from '@/src/objectives/notes';
+import { readProgram } from '@/src/objectives/program';
 import {
   loadProjectObjectiveContext,
   persistProjectObjectiveMetadata,
@@ -220,6 +221,17 @@ export async function buildObjectiveObservation(opts: {
     `Progress: ${objective.progress}% | Status: ${objective.status}`,
   );
 
+  // PROGRAM (objective-level prompt: goal / definition of better / blast radius / learnings)
+  const program = readProgram(projectSlug, objective.key);
+  sections.push('', 'PROGRAM', `path: ${program.path}`);
+  if (program.content && program.content.trim().length > 0) {
+    sections.push(program.content.trim());
+  } else {
+    sections.push(
+      '(empty) No program has been authored for this objective yet. Before committing to a direction, surface this to the user in chat: ask what "better" means for this objective (the success metric), what paths/systems are in-scope, and any constraints. Capture the answer by writing to the path above.',
+    );
+  }
+
   // NOTES
   if (notes.length > 0) {
     sections.push(

package/cloud-runtime/standalone/apps/local/src/scheduling/status.ts

@@ -0,0 +1,42 @@
+type ScheduleState = "active" | "paused" | "stopped" | string;
+
+interface ScheduledRunStatusInput {
+  state: ScheduleState;
+  nextScheduledAt: number | null | undefined;
+  lastCompletedAt: number | null | undefined;
+  inProgress?: boolean;
+  now?: number;
+}
+
+interface IntervalScheduleStatusInput {
+  state: ScheduleState;
+  lastCompletedAt: number | null | undefined;
+  intervalMs: number;
+  inProgress?: boolean;
+  now?: number;
+}
+
+export function isScheduledRunOverdue({
+  state,
+  nextScheduledAt,
+  lastCompletedAt,
+  inProgress = false,
+  now = Date.now(),
+}: ScheduledRunStatusInput): boolean {
+  if (state !== "active" || inProgress) return false;
+  if (nextScheduledAt == null || nextScheduledAt >= now) return false;
+  if (lastCompletedAt != null && lastCompletedAt >= nextScheduledAt) return false;
+  return true;
+}
+
+export function isIntervalScheduleOverdue({
+  state,
+  lastCompletedAt,
+  intervalMs,
+  inProgress = false,
+  now = Date.now(),
+}: IntervalScheduleStatusInput): boolean {
+  if (state !== "active" || inProgress) return false;
+  if (lastCompletedAt == null) return false;
+  return lastCompletedAt + intervalMs < now;
+}

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

@@ -7904,19 +7904,22 @@ async function getProjectForThread(threadId) {
   return data?.project_id ?? null;
 }
 async function getProjectWorkspace(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workspace_entries").select("*").eq("project_id", projectId).order("category", { ascending: true }).order("sort_order", { ascending: true }).order("name", { ascending: true });
-  if (error) {
-    if (isMissingRelationError(error, "workspace_entries")) return {};
-    throw error;
-  }
-  const entries = data || [];
+  const entries = await getProjectWorkspaceEntries(projectId);
   return entries.reduce((acc, entry) => {
     if (!acc[entry.category]) acc[entry.category] = [];
     acc[entry.category].push(entry);
     return acc;
   }, {});
 }
+async function getProjectWorkspaceEntries(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("workspace_entries").select("*").eq("project_id", projectId).order("category", { ascending: true }).order("sort_order", { ascending: true }).order("name", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "workspace_entries")) return [];
+    throw error;
+  }
+  return data || [];
+}
 async function createWorkspaceEntry(projectId, entry) {
   const db2 = createAdminDbClient();
   const id = (0, import_crypto.randomUUID)();
@@ -7928,7 +7931,7 @@ async function createWorkspaceEntry(projectId, entry) {
     name: entry.name,
     path: entry.path || null,
     purpose: entry.purpose || null,
-    sort_order: 0,
+    sort_order: entry.sort_order ?? 0,
     created_at: now,
     updated_at: now
   }).select().single();
@@ -7942,6 +7945,7 @@ async function updateWorkspaceEntry(projectId, entryId, updates) {
   if (updates.path !== void 0) payload.path = updates.path;
   if (updates.purpose !== void 0) payload.purpose = updates.purpose;
   if (updates.sort_order !== void 0) payload.sort_order = updates.sort_order;
+  payload.updated_at = (/* @__PURE__ */ new Date()).toISOString();
   const { data, error } = await db2.from("workspace_entries").update(payload).eq("id", entryId).eq("project_id", projectId).select().single();
   if (error) {
     if (error.code === "PGRST116") return null;
@@ -9138,6 +9142,7 @@ __export(db_exports, {
   getProjectVariables: () => getProjectVariables,
   getProjectWithRepos: () => getProjectWithRepos,
   getProjectWorkspace: () => getProjectWorkspace,
+  getProjectWorkspaceEntries: () => getProjectWorkspaceEntries,
   getProjects: () => getProjects,
   getStagePrompt: () => getStagePrompt,
   getStagePrompts: () => getStagePrompts,
@@ -10474,6 +10479,7 @@ ${skills}
 var import_child_process2, import_fs10, import_os10, import_path10, isNonEmptyString, CliRunError, createRawParser, extractClaudeAssistantText, createClaudeStreamJsonParser, createGeminiStreamJsonParser, extractCodexAssistantText, createCodexJsonParser, createThoughtFilterParser, AGX_WRAPPED_PROVIDERS;
 var init_cli_runner = __esm({
   "apps/local/lib/cli-runner.ts"() {
+    "use strict";
     import_child_process2 = require("child_process");
     import_fs10 = __toESM(require("fs"));
     import_os10 = __toESM(require("os"));
@@ -10484,8 +10490,6 @@ var init_cli_runner = __esm({
     init_scheduled_task_skill();
     isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
     CliRunError = class extends Error {
-      exitCode;
-      logs;
       constructor(message, exitCode, logs) {
         super(message);
         this.name = "CliRunError";
@@ -24563,6 +24567,7 @@ 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)
       {

package/lib/commands/workspace.js

@@ -154,6 +154,89 @@ function buildCreateBody(category, name, locationPath, purpose) {
   return body;
 }
 
+function normalizeApiUrl(apiUrl) {
+  return String(apiUrl || '').replace(/\/$/, '');
+}
+
+function buildDirectRequestHeaders(cloudConfig, contentType = null) {
+  const internalServiceToken =
+    (process.env.AGX_INTERNAL_SERVICE_TOKEN || process.env.INTERNAL_SERVICE_TOKEN || '').trim();
+  const internalCallerId =
+    (process.env.AGX_EXECUTOR_CALLER_ID || 'executor-engine').trim();
+  const headers = {
+    'x-user-id': cloudConfig?.userId || '',
+    'x-agx-caller': internalCallerId,
+    'x-executor-caller-id': internalCallerId,
+  };
+
+  if (contentType) headers['Content-Type'] = contentType;
+  if (internalServiceToken) headers['x-internal-service-token'] = internalServiceToken;
+  if (cloudConfig?.token) headers.Authorization = `Bearer ${cloudConfig.token}`;
+
+  return headers;
+}
+
+async function parseApiError(response) {
+  try {
+    const data = await response.json();
+    if (typeof data?.error === 'string' && data.error.trim()) return data.error.trim();
+  } catch {
+    // Fall through to status-based fallback.
+  }
+
+  return `HTTP ${response.status}`;
+}
+
+function readWorkspaceImportSource(importPath) {
+  if (!importPath || importPath === '-') {
+    if (process.stdin.isTTY) {
+      throw new Error('Provide a file path or pipe YAML via stdin.');
+    }
+    return {
+      yaml: fs.readFileSync(0, 'utf8'),
+      sourceLabel: 'stdin',
+      usesStdin: true,
+    };
+  }
+
+  const resolved = path.resolve(importPath);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+
+  return {
+    yaml: fs.readFileSync(resolved, 'utf8'),
+    sourceLabel: resolved,
+    usesStdin: false,
+  };
+}
+
+async function exportWorkspaceYaml({ cloudConfig, project }) {
+  const exportUrl = `${normalizeApiUrl(cloudConfig.apiUrl)}/api/projects/${project.id}/workspace/export`;
+  const response = await fetch(exportUrl, {
+    headers: buildDirectRequestHeaders(cloudConfig),
+  });
+  if (!response.ok) {
+    const message = await parseApiError(response);
+    throw new Error(`Export failed: ${message}`);
+  }
+  return response.text();
+}
+
+async function importWorkspaceYaml({ cloudConfig, project, yaml }) {
+  const importUrl = `${normalizeApiUrl(cloudConfig.apiUrl)}/api/projects/${project.id}/workspace/import`;
+  const response = await fetch(importUrl, {
+    method: 'POST',
+    headers: buildDirectRequestHeaders(cloudConfig, 'text/yaml'),
+    body: yaml,
+  });
+  if (!response.ok) {
+    const message = await parseApiError(response);
+    throw new Error(`Import failed: ${message}`);
+  }
+  return response.json().catch(() => ({}));
+}
+
 async function maybeHandleWorkspaceCommand({ cmd, args, ctx }) {
   if (cmd !== 'workspace') return false;
 
@@ -176,12 +259,13 @@ async function maybeHandleWorkspaceCommand({ cmd, args, ctx }) {
   const subArgs = workspaceArgs.slice(1);
   const skipConfirm = hasFlag('yes', subArgs) || subArgs.includes('-y');
 
-  function ensureCloud() {
+  function requireCloudConfig() {
     const cloudConfig = loadCloudConfigFile();
     if (!cloudConfig?.apiUrl) {
       console.log(`${c.red}Board API URL not configured.${c.reset} Set AGX_BOARD_URL (legacy AGX_CLOUD_URL; default is http://localhost:41741)`);
       process.exit(1);
     }
+    return cloudConfig;
   }
 
   async function resolveProject() {
@@ -193,7 +277,7 @@ async function maybeHandleWorkspaceCommand({ cmd, args, ctx }) {
   try {
     switch (subcmd) {
       case 'list': {
-        ensureCloud();
+        requireCloudConfig();
         const project = await resolveProject();
         const data = await cloudRequest('GET', `/api/projects/${project.id}/workspace`);
         const workspace = data?.workspace && typeof data.workspace === 'object' ? data.workspace : {};
@@ -203,7 +287,7 @@ async function maybeHandleWorkspaceCommand({ cmd, args, ctx }) {
       }
 
       case 'add': {
-        ensureCloud();
+        requireCloudConfig();
         const [rawCategory, rawName, rawPath] = positionalArgs(subArgs);
         const category = canonicalizeWorkspaceCategory(rawCategory);
         const name = String(rawName || '').trim();
@@ -231,7 +315,7 @@ async function maybeHandleWorkspaceCommand({ cmd, args, ctx }) {
 
       case 'remove':
       case 'rm': {
-        ensureCloud();
+        requireCloudConfig();
         const [rawCategory, rawName] = positionalArgs(subArgs);
         const category = canonicalizeWorkspaceCategory(rawCategory);
         const name = String(rawName || '').trim();
@@ -267,10 +351,62 @@ async function maybeHandleWorkspaceCommand({ cmd, args, ctx }) {
         process.exit(0);
       }
 
-      case 'export':
+      case 'export': {
+        const cloudConfig = requireCloudConfig();
+        const project = await resolveProject();
+        const outputPath = String(flag('output', subArgs) || '').trim();
+        const yaml = await exportWorkspaceYaml({ cloudConfig, project });
+
+        if (!outputPath) {
+          process.stdout.write(yaml);
+          process.exit(0);
+        }
+
+        const resolved = path.resolve(outputPath);
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(resolved, yaml, 'utf8');
+        console.log(`${c.green}✓${c.reset} Exported workspace to ${resolved}`);
+        process.exit(0);
+      }
+
       case 'import': {
-        console.log(`${c.yellow}Not yet implemented${c.reset} - see ESO-380`);
-        process.exit(1);
+        const cloudConfig = requireCloudConfig();
+        const project = await resolveProject();
+        const importPath = positionalArgs(subArgs)[0] || null;
+        const usingPipedStdin = (!importPath || importPath === '-') && !process.stdin.isTTY;
+
+        if (usingPipedStdin && !skipConfirm) {
+          console.log(`${c.red}✗${c.reset} Importing from stdin requires --yes in non-interactive mode.`);
+          process.exit(1);
+        }
+
+        const { yaml, sourceLabel } = readWorkspaceImportSource(importPath);
+        if (!yaml.trim()) {
+          throw new Error(`Empty workspace YAML from ${sourceLabel}`);
+        }
+
+        if (!skipConfirm) {
+          console.log(`${c.bold}Import workspace from:${c.reset} ${sourceLabel}`);
+          const answer = await prompt('Continue? [y/N]: ');
+          if (answer.toLowerCase() !== 'y') {
+            console.log('Cancelled.');
+            process.exit(0);
+          }
+        }
+
+        const result = await importWorkspaceYaml({ cloudConfig, project, yaml });
+        const summary = result?.summary && typeof result.summary === 'object' ? result.summary : {};
+        const created = Number(summary.created || 0);
+        const updated = Number(summary.updated || 0);
+        const total = Number(summary.total || created + updated);
+        console.log(`${c.green}✓${c.reset} Imported workspace from ${sourceLabel}`);
+        console.log(`  Created: ${created}`);
+        console.log(`  Updated: ${updated}`);
+        console.log(`  Total: ${total}`);
+        process.exit(0);
       }
 
       default:
@@ -297,4 +433,6 @@ module.exports = {
   inferProjectIdentifierFromCwd,
   formatWorkspaceLines,
   buildCreateBody,
+  readWorkspaceImportSource,
+  buildDirectRequestHeaders,
 };

package/package.json

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