@lumenflow/cli 3.19.0 → 3.20.0

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

@@ -26,10 +26,11 @@ import {
 const TOOL_NAMES = {
   STORE: 'memory:store',
   RECALL: 'memory:recall',
+  UPDATE: 'memory:update',
   FORGET: 'memory:forget',
 } as const;
 
-const VALID_MEMORY_TYPES: MemoryType[] = ['fact', 'preference', 'note'];
+const VALID_MEMORY_TYPES: MemoryType[] = ['fact', 'preference', 'note', 'snippet'];
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -126,6 +127,88 @@ async function memoryRecallTool(input: unknown, _context?: ToolContextLike): Pro
   });
 }
 
+// ---------------------------------------------------------------------------
+// memory:update
+// ---------------------------------------------------------------------------
+
+async function memoryUpdateTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
+  const parsed = toRecord(input);
+  const id = asNonEmptyString(parsed.id);
+
+  if (!id) {
+    return failure('INVALID_INPUT', 'id is required.');
+  }
+
+  const patch: Partial<MemoryRecord> = {};
+  if (parsed.type !== undefined) {
+    const type = asMemoryType(parsed.type);
+    if (!type) {
+      return failure('INVALID_INPUT', 'type must be one of fact, preference, note, snippet.');
+    }
+    patch.type = type;
+  }
+  if (parsed.content !== undefined) {
+    const content = asNonEmptyString(parsed.content);
+    if (!content) {
+      return failure('INVALID_INPUT', 'content must be a non-empty string when provided.');
+    }
+    patch.content = content;
+  }
+  if (parsed.tags !== undefined) {
+    patch.tags = asStringArray(parsed.tags);
+  }
+
+  if (Object.keys(patch).length === 0) {
+    return failure(
+      'INVALID_INPUT',
+      'memory:update requires at least one of type, content, or tags.',
+    );
+  }
+
+  const storage = getStoragePort();
+  const memories = await storage.readStore('memories');
+  const memory = memories.find((entry) => entry.id === id);
+
+  if (!memory) {
+    return failure('NOT_FOUND', `memory ${id} was not found.`);
+  }
+
+  const preview: MemoryRecord = {
+    ...memory,
+    ...patch,
+    updated_at: nowIso(),
+  };
+
+  if (isDryRun(parsed)) {
+    return success({
+      dry_run: true,
+      memory: preview as unknown as Record<string, unknown>,
+    });
+  }
+
+  await storage.withLock(async () => {
+    const latest = await storage.readStore('memories');
+    const target = latest.find((entry) => entry.id === id);
+    if (!target) {
+      return;
+    }
+    Object.assign(target, preview);
+    await storage.writeStore('memories', latest);
+    await storage.appendAudit(
+      buildAuditEvent({
+        tool: TOOL_NAMES.UPDATE,
+        op: 'update',
+        context,
+        ids: [id],
+      }),
+    );
+  });
+
+  const updated = await storage.readStore('memories');
+  const updatedMemory = updated.find((entry) => entry.id === id);
+  return success({ memory: updatedMemory as unknown as Record<string, unknown> });
+}
+
 // ---------------------------------------------------------------------------
 // memory:forget
 // ---------------------------------------------------------------------------
@@ -180,6 +263,8 @@ export default async function memoryTools(
       return memoryStoreTool(input, context);
     case TOOL_NAMES.RECALL:
       return memoryRecallTool(input, context);
+    case TOOL_NAMES.UPDATE:
+      return memoryUpdateTool(input, context);
     case TOOL_NAMES.FORGET:
       return memoryForgetTool(input, context);
     default:

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.20.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.20.0",
   "description": "Software delivery pack for LumenFlow — work units, gates, lanes, initiatives, and agent coordination",
   "keywords": [
     "lumenflow",

package/templates/core/_frameworks/lumenflow/wu-sizing-guide.md.template

@@ -102,7 +102,7 @@ Documentation WUs (`type: documentation`) have relaxed file count thresholds bec
 id: WU-XXX
 type: documentation
 code_paths:
-  - docs/operations/_frameworks/lumenflow/*.md
+  - {{DOCS_OPERATIONS_PATH}}/_frameworks/lumenflow/*.md
   - docs/01-product/*.md
 ```
 
@@ -320,7 +320,7 @@ The tooling operates in two modes:
 ```
 [wu:create] WARNING (WU-100): sizing: estimated_files (30) exceeds Simple
 threshold (20). Consider adding exception_type/exception_reason or splitting
-the WU. See docs/operations/_frameworks/lumenflow/wu-sizing-guide.md.
+the WU. See {{DOCS_OPERATIONS_PATH}}/_frameworks/lumenflow/wu-sizing-guide.md.
 ```
 
 **Strict mode (`--strict-sizing`):** `wu:brief` supports a `--strict-sizing` flag that blocks when: