stagent 0.1.12 → 0.1.13

package/README.md

@@ -1,8 +1,10 @@
 # Stagent
 
-> Govern Your AI Agents. Operate With Oversight.
+> Governed AI Agent Workspace — Supervised Local Execution, Workflows, Documents, and Provider Runtimes.
 
-[![Next.js 16](https://img.shields.io/badge/Next.js-16-black)](https://nextjs.org/) [![React 19](https://img.shields.io/badge/React-19-61DAFB)](https://react.dev/) [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6)](https://www.typescriptlang.org/) [![Claude Agent SDK](https://img.shields.io/badge/Claude-Agent_SDK-D97706)](https://docs.anthropic.com/) [![OpenAI Codex App Server](https://img.shields.io/badge/OpenAI-Codex_App_Server-10A37F)](https://developers.openai.com/codex/app-server) [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
+[![npm](https://img.shields.io/npm/v/stagent)](https://www.npmjs.com/package/stagent) [![Next.js 16](https://img.shields.io/badge/Next.js-16-black)](https://nextjs.org/) [![React 19](https://img.shields.io/badge/React-19-61DAFB)](https://react.dev/) [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6)](https://www.typescriptlang.org/) [![Claude Agent SDK](https://img.shields.io/badge/Claude-Agent_SDK-D97706)](https://docs.anthropic.com/) [![OpenAI Codex App Server](https://img.shields.io/badge/OpenAI-Codex_App_Server-10A37F)](https://developers.openai.com/codex/app-server) [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
+
+**[stagent.io](https://stagent.io)** · **[GitHub](https://github.com/navam-io/stagent)**
 
 ## Quick Start
 
@@ -10,7 +12,7 @@
 npx stagent
 ```
 
-Open [localhost:3000](http://localhost:3000).
+Open [localhost:3000](http://localhost:3000). That's it — zero config, local SQLite, own your data.
 
 **Profiles & Policies** · **Blueprints & Schedules** · **Built-in Playbook** · **Open Source**
 
@@ -24,13 +26,20 @@ Open [localhost:3000](http://localhost:3000).
 
 ## Why Stagent
 
-AI agents are powerful — but production use breaks down when teams cannot see what the agent is doing, which rules it follows, or intervene before an unsafe action lands. Stagent gives you a governed operations workspace where every run is visible, every profile is reusable, and every approval is auditable. Run it locally with `npx stagent` and own your data from day one.
+AI agents are powerful — but production use breaks down when teams cannot see what the agent is doing, which rules it follows, or intervene before an unsafe action lands. Stagent gives you a **governed operations workspace** where every run is visible, every profile is reusable, and every approval is auditable.
+
+- **Local-first** — SQLite database, no cloud dependency, `npx stagent` and go
+- **Multi-provider** — Claude Code + OpenAI Codex App Server behind one runtime registry
+- **Human-in-the-loop** — Inbox approvals, ambient toasts, tool permission policies
+- **Reusable profiles** — 13+ agent profiles with instructions, tool policies, and runtime tuning
+- **Workflow orchestration** — 6 patterns (sequence, planner-executor, checkpoint, parallel, loop, swarm)
+- **Cost governance** — Usage metering, budgets, and spend visibility per provider and model
 
 ---
 
 ## Runtime Bridge
 
-Stagent ships a shared runtime registry that routes tasks, schedules, and workflow steps through two governed execution backends: **Claude Code** (Anthropic Claude Agent SDK) and **OpenAI Codex App Server**. Both land in the same inbox, monitoring, and task-state surfaces — so switching providers is a config change, not a rewrite.
+Stagent ships a shared runtime registry that routes tasks, schedules, and workflow steps through two governed execution backends: **Claude Code** (Anthropic Claude Agent SDK) and **OpenAI Codex App Server**. Both land in the same inbox, monitoring, and task-state surfaces — switching providers is a config change, not a rewrite.
 
 ---
 
@@ -120,9 +129,9 @@ Claude Agent SDK integration with the `canUseTool` polling pattern remains the d
 OpenAI Codex App Server is integrated as Stagent's second governed runtime. Codex-backed tasks preserve project working directories, document context, resumable thread IDs, inbox approval requests, user questions, and provider-labeled logs. The same runtime can also power task assist, scheduled firings, and workflow child tasks.
 
 #### Agent Profiles
-Profile-backed execution with specialist definitions for different job types. Each profile packages instructions, allowed tools, max turns, and output format so teams can reuse behavior intentionally instead of relying on ad hoc prompts. Workflow steps and schedules can reference profiles directly, and runtimes can be selected independently when provider support differs.
+Profile-backed execution with specialist definitions for different job types. Each profile packages instructions, allowed tools, max turns, and output format so teams can reuse behavior intentionally instead of relying on ad hoc prompts. Profile cards display role-based icon circles with keyword-inferred colors (blue for work, purple for personal), alongside domain tags, runtime badges, and tool counts. Workflow steps and schedules can reference profiles directly, and runtimes can be selected independently when provider support differs.
 
-<img src="https://raw.githubusercontent.com/navam-io/stagent/main/public/readme/profiles-list.png" alt="Stagent agent profiles" width="1200" />
+<img src="https://raw.githubusercontent.com/navam-io/stagent/main/public/readme/profiles-list.png" alt="Stagent agent profiles with role-based icon circles" width="1200" />
 
 #### Workflows
 Multi-step task orchestration with six patterns:
@@ -167,12 +176,12 @@ Resume failed or cancelled agent tasks with one click. Tracks retry counts (limi
 Iterative agent loop pattern with four stop conditions: max iterations, time budget, human cancel, and agent-signaled completion. Each iteration creates a child task with previous output as context. Loop status view with iteration timeline, progress bar, and expandable results. Pause/resume via DB status polling.
 
 #### Agent Profile Catalog
-Curated agent profiles across work and personal domains, built as portable Claude Code skill directories with `profile.yaml` sidecars. The profile gallery supports domain filtering and search, while YAML customization, GitHub import, and behavioral smoke tests keep profile behavior inspectable and reusable.
+Curated agent profiles across work and personal domains, built as portable Claude Code skill directories with `profile.yaml` sidecars. The profile gallery displays role-based icon circles with keyword-inferred colors and supports domain filtering and search, while YAML customization, GitHub import, and behavioral smoke tests keep profile behavior inspectable and reusable.
 
 #### Workflow Blueprints
-Pre-configured workflow templates across work and personal domains. Browse blueprints in a gallery with filtering and search, preview steps and required variables, fill in a dynamic form, and create draft workflows with resolved prompts and profile assignments. Create custom blueprints via YAML or import from GitHub URLs. Lineage tracking connects workflows back to their source blueprint.
+Pre-configured workflow templates across work and personal domains. Browse blueprints in a gallery with pattern-colored icon circles, domain tags, and difficulty badges. Preview steps and required variables, fill in a dynamic form, and create draft workflows with resolved prompts and profile assignments. Create custom blueprints via YAML or import from GitHub URLs. Lineage tracking connects workflows back to their source blueprint.
 
-<img src="https://raw.githubusercontent.com/navam-io/stagent/main/public/readme/workflows-list.png" alt="Stagent workflow management" width="1200" />
+<img src="https://raw.githubusercontent.com/navam-io/stagent/main/public/readme/workflows-list.png" alt="Stagent workflows with keyword-inferred icon circles" width="1200" />
 
 ### Documents
 
@@ -234,7 +243,9 @@ Real-time agent log streaming via Server-Sent Events. Filter by task or event ty
 File upload with drag-and-drop in task creation. Type-aware content preview for text, markdown (via react-markdown), code, and JSON. Copy-to-clipboard and download-as-file for task outputs.
 
 #### Settings
-Configuration hub with provider-aware sections: Claude authentication (API key or OAuth), OpenAI Codex runtime API-key management, tool permissions (saved "Always Allow" patterns with revoke), and data management.
+Configuration hub with provider-aware sections: Claude authentication (API key or OAuth), OpenAI Codex runtime API-key management, tool permissions (saved "Always Allow" patterns with revoke), permission presets, budget configuration, and data management.
+
+<img src="https://raw.githubusercontent.com/navam-io/stagent/main/public/readme/settings-list.png" alt="Stagent settings" width="1200" />
 
 #### CLI
 The `npx stagent` entry point boots a Next.js server from the published npm package. It is built from `bin/cli.ts` into `dist/cli.js` using tsup, and serves as the primary distribution channel — no clone required.
@@ -395,44 +406,23 @@ All 14 features shipped across three layers:
 | **Core** | Project management, task board, agent integration, inbox notifications, monitoring dashboard |
 | **Polish** | Homepage dashboard, UX fixes, workflow engine, AI task assist, content handling, session management |
 
-### Post-MVP — Complete (31 features)
-
-| Category | Feature | What shipped |
-|----------|---------|-------------|
-| **Documents** | File Attachments | Upload data layer with project/task linking |
-| | Document Preprocessing | Text extraction for 5 formats (text, PDF, images, Office, spreadsheets) |
-| | Agent Document Context | Automatic document injection into agent prompts |
-| | Document Browser | Table/grid views, search, filters, bulk operations at `/documents` |
-| | Document Output Generation | Agent-generated documents as deliverables |
-| **Agent Intelligence** | Multi-Agent Routing | Profile registry (4 profiles), task classifier, per-step profile assignment |
-| | Autonomous Loop Execution | 4 stop conditions, iteration context chaining, pause/resume, loop status view |
-| | Multi-Agent Swarm | Mayor → worker pool → refinery orchestration with retryable stages |
-| | AI Assist → Workflows | Bridge task assist into workflow engine with profile assignment and pattern selection |
-| | Agent Self-Improvement | Pattern extraction from logs, human-approved context evolution, versioned rollback |
-| | Workflow Context Batching | Workflow-scoped proposal buffering with batch approve/reject |
-| **Agent Profiles** | Agent Profile Catalog | 13 domain-specific profiles, GitHub import, behavioral testing, MCP passthrough |
-| | Workflow Blueprints | 8 templates, gallery, YAML editor, dynamic forms, GitHub import, lineage tracking |
-| **UI Enhancement** | Ambient Approvals | Shell-level approval presenter on any route for fast supervision |
-| | Micro-Visualizations | Sparklines, mini bars, donut rings — zero-dependency SVG charts |
-| | Command Palette | ⌘K palette with navigation, create actions, recent items, theme toggle |
-| | Operational Surface | Cross-route composition with consistent layout, density, and interaction patterns |
-| | Profile Surface | Profile gallery stability, detail views, and behavioral testing UI |
-| | Accessibility | ARIA labels, keyboard navigation, focus management, screen reader support |
-| | UI Density Refinement | Tightened spacing, typography, and visual hierarchy across all routes |
-| | Kanban Board Operations | Inline editing, bulk operations, card animations, edit dialog |
-| | Board Context Persistence | Persisted filters, sort order, and project selection across sessions |
-| **Platform** | Scheduled Prompt Loops | Cron + human-friendly intervals, one-shot/recurring, pause/resume lifecycle |
-| | Tool Permission Persistence | "Always Allow" patterns, pre-check bypass, Settings management |
-| | Tool Permission Presets | 3 layered presets (read-only, git-safe, full-auto) with risk badges |
-| | Provider Runtimes | Shared runtime registry with Claude Code and OpenAI Codex App Server adapters |
-| | OpenAI Codex Runtime | Codex App Server integration with inbox approvals, logs, and thread resumption |
-| | Cross-Provider Profiles | Profile compatibility layer ensuring profiles work across Claude and Codex runtimes |
-| | Parallel Fork/Join | 2-5 concurrent research branches with synthesis step |
-| **Runtime Quality** | E2E Test Automation | API-level test suite covering both runtimes, 4 profiles, 4 workflow patterns |
-| **Knowledge** | Playbook | Built-in documentation with usage-stage awareness, adoption heatmap, guided learning journeys |
-| **Governance** | Usage Metering Ledger | Provider-normalized token and spend tracking across all execution paths |
-| | Spend Budget Guardrails | Per-project and global budgets with enforcement and alerts |
-| | Cost & Usage Dashboard | Summary cards, trend views, provider/model breakdowns, budget audit visibility |
+### Post-MVP — 31 features shipped
+
+| Category | Features |
+|----------|---------|
+| **Documents** (5) | File attachments, preprocessing (5 formats), agent context injection, document browser, output generation |
+| **Agent Intelligence** (6) | Multi-agent routing, autonomous loops, multi-agent swarm, AI assist→workflows, agent self-improvement, workflow context batching |
+| **Agent Profiles** (2) | Agent profile catalog (13+ profiles), workflow blueprints (8 templates) |
+| **UI Enhancement** (13) | Ambient approvals, learned context UX, micro-visualizations, command palette, operational surface, profile surface, accessibility, UI density, kanban operations, board persistence, detail view redesign, playbook documentation, workflow UX overhaul (in-progress) |
+| **Platform** (8) | Scheduled prompt loops, tool permissions, provider runtimes, OpenAI Codex runtime, cross-provider profiles, parallel fork/join, tool permission presets, npm publish (deferred) |
+| **Runtime Quality** (2) | SDK runtime hardening, E2E test automation |
+| **Governance** (3) | Usage metering ledger, spend budget guardrails, cost & usage dashboard |
+
+### In Progress
+
+| Feature | Description |
+|---------|-------------|
+| Workflow UX Overhaul | Document context propagation, output readability, dashboard visibility, AI assist guidance |
 
 ---
 
@@ -441,7 +431,7 @@ All 14 features shipped across three layers:
 ### Contributor Setup
 
 ```bash
-git clone <repo-url> && cd stagent && npm install
+git clone https://github.com/navam-io/stagent.git && cd stagent && npm install
 
 # Set up one or both runtime credentials
 cat > .env.local <<'EOF'
@@ -463,6 +453,10 @@ npm run dev
 
 See `AGENTS.md` for architecture details and development conventions.
 
+---
+
 ## License
 
 Licensed under the [Apache License 2.0](LICENSE).
+
+Copyright 2025-2026 [Navam](https://navam.io)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stagent",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Governed AI agent workspace for supervised local execution, workflows, documents, and provider runtimes.",
   "keywords": [
     "ai",

package/src/app/api/tasks/[id]/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { tasks } from "@/lib/db/schema";
-import { eq } from "drizzle-orm";
+import { tasks, projects, workflows, schedules, usageLedger } from "@/lib/db/schema";
+import { eq, sum, min, max } from "drizzle-orm";
 import { updateTaskSchema } from "@/lib/validators/task";
 import { isValidTransition, type TaskStatus } from "@/lib/constants/task-status";
 import { validateRuntimeProfileAssignment } from "@/lib/agents/profiles/assignment-validation";
@@ -13,7 +13,58 @@ export async function GET(
   const { id } = await params;
   const [task] = await db.select().from(tasks).where(eq(tasks.id, id));
   if (!task) return NextResponse.json({ error: "Not found" }, { status: 404 });
-  return NextResponse.json(task);
+
+  // Join relationship names
+  let projectName: string | undefined;
+  let workflowName: string | undefined;
+  let scheduleName: string | undefined;
+
+  if (task.projectId) {
+    const [p] = await db.select({ name: projects.name }).from(projects).where(eq(projects.id, task.projectId));
+    projectName = p?.name;
+  }
+  if (task.workflowId) {
+    const [w] = await db.select({ name: workflows.name }).from(workflows).where(eq(workflows.id, task.workflowId));
+    workflowName = w?.name;
+  }
+  if (task.scheduleId) {
+    const [s] = await db.select({ name: schedules.name }).from(schedules).where(eq(schedules.id, task.scheduleId));
+    scheduleName = s?.name;
+  }
+
+  // Aggregate usage from usage_ledger
+  const [usage] = await db
+    .select({
+      inputTokens: sum(usageLedger.inputTokens),
+      outputTokens: sum(usageLedger.outputTokens),
+      totalTokens: sum(usageLedger.totalTokens),
+      costMicros: sum(usageLedger.costMicros),
+      modelId: max(usageLedger.modelId),
+      startedAt: min(usageLedger.startedAt),
+      finishedAt: max(usageLedger.finishedAt),
+    })
+    .from(usageLedger)
+    .where(eq(usageLedger.taskId, id));
+
+  const hasUsage = usage?.totalTokens != null;
+
+  return NextResponse.json({
+    ...task,
+    projectName,
+    workflowName,
+    scheduleName,
+    usage: hasUsage
+      ? {
+          inputTokens: usage.inputTokens ? Number(usage.inputTokens) : null,
+          outputTokens: usage.outputTokens ? Number(usage.outputTokens) : null,
+          totalTokens: usage.totalTokens ? Number(usage.totalTokens) : null,
+          costMicros: usage.costMicros ? Number(usage.costMicros) : null,
+          modelId: usage.modelId ?? null,
+          startedAt: usage.startedAt instanceof Date ? usage.startedAt.toISOString() : usage.startedAt,
+          finishedAt: usage.finishedAt instanceof Date ? usage.finishedAt.toISOString() : usage.finishedAt,
+        }
+      : undefined,
+  });
 }
 
 export async function PATCH(

package/src/app/api/workflows/[id]/route.ts

@@ -1,7 +1,15 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { workflows } from "@/lib/db/schema";
-import { eq } from "drizzle-orm";
+import {
+  workflows,
+  tasks,
+  agentLogs,
+  notifications,
+  documents,
+  learnedContext,
+  usageLedger,
+} from "@/lib/db/schema";
+import { eq, inArray } from "drizzle-orm";
 import type { WorkflowDefinition } from "@/lib/workflows/types";
 import { validateWorkflowDefinitionAssignments } from "@/lib/agents/profiles/assignment-validation";
 import { validateWorkflowDefinition } from "@/lib/workflows/definition-validation";
@@ -127,7 +135,38 @@ export async function DELETE(
     );
   }
 
-  await db.delete(workflows).where(eq(workflows.id, id));
+  try {
+    // Cascade-delete in FK-safe order
+    const taskIds = db
+      .select({ id: tasks.id })
+      .from(tasks)
+      .where(eq(tasks.workflowId, id))
+      .all()
+      .map((r) => r.id);
+
+    // Delete usage ledger entries (reference both workflowId and taskId)
+    db.delete(usageLedger).where(eq(usageLedger.workflowId, id)).run();
+
+    if (taskIds.length > 0) {
+      // Delete task children first
+      db.delete(agentLogs).where(inArray(agentLogs.taskId, taskIds)).run();
+      db.delete(notifications).where(inArray(notifications.taskId, taskIds)).run();
+      db.delete(documents).where(inArray(documents.taskId, taskIds)).run();
+      db.delete(learnedContext).where(inArray(learnedContext.sourceTaskId, taskIds)).run();
+      db.delete(usageLedger).where(inArray(usageLedger.taskId, taskIds)).run();
+      // Delete the tasks themselves
+      db.delete(tasks).where(inArray(tasks.id, taskIds)).run();
+    }
+
+    // Finally delete the workflow
+    db.delete(workflows).where(eq(workflows.id, id)).run();
 
-  return NextResponse.json({ deleted: true });
+    return NextResponse.json({ deleted: true });
+  } catch (err) {
+    console.error("Workflow delete failed:", err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Delete failed" },
+      { status: 500 }
+    );
+  }
 }

package/src/app/api/workflows/[id]/status/route.ts

@@ -1,9 +1,71 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { workflows } from "@/lib/db/schema";
-import { eq } from "drizzle-orm";
+import { workflows, documents } from "@/lib/db/schema";
+import { eq, and, inArray } from "drizzle-orm";
 import { parseWorkflowState } from "@/lib/workflows/engine";
 
+/** Collect output documents for workflow step tasks + input documents from parent task */
+async function getWorkflowDocuments(
+  state: { stepStates: Array<{ taskId?: string }> } | null,
+  sourceTaskId?: string
+) {
+  const stepDocuments: Record<string, Array<{ id: string; originalName: string; mimeType: string; storagePath: string; direction: string }>> = {};
+  const parentDocuments: Array<{ id: string; originalName: string; mimeType: string; storagePath: string; direction: string }> = [];
+
+  try {
+    // Collect step task IDs that have completed
+    const stepTaskIds = (state?.stepStates ?? [])
+      .map((s) => s.taskId)
+      .filter((id): id is string => !!id);
+
+    if (stepTaskIds.length > 0) {
+      const outputDocs = await db
+        .select({
+          id: documents.id,
+          taskId: documents.taskId,
+          originalName: documents.originalName,
+          mimeType: documents.mimeType,
+          storagePath: documents.storagePath,
+          direction: documents.direction,
+        })
+        .from(documents)
+        .where(and(inArray(documents.taskId, stepTaskIds), eq(documents.direction, "output")));
+
+      for (const doc of outputDocs) {
+        if (!doc.taskId) continue;
+        if (!stepDocuments[doc.taskId]) stepDocuments[doc.taskId] = [];
+        stepDocuments[doc.taskId].push({
+          id: doc.id,
+          originalName: doc.originalName,
+          mimeType: doc.mimeType,
+          storagePath: doc.storagePath,
+          direction: doc.direction,
+        });
+      }
+    }
+
+    // Parent task input documents
+    if (sourceTaskId) {
+      const inputDocs = await db
+        .select({
+          id: documents.id,
+          originalName: documents.originalName,
+          mimeType: documents.mimeType,
+          storagePath: documents.storagePath,
+          direction: documents.direction,
+        })
+        .from(documents)
+        .where(and(eq(documents.taskId, sourceTaskId), eq(documents.direction, "input")));
+
+      parentDocuments.push(...inputDocs);
+    }
+  } catch (error) {
+    console.error("[workflow-status] Failed to query workflow documents:", error);
+  }
+
+  return { stepDocuments, parentDocuments };
+}
+
 export async function GET(
   _req: NextRequest,
   { params }: { params: Promise<{ id: string }> }
@@ -20,6 +82,8 @@ export async function GET(
   }
 
   const { definition, state, loopState } = parseWorkflowState(workflow.definition);
+  const sourceTaskId: string | undefined = definition.sourceTaskId;
+  const { stepDocuments, parentDocuments } = await getWorkflowDocuments(state, sourceTaskId);
 
   // Loop pattern returns loop-specific data instead of step states
   if (definition.pattern === "loop") {
@@ -34,6 +98,8 @@ export async function GET(
       swarmConfig: definition.swarmConfig,
       loopState,
       steps: definition.steps,
+      stepDocuments,
+      parentDocuments,
     });
   }
 
@@ -50,5 +116,7 @@ export async function GET(
       state: state?.stepStates[i] ?? { stepId: step.id, status: "pending" },
     })),
     workflowState: state,
+    stepDocuments,
+    parentDocuments,
   });
 }

package/src/app/api/workflows/from-assist/route.ts

@@ -23,7 +23,7 @@ interface FromAssistBody {
 
 export async function POST(req: NextRequest) {
   const body = (await req.json()) as FromAssistBody;
-  const { name, projectId, definition, priority, assignedAgent, executeImmediately, parentTask } = body;
+  const { name, projectId, definition, priority, assignedAgent, executeImmediately } = body;
 
   if (!name?.trim()) {
     return NextResponse.json({ error: "Name is required" }, { status: 400 });
@@ -46,53 +46,27 @@ export async function POST(req: NextRequest) {
     return NextResponse.json({ error: compatibilityError }, { status: 400 });
   }
 
-  // Transaction: create workflow + tasks + optional parent task atomically
+  // Transaction: create workflow + step tasks atomically (no phantom parent task)
   const workflowId = crypto.randomUUID();
   const now = new Date();
   const taskIds: string[] = [];
-  let parentTaskId: string | null = null;
 
   try {
     db.transaction((tx) => {
-      // Create parent task (no workflowId — visible on dashboard)
-      if (parentTask?.title) {
-        parentTaskId = crypto.randomUUID();
-        tx.insert(tasks)
-          .values({
-            id: parentTaskId,
-            title: parentTask.title,
-            description: parentTask.description || null,
-            projectId: projectId || null,
-            workflowId: null,
-            status: executeImmediately ? "running" : "planned",
-            assignedAgent: assignedAgent ?? null,
-            agentProfile: parentTask.agentProfile ?? null,
-            priority: priority ?? 2,
-            createdAt: now,
-            updatedAt: now,
-          })
-          .run();
-      }
-
-      // Store sourceTaskId in definition for parent↔workflow linkage
-      const defToStore = parentTaskId
-        ? { ...definition, sourceTaskId: parentTaskId }
-        : definition;
-
-      // Create workflow
+      // Create workflow — no sourceTaskId needed since there's no parent task
       tx.insert(workflows)
         .values({
           id: workflowId,
           name: name.trim(),
           projectId: projectId || null,
-          definition: JSON.stringify(defToStore),
+          definition: JSON.stringify(definition),
           status: executeImmediately ? "active" : "draft",
           createdAt: now,
           updatedAt: now,
         })
         .run();
 
-      // Create tasks for each step (with workflowId — hidden from dashboard)
+      // Create tasks for each step (with workflowId — hidden from dashboard kanban)
       for (const step of definition.steps) {
         const taskId = crypto.randomUUID();
         taskIds.push(taskId);
@@ -135,7 +109,7 @@ export async function POST(req: NextRequest) {
     {
       workflow: created,
       taskIds,
-      parentTaskId,
+      parentTaskId: null,
       status: executeImmediately ? "started" : "created",
     },
     { status: 201 }

package/src/app/dashboard/page.tsx

@@ -2,9 +2,11 @@ import { Suspense } from "react";
 import { db } from "@/lib/db";
 import { tasks, projects, workflows } from "@/lib/db/schema";
 import { desc, isNull } from "drizzle-orm";
+import { parseWorkflowState } from "@/lib/workflows/engine";
 import { KanbanBoard } from "@/components/tasks/kanban-board";
 import { SkeletonBoard } from "@/components/tasks/skeleton-board";
 import type { TaskItem } from "@/components/tasks/task-card";
+import type { WorkflowKanbanItem } from "@/components/workflows/workflow-kanban-card";
 
 export const dynamic = "force-dynamic";
 
@@ -21,38 +23,74 @@ async function BoardContent() {
     .from(projects)
     .orderBy(projects.name);
 
-  // Build project name lookup for task cards
+  // Build project name lookup
   const projectMap = new Map(allProjects.map((p) => [p.id, p.name]));
 
-  // Look up linked workflows for parent tasks (via sourceTaskId in definition JSON)
+  // Fetch all workflows for kanban display
   const allWorkflows = await db
-    .select({ id: workflows.id, definition: workflows.definition, status: workflows.status })
-    .from(workflows);
-
-  const linkedWorkflowMap = new Map<string, { workflowId: string; workflowStatus: string }>();
-  for (const w of allWorkflows) {
-    try {
-      const def = JSON.parse(w.definition);
-      if (def.sourceTaskId) {
-        linkedWorkflowMap.set(def.sourceTaskId, {
-          workflowId: w.id,
-          workflowStatus: w.status,
-        });
-      }
-    } catch { /* skip invalid JSON */ }
-  }
+    .select()
+    .from(workflows)
+    .orderBy(desc(workflows.updatedAt));
 
-  // Serialize Date objects for client component consumption
+  // Serialize tasks (no more linkedWorkflow fields)
   const serializedTasks: TaskItem[] = allTasks.map((t) => ({
     ...t,
     projectName: t.projectId ? projectMap.get(t.projectId) ?? undefined : undefined,
-    linkedWorkflowId: linkedWorkflowMap.get(t.id)?.workflowId,
-    linkedWorkflowStatus: linkedWorkflowMap.get(t.id)?.workflowStatus,
     createdAt: t.createdAt.toISOString(),
     updatedAt: t.updatedAt.toISOString(),
   }));
 
-  return <KanbanBoard initialTasks={serializedTasks} projects={allProjects} />;
+  // Build workflow kanban items with step progress
+  const serializedWorkflows: WorkflowKanbanItem[] = allWorkflows.map((w) => {
+    let stepProgress = { current: 0, total: 0 };
+    let currentStepName: string | undefined;
+
+    try {
+      const { definition, state } = parseWorkflowState(w.definition);
+      if (definition.steps) {
+        stepProgress.total = definition.steps.length;
+        if (state) {
+          stepProgress.current = state.stepStates.filter(
+            (s) => s.status === "completed"
+          ).length;
+          const running = state.stepStates.find((s) => s.status === "running");
+          if (running) {
+            currentStepName = definition.steps.find(
+              (step) => step.id === running.stepId
+            )?.name;
+          }
+        }
+      }
+    } catch {
+      /* skip parse errors */
+    }
+
+    return {
+      type: "workflow" as const,
+      id: w.id,
+      name: w.name,
+      status: w.status,
+      pattern: (() => {
+        try {
+          return JSON.parse(w.definition).pattern ?? "sequence";
+        } catch {
+          return "sequence";
+        }
+      })(),
+      projectName: w.projectId ? projectMap.get(w.projectId) ?? undefined : undefined,
+      stepProgress,
+      currentStepName,
+      createdAt: w.createdAt.toISOString(),
+    };
+  });
+
+  return (
+    <KanbanBoard
+      initialTasks={serializedTasks}
+      initialWorkflows={serializedWorkflows}
+      projects={allProjects}
+    />
+  );
 }
 
 export default function DashboardPage() {