@kynetic-ai/spec 0.10.0 → 0.12.0

package/dist/daemon/routes/tasks.ts

@@ -14,6 +14,9 @@
  * - ac-5: GET /api/tasks/:ref resolves via ReferenceIndex
  * - ac-6: POST /api/tasks/:ref/start transitions state
  * - ac-7: POST /api/tasks/:ref/note appends note
+ * - @ui-task-board ac-6: POST /api/tasks/:ref/submit transitions to pending_review
+ * - @ui-task-board ac-6: POST /api/tasks/:ref/complete transitions to completed
+ * - @ui-task-board ac-6: POST /api/tasks/:ref/block transitions to blocked
  */
 
 import { Elysia, t } from 'elysia';
@@ -21,6 +24,7 @@ import {
   initContext,
   loadAllTasks,
   loadAllItems,
+  loadPlans,
   ReferenceIndex,
   createNote,
   saveTask,
@@ -30,6 +34,8 @@ import {
 } from '../../parser/index.js';
 import { commitIfShadow } from '../../parser/shadow.js';
 import type { PubSubManager } from '../websocket/pubsub';
+import { getRelatedSessionsForTask } from './session-related.js';
+import { resolveRefTitle, resolveRefEntries } from './ref-resolution.js';
 
 interface TasksRouteOptions {
   pubsub: PubSubManager;
@@ -72,6 +78,31 @@ export function createTasksRoutes(options: TasksRouteOptions) {
           );
         }
 
+        // Automation filter — filter by automation eligibility status
+        if (query.automation) {
+          filtered = filtered.filter((task) => task.automation === query.automation);
+        }
+
+        // Plan filter — show only tasks derived from a given plan
+        if (query.plan) {
+          const plans = await loadPlans(ctx);
+          const plan = plans.find(
+            (p) => p._ulid === query.plan || p.slugs.includes(query.plan!)
+          );
+          if (plan) {
+            const derivedRefs = new Set(
+              plan.derived_tasks.map((r) => (r.startsWith('@') ? r.slice(1) : r))
+            );
+            filtered = filtered.filter(
+              (task) =>
+                derivedRefs.has(task._ulid) ||
+                task.slugs.some((s) => derivedRefs.has(s))
+            );
+          } else {
+            filtered = [];
+          }
+        }
+
         // AC: @api-contract ac-4 - Pagination
         const total = filtered.length;
         const offset = Number(query.offset) || 0;
@@ -81,16 +112,20 @@ export function createTasksRoutes(options: TasksRouteOptions) {
 
         // AC: @api-contract ac-2 - Return with status, priority, spec_ref, notes count
         // AC: @web-dashboard ac-1 - Include depends_on for blocked task computation
+        // AC: @ui-api-ref-resolution ac-1 - Include spec_title resolved server-side
         const items = paginated.map((task) => ({
           _ulid: task._ulid,
           slugs: task.slugs,
           title: task.title,
+          type: task.type || 'task',
           status: task.status,
           priority: task.priority,
           spec_ref: task.spec_ref,
+          spec_title: resolveRefTitle(index, task.spec_ref),
           meta_ref: task.meta_ref,
           tags: task.tags,
           depends_on: task.depends_on || [],
+          automation: task.automation,
           notes_count: task.notes?.length || 0,
           todos_count: task.todos?.length || 0,
           started_at: task.started_at,
@@ -111,6 +146,8 @@ export function createTasksRoutes(options: TasksRouteOptions) {
           status: t.Optional(t.Union([t.String(), t.Array(t.String())])),
           type: t.Optional(t.Union([t.String(), t.Array(t.String())])),
           tag: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+          automation: t.Optional(t.String()),
+          plan: t.Optional(t.String()),
           limit: t.Optional(t.String()),
           offset: t.Optional(t.String()),
         }),
@@ -125,7 +162,8 @@ export function createTasksRoutes(options: TasksRouteOptions) {
         const ctx = await initContext(projectContext.path);
         const tasks = await loadAllTasks(ctx);
         const items = await loadAllItems(ctx);
-        const index = new ReferenceIndex(tasks, items);
+        const plans = await loadPlans(ctx);
+        const index = new ReferenceIndex(tasks, items, [], plans);
 
         // AC: @api-contract ac-5, @trait-api-endpoint ac-2 - Resolve ref via ReferenceIndex
         const result = index.resolve(params.ref);
@@ -150,19 +188,36 @@ export function createTasksRoutes(options: TasksRouteOptions) {
         }
 
         // AC: @api-contract ac-5 - Return full task with notes, todos, dependencies
+        // AC: @ui-task-board ac-3 - Include type, description, blocked_by, vcs_refs, plan_ref, session_ref
+        // AC: @ui-api-ref-resolution ac-1, ac-2 - Include resolved titles for refs
         return {
           _ulid: task._ulid,
           slugs: task.slugs,
           title: task.title,
+          type: task.type || 'task',
           status: task.status,
           priority: task.priority,
           spec_ref: task.spec_ref,
+          spec_title: resolveRefTitle(index, task.spec_ref),
           meta_ref: task.meta_ref,
           tags: task.tags,
           description: task.description,
+          derivation: task.derivation,
           depends_on: task.depends_on,
+          resolved_depends_on: resolveRefEntries(index, task.depends_on),
+          blocked_by: task.blocked_by || [],
+          resolved_blocked_by: resolveRefEntries(index, task.blocked_by),
+          context: task.context || [],
+          vcs_refs: (task.vcs_refs || []).map((v) =>
+            typeof v === 'string' ? v : v.type ? `${v.type}:${v.ref}` : v.ref
+          ),
+          plan_ref: task.plan_ref,
+          plan_title: resolveRefTitle(index, task.plan_ref),
+          session_ref: task.session_id,
           notes: task.notes,
+          notes_count: task.notes?.length || 0,
           todos: task.todos,
+          todos_count: task.todos?.length || 0,
           started_at: task.started_at,
           completed_at: task.completed_at,
           cancelled_at: task.cancelled_at,
@@ -178,6 +233,37 @@ export function createTasksRoutes(options: TasksRouteOptions) {
       }
     )
 
+    .get(
+      '/:ref/sessions',
+      async ({ params, error: errorResponse, projectContext }) => {
+        const ctx = await initContext(projectContext.path);
+        const tasks = await loadAllTasks(ctx);
+        const items = await loadAllItems(ctx);
+        const result = await getRelatedSessionsForTask({
+          taskRef: params.ref,
+          tasks,
+          items,
+          sessionsDir: ctx.sessionsDir,
+        });
+
+        if ('error' in result) {
+          return errorResponse(404, result.error);
+        }
+
+        return {
+          items: result.sessions,
+          total: result.sessions.length,
+          offset: 0,
+          limit: result.sessions.length,
+        };
+      },
+      {
+        params: t.Object({
+          ref: t.String(),
+        }),
+      }
+    )
+
     // AC: @api-contract ac-6 - Start task
     .post(
       '/:ref/start',
@@ -229,12 +315,15 @@ export function createTasksRoutes(options: TasksRouteOptions) {
         await commitIfShadow(ctx.shadow, `task: start ${params.ref}`);
 
         // AC: @api-contract ac-6, @trait-api-endpoint ac-5 - WebSocket broadcast
+        // AC: @ui-api-aggregation ac-4 - Include title and old/new status
         // AC: @multi-directory-daemon ac-18 - Broadcast scoped to request project
         pubsub.broadcast('tasks:updates', 'task_updated', {
           ref: params.ref,
           ulid: task._ulid,
           action: 'start',
-          status: 'in_progress',
+          title: task.title,
+          old_status: task.status,
+          new_status: 'in_progress',
         }, projectContext.path);
 
         // AC: @api-contract ac-6 - Return updated task
@@ -301,11 +390,15 @@ export function createTasksRoutes(options: TasksRouteOptions) {
         await commitIfShadow(ctx.shadow, `task: add note to ${params.ref}`);
 
         // AC: @api-contract ac-7 - WebSocket broadcast
+        // AC: @ui-api-aggregation ac-4 - Include title (no status change for notes)
         // AC: @multi-directory-daemon ac-18 - Broadcast scoped to request project
         pubsub.broadcast('tasks:updates', 'task_updated', {
           ref: params.ref,
           ulid: task._ulid,
           action: 'note_added',
+          title: task.title,
+          old_status: null,
+          new_status: null,
           note_ulid: note._ulid,
         }, projectContext.path);
 
@@ -323,5 +416,167 @@ export function createTasksRoutes(options: TasksRouteOptions) {
           content: t.String(),
         }),
       }
+    )
+
+    // AC: @ui-task-board ac-6 - Submit task for review
+    .post(
+      '/:ref/submit',
+      async ({ params, error: errorResponse, projectContext }) => {
+        const ctx = await initContext(projectContext.path);
+        const tasks = await loadAllTasks(ctx);
+        const items = await loadAllItems(ctx);
+        const index = new ReferenceIndex(tasks, items);
+
+        const result = index.resolve(params.ref);
+        if (!result.ok) {
+          return errorResponse(404, {
+            error: 'not_found',
+            message: `Task reference "${params.ref}" not found`,
+          });
+        }
+
+        const task = tasks.find((t) => t._ulid === result.ulid);
+        if (!task) {
+          return errorResponse(404, {
+            error: 'not_found',
+            message: `Reference "${params.ref}" is not a task`,
+          });
+        }
+
+        if (task.status !== 'in_progress' && task.status !== 'needs_work') {
+          return errorResponse(409, {
+            error: 'invalid_transition',
+            message: `Cannot submit task with status "${task.status}". Must be in_progress or needs_work.`,
+            current: task.status,
+            valid_transitions: ['pending_review'],
+          });
+        }
+
+        const updatedTask: LoadedTask = { ...task, status: 'pending_review' };
+        await saveTask(ctx, updatedTask);
+        await syncSpecImplementationStatus(ctx, updatedTask, tasks, items, index);
+        await commitIfShadow(ctx.shadow, `task: submit ${params.ref}`);
+
+        // AC: @ui-api-aggregation ac-4 - Include title and old/new status
+        pubsub.broadcast('tasks:updates', 'task_updated', {
+          ref: params.ref,
+          ulid: task._ulid,
+          action: 'submit',
+          title: task.title,
+          old_status: task.status,
+          new_status: 'pending_review',
+        }, projectContext.path);
+
+        return updatedTask;
+      },
+      { params: t.Object({ ref: t.String() }) }
+    )
+
+    // AC: @ui-task-board ac-6 - Complete task
+    .post(
+      '/:ref/complete',
+      async ({ params, body, error: errorResponse, projectContext }) => {
+        const ctx = await initContext(projectContext.path);
+        const tasks = await loadAllTasks(ctx);
+        const items = await loadAllItems(ctx);
+        const index = new ReferenceIndex(tasks, items);
+
+        const result = index.resolve(params.ref);
+        if (!result.ok) {
+          return errorResponse(404, {
+            error: 'not_found',
+            message: `Task reference "${params.ref}" not found`,
+          });
+        }
+
+        const task = tasks.find((t) => t._ulid === result.ulid);
+        if (!task) {
+          return errorResponse(404, {
+            error: 'not_found',
+            message: `Reference "${params.ref}" is not a task`,
+          });
+        }
+
+        const updatedTask: LoadedTask = {
+          ...task,
+          status: 'completed',
+          completed_at: new Date().toISOString(),
+          closed_reason: body.reason,
+        };
+        await saveTask(ctx, updatedTask);
+        await syncSpecImplementationStatus(ctx, updatedTask, tasks, items, index);
+        await commitIfShadow(ctx.shadow, `task: complete ${params.ref}`);
+
+        // AC: @ui-api-aggregation ac-4 - Include title and old/new status
+        pubsub.broadcast('tasks:updates', 'task_updated', {
+          ref: params.ref,
+          ulid: task._ulid,
+          action: 'complete',
+          title: task.title,
+          old_status: task.status,
+          new_status: 'completed',
+        }, projectContext.path);
+
+        return updatedTask;
+      },
+      {
+        params: t.Object({ ref: t.String() }),
+        body: t.Object({ reason: t.String() }),
+      }
+    )
+
+    // AC: @ui-task-board ac-6 - Block task
+    .post(
+      '/:ref/block',
+      async ({ params, body, error: errorResponse, projectContext }) => {
+        const ctx = await initContext(projectContext.path);
+        const tasks = await loadAllTasks(ctx);
+        const items = await loadAllItems(ctx);
+        const index = new ReferenceIndex(tasks, items);
+
+        const result = index.resolve(params.ref);
+        if (!result.ok) {
+          return errorResponse(404, {
+            error: 'not_found',
+            message: `Task reference "${params.ref}" not found`,
+          });
+        }
+
+        const task = tasks.find((t) => t._ulid === result.ulid);
+        if (!task) {
+          return errorResponse(404, {
+            error: 'not_found',
+            message: `Reference "${params.ref}" is not a task`,
+          });
+        }
+
+        const author = getAuthor(ctx.config?.identity?.author);
+        const note = createNote(`Blocked: ${body.reason}`, author);
+
+        const updatedTask: LoadedTask = {
+          ...task,
+          status: 'blocked',
+          notes: [...(task.notes || []), note],
+        };
+        await saveTask(ctx, updatedTask);
+        await syncSpecImplementationStatus(ctx, updatedTask, tasks, items, index);
+        await commitIfShadow(ctx.shadow, `task: block ${params.ref}`);
+
+        // AC: @ui-api-aggregation ac-4 - Include title and old/new status
+        pubsub.broadcast('tasks:updates', 'task_updated', {
+          ref: params.ref,
+          ulid: task._ulid,
+          action: 'block',
+          title: task.title,
+          old_status: task.status,
+          new_status: 'blocked',
+        }, projectContext.path);
+
+        return updatedTask;
+      },
+      {
+        params: t.Object({ ref: t.String() }),
+        body: t.Object({ reason: t.String() }),
+      }
     );
 }

package/dist/daemon/routes/triage.ts

@@ -25,6 +25,9 @@ import { Elysia, t } from 'elysia';
 import { ulid } from 'ulidx';
 import {
   initContext,
+  loadAllTasks,
+  loadAllItems,
+  ReferenceIndex,
   loadTriageRecords,
   saveTriageRecord,
   findTriageRecordByRef,
@@ -34,6 +37,7 @@ import {
   getAuthor,
   type LoadedTriageRecord,
 } from '../../parser/index.js';
+import { resolveRefEntries } from './ref-resolution.js';
 import { commitIfShadow } from '../../parser/shadow.js';
 import { normalizeRefInput } from '../../schema/index.js';
 import type { TriageAction } from '../../schema/index.js';
@@ -87,8 +91,27 @@ export function createTriageRoutes(options: TriageRouteOptions) {
 
         const paginated = filtered.slice(offset, offset + limit);
 
+        // AC: @ui-api-ref-resolution ac-2 - Resolve evidence_refs titles
+        const hasEvidenceRefs = paginated.some((r) => r.evidence_refs?.length > 0);
+        let refIndex: ReferenceIndex | null = null;
+        if (hasEvidenceRefs) {
+          try {
+            const tasks = await loadAllTasks(ctx);
+            const items = await loadAllItems(ctx);
+            refIndex = new ReferenceIndex(tasks, items);
+          } catch {
+            // Non-critical
+          }
+        }
+        const enriched = refIndex
+          ? paginated.map((r) => ({
+              ...r,
+              resolved_evidence_refs: resolveRefEntries(refIndex!, r.evidence_refs),
+            }))
+          : paginated;
+
         return {
-          items: paginated,
+          items: enriched,
           total,
           offset,
           limit,
@@ -223,6 +246,7 @@ export function createTriageRoutes(options: TriageRouteOptions) {
     )
 
     // GET single triage record
+    // AC: @ui-api-ref-resolution ac-2 - Resolve evidence_refs titles
     .get(
       '/:ref',
       async ({ params, error: errorResponse, projectContext }) => {
@@ -240,6 +264,21 @@ export function createTriageRoutes(options: TriageRouteOptions) {
           });
         }
 
+        // AC: @ui-api-ref-resolution ac-2 - Resolve evidence_refs
+        if (record.evidence_refs?.length > 0) {
+          try {
+            const tasks = await loadAllTasks(ctx);
+            const items = await loadAllItems(ctx);
+            const refIndex = new ReferenceIndex(tasks, items);
+            return {
+              ...record,
+              resolved_evidence_refs: resolveRefEntries(refIndex, record.evidence_refs),
+            };
+          } catch {
+            // Non-critical
+          }
+        }
+
         return record;
       },
       {

package/dist/daemon/routes/validation.ts

@@ -218,7 +218,7 @@ export function createValidationRoutes(options: ValidationRouteOptions = {}) {
         refWarnings: result.refWarnings,
         orphans: result.orphans,
         completenessWarnings: result.completenessWarnings,
-        traitCycles: result.traitCycles,
+        traitCycles: result.traitCycleErrors,
       };
     })