@lumenflow/cli 3.19.0 → 3.21.0

package/packs/sidekick/tool-impl/routine-tools.ts

@@ -23,8 +23,11 @@ import {
 const TOOL_NAMES = {
   CREATE: 'routine:create',
   LIST: 'routine:list',
+  UPDATE: 'routine:update',
+  DELETE: 'routine:delete',
   RUN: 'routine:run',
 } as const;
+const ROUTINE_ID_REQUIRED_MESSAGE = 'id is required.';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -80,6 +83,13 @@ function normalizeSteps(value: unknown): NormalizeStepsResult {
   return { steps, warnings };
 }
 
+function asOptionalBoolean(value: unknown): boolean | null {
+  if (value === true || value === false) {
+    return value;
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // routine:create
 // ---------------------------------------------------------------------------
@@ -105,6 +115,8 @@ async function routineCreateTool(input: unknown, context?: ToolContextLike): Pro
     id: createId('routine'),
     name,
     steps,
+    cron: asNonEmptyString(parsed.cron) ?? undefined,
+    enabled: asOptionalBoolean(parsed.enabled) ?? true,
     created_at: now,
     updated_at: now,
   };
@@ -145,11 +157,13 @@ async function routineCreateTool(input: unknown, context?: ToolContextLike): Pro
 async function routineListTool(input: unknown, _context?: ToolContextLike): Promise<ToolOutput> {
   const parsed = toRecord(input);
   const limit = asInteger(parsed.limit);
+  const enabledOnly = parsed.enabled_only === true;
 
   const storage = getStoragePort();
   const routines = await storage.readStore('routines');
 
-  const sorted = routines.toSorted((a, b) => Date.parse(b.updated_at) - Date.parse(a.updated_at));
+  const filtered = enabledOnly ? routines.filter((routine) => routine.enabled) : routines;
+  const sorted = filtered.toSorted((a, b) => Date.parse(b.updated_at) - Date.parse(a.updated_at));
 
   const items = limit && limit > 0 ? sorted.slice(0, limit) : sorted;
 
@@ -159,6 +173,142 @@ async function routineListTool(input: unknown, _context?: ToolContextLike): Prom
   });
 }
 
+// ---------------------------------------------------------------------------
+// routine:update
+// ---------------------------------------------------------------------------
+
+async function routineUpdateTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
+  const parsed = toRecord(input);
+  const id = asNonEmptyString(parsed.id);
+
+  if (!id) {
+    return failure('INVALID_INPUT', ROUTINE_ID_REQUIRED_MESSAGE);
+  }
+
+  const patch: Partial<RoutineRecord> = {};
+  const name = asNonEmptyString(parsed.name);
+  const cron =
+    typeof parsed.cron === 'string' ? (asNonEmptyString(parsed.cron) ?? undefined) : null;
+  const enabled = asOptionalBoolean(parsed.enabled);
+
+  if (name) {
+    patch.name = name;
+  }
+  if (cron !== null) {
+    patch.cron = cron;
+  }
+  if (enabled !== null) {
+    patch.enabled = enabled;
+  }
+  if (parsed.steps !== undefined) {
+    const { steps, warnings } = normalizeSteps(parsed.steps);
+    if (steps.length === 0) {
+      const detail =
+        warnings.length > 0
+          ? `steps must include at least one tool step. Issues: ${warnings.join('; ')}`
+          : 'steps must include at least one tool step.';
+      return failure('INVALID_INPUT', detail);
+    }
+    patch.steps = steps;
+  }
+
+  if (Object.keys(patch).length === 0) {
+    return failure(
+      'INVALID_INPUT',
+      'routine:update requires at least one of name, steps, cron, or enabled.',
+    );
+  }
+
+  const storage = getStoragePort();
+  const routines = await storage.readStore('routines');
+  const routine = routines.find((entry) => entry.id === id);
+
+  if (!routine) {
+    return failure('NOT_FOUND', `routine ${id} was not found.`);
+  }
+
+  const preview: RoutineRecord = {
+    ...routine,
+    ...patch,
+    updated_at: nowIso(),
+  };
+
+  if (isDryRun(parsed)) {
+    return success({
+      dry_run: true,
+      routine: preview as unknown as Record<string, unknown>,
+    });
+  }
+
+  await storage.withLock(async () => {
+    const latest = await storage.readStore('routines');
+    const target = latest.find((entry) => entry.id === id);
+    if (!target) {
+      return;
+    }
+    Object.assign(target, preview);
+    await storage.writeStore('routines', latest);
+    await storage.appendAudit(
+      buildAuditEvent({
+        tool: TOOL_NAMES.UPDATE,
+        op: 'update',
+        context,
+        ids: [id],
+      }),
+    );
+  });
+
+  const updated = await storage.readStore('routines');
+  const updatedRoutine = updated.find((entry) => entry.id === id);
+  return success({ routine: updatedRoutine as unknown as Record<string, unknown> });
+}
+
+// ---------------------------------------------------------------------------
+// routine:delete
+// ---------------------------------------------------------------------------
+
+async function routineDeleteTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
+  const parsed = toRecord(input);
+  const id = asNonEmptyString(parsed.id);
+
+  if (!id) {
+    return failure('INVALID_INPUT', ROUTINE_ID_REQUIRED_MESSAGE);
+  }
+
+  const storage = getStoragePort();
+  const routines = await storage.readStore('routines');
+  const routine = routines.find((entry) => entry.id === id);
+
+  if (!routine) {
+    return failure('NOT_FOUND', `routine ${id} was not found.`);
+  }
+
+  if (isDryRun(parsed)) {
+    return success({
+      dry_run: true,
+      deleted_id: id,
+    });
+  }
+
+  await storage.withLock(async () => {
+    const latest = await storage.readStore('routines');
+    await storage.writeStore(
+      'routines',
+      latest.filter((entry) => entry.id !== id),
+    );
+    await storage.appendAudit(
+      buildAuditEvent({
+        tool: TOOL_NAMES.DELETE,
+        op: 'delete',
+        context,
+        ids: [id],
+      }),
+    );
+  });
+
+  return success({ deleted_id: id });
+}
+
 // ---------------------------------------------------------------------------
 // routine:run (PLAN-ONLY -- does NOT execute tool steps)
 // ---------------------------------------------------------------------------
@@ -168,7 +318,7 @@ async function routineRunTool(input: unknown, context?: ToolContextLike): Promis
   const id = asNonEmptyString(parsed.id);
 
   if (!id) {
-    return failure('INVALID_INPUT', 'id is required.');
+    return failure('INVALID_INPUT', ROUTINE_ID_REQUIRED_MESSAGE);
   }
 
   const storage = getStoragePort();
@@ -218,6 +368,10 @@ export default async function routineTools(
       return routineCreateTool(input, context);
     case TOOL_NAMES.LIST:
       return routineListTool(input, context);
+    case TOOL_NAMES.UPDATE:
+      return routineUpdateTool(input, context);
+    case TOOL_NAMES.DELETE:
+      return routineDeleteTool(input, context);
     case TOOL_NAMES.RUN:
       return routineRunTool(input, context);
     default:

package/packs/sidekick/tool-impl/storage.ts

@@ -21,8 +21,8 @@ const RANDOM_BYTES_LENGTH = 4;
 // ---------------------------------------------------------------------------
 
 export type TaskPriority = 'P0' | 'P1' | 'P2' | 'P3';
-export type TaskStatus = 'pending' | 'done';
-export type MemoryType = 'fact' | 'preference' | 'note';
+export type TaskStatus = 'pending' | 'done' | 'canceled';
+export type MemoryType = 'fact' | 'preference' | 'note' | 'snippet';
 
 export interface TaskRecord {
   id: string;
@@ -32,10 +32,12 @@ export interface TaskRecord {
   status: TaskStatus;
   tags: string[];
   due_at?: string;
+  cron?: string;
   note?: string;
   created_at: string;
   updated_at: string;
   completed_at?: string;
+  canceled_at?: string;
 }
 
 export interface MemoryRecord {
@@ -71,6 +73,8 @@ export interface RoutineRecord {
   id: string;
   name: string;
   steps: RoutineStepRecord[];
+  cron?: string;
+  enabled: boolean;
   created_at: string;
   updated_at: string;
 }
@@ -140,9 +144,6 @@ const LOCK_FILE_PATH = '.lock';
 // ---------------------------------------------------------------------------
 
 function cloneStore<K extends StoreName>(store: K, value: SidekickStores[K]): SidekickStores[K] {
-  if (Array.isArray(value)) {
-    return value.map((entry) => ({ ...entry })) as SidekickStores[K];
-  }
   return structuredClone(value) as SidekickStores[K];
 }
 

package/packs/sidekick/tool-impl/task-tools.ts

@@ -9,6 +9,7 @@ import {
   buildAuditEvent,
   createId,
   failure,
+  includesText,
   isDryRun,
   matchesTags,
   nowIso,
@@ -25,12 +26,15 @@ import {
 const TOOL_NAMES = {
   CREATE: 'task:create',
   LIST: 'task:list',
+  UPDATE: 'task:update',
+  CANCEL: 'task:cancel',
   COMPLETE: 'task:complete',
   SCHEDULE: 'task:schedule',
 } as const;
 
 const VALID_PRIORITIES: TaskPriority[] = ['P0', 'P1', 'P2', 'P3'];
 const DEFAULT_PRIORITY: TaskPriority = 'P2';
+const TASK_ID_REQUIRED_MESSAGE = 'id is required.';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -42,6 +46,57 @@ function asPriority(value: unknown): TaskPriority {
     : DEFAULT_PRIORITY;
 }
 
+function resolveTaskUpdatePatch(parsed: Record<string, unknown>): Partial<TaskRecord> {
+  const patch: Partial<TaskRecord> = {};
+  const title = asNonEmptyString(parsed.title);
+  const description =
+    typeof parsed.description === 'string'
+      ? (asNonEmptyString(parsed.description) ?? undefined)
+      : null;
+  const dueAt =
+    typeof parsed.due_at === 'string' ? (asNonEmptyString(parsed.due_at) ?? undefined) : null;
+  const cron =
+    typeof parsed.cron === 'string' ? (asNonEmptyString(parsed.cron) ?? undefined) : null;
+
+  if (title) {
+    patch.title = title;
+  }
+  if (description !== null) {
+    patch.description = description;
+  }
+  if (dueAt !== null) {
+    patch.due_at = dueAt;
+  }
+  if (cron !== null) {
+    patch.cron = cron;
+  }
+  if (parsed.priority !== undefined) {
+    patch.priority = asPriority(parsed.priority);
+  }
+  if (parsed.tags !== undefined) {
+    patch.tags = asStringArray(parsed.tags);
+  }
+
+  return patch;
+}
+
+function applyTaskPatch(task: TaskRecord, patch: Partial<TaskRecord>): TaskRecord {
+  return {
+    ...task,
+    ...patch,
+    updated_at: nowIso(),
+  };
+}
+
+function buildCanceledTask(task: TaskRecord): TaskRecord {
+  return {
+    ...task,
+    status: 'canceled',
+    canceled_at: nowIso(),
+    updated_at: nowIso(),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // task:create
 // ---------------------------------------------------------------------------
@@ -97,6 +152,7 @@ async function taskListTool(input: unknown, _context?: ToolContextLike): Promise
   const statusFilter = asNonEmptyString(parsed.status);
   const priorityFilter = asNonEmptyString(parsed.priority);
   const tags = asStringArray(parsed.tags);
+  const search = asNonEmptyString(parsed.search);
   const dueBefore = asNonEmptyString(parsed.due_before);
   const limit = asInteger(parsed.limit);
 
@@ -113,6 +169,9 @@ async function taskListTool(input: unknown, _context?: ToolContextLike): Promise
     if (!matchesTags(tags, task.tags)) {
       return false;
     }
+    if (!includesText(`${task.title}\n${task.description ?? ''}`, search)) {
+      return false;
+    }
     if (dueBefore && task.due_at) {
       if (Date.parse(task.due_at) >= Date.parse(dueBefore)) {
         return false;
@@ -134,6 +193,70 @@ async function taskListTool(input: unknown, _context?: ToolContextLike): Promise
   });
 }
 
+// ---------------------------------------------------------------------------
+// task:update
+// ---------------------------------------------------------------------------
+
+async function taskUpdateTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
+  const parsed = toRecord(input);
+  const id = asNonEmptyString(parsed.id);
+
+  if (!id) {
+    return failure('INVALID_INPUT', TASK_ID_REQUIRED_MESSAGE);
+  }
+
+  const patch = resolveTaskUpdatePatch(parsed);
+  if (Object.keys(patch).length === 0) {
+    return failure(
+      'INVALID_INPUT',
+      'task:update requires at least one of title, description, priority, tags, due_at, or cron.',
+    );
+  }
+
+  const storage = getStoragePort();
+  const tasks = await storage.readStore('tasks');
+  const task = tasks.find((entry) => entry.id === id);
+
+  if (!task) {
+    return failure('NOT_FOUND', `task ${id} was not found.`);
+  }
+  if (task.status === 'canceled') {
+    return failure(
+      'INVALID_STATE',
+      `task ${id} is canceled and cannot be completed. Reopen it with task:update before completing.`,
+    );
+  }
+
+  if (isDryRun(parsed)) {
+    return success({
+      dry_run: true,
+      task: applyTaskPatch(task, patch) as unknown as Record<string, unknown>,
+    });
+  }
+
+  await storage.withLock(async () => {
+    const latest = await storage.readStore('tasks');
+    const target = latest.find((entry) => entry.id === id);
+    if (!target) {
+      return;
+    }
+    Object.assign(target, applyTaskPatch(target, patch));
+    await storage.writeStore('tasks', latest);
+    await storage.appendAudit(
+      buildAuditEvent({
+        tool: TOOL_NAMES.UPDATE,
+        op: 'update',
+        context,
+        ids: [id],
+      }),
+    );
+  });
+
+  const updated = await storage.readStore('tasks');
+  const updatedTask = updated.find((entry) => entry.id === id);
+  return success({ task: updatedTask as unknown as Record<string, unknown> });
+}
+
 // ---------------------------------------------------------------------------
 // task:complete
 // ---------------------------------------------------------------------------
@@ -143,7 +266,7 @@ async function taskCompleteTool(input: unknown, context?: ToolContextLike): Prom
   const id = asNonEmptyString(parsed.id);
 
   if (!id) {
-    return failure('INVALID_INPUT', 'id is required.');
+    return failure('INVALID_INPUT', TASK_ID_REQUIRED_MESSAGE);
   }
 
   const storage = getStoragePort();
@@ -190,6 +313,62 @@ async function taskCompleteTool(input: unknown, context?: ToolContextLike): Prom
   return success({ task: completedTask as unknown as Record<string, unknown> });
 }
 
+// ---------------------------------------------------------------------------
+// task:cancel
+// ---------------------------------------------------------------------------
+
+async function taskCancelTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
+  const parsed = toRecord(input);
+  const id = asNonEmptyString(parsed.id);
+
+  if (!id) {
+    return failure('INVALID_INPUT', TASK_ID_REQUIRED_MESSAGE);
+  }
+
+  const storage = getStoragePort();
+  const tasks = await storage.readStore('tasks');
+  const task = tasks.find((entry) => entry.id === id);
+
+  if (!task) {
+    return failure('NOT_FOUND', `task ${id} was not found.`);
+  }
+  if (task.status === 'done') {
+    return failure(
+      'INVALID_STATE',
+      `task ${id} is already done and cannot be canceled. Use task:update if you only need to adjust metadata.`,
+    );
+  }
+
+  if (isDryRun(parsed)) {
+    return success({
+      dry_run: true,
+      task: buildCanceledTask(task) as unknown as Record<string, unknown>,
+    });
+  }
+
+  await storage.withLock(async () => {
+    const latest = await storage.readStore('tasks');
+    const target = latest.find((entry) => entry.id === id);
+    if (!target) {
+      return;
+    }
+    Object.assign(target, buildCanceledTask(target));
+    await storage.writeStore('tasks', latest);
+    await storage.appendAudit(
+      buildAuditEvent({
+        tool: TOOL_NAMES.CANCEL,
+        op: 'update',
+        context,
+        ids: [id],
+      }),
+    );
+  });
+
+  const updated = await storage.readStore('tasks');
+  const canceledTask = updated.find((entry) => entry.id === id);
+  return success({ task: canceledTask as unknown as Record<string, unknown> });
+}
+
 // ---------------------------------------------------------------------------
 // task:schedule
 // ---------------------------------------------------------------------------
@@ -199,7 +378,7 @@ async function taskScheduleTool(input: unknown, context?: ToolContextLike): Prom
   const id = asNonEmptyString(parsed.id);
 
   if (!id) {
-    return failure('INVALID_INPUT', 'id is required.');
+    return failure('INVALID_INPUT', TASK_ID_REQUIRED_MESSAGE);
   }
 
   const storage = getStoragePort();
@@ -232,9 +411,8 @@ async function taskScheduleTool(input: unknown, context?: ToolContextLike): Prom
       if (dueAt) {
         target.due_at = dueAt;
       }
-      // cron is stored but TaskRecord doesn't have it yet -- extend inline
       if (cron) {
-        (target as unknown as Record<string, unknown>).cron = cron;
+        target.cron = cron;
       }
       target.updated_at = nowIso();
       await storage.writeStore('tasks', latest);
@@ -268,6 +446,10 @@ export default async function taskTools(
       return taskCreateTool(input, context);
     case TOOL_NAMES.LIST:
       return taskListTool(input, context);
+    case TOOL_NAMES.UPDATE:
+      return taskUpdateTool(input, context);
+    case TOOL_NAMES.CANCEL:
+      return taskCancelTool(input, context);
     case TOOL_NAMES.COMPLETE:
       return taskCompleteTool(input, context);
     case TOOL_NAMES.SCHEDULE:

package/packs/software-delivery/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @lumenflow/packs-software-delivery@3.19.0 build /home/runner/work/lumenflow-dev/lumenflow-dev/packages/@lumenflow/packs/software-delivery
+> @lumenflow/packs-software-delivery@3.21.0 build /home/runner/work/lumenflow-dev/lumenflow-dev/packages/@lumenflow/packs/software-delivery
 > tsc
 

package/packs/software-delivery/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/packs-software-delivery",
-  "version": "3.19.0",
+  "version": "3.21.0",
   "description": "Software delivery pack for LumenFlow — work units, gates, lanes, initiatives, and agent coordination",
   "keywords": [
     "lumenflow",

package/templates/core/.lumenflow/constraints.md.template

@@ -3,11 +3,11 @@
 **Version:** 1.3
 **Last updated:** {{DATE}}
 
-This document contains the 9 non-negotiable constraints that every agent must keep "in working memory" from first plan through `wu:done`.
+This document contains the 11 non-negotiable constraints that every agent must keep "in working memory" from first plan through `wu:done`.
 
 ---
 
-## The 9 Non-Negotiable Constraints
+## The 11 Non-Negotiable Constraints
 
 ### 1. Worktree Discipline and Git Safety
 
@@ -175,6 +175,16 @@ If you see something broken on main (failing gates, format issues, typos, lint e
 
 **Why:** Lane boundaries define ownership, WIP limits, and parallel execution safety. Misassigned WUs undermine these guarantees and create coordination confusion.
 
+**Occupied-lane workaround:**
+
+If the ideal lane is occupied by another WU (WIP limit reached), do NOT wait, force the lock, or try to modify the other WU. Instead:
+
+1. Use a nearby lane whose `code_paths` overlap with the files you need to change
+2. Or ask the user which lane to use
+3. Or wait for the lane to free up if the user prefers
+
+Never touch, release, or complete another agent's WU to free a lane.
+
 ---
 
 ### 9. YAML Files Must Be Modified via CLI Tooling Only (WU-1907)
@@ -205,6 +215,61 @@ If you see something broken on main (failing gates, format issues, typos, lint e
 
 ---
 
+### 10. Stop and Escalate After 3 Failures
+
+**Rule:** If the same operation fails 3 times, STOP. Do not retry. Escalate to the user with a summary of what failed and why.
+
+**Applies to:**
+
+- CLI commands (`wu:create`, `wu:claim`, `wu:done`, `gates`, etc.)
+- Git operations (push, merge, rebase)
+- Build/install operations
+- Any repeated error, including validation failures
+
+**What "same operation" means:**
+
+Retrying `wu:create` with slightly different flags after each validation error counts as the same operation. Six attempts with six different missing-field errors is still one operation failing six times. The fix is to run `--help` and read the requirements, not to guess-and-retry.
+
+**Escalation format:**
+
+```
+I've attempted [operation] 3 times and it's still failing.
+
+Attempts:
+1. [what I tried] → [error]
+2. [what I tried] → [error]
+3. [what I tried] → [error]
+
+Root cause: [my best diagnosis]
+Options: [what I think the fix is, or "I don't know"]
+```
+
+**Why:** Retry loops waste user time and context window. Three failures usually means the agent has a wrong mental model of the problem. Escalating early lets the user correct course before the agent creates additional mess (orphaned commits, diverged branches, locked lanes) that requires manual cleanup.
+
+---
+
+### 11. Client-Facing Content Accuracy
+
+**Rule:** When writing or updating content shown to external stakeholders (client portals, proposals, meeting materials), do not treat internal docs as ground truth for factual claims. Flag specific claims to the user for verification.
+
+**Claims that require user verification:**
+
+- Headcount, team size, or organisational structure
+- Revenue, AUM, or financial figures
+- Product status (shipped vs planned vs architectural)
+- Customer-specific details (tech stack, timelines, contract terms)
+- Competitive claims ("no other platform can...")
+
+**Enforcement:**
+
+- Before committing client-facing copy with specific factual claims, present a summary of claims to the user: "I'm about to commit these facts — please confirm they're current"
+- If internal docs contradict each other, flag the contradiction rather than picking one
+- Never cite a public URL or external source to "verify" an internal claim without telling the user you did so — the external source may also be stale
+
+**Why:** Internal docs go stale. An agent confidently writing "four-person engineering team" into a client portal when the team is actually 12+ undermines trust in both the portal and the agent. The user always knows what's current; the docs often don't.
+
+---
+
 ## Mini Audit Checklist
 
 Before running `wu:done`, verify:
@@ -296,7 +361,7 @@ Context compaction causes agents to lose critical rules. See [wu-sizing-guide.md
 
 Stop and ask a human when:
 
-- Same error repeats 3 times
+- Same error repeats 3 times (see Constraint 10 — this is non-negotiable, not advisory)
 - Auth or permissions changes required
 - PII/safety issues discovered
 - Cloud spend or secrets involved