stagent 0.6.2 → 0.6.3

package/dist/cli.js

@@ -112,7 +112,10 @@ var STAGENT_TABLES = [
   "agent_memory",
   "channel_configs",
   "channel_bindings",
-  "agent_messages"
+  "agent_messages",
+  "workflow_document_inputs",
+  "schedule_document_inputs",
+  "project_document_defaults"
 ];
 function bootstrapStagentDatabase(sqlite2) {
   sqlite2.exec(`
@@ -139,6 +142,7 @@ function bootstrapStagentDatabase(sqlite2) {
       result TEXT,
       session_id TEXT,
       resume_count INTEGER DEFAULT 0 NOT NULL,
+      workflow_run_number INTEGER,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
@@ -152,6 +156,7 @@ function bootstrapStagentDatabase(sqlite2) {
       name TEXT NOT NULL,
       definition TEXT NOT NULL,
       status TEXT DEFAULT 'draft' NOT NULL,
+      run_number INTEGER DEFAULT 0 NOT NULL,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION
@@ -347,6 +352,8 @@ function bootstrapStagentDatabase(sqlite2) {
   addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN heartbeat_spent_today INTEGER DEFAULT 0 NOT NULL;`);
   addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN heartbeat_budget_reset_at INTEGER;`);
   addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN source_type TEXT;`);
+  addColumnIfMissing(`ALTER TABLE workflows ADD COLUMN run_number INTEGER DEFAULT 0 NOT NULL;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN workflow_run_number INTEGER;`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN version INTEGER NOT NULL DEFAULT 1;`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN source TEXT DEFAULT 'upload';`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN conversation_id TEXT REFERENCES conversations(id);`);
@@ -619,6 +626,45 @@ function bootstrapStagentDatabase(sqlite2) {
     CREATE INDEX IF NOT EXISTS idx_agent_messages_to_status ON agent_messages(to_profile_id, status);
     CREATE INDEX IF NOT EXISTS idx_agent_messages_task ON agent_messages(task_id);
   `);
+  sqlite2.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_document_inputs (
+      id TEXT PRIMARY KEY NOT NULL,
+      workflow_id TEXT NOT NULL,
+      document_id TEXT NOT NULL,
+      step_id TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (workflow_id) REFERENCES workflows(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (document_id) REFERENCES documents(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_wdi_workflow ON workflow_document_inputs(workflow_id);
+    CREATE INDEX IF NOT EXISTS idx_wdi_document ON workflow_document_inputs(document_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_wdi_workflow_doc_step ON workflow_document_inputs(workflow_id, document_id, step_id);
+
+    CREATE TABLE IF NOT EXISTS schedule_document_inputs (
+      id TEXT PRIMARY KEY NOT NULL,
+      schedule_id TEXT NOT NULL,
+      document_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (schedule_id) REFERENCES schedules(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (document_id) REFERENCES documents(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sdi_schedule ON schedule_document_inputs(schedule_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_sdi_schedule_doc ON schedule_document_inputs(schedule_id, document_id);
+
+    CREATE TABLE IF NOT EXISTS project_document_defaults (
+      id TEXT PRIMARY KEY NOT NULL,
+      project_id TEXT NOT NULL,
+      document_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
+      FOREIGN KEY (document_id) REFERENCES documents(id) ON UPDATE NO ACTION ON DELETE NO ACTION
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_pdd_project ON project_document_defaults(project_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_pdd_project_doc ON project_document_defaults(project_id, document_id);
+  `);
 }
 function hasLegacyStagentTables(sqlite2) {
   const placeholders = STAGENT_TABLES.map(() => "?").join(", ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stagent",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "AI Business Operating System — run your business with AI agents. Local-first, multi-provider, governed.",
   "keywords": [
     "ai",
@@ -27,7 +27,6 @@
     "dist/",
     "docs/",
     "src/",
-    "public/icon.svg",
     "public/icon-512.png",
     "public/stagent-s-64.png",
     "public/stagent-s-128.png",

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

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { documents, tasks, projects } from "@/lib/db/schema";
+import { documents, tasks, projects, workflows } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import { unlink } from "fs/promises";
 import { z } from "zod/v4";
@@ -42,9 +42,13 @@ export async function GET(
       updatedAt: documents.updatedAt,
       taskTitle: tasks.title,
       projectName: projects.name,
+      workflowId: workflows.id,
+      workflowName: workflows.name,
+      workflowRunNumber: tasks.workflowRunNumber,
     })
     .from(documents)
     .leftJoin(tasks, eq(documents.taskId, tasks.id))
+    .leftJoin(workflows, eq(tasks.workflowId, workflows.id))
     .leftJoin(projects, eq(documents.projectId, projects.id))
     .where(eq(documents.id, id));
 

package/src/app/api/documents/[id]/versions/route.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { documents, tasks } from "@/lib/db/schema";
+import { eq, and, desc } from "drizzle-orm";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  // First, get the document to find its originalName and projectId
+  const [doc] = await db
+    .select({
+      originalName: documents.originalName,
+      projectId: documents.projectId,
+      direction: documents.direction,
+    })
+    .from(documents)
+    .where(eq(documents.id, id));
+
+  if (!doc) {
+    return NextResponse.json({ error: "Document not found" }, { status: 404 });
+  }
+
+  // Only output documents have version history
+  if (doc.direction !== "output" || !doc.projectId) {
+    return NextResponse.json([]);
+  }
+
+  // Find all output documents with same originalName + projectId
+  const versions = await db
+    .select({
+      id: documents.id,
+      version: documents.version,
+      size: documents.size,
+      status: documents.status,
+      createdAt: documents.createdAt,
+      workflowRunNumber: tasks.workflowRunNumber,
+    })
+    .from(documents)
+    .leftJoin(tasks, eq(documents.taskId, tasks.id))
+    .where(
+      and(
+        eq(documents.originalName, doc.originalName),
+        eq(documents.projectId, doc.projectId),
+        eq(documents.direction, "output")
+      )
+    )
+    .orderBy(desc(documents.version));
+
+  return NextResponse.json(versions);
+}

package/src/app/api/documents/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { documents, tasks, projects } from "@/lib/db/schema";
+import { documents, tasks, projects, workflows } from "@/lib/db/schema";
 import { eq, and, like, or, desc } from "drizzle-orm";
 import { access, stat, copyFile, mkdir } from "fs/promises";
 import path, { basename, extname, join } from "path";
@@ -74,9 +74,13 @@ export async function GET(req: NextRequest) {
       updatedAt: documents.updatedAt,
       taskTitle: tasks.title,
       projectName: projects.name,
+      workflowId: workflows.id,
+      workflowName: workflows.name,
+      workflowRunNumber: tasks.workflowRunNumber,
     })
     .from(documents)
     .leftJoin(tasks, eq(documents.taskId, tasks.id))
+    .leftJoin(workflows, eq(tasks.workflowId, workflows.id))
     .leftJoin(projects, eq(documents.projectId, projects.id))
     .where(conditions.length > 0 ? and(...conditions) : undefined)
     .orderBy(desc(documents.createdAt));

package/src/app/api/projects/[id]/documents/route.ts

@@ -0,0 +1,124 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import {
+  projectDocumentDefaults,
+  documents,
+  projects,
+} from "@/lib/db/schema";
+import { eq, inArray } from "drizzle-orm";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+/**
+ * GET /api/projects/[id]/documents
+ * List all default document bindings for a project, with document metadata.
+ */
+export async function GET(
+  _request: NextRequest,
+  context: RouteContext
+) {
+  const { id: projectId } = await context.params;
+
+  try {
+    const bindings = await db
+      .select()
+      .from(projectDocumentDefaults)
+      .where(eq(projectDocumentDefaults.projectId, projectId));
+
+    if (bindings.length === 0) {
+      return NextResponse.json([]);
+    }
+
+    const docIds = bindings.map((b) => b.documentId);
+    const docs = await db
+      .select()
+      .from(documents)
+      .where(inArray(documents.id, docIds));
+
+    // Return flat document list (same shape as /api/documents)
+    return NextResponse.json(
+      docs.map((doc) => ({
+        id: doc.id,
+        originalName: doc.originalName,
+        filename: doc.filename,
+        mimeType: doc.mimeType,
+        size: doc.size,
+        direction: doc.direction,
+        status: doc.status,
+        category: doc.category,
+      }))
+    );
+  } catch (error) {
+    console.error("[project-documents] GET failed:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch project documents" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * PUT /api/projects/[id]/documents
+ * Replace all default document bindings for a project.
+ * Body: { documentIds: string[] }
+ */
+export async function PUT(
+  request: NextRequest,
+  context: RouteContext
+) {
+  const { id: projectId } = await context.params;
+
+  try {
+    const body = await request.json();
+    const { documentIds } = body as { documentIds: string[] };
+
+    if (!Array.isArray(documentIds)) {
+      return NextResponse.json(
+        { error: "documentIds must be an array" },
+        { status: 400 }
+      );
+    }
+
+    // Verify project exists
+    const [project] = await db
+      .select({ id: projects.id })
+      .from(projects)
+      .where(eq(projects.id, projectId));
+
+    if (!project) {
+      return NextResponse.json(
+        { error: "Project not found" },
+        { status: 404 }
+      );
+    }
+
+    // Remove all existing bindings
+    await db
+      .delete(projectDocumentDefaults)
+      .where(eq(projectDocumentDefaults.projectId, projectId));
+
+    // Insert new bindings
+    const now = new Date();
+    for (const docId of documentIds) {
+      try {
+        await db.insert(projectDocumentDefaults).values({
+          id: crypto.randomUUID(),
+          projectId,
+          documentId: docId,
+          createdAt: now,
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "";
+        if (!msg.includes("UNIQUE constraint")) throw err;
+      }
+    }
+
+    return NextResponse.json({ updated: documentIds.length, projectId });
+  } catch (error) {
+    console.error("[project-documents] PUT failed:", error);
+    return NextResponse.json(
+      { error: "Failed to update project documents" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -16,6 +16,7 @@ import {
   environmentScans,
   chatMessages,
   conversations,
+  projectDocumentDefaults,
 } from "@/lib/db/schema";
 import { eq, inArray } from "drizzle-orm";
 import { updateProjectSchema } from "@/lib/validators/project";
@@ -42,16 +43,44 @@ export async function PATCH(
 ) {
   const { id } = await params;
   const body = await req.json();
-  const parsed = updateProjectSchema.safeParse(body);
+  // Extract documentIds before validation (not a project column)
+  const { documentIds, ...projectBody } = body as Record<string, unknown> & { documentIds?: string[] };
+  const parsed = updateProjectSchema.safeParse(projectBody);
   if (!parsed.success) {
     return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
   }
 
+  const now = new Date();
   await db
     .update(projects)
-    .set({ ...parsed.data, updatedAt: new Date() })
+    .set({ ...parsed.data, updatedAt: now })
     .where(eq(projects.id, id));
 
+  // Handle default document bindings
+  if (documentIds !== undefined) {
+    try {
+      // Replace all bindings
+      await db
+        .delete(projectDocumentDefaults)
+        .where(eq(projectDocumentDefaults.projectId, id));
+      for (const docId of documentIds) {
+        try {
+          await db.insert(projectDocumentDefaults).values({
+            id: crypto.randomUUID(),
+            projectId: id,
+            documentId: docId,
+            createdAt: now,
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : "";
+          if (!msg.includes("UNIQUE constraint")) throw err;
+        }
+      }
+    } catch (err) {
+      console.error("[projects] Document defaults update failed:", err);
+    }
+  }
+
   const [updated] = await db
     .select()
     .from(projects)
@@ -160,7 +189,10 @@ export async function DELETE(
         .run();
     }
 
-    // 6. Direct project children
+    // 6. Project document defaults (junction table)
+    db.delete(projectDocumentDefaults).where(eq(projectDocumentDefaults.projectId, id)).run();
+
+    // 7. Direct project children
     db.delete(documents).where(eq(documents.projectId, id)).run();
     db.delete(tasks).where(eq(tasks.projectId, id)).run();
     if (workflowIds.length > 0) {

package/src/app/api/projects/__tests__/delete-project.test.ts

@@ -27,6 +27,7 @@ describe("project DELETE cascade coverage", () => {
     "environmentScans",
     "environmentCheckpoints",
     "conversations",
+    "projectDocumentDefaults",
   ];
 
   // Tables that are indirect children (FK to a table that has projectId)

package/src/app/api/schedules/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { schedules } from "@/lib/db/schema";
+import { schedules, scheduleDocumentInputs } from "@/lib/db/schema";
 import { desc, eq } from "drizzle-orm";
 import { parseInterval, computeNextFireTime } from "@/lib/schedules/interval-parser";
 import { parseNaturalLanguage } from "@/lib/schedules/nlp-parser";
@@ -34,6 +34,7 @@ export async function POST(req: NextRequest) {
     activeHoursEnd,
     activeTimezone,
     heartbeatBudgetPerDay,
+    documentIds,
   } =
     body as {
       name?: string;
@@ -51,6 +52,7 @@ export async function POST(req: NextRequest) {
       activeHoursEnd?: number;
       activeTimezone?: string;
       heartbeatBudgetPerDay?: number;
+      documentIds?: string[];
     };
 
   const scheduleType = type ?? "scheduled";
@@ -167,6 +169,22 @@ export async function POST(req: NextRequest) {
     updatedAt: now,
   });
 
+  // Link documents to schedule
+  if (documentIds && documentIds.length > 0) {
+    try {
+      for (const docId of documentIds) {
+        await db.insert(scheduleDocumentInputs).values({
+          id: crypto.randomUUID(),
+          scheduleId: id,
+          documentId: docId,
+          createdAt: now,
+        });
+      }
+    } catch (err) {
+      console.error("[schedules] Document association failed:", err);
+    }
+  }
+
   const [created] = await db
     .select()
     .from(schedules)

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

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { tasks, projects, workflows, schedules, usageLedger } from "@/lib/db/schema";
+import { tasks, projects, workflows, schedules, usageLedger, documents } 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";
@@ -106,11 +106,46 @@ export async function PATCH(
     }
   }
 
+  // Extract documentIds before spreading into task update (not a task column)
+  const { documentIds, ...taskFields } = parsed.data;
+  const now = new Date();
+
   await db
     .update(tasks)
-    .set({ ...parsed.data, updatedAt: new Date() })
+    .set({ ...taskFields, updatedAt: now })
     .where(eq(tasks.id, id));
 
+  // Handle document linking/unlinking
+  if (documentIds !== undefined) {
+    try {
+      // Unlink documents previously linked to this task that are no longer selected
+      const currentDocs = await db
+        .select({ id: documents.id })
+        .from(documents)
+        .where(eq(documents.taskId, id));
+      const newDocSet = new Set(documentIds);
+      for (const doc of currentDocs) {
+        if (!newDocSet.has(doc.id)) {
+          await db.update(documents)
+            .set({ taskId: null, updatedAt: now })
+            .where(eq(documents.id, doc.id));
+        }
+      }
+      // Link newly selected documents
+      for (const docId of documentIds) {
+        await db.update(documents)
+          .set({
+            taskId: id,
+            projectId: existing.projectId,
+            updatedAt: now,
+          })
+          .where(eq(documents.id, docId));
+      }
+    } catch (err) {
+      console.error("[tasks] Document association failed:", err);
+    }
+  }
+
   const [updated] = await db.select().from(tasks).where(eq(tasks.id, id));
   return NextResponse.json(updated);
 }

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

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { eq, and, ne, isNull } from "drizzle-orm";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [task] = await db
+    .select({
+      workflowId: tasks.workflowId,
+      workflowRunNumber: tasks.workflowRunNumber,
+    })
+    .from(tasks)
+    .where(eq(tasks.id, id));
+
+  if (!task || !task.workflowId) {
+    return NextResponse.json([]);
+  }
+  // Match siblings by workflowId + workflowRunNumber.
+  // For pre-existing tasks (workflowRunNumber is NULL), match all tasks
+  // in the same workflow that also have NULL workflowRunNumber.
+  const runCondition = task.workflowRunNumber != null
+    ? eq(tasks.workflowRunNumber, task.workflowRunNumber)
+    : isNull(tasks.workflowRunNumber);
+
+  const siblings = await db
+    .select({
+      id: tasks.id,
+      title: tasks.title,
+      status: tasks.status,
+      createdAt: tasks.createdAt,
+    })
+    .from(tasks)
+    .where(
+      and(
+        eq(tasks.workflowId, task.workflowId),
+        runCondition,
+        ne(tasks.id, id)
+      )
+    )
+    .orderBy(tasks.createdAt);
+
+  return NextResponse.json(siblings);
+}

package/src/app/api/tasks/route.ts

@@ -66,27 +66,26 @@ export async function POST(req: NextRequest) {
     updatedAt: now,
   });
 
-  // Link already-uploaded documents to this task
-  if (parsed.data.fileIds && parsed.data.fileIds.length > 0) {
+  // Link documents to this task (from document picker or legacy fileIds)
+  if (parsed.data.documentIds && parsed.data.documentIds.length > 0) {
     try {
-      for (const fileId of parsed.data.fileIds) {
-        // Update existing document record (created by /api/uploads) to link to this task
+      for (const docId of parsed.data.documentIds) {
         await db.update(documents)
           .set({
             taskId: id,
             projectId: parsed.data.projectId ?? null,
             updatedAt: now,
           })
-          .where(eq(documents.id, fileId));
+          .where(eq(documents.id, docId));
 
         // Trigger processing if not already done (fire-and-forget)
-        processDocument(fileId).catch((err) => {
-          console.error(`[tasks] processDocument failed for ${fileId}:`, err);
+        processDocument(docId).catch((err) => {
+          console.error(`[tasks] processDocument failed for ${docId}:`, err);
         });
       }
     } catch (err) {
-      // File association is best-effort — don't fail task creation
-      console.error("[tasks] File association failed:", err);
+      // Document association is best-effort — don't fail task creation
+      console.error("[tasks] Document association failed:", err);
     }
   }