syntaur 0.18.0 → 0.20.0

package/dist/dashboard/server.js

@@ -284,10 +284,14 @@ function parseAssignmentFrontmatter(fileContent) {
     links: parseLinks(frontmatter),
     blockedReason: getField2("blockedReason"),
     workspace: parseWorkspace(frontmatter),
-    tags: parseTags(frontmatter)
+    tags: parseTags(frontmatter),
+    archived: getField2("archived") === "true",
+    archivedAt: getField2("archivedAt"),
+    archivedReason: getField2("archivedReason")
   };
 }
 function formatYamlValue(value) {
+  if (typeof value === "boolean") return value ? "true" : "false";
   if (value === null) return "null";
   if (/^\d{4}-\d{2}-\d{2}T/.test(value)) {
     return `"${value}"`;
@@ -306,6 +310,12 @@ function updateAssignmentFile(fileContent, updates) {
     const fieldRegex = new RegExp(`^(${key}:)\\s*.*$`, "m");
     if (fieldRegex.test(result)) {
       result = result.replace(fieldRegex, `$1 ${formatted}`);
+    } else {
+      const closeIdx = result.indexOf("\n---", 4);
+      if (closeIdx !== -1) {
+        result = `${result.slice(0, closeIdx)}
+${key}: ${formatted}${result.slice(closeIdx)}`;
+      }
     }
   }
   return result;
@@ -582,6 +592,9 @@ function parseAssignmentFull(fileContent) {
     },
     externalIds: parseExternalIds2(fm),
     tags: parseListField(fm, "tags"),
+    archived: getField(fm, "archived") === "true",
+    archivedAt: getField(fm, "archivedAt"),
+    archivedReason: getField(fm, "archivedReason"),
     created: getField(fm, "created") ?? "",
     updated: getField(fm, "updated") ?? "",
     body
@@ -1456,6 +1469,53 @@ async function migrateLegacyProjectFiles(projectsDir) {
   }
   return result;
 }
+function setFrontmatterField(content, key, value) {
+  const formatted = value === null ? "null" : typeof value === "boolean" ? String(value) : value;
+  const fieldRegex = new RegExp(`^(${key}:)\\s*.*$`, "m");
+  if (fieldRegex.test(content)) {
+    return content.replace(fieldRegex, `$1 ${formatted}`);
+  }
+  const closingIdx = content.indexOf("\n---", 4);
+  if (closingIdx === -1) return content;
+  return `${content.slice(0, closingIdx)}
+${key}: ${formatted}${content.slice(closingIdx)}`;
+}
+function readFrontmatterField(content, key) {
+  const match = content.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
+  if (!match) return null;
+  const raw = match[1].trim().replace(/^['"]|['"]$/g, "");
+  return raw === "" || raw === "null" ? null : raw;
+}
+async function migrateLegacyArchivedProjects(projectsDir) {
+  const result = { reconciled: [] };
+  if (!await fileExists(projectsDir)) return result;
+  let entries;
+  try {
+    entries = await readdir2(projectsDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectMd = resolve5(projectsDir, entry.name, "project.md");
+    try {
+      if (!await fileExists(projectMd)) continue;
+      const content = await readFile3(projectMd, "utf-8");
+      if (readFrontmatterField(content, "statusOverride") !== "archived") continue;
+      let next = setFrontmatterField(content, "archived", true);
+      if (readFrontmatterField(content, "archivedAt") === null) {
+        next = setFrontmatterField(next, "archivedAt", nowTimestamp());
+      }
+      next = setFrontmatterField(next, "statusOverride", null);
+      next = setFrontmatterField(next, "updated", nowTimestamp());
+      await writeFile2(projectMd, next, "utf-8");
+      result.reconciled.push(entry.name);
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
 async function migrateLegacyConfig(configPath) {
   const result = {
     renamedField: false,
@@ -1549,6 +1609,7 @@ var init_fs_migration = __esm({
   "src/utils/fs-migration.ts"() {
     "use strict";
     init_fs();
+    init_timestamp();
   }
 });
 
@@ -2997,7 +3058,7 @@ import { readdir as readdir3, readFile as readFile5, unlink } from "fs/promises"
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function setFrontmatterField(content, key, value) {
+function setFrontmatterField2(content, key, value) {
   const regex = new RegExp(`^(${escapeRegExp(key)}:)\\s*.*$`, "m");
   if (regex.test(content)) {
     return content.replace(regex, `$1 ${value}`);
@@ -3146,8 +3207,8 @@ async function renamePlaybook(playbooksDir2, oldSlug, newSlug) {
     }
   }
   const raw = await readFile5(oldPath, "utf-8");
-  let next = setFrontmatterField(raw, "slug", newSlug);
-  next = setFrontmatterField(next, "updated", `"${nowTimestamp()}"`);
+  let next = setFrontmatterField2(raw, "slug", newSlug);
+  next = setFrontmatterField2(next, "updated", `"${nowTimestamp()}"`);
   await writeFileForce(newPath, next);
   if (!renamedInPlace) {
     await unlink(oldPath);
@@ -4764,6 +4825,12 @@ function setUpdatedField(content, value) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function isProjectArchived(p) {
+  return p.archived === true;
+}
+function activeAssignments(items) {
+  return items.filter((item) => item.archived !== true);
+}
 function createTraces() {
   return { entries: [], subPhases: /* @__PURE__ */ new Map() };
 }
@@ -4901,7 +4968,7 @@ function clearStatusConfigCache() {
 }
 async function listProjects(projectsDir) {
   const projectRecords = await listProjectRecords(projectsDir);
-  return projectRecords.map((record) => record.summary);
+  return projectRecords.filter((record) => !isProjectArchived(record.summary)).map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
   const registryPath = resolve13(dirname2(projectsDir), "workspaces.json");
@@ -5033,7 +5100,9 @@ async function getOverview(projectsDir, serversDir2, assignmentsDir2, options =
     "list-standalone-records",
     () => listStandaloneRecords(assignmentsDir2)
   );
-  const recentActivity = buildRecentActivity(projectRecords, standaloneRecords);
+  const activeProjectRecords = projectRecords.filter((record) => !isProjectArchived(record.summary));
+  const activeStandaloneRecords = standaloneRecords.filter((sr) => sr.record.archived !== true);
+  const recentActivity = buildRecentActivity(activeProjectRecords, activeStandaloneRecords);
   const staleLimit = clamp(
     Number.isFinite(options.staleLimit) ? Number(options.staleLimit) : STALE_LIMIT_DEFAULT,
     1,
@@ -5092,56 +5161,111 @@ async function getOverview(projectsDir, serversDir2, assignmentsDir2, options =
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     firstRun: projectRecords.length === 0 && standaloneRecords.length === 0,
     stats: {
-      activeProjects: projectRecords.filter((record) => record.summary.status === "active").length,
-      inProgressAssignments: projectRecords.reduce(
+      activeProjects: activeProjectRecords.filter((record) => record.summary.status === "active").length,
+      inProgressAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["in_progress"] ?? 0),
         0
       ),
-      blockedAssignments: projectRecords.reduce(
+      blockedAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["blocked"] ?? 0),
         0
       ),
-      reviewAssignments: projectRecords.reduce(
+      reviewAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["review"] ?? 0),
         0
       ),
-      failedAssignments: projectRecords.reduce(
+      failedAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["failed"] ?? 0),
         0
       ),
-      staleAssignments: projectRecords.reduce(
-        (total, record) => total + record.assignments.filter((assignment) => isStale(assignment.updated)).length,
+      staleAssignments: activeProjectRecords.reduce(
+        (total, record) => total + activeAssignments(record.assignments).filter((assignment) => isStale(assignment.updated)).length,
         0
-      ) + standaloneRecords.filter((sr) => isStale(sr.record.updated)).length
+      ) + activeStandaloneRecords.filter((sr) => isStale(sr.record.updated)).length
     },
     hero,
     segments,
     recentSessions,
-    recentProjects: projectRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_PROJECTS_LIMIT),
+    recentProjects: activeProjectRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_PROJECTS_LIMIT),
     recentActivity: recentActivity.slice(0, RECENT_ACTIVITY_LIMIT),
     serverStats
   };
 }
-async function listAssignmentsBoard(projectsDir, assignmentsDir2) {
+async function listAssignmentsBoard(projectsDir, assignmentsDir2, options = {}) {
+  const mode = options.archived ?? "exclude";
   const projectRecords = await listProjectRecords(projectsDir);
   const projectItems = await Promise.all(
-    projectRecords.flatMap(
-      async (record) => Promise.all(
-        record.assignments.map(
+    projectRecords.flatMap(async (record) => {
+      if (mode === "only") {
+        return Promise.all(
+          record.assignments.filter((assignment) => assignment.archived === true).map(async (assignment) => toAssignmentBoardItem(projectsDir, record, assignment))
+        );
+      }
+      if (isProjectArchived(record.summary)) return [];
+      return Promise.all(
+        activeAssignments(record.assignments).map(
           async (assignment) => toAssignmentBoardItem(projectsDir, record, assignment)
         )
-      )
-    )
+      );
+    })
   );
   const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  const filteredStandalone = mode === "only" ? standaloneRecords.filter((sr) => sr.record.archived === true) : standaloneRecords.filter((sr) => sr.record.archived !== true);
   const standaloneItems = await Promise.all(
-    standaloneRecords.map(async (sr) => toStandaloneBoardItem(sr))
+    filteredStandalone.map(async (sr) => toStandaloneBoardItem(sr))
   );
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     assignments: [...projectItems.flat(), ...standaloneItems].sort((left, right) => compareTimestamps(right.updated, left.updated))
   };
 }
+function toArchivedAssignmentItem(assignment, projectSlug, projectTitle) {
+  return {
+    id: assignment.id,
+    slug: assignment.slug,
+    title: assignment.title,
+    status: assignment.status,
+    type: assignment.type,
+    priority: assignment.priority,
+    projectSlug,
+    projectTitle,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason,
+    updated: assignment.updated
+  };
+}
+async function listArchived(projectsDir, assignmentsDir2) {
+  const projectRecords = await listProjectRecords(projectsDir);
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  const projects = projectRecords.filter((record) => isProjectArchived(record.summary)).map((record) => ({
+    slug: record.summary.slug,
+    title: record.summary.title,
+    archivedAt: record.summary.archivedAt,
+    archivedReason: record.summary.archivedReason,
+    assignments: record.assignments.map(
+      (assignment) => toArchivedAssignmentItem(assignment, record.summary.slug, record.summary.title)
+    ).sort((left, right) => compareTimestamps(right.updated, left.updated))
+  })).sort((left, right) => compareTimestamps(right.archivedAt ?? "", left.archivedAt ?? ""));
+  const individuallyArchived = [];
+  for (const record of projectRecords) {
+    if (isProjectArchived(record.summary)) continue;
+    for (const assignment of record.assignments) {
+      if (assignment.archived === true) {
+        individuallyArchived.push(
+          toArchivedAssignmentItem(assignment, record.summary.slug, record.summary.title)
+        );
+      }
+    }
+  }
+  for (const sr of standaloneRecords) {
+    if (sr.record.archived === true) {
+      individuallyArchived.push(toArchivedAssignmentItem(sr.record, null, null));
+    }
+  }
+  individuallyArchived.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return { projects, assignments: individuallyArchived };
+}
 async function toStandaloneBoardItem(sr) {
   return {
     ...toAssignmentSummary(sr.record),
@@ -5236,7 +5360,7 @@ async function getProjectDetail(projectsDir, slug) {
   const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
   const resources = await listResources(projectPath);
   const memories = await listMemories(projectPath);
-  const updated = getProjectActivityTimestamp(project.updated, assignments);
+  const updated = getProjectActivityTimestamp(project.updated, activeAssignments(assignments));
   return {
     slug: project.slug || slug,
     title: project.title,
@@ -5357,6 +5481,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     projectWorkspace,
     externalIds: assignment.externalIds,
     tags: assignment.tags,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason,
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -5607,6 +5734,9 @@ async function buildStandaloneAssignmentDetail(resolved) {
     projectWorkspace: assignment.workspaceGroup,
     externalIds: assignment.externalIds,
     tags: assignment.tags,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason,
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -5636,6 +5766,7 @@ async function computeProjectRecords(projectsDir, traces) {
   if (!migratedProjectsDirs.has(projectsDir)) {
     migratedProjectsDirs.add(projectsDir);
     await migrateLegacyProjectFiles(projectsDir);
+    await migrateLegacyArchivedProjects(projectsDir);
   }
   const entries = await readdir7(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
@@ -5656,7 +5787,7 @@ async function computeProjectRecords(projectsDir, traces) {
       const t2 = traces ? performance.now() : 0;
       const rollup = await buildProjectRollup(projectPath, project, assignments, traces);
       if (traces) accumulatePhase(traces, "build-rollup", performance.now() - t2);
-      const updated = getProjectActivityTimestamp(project.updated, assignments);
+      const updated = getProjectActivityTimestamp(project.updated, activeAssignments(assignments));
       const t3 = traces ? performance.now() : 0;
       const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
       if (traces) accumulatePhase(traces, "load-dep-graph", performance.now() - t3);
@@ -5866,9 +5997,10 @@ async function loadDependencyGraph(projectPath, assignments) {
   return buildDependencyGraph(assignments);
 }
 async function buildProjectRollup(projectPath, project, assignments, traces) {
-  const progress = { total: assignments.length };
+  const active = activeAssignments(assignments);
+  const progress = { total: active.length };
   const perAssignment = await Promise.all(
-    assignments.map(async (assignment) => {
+    active.map(async (assignment) => {
       const t0 = traces ? performance.now() : 0;
       const openQuestions2 = await countOpenQuestions(projectPath, assignment.slug);
       if (traces) accumulatePhase(traces, "count-open-questions", performance.now() - t0);
@@ -5916,7 +6048,12 @@ function toAssignmentSummary(assignment) {
     assignee: assignment.assignee,
     dependsOn: assignment.dependsOn,
     links: assignment.links,
-    updated: assignment.updated
+    tags: assignment.tags,
+    created: assignment.created,
+    updated: assignment.updated,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason
   };
 }
 async function toAssignmentBoardItem(projectsDir, projectRecord, assignment) {
@@ -6054,12 +6191,14 @@ async function buildOverviewSegmentBuckets(projectsDir, projectRecords, standalo
   const buckets = emptyBuckets();
   const newestPool = [];
   for (const record of projectRecords) {
+    if (isProjectArchived(record.summary)) continue;
     const depMap = /* @__PURE__ */ new Map();
     for (const a of record.assignments) {
       depMap.set(a.slug, a.status);
     }
+    const visibleAssignments = activeAssignments(record.assignments);
     const resolvedTransitions = await Promise.all(
-      record.assignments.map(async (assignment) => {
+      visibleAssignments.map(async (assignment) => {
         const t0 = traces ? performance.now() : 0;
         const availableTransitions = await getAvailableTransitions(
           projectsDir,
@@ -6128,7 +6267,7 @@ async function buildOverviewSegmentBuckets(projectsDir, projectRecords, standalo
     }
   }
   const resolvedStandaloneTransitions = await Promise.all(
-    standaloneRecords.map(async (sr) => {
+    standaloneRecords.filter((sr) => sr.record.archived !== true).map(async (sr) => {
       const t0 = traces ? performance.now() : 0;
       const availableTransitions = await getStandaloneAvailableTransitions(sr.record);
       if (traces) accumulatePhase(traces, "get-available-transitions", performance.now() - t0);
@@ -6254,7 +6393,7 @@ function buildRecentActivity(projectRecords, standaloneRecords = []) {
       assignmentSlug: null,
       summary: `Project status is ${record.summary.status}.`
     });
-    for (const assignment of record.assignments) {
+    for (const assignment of activeAssignments(record.assignments)) {
       activity.push({
         id: `assignment:${record.summary.slug}:${assignment.slug}`,
         type: "assignment",
@@ -6926,6 +7065,7 @@ var SORT_FIELDS = [
   "priority",
   "assignee",
   "dependencies",
+  "created",
   "updated"
 ];
 var SORT_DIRECTIONS = ["asc", "desc"];
@@ -6939,6 +7079,37 @@ var GROUPINGS = [
   "project"
 ];
 var ACTIVITIES = ["all", "stale", "fresh"];
+var DATE_RANGE_FIELDS = ["created", "updated"];
+var DATE_RANGE_PRESETS = [
+  "last_24h",
+  "last_7d",
+  "last_30d",
+  "last_90d",
+  "older_7d",
+  "older_30d"
+];
+var YMD_RE = /^\d{4}-\d{2}-\d{2}$/;
+function isDateRangeField(v) {
+  return typeof v === "string" && DATE_RANGE_FIELDS.includes(v);
+}
+function isDateRangePreset(v) {
+  return typeof v === "string" && DATE_RANGE_PRESETS.includes(v);
+}
+function isDateRange(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const r = v;
+  if (!isDateRangeField(r.field)) return false;
+  for (const key of Object.keys(r)) {
+    if (key !== "field" && key !== "preset" && key !== "from" && key !== "to") return false;
+  }
+  const hasPreset = r.preset !== void 0;
+  const hasAbsolute = r.from !== void 0 || r.to !== void 0;
+  if (hasPreset && hasAbsolute) return false;
+  if (hasPreset && !isDateRangePreset(r.preset)) return false;
+  if (r.from !== void 0 && (typeof r.from !== "string" || !YMD_RE.test(r.from))) return false;
+  if (r.to !== void 0 && (typeof r.to !== "string" || !YMD_RE.test(r.to))) return false;
+  return true;
+}
 function toFilterValues(v) {
   const arr = v === void 0 ? [] : Array.isArray(v) ? v : [v];
   const out = [];
@@ -7114,7 +7285,7 @@ function isViewPrefsDefaults(file) {
   if (g.density !== d.density) return false;
   if (g.grouping !== d.grouping) return false;
   const gf = g.filters;
-  for (const key of ["status", "type", "priority", "assignee", "project"]) {
+  for (const key of ["status", "type", "priority", "assignee", "project", "tags"]) {
     if (toFilterValues(gf[key]).length > 0) return false;
   }
   if (gf.activity !== void 0 && gf.activity !== "all") return false;
@@ -7131,6 +7302,7 @@ var TABLE_COLUMN_IDS = [
   "priority",
   "assignee",
   "dependencies",
+  "created",
   "updated"
 ];
 function isTableColumnId(value) {
@@ -7206,10 +7378,12 @@ function isTableColumnVisibility(value) {
 function isViewFilters(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const obj = value;
-  for (const key of ["status", "type", "priority", "assignee", "project"]) {
+  for (const key of ["status", "type", "priority", "assignee", "project", "tags"]) {
     if (obj[key] !== void 0 && !isFilterValue(obj[key])) return false;
   }
   if (obj.activity !== void 0 && !isActivity(obj.activity)) return false;
+  if (obj.dateRange !== void 0 && !isDateRange(obj.dateRange)) return false;
+  if (obj.search !== void 0 && typeof obj.search !== "string") return false;
   return true;
 }
 function isSavedViewConfig(value) {
@@ -8076,6 +8250,9 @@ workspace:
   branch: null
   parentBranch: null
 tags: []
+archived: false
+archivedAt: null
+archivedReason: null
 ---
 
 # ${params2.title}
@@ -8422,6 +8599,13 @@ ${key}: ${formatted}${content.slice(closingIdx)}`;
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function applyArchiveFields(content, archived, reason) {
+  let next = setTopLevelField(content, "archived", archived);
+  next = setTopLevelField(next, "archivedAt", archived ? nowTimestamp() : null);
+  next = setTopLevelField(next, "archivedReason", archived ? reason : null);
+  next = setTopLevelField(next, "updated", nowTimestamp());
+  return next;
+}
 function appendLogEntry2(existingContent, countField, nextCount, heading, body, emptyPlaceholder) {
   const timestamp = nowTimestamp();
   let next = setTopLevelField(existingContent, "updated", timestamp);
@@ -9715,7 +9899,7 @@ ${entry}`;
       }
       const { status } = req.body || {};
       const config = await getStatusConfig();
-      const validStatuses = ["active", "archived", ...config.statuses.map((s) => s.id)];
+      const validStatuses = ["active", ...config.statuses.map((s) => s.id)];
       if (status !== null && (typeof status !== "string" || !validStatuses.includes(status))) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
@@ -9767,6 +9951,106 @@ ${entry}`;
       res.status(500).json({ error: `Failed to override status: ${error.message}` });
     }
   });
+  function archiveReason(body) {
+    const reason = body?.reason;
+    return typeof reason === "string" && reason.trim() ? reason : null;
+  }
+  router.post("/api/projects/:slug/archive", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+        return;
+      }
+      const content = await readFile14(projectPath, "utf-8");
+      await writeFileForce(projectPath, applyArchiveFields(content, true, archiveReason(req.body)));
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project });
+    } catch (error) {
+      console.error("Error archiving project:", error);
+      res.status(500).json({ error: `Failed to archive project: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/unarchive", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+        return;
+      }
+      const content = await readFile14(projectPath, "utf-8");
+      await writeFileForce(projectPath, applyArchiveFields(content, false, null));
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project });
+    } catch (error) {
+      console.error("Error restoring project:", error);
+      res.status(500).json({ error: `Failed to restore project: ${error.message}` });
+    }
+  });
+  async function handleAssignmentArchive(req, res, archived) {
+    const projectSlug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const assignmentPath = resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
+    if (!await fileExists(assignmentPath)) {
+      res.status(404).json({ error: "Assignment not found" });
+      return;
+    }
+    const content = await readFile14(assignmentPath, "utf-8");
+    await writeFileForce(assignmentPath, applyArchiveFields(content, archived, archived ? archiveReason(req.body) : null));
+    const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+    res.json({ assignment });
+  }
+  router.post("/api/projects/:slug/assignments/:aslug/archive", async (req, res) => {
+    try {
+      await handleAssignmentArchive(req, res, true);
+    } catch (error) {
+      console.error("Error archiving assignment:", error);
+      res.status(500).json({ error: `Failed to archive assignment: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/assignments/:aslug/unarchive", async (req, res) => {
+    try {
+      await handleAssignmentArchive(req, res, false);
+    } catch (error) {
+      console.error("Error restoring assignment:", error);
+      res.status(500).json({ error: `Failed to restore assignment: ${error.message}` });
+    }
+  });
+  async function handleStandaloneArchive(req, res, archived) {
+    if (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const resolved = await resolveAssignmentById(projectsDir, assignmentsDir2, id);
+    if (!resolved) {
+      res.status(404).json({ error: `Assignment "${id}" not found` });
+      return;
+    }
+    const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+    const content = await readFile14(assignmentPath, "utf-8");
+    await writeFileForce(assignmentPath, applyArchiveFields(content, archived, archived ? archiveReason(req.body) : null));
+    const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir2, id);
+    res.json({ assignment });
+  }
+  router.post("/api/assignments/:id/archive", async (req, res) => {
+    try {
+      await handleStandaloneArchive(req, res, true);
+    } catch (error) {
+      console.error("Error archiving assignment:", error);
+      res.status(500).json({ error: `Failed to archive assignment: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/unarchive", async (req, res) => {
+    try {
+      await handleStandaloneArchive(req, res, false);
+    } catch (error) {
+      console.error("Error restoring assignment:", error);
+      res.status(500).json({ error: `Failed to restore assignment: ${error.message}` });
+    }
+  });
   router.patch("/api/projects/:slug/assignments/:aslug/assignee", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
@@ -10416,84 +10700,6 @@ ${entry}`;
       res.status(500).json({ error: `Failed to update title: ${error.message}` });
     }
   });
-  router.post("/api/assignments/bulk-status-override", async (req, res) => {
-    try {
-      const body = req.body;
-      if (!body || typeof body !== "object" || !Array.isArray(body.items)) {
-        res.status(400).json({ error: "Request body must include `items` (array)." });
-        return;
-      }
-      const items = body.items;
-      if (items.length === 0) {
-        res.status(400).json({ error: "`items` must contain at least one entry." });
-        return;
-      }
-      if (items.length > 200) {
-        res.status(400).json({ error: "`items` is capped at 200 entries per call." });
-        return;
-      }
-      const config = await getStatusConfig();
-      const validStatuses = new Set(config.statuses.map((s) => s.id));
-      const timestamp = nowTimestamp();
-      const results = [];
-      let succeeded = 0;
-      let failed = 0;
-      for (let index = 0; index < items.length; index += 1) {
-        const raw = items[index];
-        const itemKey = buildBulkItemKey(raw, index);
-        try {
-          if (!raw || typeof raw !== "object") {
-            throw new Error("item must be an object");
-          }
-          const item = raw;
-          const status = typeof item.status === "string" ? item.status : null;
-          if (!status || !validStatuses.has(status)) {
-            throw new Error(`invalid status "${status ?? ""}"`);
-          }
-          let assignmentPath = null;
-          if (typeof item.id === "string" && item.id.trim()) {
-            if (!assignmentsDir2) {
-              throw new Error("standalone assignments are not configured on this server");
-            }
-            const resolved = await resolveAssignmentById(projectsDir, assignmentsDir2, item.id);
-            if (!resolved) {
-              throw new Error(`assignment "${item.id}" not found`);
-            }
-            assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-          } else if (typeof item.projectSlug === "string" && typeof item.assignmentSlug === "string" && item.projectSlug && item.assignmentSlug) {
-            assignmentPath = resolve18(
-              projectsDir,
-              item.projectSlug,
-              "assignments",
-              item.assignmentSlug,
-              "assignment.md"
-            );
-          } else {
-            throw new Error("must supply either `id` or both `projectSlug` and `assignmentSlug`");
-          }
-          if (!await fileExists(assignmentPath)) {
-            throw new Error("assignment file not found");
-          }
-          let content = await readFile14(assignmentPath, "utf-8");
-          content = setTopLevelField(content, "status", status);
-          content = setTopLevelField(content, "updated", timestamp);
-          if (status !== "blocked") {
-            content = setTopLevelField(content, "blockedReason", null);
-          }
-          await writeFileForce(assignmentPath, content);
-          results.push({ key: itemKey, ok: true });
-          succeeded += 1;
-        } catch (error) {
-          results.push({ key: itemKey, ok: false, error: error.message });
-          failed += 1;
-        }
-      }
-      res.json({ results, succeeded, failed });
-    } catch (error) {
-      console.error("Error in bulk-status-override:", error);
-      res.status(500).json({ error: `Bulk status override failed: ${error.message}` });
-    }
-  });
   router.patch("/api/assignments/:id/acceptance-criteria/:index", async (req, res) => {
     try {
       if (!assignmentsDir2) {
@@ -10607,16 +10813,6 @@ function validateTitleBody(body) {
   }
   return { ok: true, value: trimmed };
 }
-function buildBulkItemKey(raw, index) {
-  if (raw && typeof raw === "object") {
-    const item = raw;
-    if (typeof item.id === "string" && item.id.trim()) return item.id;
-    if (typeof item.projectSlug === "string" && typeof item.assignmentSlug === "string") {
-      return `${item.projectSlug}/${item.assignmentSlug}`;
-    }
-  }
-  return `#${index}`;
-}
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
   const commentsPath = resolve18(assignmentDir, "comments.md");
   const { body, author, type, replyTo } = req.body || {};
@@ -15812,7 +16008,7 @@ function createDashboardServer(options) {
     }
   });
   const VIEW_PREFS_LOCK = "vp:global";
-  const FILTER_KEYS = /* @__PURE__ */ new Set(["status", "type", "priority", "assignee", "project", "activity"]);
+  const FILTER_KEYS = /* @__PURE__ */ new Set(["status", "type", "priority", "assignee", "project", "tags", "activity"]);
   const GLOBAL_KEYS = /* @__PURE__ */ new Set(["defaultView", "sortField", "sortDirection", "density", "grouping", "filters"]);
   const SCOPE_KEYS = /* @__PURE__ */ new Set(["defaultView", "sortField", "sortDirection", "grouping", "filters"]);
   const ROOT_KEYS = /* @__PURE__ */ new Set(["global", "projects"]);
@@ -15831,7 +16027,7 @@ function createDashboardServer(options) {
     const unknown = unknownKey(obj, FILTER_KEYS, "filters");
     if (unknown) return { ok: false, error: unknown };
     const out = {};
-    for (const key of ["status", "type", "priority", "assignee", "project"]) {
+    for (const key of ["status", "type", "priority", "assignee", "project", "tags"]) {
       if (obj[key] !== void 0) {
         if (!isFilterValue(obj[key])) {
           return { ok: false, error: `filters.${key} must be a non-empty string or array of non-empty strings` };
@@ -16056,6 +16252,15 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to list assignments" });
     }
   });
+  app.get("/api/archived", async (_req, res) => {
+    try {
+      const result = await listArchived(projectsDir, assignmentsDir2);
+      res.json(result);
+    } catch (error) {
+      console.error("Error listing archived content:", error);
+      res.status(500).json({ error: "Failed to list archived content" });
+    }
+  });
   app.get("/api/projects/:slug", async (req, res) => {
     try {
       const detail = await getProjectDetail(projectsDir, req.params.slug);