@jterrats/open-orchestra 0.4.2-beta.1 → 0.5.0-beta.0

package/dist/assets/web-console.js

@@ -25,6 +25,7 @@ var endpoints = [
   ["usage", "/api/usage"],
   ["budget", "/api/budget"],
   ["tasks", "/api/tasks"],
+  ["workflowRuns", "/api/workflow/runs"],
   ["evidenceView", "/api/evidence/view"],
   ["roleActivation", "/api/roles/activation"],
   ["skills", "/api/skills"],
@@ -35,11 +36,15 @@ var endpoints = [
 ];
 var statePill = document.querySelector("#load-state");
 var lastUpdated = document.querySelector("#last-updated");
+var adoptionGuide = document.querySelector("#adoption-guide");
+var releaseReadiness = document.querySelector("#release-readiness");
 var metrics = document.querySelector("#metrics");
 var validation = document.querySelector("#validation");
 var workspaceView = document.querySelector("#workspace-view");
 var graph = document.querySelector("#graph");
 var actions = document.querySelector("#actions");
+var taskDetailSelect = document.querySelector("#task-detail-select");
+var taskDetail = document.querySelector("#task-detail");
 var taskOwner = document.querySelector("#task-owner");
 var charts = document.querySelector("#charts");
 var evidenceTask = document.querySelector("#evidence-task");
@@ -47,6 +52,8 @@ var evidenceType = document.querySelector("#evidence-type");
 var evidenceList = document.querySelector("#evidence-list");
 var rolesView = document.querySelector("#roles-view");
 var planningView = document.querySelector("#planning-view");
+var workflowTask = document.querySelector("#workflow-task");
+var workflowRuns = document.querySelector("#workflow-runs");
 var costView = document.querySelector("#cost-view");
 var playwrightTask = document.querySelector("#playwright-task");
 var playwrightPlan = document.querySelector("#playwright-plan");
@@ -79,6 +86,10 @@ document.querySelector("#skills-render").addEventListener("click", loadSkillRend
 document.querySelector("#lesson-add").addEventListener("click", addLesson);
 document.querySelector("#lesson-promote").addEventListener("click", promoteLessons);
 document.querySelector("#task-add").addEventListener("click", addTaskFromWeb);
+document.querySelector("#task-detail-refresh").addEventListener("click", loadTaskDetail);
+taskDetailSelect.addEventListener("change", loadTaskDetail);
+document.querySelector("#workflow-start").addEventListener("click", startWorkflowFromWeb);
+workflowRuns.addEventListener("click", handleWorkflowAction);
 loadDashboard();
 function applyStoredTheme() {
   const stored = localStorage.getItem("open-orchestra-theme");
@@ -129,15 +140,20 @@ function render(data) {
     metric(data.validation.valid ? "Valid" : "Needs work", "Workspace")
   ]);
   renderValidation(data.validation);
+  renderAdoptionGuide(data);
+  renderReleaseReadiness(data);
   renderWorkspace(data.workspaceClassification, data.runtimeAdapters);
   renderGraph(data.graph);
   renderActions(data);
+  renderTaskDetailControls(data.tasks);
   renderTaskWriteControls(data.roles);
   renderCharts(data);
   renderEvidenceControls(data);
   renderEvidence(data.evidenceView);
   renderRoles(data.roleActivation);
   renderPlanning(data.roleActivation);
+  renderWorkflowControls(data.tasks, data.workflowRuns);
+  renderWorkflowRuns(data.workflowRuns);
   renderCost(data.usage, data.budget);
   renderPlaywrightTasks(data.tasks);
   renderSkillControls(data);
@@ -146,6 +162,149 @@ function render(data) {
   renderLessons(data.lessons);
   loadPlaywrightPlan();
   loadSkillPlan();
+  loadTaskDetail();
+}
+function renderTaskDetailControls(tasks) {
+  const currentValue = taskDetailSelect.value;
+  replace(
+    taskDetailSelect,
+    tasks.length > 0 ? tasks.map(function(task) {
+      return option(task.id, task.id + " - " + task.title);
+    }) : [option("", "No tasks")]
+  );
+  if (currentValue) {
+    taskDetailSelect.value = currentValue;
+  }
+}
+async function loadTaskDetail() {
+  if (!taskDetailSelect.value) {
+    replace(taskDetail, [
+      empty(
+        "No task selected",
+        "Create or select a task to inspect acceptance, evidence, and gates."
+      )
+    ]);
+    return;
+  }
+  try {
+    const response = await fetch(
+      "/api/task/detail?task=" + encodeURIComponent(taskDetailSelect.value)
+    );
+    if (!response.ok) {
+      throw new Error("task detail returned " + response.status);
+    }
+    renderTaskDetail(await response.json());
+  } catch (error) {
+    replace(taskDetail, [
+      empty("Task detail unavailable", String(error.message || error))
+    ]);
+  }
+}
+function renderTaskDetail(detail) {
+  const context = detail.context;
+  const task = context.task;
+  const releaseReadiness2 = detail.releaseReadiness;
+  const rows = document.createElement("div");
+  rows.className = "detail-grid";
+  rows.append(
+    detailBlock("Summary", [
+      task.id + " [" + task.status + "] " + task.title,
+      "Owner: " + task.ownerRole,
+      "Backlog: " + (task.backlogItem || "missing")
+    ]),
+    detailBlock("Acceptance Criteria", task.acceptanceCriteria || []),
+    detailBlock("Definition of Ready", readinessLines(context)),
+    detailBlock("Definition of Done", releaseReadinessLines(releaseReadiness2)),
+    detailBlock(
+      "AC Coverage",
+      releaseCoverageLines(detail.releaseReadinessReport)
+    ),
+    detailBlock("Risks", task.risks || []),
+    detailBlock("Handoffs", eventLines(context.handoffs)),
+    detailBlock("Reviews", eventLines(context.reviews)),
+    detailBlock("Evidence", eventLines(context.evidence)),
+    detailBlock("Gates", eventLines(context.gates)),
+    detailBlock("Next Actions", taskNextActions(context, releaseReadiness2))
+  );
+  replace(taskDetail, [rows]);
+}
+function releaseCoverageLines(report) {
+  if (!report || !Array.isArray(report.acceptanceCoverage)) {
+    return ["Coverage unavailable"];
+  }
+  if (report.acceptanceCoverage.length === 0) {
+    return ["No acceptance criteria"];
+  }
+  return report.acceptanceCoverage.map(function(coverage) {
+    const status = coverage.covered ? "covered" : "missing";
+    const suffix = coverage.missing && coverage.missing.length > 0 ? " (" + coverage.missing.join(", ") + ")" : "";
+    return coverage.criterion + ": " + status + suffix;
+  });
+}
+function readinessLines(context) {
+  const missing = [];
+  [
+    "backlogItem",
+    "goal",
+    "scope",
+    "acceptanceCriteria",
+    "assumptions",
+    "risks",
+    "testStrategy"
+  ].forEach(function(field) {
+    const value = context.task[field];
+    if (Array.isArray(value) ? value.length === 0 : !value) {
+      missing.push(field);
+    }
+  });
+  return missing.length === 0 ? ["Ready for implementation"] : missing.map(function(field) {
+    return "Missing " + field;
+  });
+}
+function releaseReadinessLines(releaseReadiness2) {
+  if (releaseReadiness2.passed) {
+    return ["Release readiness passed"];
+  }
+  return releaseReadiness2.missing.map(function(field) {
+    return "Missing " + field;
+  });
+}
+function taskNextActions(context, releaseReadiness2) {
+  const actions2 = [];
+  if ((context.task.acceptanceCriteria || []).length === 0) {
+    actions2.push("Add acceptance criteria before implementation.");
+  }
+  if (context.handoffs.length === 0) {
+    actions2.push("Create the next role handoff when work changes owner.");
+  }
+  if (context.evidence.length === 0) {
+    actions2.push(
+      "Attach command, report, screenshot, trace, or video evidence."
+    );
+  }
+  if (!releaseReadiness2.passed) {
+    actions2.push("Resolve release-readiness missing fields.");
+  }
+  return actions2.length > 0 ? actions2 : ["No task-specific action required."];
+}
+function eventLines(events) {
+  return events.length > 0 ? events.map(function(event) {
+    return event.actor + ": " + event.summary;
+  }) : ["none"];
+}
+function detailBlock(title, lines) {
+  const block = document.createElement("section");
+  block.className = "detail-block";
+  const heading = document.createElement("h3");
+  heading.textContent = title;
+  const list = document.createElement("ul");
+  (lines.length > 0 ? lines : ["none"]).forEach(function(line) {
+    const item = document.createElement("li");
+    item.textContent = line;
+    list.append(item);
+  });
+  block.append(heading, list);
+  return block;
 }
 function renderTaskWriteControls(roles) {
   replace(
@@ -187,6 +346,135 @@ async function addTaskFromWeb() {
   });
   await loadDashboard();
 }
+function renderAdoptionGuide(data) {
+  const next = determinePrimaryNextAction(data);
+  const container = document.createElement("div");
+  const lead = document.createElement("p");
+  lead.textContent = next.summary;
+  const commands = document.createElement("div");
+  commands.className = "command-list";
+  next.commands.forEach(function(command) {
+    const chip = document.createElement("code");
+    chip.className = "command-chip";
+    chip.textContent = command;
+    commands.append(chip);
+  });
+  const steps = document.createElement("ol");
+  steps.className = "step-list";
+  next.steps.forEach(function(step, index) {
+    const item = document.createElement("li");
+    const number = document.createElement("b");
+    number.textContent = String(index + 1);
+    const text = document.createElement("span");
+    text.textContent = step;
+    item.append(number, text);
+    steps.append(item);
+  });
+  container.append(lead, commands, steps);
+  replace(adoptionGuide, [container]);
+}
+function determinePrimaryNextAction(data) {
+  if (!data.validation.valid) {
+    return {
+      summary: "Resolve workspace validation before starting or releasing work.",
+      commands: ["orchestra validate", "orchestra health --json"],
+      steps: [
+        "Inspect validation errors and warnings.",
+        "Fix missing workflow files, invalid task references, or stale locks.",
+        "Refresh the console after validation passes."
+      ]
+    };
+  }
+  if (data.status.tasks.total === 0) {
+    return {
+      summary: "Create the first governed task with an owner and acceptance criteria.",
+      commands: [
+        'orchestra task add --id STORY-001 --title "First story" --owner developer --acceptance "verified outcome"',
+        "orchestra context --task STORY-001 --json"
+      ],
+      steps: [
+        "Add a task from the console or CLI.",
+        "Confirm the owner role and acceptance criteria.",
+        "Render context before implementation starts."
+      ]
+    };
+  }
+  if (data.graph.ready.length > 0) {
+    const task = data.graph.ready[0];
+    return {
+      summary: task.id + " is ready. Start with context, memory, and planning.",
+      commands: [
+        "orchestra context --task " + task.id + " --json",
+        "orchestra memory hook --point before_plan --task " + task.id + " --json",
+        "orchestra workflow run --task " + task.id + " --dry-run --gates phase"
+      ],
+      steps: [
+        "Review task context and relevant memory.",
+        "Confirm role plan and workflow gates.",
+        "Start the workflow when the plan matches the work."
+      ]
+    };
+  }
+  if (data.approvals.length > 0) {
+    return {
+      summary: "There are approval artifacts waiting for a release or workflow decision.",
+      commands: ["orchestra approvals list --json", "orchestra summary --json"],
+      steps: [
+        "Review each pending approval artifact.",
+        "Approve, reject, or capture accepted risk.",
+        "Resume the paused workflow after approval."
+      ]
+    };
+  }
+  return {
+    summary: "The workspace has no immediate blocking action.",
+    commands: ["orchestra summary --json", "orchestra release check --json"],
+    steps: [
+      "Review summary for stale evidence or locks.",
+      "Run release check before tagging.",
+      "Record smoke and rollback evidence when preparing a release."
+    ]
+  };
+}
+function renderReleaseReadiness(data) {
+  const evidenceCount = data.evidence.length;
+  const approvalCount = data.approvals.length;
+  const rows = [
+    readinessRow(
+      data.validation.valid,
+      "Workspace validation",
+      data.validation.valid ? "Valid" : "Needs fixes"
+    ),
+    readinessRow(
+      data.graph.blocked.length === 0 && data.graph.locked.length === 0,
+      "Task flow",
+      data.graph.blocked.length + " blocked, " + data.graph.locked.length + " locked"
+    ),
+    readinessRow(evidenceCount > 0, "Evidence", evidenceCount + " artifact(s)"),
+    readinessRow(
+      approvalCount === 0,
+      "Approvals",
+      approvalCount + " pending artifact(s)"
+    ),
+    readinessRow(
+      data.budget.passed,
+      "Budget",
+      data.budget.passed ? "Within configured limits" : data.budget.violations.length + " violation(s)"
+    )
+  ];
+  replace(releaseReadiness, rows);
+}
+function readinessRow(ok, title, detail) {
+  const node = listItem(title, detail);
+  const tag = document.createElement("span");
+  tag.className = ok ? "tag ok" : "tag warn";
+  tag.textContent = ok ? "ready" : "attention";
+  const row = document.createElement("div");
+  row.className = "tag-row";
+  row.append(tag);
+  node.append(row);
+  return node;
+}
 function renderWorkspace(classification, adapters) {
   const adapterNames = adapters.map(function(adapter) {
     return adapter.label;
@@ -273,6 +561,138 @@ function renderChart(current, canvasId, type, slices) {
     }
   });
 }
+function renderWorkflowControls(tasks, runs) {
+  const currentValue = workflowTask.value;
+  replace(
+    workflowTask,
+    tasks.length > 0 ? tasks.map(function(task) {
+      return option(task.id, task.id);
+    }) : [option("", "No tasks")]
+  );
+  if (currentValue) {
+    workflowTask.value = currentValue;
+  }
+  const runningTaskIds = new Set(
+    runs.filter(function(run) {
+      return run.status === "running" || run.status === "paused";
+    }).map(function(run) {
+      return run.taskId;
+    })
+  );
+  document.querySelector("#workflow-start").disabled = !workflowTask.value || runningTaskIds.has(workflowTask.value);
+}
+function renderWorkflowRuns(runs) {
+  replace(
+    workflowRuns,
+    runs.length > 0 ? runs.slice(0, 8).map(workflowRunItem) : [
+      empty(
+        "No workflow runs yet",
+        "Start a task workflow to track phases, gates, and handoffs."
+      )
+    ]
+  );
+}
+function workflowRunItem(run) {
+  const phases = (run.phases || []).map(function(phase) {
+    return phase.phase + ":" + phase.status;
+  }).join(" -> ");
+  const node = listItem(
+    run.id + " [" + run.status + "]",
+    run.taskId + " - gates " + run.gates + (phases ? " - " + phases : "")
+  );
+  const pausedGate = [...run.phases || []].reverse().find(function(phase) {
+    return phase.status === "gate_paused";
+  });
+  const row = document.createElement("div");
+  row.className = "tag-row";
+  if (pausedGate) {
+    const approve = document.createElement("button");
+    approve.className = "text-button";
+    approve.type = "button";
+    approve.dataset.workflowAction = "approve";
+    approve.dataset.run = run.id;
+    approve.dataset.task = run.taskId;
+    approve.dataset.gate = pausedGate.gateId || "";
+    approve.textContent = "Approve Gate";
+    row.append(approve);
+  }
+  if (run.status === "paused") {
+    const resume = document.createElement("button");
+    resume.className = "text-button";
+    resume.type = "button";
+    resume.dataset.workflowAction = "resume";
+    resume.dataset.run = run.id;
+    resume.dataset.task = run.taskId;
+    resume.textContent = "Resume";
+    row.append(resume);
+  }
+  node.append(row);
+  return node;
+}
+async function startWorkflowFromWeb() {
+  if (!workflowTask.value) {
+    setLoading("Select a task to start workflow", "warn");
+    return;
+  }
+  const response = await fetch("/api/workflow/start", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      task: workflowTask.value,
+      gates: document.querySelector("#workflow-gates").value
+    })
+  });
+  if (!response.ok) {
+    setLoading("Workflow start failed", "warn");
+    return;
+  }
+  await loadDashboard();
+}
+async function handleWorkflowAction(event) {
+  const button = event.target.closest("[data-workflow-action]");
+  if (!button) {
+    return;
+  }
+  if (button.dataset.workflowAction === "approve") {
+    await approveWorkflowGateFromWeb(button);
+    return;
+  }
+  if (button.dataset.workflowAction === "resume") {
+    await resumeWorkflowFromWeb(button);
+  }
+}
+async function approveWorkflowGateFromWeb(button) {
+  const response = await fetch("/api/workflow/gate-approve", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      run: button.dataset.run,
+      gate: button.dataset.gate,
+      approver: document.querySelector("#workflow-approver").value,
+      rationale: document.querySelector("#workflow-rationale").value
+    })
+  });
+  if (!response.ok) {
+    setLoading("Gate approval failed", "warn");
+    return;
+  }
+  await loadDashboard();
+}
+async function resumeWorkflowFromWeb(button) {
+  const response = await fetch("/api/workflow/resume", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      task: button.dataset.task,
+      run: button.dataset.run
+    })
+  });
+  if (!response.ok) {
+    setLoading("Workflow resume failed", "warn");
+    return;
+  }
+  await loadDashboard();
+}
 function renderCost(usage, budget) {
   const rows = [
     listItem("Requests", String(usage.totals.requests)),
@@ -723,10 +1143,7 @@ function renderGraph(plan) {
     ["Complete", plan.complete]
   ].flatMap(function(group) {
     return group[1].slice(0, 4).map(function(item) {
-      return listItem(
-        item.title,
-        group[0] + " - " + item.id + " - " + item.ownerRole
-      );
+      return listItem(item.title, graphItemDetail(group[0], item));
     });
   });
   replace(
@@ -739,6 +1156,20 @@ function renderGraph(plan) {
     ]
   );
 }
+function graphItemDetail(group, item) {
+  const base = group + " - " + item.id + " - " + item.ownerRole;
+  if (group === "Blocked" && item.incomplete?.length > 0) {
+    return base + " - blockers: " + item.incomplete.map(function(dependency) {
+      return dependency.id + " [" + dependency.status + "]";
+    }).join(", ");
+  }
+  if (group === "Locked" && item.locks?.length > 0) {
+    return base + " - locks: " + item.locks.map(function(lock) {
+      return lock.path + " (" + lock.reason + ")";
+    }).join(", ");
+  }
+  return base;
+}
 function renderActions(data) {
   const next = [];
   if (!data.validation.valid) {
@@ -826,6 +1257,7 @@ function renderEmpty(title, detail) {
   replace(workspaceView, []);
   replace(graph, []);
   replace(actions, []);
+  replace(taskDetail, []);
 }
 function setLoading(label, tone) {
   statePill.textContent = label;