@worca/ui 0.32.0 → 0.33.0

package/app/styles.css

@@ -5651,6 +5651,36 @@ sl-tooltip.bead-tooltip::part(body) {
   gap: 4px;
 }
 
+/* Workspace plan upload (existing mode) */
+.workspace-plan-upload {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.workspace-plan-advanced {
+  font-size: 13px;
+}
+.workspace-plan-advanced sl-input {
+  margin-top: 4px;
+}
+
+/* Per-project plan rows (per-repo mode) */
+.per-project-plans {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.per-project-plan-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.per-project-plan-name {
+  min-width: 100px;
+  font-size: 13px;
+  font-weight: 500;
+}
+
 /* Base-branch validation states */
 .base-branch-validating {
   display: flex;
@@ -6288,6 +6318,9 @@ sl-dialog.markdown-dialog::part(body) {
   font-size: 12px;
   max-height: 200px;
   overflow-y: auto;
+  /* Inherit the tooltip's (light) text color instead of --fg, which is the
+     main-panel foreground and renders dark-on-dark inside the tooltip. */
+  color: inherit;
 }
 .bead-tooltip-excerpt.markdown-body p {
   margin: 0.3em 0;
@@ -6297,6 +6330,18 @@ sl-dialog.markdown-dialog::part(body) {
   max-height: 120px;
   overflow: auto;
 }
+/* The base markdown code/blockquote/link colors assume the light main panel;
+   re-tint them for the dark tooltip surface so they stay legible. */
+.bead-tooltip-excerpt.markdown-body code,
+.bead-tooltip-excerpt.markdown-body pre {
+  background: rgba(255, 255, 255, 0.1);
+  border-color: rgba(255, 255, 255, 0.15);
+}
+.bead-tooltip-excerpt.markdown-body blockquote {
+  color: inherit;
+  opacity: 0.8;
+  border-left-color: rgba(255, 255, 255, 0.3);
+}
 
 .workspace-run-card .workspace-card-root,
 .workspace-run-card .workspace-card-name {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/server/app.js

@@ -65,6 +65,39 @@ function runWorcaCleanupSubprocess(flag, id) {
   });
 }
 
+export function buildWorkspaceArgs(workspace_root, workspace_id, manifest) {
+  const args = [
+    '-m',
+    'worca.scripts.run_workspace',
+    workspace_root,
+    '--workspace-id',
+    workspace_id,
+  ];
+  if (manifest.work_request?.source) {
+    args.push('--source', manifest.work_request.source);
+  } else {
+    args.push('--prompt', manifest.work_request?.description ?? '');
+  }
+  if (manifest.branch_template) {
+    args.push('--branch', manifest.branch_template);
+  }
+  if (manifest.skip_integration) args.push('--skip-integration');
+  if (manifest.skip_planning) args.push('--skip-planning');
+  if (manifest.max_parallel) {
+    args.push('--max-parallel', String(manifest.max_parallel));
+  }
+  for (const p of manifest.guide?.paths || []) {
+    args.push('--guide', p);
+  }
+  if (manifest.workspace_plan_path) {
+    args.push('--workspace-plan', manifest.workspace_plan_path);
+  }
+  for (const [name, path] of Object.entries(manifest.project_plans || {})) {
+    args.push('--project-plan', `${name}=${path}`);
+  }
+  return args;
+}
+
 export function createApp(options = {}) {
   const app = express();
   const appDir = join(dirname(fileURLToPath(import.meta.url)), '..', 'app');
@@ -733,29 +766,7 @@ export function createApp(options = {}) {
           child.unref();
           return;
         }
-        const args = [
-          '-m',
-          'worca.scripts.run_workspace',
-          workspace_root,
-          '--workspace-id',
-          workspace_id,
-        ];
-        if (manifest.work_request?.source) {
-          args.push('--source', manifest.work_request.source);
-        } else {
-          args.push('--prompt', manifest.work_request?.description ?? '');
-        }
-        if (manifest.branch_template) {
-          args.push('--branch', manifest.branch_template);
-        }
-        if (manifest.skip_integration) args.push('--skip-integration');
-        if (manifest.skip_planning) args.push('--skip-planning');
-        if (manifest.max_parallel) {
-          args.push('--max-parallel', String(manifest.max_parallel));
-        }
-        for (const p of manifest.guide?.paths || []) {
-          args.push('--guide', p);
-        }
+        const args = buildWorkspaceArgs(workspace_root, workspace_id, manifest);
         const child = spawn('python3', args, {
           detached: true,
           stdio: 'ignore',

package/server/integrations/renderers.js

@@ -453,6 +453,32 @@ function renderWorkspacePlanFailed(envelope) {
   return mdMsg(parts.join('\n'), 'error');
 }
 
+function renderWorkspacePlanLoaded(envelope) {
+  const p = envelope.payload ?? {};
+  const parts = [`📋 **Workspace plan loaded:** ${workspaceTitle(envelope)}`];
+  parts.push(
+    `   **Mode:** ${p.mode ?? '?'} (${p.project_count ?? '?'} project${p.project_count === 1 ? '' : 's'})`,
+  );
+  return mdMsg(parts.join('\n'), 'info');
+}
+
+function renderWorkspacePlanPartial(envelope) {
+  const p = envelope.payload ?? {};
+  const uncovered = Array.isArray(p.uncovered_projects)
+    ? p.uncovered_projects
+    : [];
+  const parts = [
+    `⚠ **Workspace plan partial coverage:** ${workspaceTitle(envelope)}`,
+  ];
+  parts.push(
+    `   **Mode:** ${p.mode ?? '?'} — ${uncovered.length} uncovered project${uncovered.length === 1 ? '' : 's'}`,
+  );
+  if (uncovered.length > 0) {
+    parts.push(`   **Uncovered:** ${uncovered.join(', ')}`);
+  }
+  return mdMsg(parts.join('\n'), 'warning');
+}
+
 function renderWorkspaceTierStarted(envelope) {
   const p = envelope.payload ?? {};
   const projects = Array.isArray(p.projects) ? p.projects : [];
@@ -570,6 +596,8 @@ export const OPT_IN_RENDERERS = {
   'workspace.plan.started': renderWorkspacePlanStarted,
   'workspace.plan.completed': renderWorkspacePlanCompleted,
   'workspace.plan.failed': renderWorkspacePlanFailed,
+  'workspace.plan.loaded': renderWorkspacePlanLoaded,
+  'workspace.plan.partial': renderWorkspacePlanPartial,
   'workspace.tier.started': renderWorkspaceTierStarted,
   'workspace.tier.completed': renderWorkspaceTierCompleted,
   'workspace.integration_test.started': renderWorkspaceIntegrationStarted,

package/server/workspace-routes.js

@@ -29,6 +29,8 @@ import {
 } from './paths.js';
 
 const GUIDE_CAP_BYTES_DEFAULT = 64 * 1024;
+const PROJECT_PLAN_CAP_BYTES = 256 * 1024;
+const WORKSPACE_PLAN_CAP_BYTES = 256 * 1024;
 
 const WS_ID_RE = /^ws_\d{12}_[0-9a-f]{1,32}$/;
 
@@ -557,6 +559,105 @@ function parseMultipart(body, contentType) {
   return parts;
 }
 
+// ─── plan strategy resolution ─────────────────────────────────────────────
+
+/**
+ * Map a plan_mode to the manifest fields it implies and validate
+ * mode-specific preconditions.
+ *
+ * @param {string} plan_mode - 'master' | 'existing' | 'per-repo' | 'independent'
+ * @param {string|null} workspace_plan_path
+ * @param {Object|null} project_plans - { projectName: filePath, ... }
+ * @param {Object} ws - parsed workspace.json (needs ws.projects)
+ * @returns {{ ok: true, fields: object } | { ok: false, status: number, error: string }}
+ */
+export function _resolvePlanStrategy(
+  plan_mode,
+  workspace_plan_path,
+  project_plans,
+  ws,
+) {
+  const mode = plan_mode || 'master';
+  const projectNames = new Set((ws.projects ?? []).map((p) => p.name));
+
+  if (mode === 'existing') {
+    if (!workspace_plan_path) {
+      return {
+        ok: false,
+        status: 400,
+        error:
+          'existing mode requires a workspace plan (upload or server-side path)',
+      };
+    }
+    return {
+      ok: true,
+      fields: {
+        plan_mode: 'existing',
+        workspace_plan_path,
+        project_plans: null,
+        skip_planning: false,
+      },
+    };
+  }
+
+  if (mode === 'per-repo') {
+    const plans = project_plans ?? {};
+    const planKeys = Object.keys(plans);
+    if (planKeys.length === 0) {
+      return {
+        ok: false,
+        status: 400,
+        error: 'per-repo mode requires at least one project plan',
+      };
+    }
+    const unknown = planKeys.filter((name) => !projectNames.has(name));
+    if (unknown.length > 0) {
+      return {
+        ok: false,
+        status: 422,
+        error: `Unknown project(s) in per-repo plans: ${unknown.join(', ')}`,
+      };
+    }
+    return {
+      ok: true,
+      fields: {
+        plan_mode: 'per-repo',
+        workspace_plan_path: null,
+        project_plans: plans,
+        skip_planning: false,
+      },
+    };
+  }
+
+  if (mode === 'independent') {
+    return {
+      ok: true,
+      fields: {
+        plan_mode: 'independent',
+        workspace_plan_path: null,
+        project_plans: null,
+        skip_planning: true,
+      },
+    };
+  }
+
+  // master (default) — ignore any stray plan inputs. master mode always runs
+  // the master planner; the Python CLI infers its mode from which flags are
+  // present, so passing --workspace-plan/--project-plan through here would
+  // silently run the job as existing/per-repo while the manifest (and badge)
+  // still claimed "master". Null them out to keep declared mode and actual
+  // behavior in lockstep.
+  return {
+    ok: true,
+    fields: {
+      plan_mode: 'master',
+      workspace_plan_path: null,
+      project_plans: null,
+      skip_planning: false,
+    },
+  };
+}
+
 // ─── default injectables ──────────────────────────────────────────────────
 
 function defaultValidateBaseBranch(repoPath, branch) {
@@ -929,6 +1030,8 @@ export function createWorkspaceRouter({
 
       let fields = {};
       const guideFiles = [];
+      let workspacePlanFileData = null;
+      const projectPlanFiles = {};
 
       if (isMultipart) {
         const rawBody = await readRawBody(req);
@@ -939,7 +1042,21 @@ export function createWorkspaceRouter({
             .json({ ok: false, error: 'Failed to parse multipart body' });
         }
         for (const part of parts) {
-          if (part.filename != null) {
+          if (part.name === 'workspace_plan_file' && part.filename != null) {
+            workspacePlanFileData = {
+              filename: part.filename,
+              content: part.content,
+            };
+          } else if (
+            part.name?.startsWith('project_plan_') &&
+            part.filename != null
+          ) {
+            const projectName = part.name.slice('project_plan_'.length);
+            projectPlanFiles[projectName] = {
+              filename: part.filename,
+              content: part.content,
+            };
+          } else if (part.filename != null) {
             guideFiles.push({ filename: part.filename, content: part.content });
           } else if (part.name) {
             fields[part.name] = part.content.toString('utf8');
@@ -1035,6 +1152,57 @@ export function createWorkspaceRouter({
         guideEntry = { paths, bytes: totalBytes, filenames, uploaded: true };
       }
 
+      // ── workspace plan file upload / server-side path ──────────────
+      let workspacePlanPath = null;
+      if (workspacePlanFileData) {
+        if (workspacePlanFileData.content.length > WORKSPACE_PLAN_CAP_BYTES) {
+          return res.status(400).json({
+            ok: false,
+            error: 'Workspace plan exceeds 256 KB limit',
+          });
+        }
+        workspacePlanPath = join(wsRunDir, 'workspace-plan.json');
+        writeFileSync(workspacePlanPath, workspacePlanFileData.content);
+      } else if (fields.workspace_plan) {
+        if (!existsSync(fields.workspace_plan)) {
+          return res.status(400).json({
+            ok: false,
+            error: `workspace_plan path not found: ${fields.workspace_plan}`,
+          });
+        }
+        workspacePlanPath = fields.workspace_plan;
+      }
+
+      // ── per-project plan file uploads ──────────────────────────────
+      const projectPlans = {};
+      for (const [name, file] of Object.entries(projectPlanFiles)) {
+        if (file.content.length > PROJECT_PLAN_CAP_BYTES) {
+          return res.status(400).json({
+            ok: false,
+            error: `Project plan for "${name}" exceeds 256 KB limit`,
+          });
+        }
+        const safeName = sanitizeFilename(name);
+        const plansDir = join(wsRunDir, 'plans');
+        mkdirSync(plansDir, { recursive: true });
+        const planPath = join(plansDir, `${safeName}.md`);
+        writeFileSync(planPath, file.content);
+        projectPlans[name] = planPath;
+      }
+
+      // ── resolve plan strategy + validate ──────────────────────────
+      const planResult = _resolvePlanStrategy(
+        plan_mode,
+        workspacePlanPath,
+        Object.keys(projectPlans).length > 0 ? projectPlans : null,
+        ws,
+      );
+      if (!planResult.ok) {
+        return res
+          .status(planResult.status)
+          .json({ ok: false, error: planResult.error });
+      }
+
       const tiers = computeTiers(ws.projects);
       const dagTiers = tiers.map((projects, i) => ({
         tier: i,
@@ -1054,10 +1222,10 @@ export function createWorkspaceRouter({
           source: source ?? null,
         },
         guide: guideEntry,
+        ...planResult.fields,
         branch_template: branch_template ?? 'workspace/{slug}/{project}',
         max_parallel: Number(max_parallel) || 5,
         skip_integration: false,
-        skip_planning: plan_mode === 'skip',
         status: 'planning',
         halt_reason: null,
         dag: { tiers: dagTiers },