@joshuaswarren/openclaw-engram 8.3.35 → 8.3.36

package/dist/index.js

@@ -16350,8 +16350,8 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path38 from "path";
-import { access as access2, readFile as readFile27, readdir as readdir16, unlink as unlink5 } from "fs/promises";
+import path39 from "path";
+import { access as access2, readFile as readFile28, readdir as readdir17, unlink as unlink5 } from "fs/promises";
 
 // src/transfer/export-json.ts
 import path26 from "path";
@@ -17230,8 +17230,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path40 = typeof record.path === "string" ? record.path : "";
-      if (!path40.startsWith("transcripts/") && !path40.includes("/transcripts/")) continue;
+      const path41 = typeof record.path === "string" ? record.path : "";
+      if (!path41.startsWith("transcripts/") && !path41.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -17699,6 +17699,351 @@ async function migrateObservations(options) {
   };
 }
 
+// src/work/storage.ts
+import path38 from "path";
+import { randomUUID } from "crypto";
+import { mkdir as mkdir27, readdir as readdir16, readFile as readFile27, rm as rm3, writeFile as writeFile24 } from "fs/promises";
+var TASK_TRANSITIONS = {
+  todo: /* @__PURE__ */ new Set(["in_progress", "blocked", "cancelled"]),
+  in_progress: /* @__PURE__ */ new Set(["todo", "blocked", "done", "cancelled"]),
+  blocked: /* @__PURE__ */ new Set(["todo", "in_progress", "cancelled"]),
+  done: /* @__PURE__ */ new Set(),
+  cancelled: /* @__PURE__ */ new Set()
+};
+function serializeFrontmatter2(values) {
+  const lines = Object.entries(values).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  return `---
+${lines.join("\n")}
+---`;
+}
+function parseFrontmatter3(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  const fm = match[1] ?? "";
+  const body = match[2] ?? "";
+  const data = {};
+  for (const line of fm.split("\n")) {
+    if (!line.trim()) continue;
+    const idx = line.indexOf(":");
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    try {
+      data[key] = JSON.parse(rawValue);
+    } catch {
+      data[key] = rawValue;
+    }
+  }
+  return { data, body };
+}
+function toSafeSlug(value) {
+  return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 80);
+}
+var WORK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
+function makeId(prefix, titleOrName, now) {
+  const slug = toSafeSlug(titleOrName) || "item";
+  const nonce = randomUUID().slice(0, 8);
+  return `${prefix}-${now.getTime()}-${slug}-${nonce}`;
+}
+function assertValidWorkId(id, kind) {
+  if (!WORK_ID_PATTERN.test(id)) {
+    throw new Error(`invalid ${kind} id: ${id}`);
+  }
+}
+function ensureString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function ensureStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function ensureNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function ensureTaskStatus(value) {
+  if (value === "todo" || value === "in_progress" || value === "blocked" || value === "done" || value === "cancelled") {
+    return value;
+  }
+  return "todo";
+}
+function ensureTaskPriority(value) {
+  if (value === "low" || value === "medium" || value === "high") return value;
+  return "medium";
+}
+function ensureProjectStatus(value) {
+  if (value === "active" || value === "on_hold" || value === "completed" || value === "archived") return value;
+  return "active";
+}
+var WorkStorage = class {
+  constructor(memoryDir) {
+    this.memoryDir = memoryDir;
+    this.tasksDir = path38.join(memoryDir, "work", "tasks");
+    this.projectsDir = path38.join(memoryDir, "work", "projects");
+  }
+  tasksDir;
+  projectsDir;
+  async ensureDirectories() {
+    await mkdir27(this.tasksDir, { recursive: true });
+    await mkdir27(this.projectsDir, { recursive: true });
+  }
+  taskPath(id) {
+    assertValidWorkId(id, "task");
+    return path38.join(this.tasksDir, `${id}.md`);
+  }
+  projectPath(id) {
+    assertValidWorkId(id, "project");
+    return path38.join(this.projectsDir, `${id}.md`);
+  }
+  serializeTask(task) {
+    return `${serializeFrontmatter2(task)}
+
+${task.description}
+`;
+  }
+  serializeProject(project) {
+    return `${serializeFrontmatter2(project)}
+
+${project.description}
+`;
+  }
+  parseTask(raw) {
+    const parsed = parseFrontmatter3(raw);
+    if (!parsed) return null;
+    const d = parsed.data;
+    return {
+      id: ensureString(d.id),
+      title: ensureString(d.title),
+      description: ensureString(d.description, parsed.body.trim()),
+      status: ensureTaskStatus(d.status),
+      priority: ensureTaskPriority(d.priority),
+      owner: ensureNullableString(d.owner),
+      assignee: ensureNullableString(d.assignee),
+      projectId: ensureNullableString(d.projectId),
+      tags: ensureStringArray(d.tags),
+      dueAt: ensureNullableString(d.dueAt),
+      createdAt: ensureString(d.createdAt),
+      updatedAt: ensureString(d.updatedAt)
+    };
+  }
+  parseProject(raw) {
+    const parsed = parseFrontmatter3(raw);
+    if (!parsed) return null;
+    const d = parsed.data;
+    return {
+      id: ensureString(d.id),
+      name: ensureString(d.name),
+      description: ensureString(d.description, parsed.body.trim()),
+      status: ensureProjectStatus(d.status),
+      owner: ensureNullableString(d.owner),
+      tags: ensureStringArray(d.tags),
+      taskIds: ensureStringArray(d.taskIds),
+      createdAt: ensureString(d.createdAt),
+      updatedAt: ensureString(d.updatedAt)
+    };
+  }
+  async createTask(input, now = /* @__PURE__ */ new Date()) {
+    await this.ensureDirectories();
+    const timestamp = now.toISOString();
+    const task = {
+      id: input.id ?? makeId("task", input.title, now),
+      title: input.title,
+      description: input.description ?? "",
+      status: input.status ?? "todo",
+      priority: input.priority ?? "medium",
+      owner: input.owner ?? null,
+      assignee: input.assignee ?? null,
+      projectId: input.projectId ?? null,
+      tags: input.tags ?? [],
+      dueAt: input.dueAt ?? null,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (task.projectId) {
+      const project = await this.getProject(task.projectId);
+      if (!project) {
+        throw new Error(`project not found: ${task.projectId}`);
+      }
+    }
+    await writeFile24(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+    if (task.projectId) {
+      await this.addTaskIdToProject(task.projectId, task.id, now);
+    }
+    return task;
+  }
+  async getTask(id) {
+    try {
+      const raw = await readFile27(this.taskPath(id), "utf-8");
+      return this.parseTask(raw);
+    } catch {
+      return null;
+    }
+  }
+  async listTasks(filter) {
+    await this.ensureDirectories();
+    const entries = await readdir16(this.tasksDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = await readFile27(path38.join(this.tasksDir, entry.name), "utf-8");
+      const task = this.parseTask(raw);
+      if (!task) continue;
+      if (filter?.status && task.status !== filter.status) continue;
+      if (filter?.owner && task.owner !== filter.owner) continue;
+      if (filter?.assignee && task.assignee !== filter.assignee) continue;
+      if (filter?.projectId && task.projectId !== filter.projectId) continue;
+      out.push(task);
+    }
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out;
+  }
+  async updateTask(id, patch, now = /* @__PURE__ */ new Date()) {
+    const existing = await this.getTask(id);
+    if (!existing) return null;
+    const projectIdPatched = Object.prototype.hasOwnProperty.call(patch, "projectId");
+    const statusPatched = Object.prototype.hasOwnProperty.call(patch, "status");
+    const nextProjectId = projectIdPatched ? patch.projectId ?? null : existing.projectId;
+    if (statusPatched && patch.status && existing.status !== patch.status && !TASK_TRANSITIONS[existing.status].has(patch.status)) {
+      throw new Error(`invalid task status transition: ${existing.status} -> ${patch.status}`);
+    }
+    if (projectIdPatched && nextProjectId) {
+      const nextProject = await this.getProject(nextProjectId);
+      if (!nextProject) {
+        throw new Error(`project not found: ${nextProjectId}`);
+      }
+    }
+    if (projectIdPatched && existing.projectId !== nextProjectId) {
+      if (existing.projectId) {
+        await this.removeTaskIdFromProject(existing.projectId, id, now);
+      }
+      if (nextProjectId) {
+        await this.addTaskIdToProject(nextProjectId, id, now);
+      }
+    }
+    const next = {
+      ...existing,
+      ...patch,
+      projectId: nextProjectId,
+      tags: patch.tags ?? existing.tags,
+      updatedAt: now.toISOString()
+    };
+    await writeFile24(this.taskPath(id), this.serializeTask(next), "utf-8");
+    return next;
+  }
+  async transitionTask(id, nextStatus, now = /* @__PURE__ */ new Date()) {
+    const existing = await this.getTask(id);
+    if (!existing) throw new Error(`task not found: ${id}`);
+    if (existing.status === nextStatus) return existing;
+    if (!TASK_TRANSITIONS[existing.status].has(nextStatus)) {
+      throw new Error(`invalid task status transition: ${existing.status} -> ${nextStatus}`);
+    }
+    const updated = await this.updateTask(id, { status: nextStatus }, now);
+    if (!updated) throw new Error(`task not found after update: ${id}`);
+    return updated;
+  }
+  async deleteTask(id) {
+    try {
+      const existing = await this.getTask(id);
+      await rm3(this.taskPath(id));
+      if (existing?.projectId) {
+        await this.removeTaskIdFromProject(existing.projectId, id);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async createProject(input, now = /* @__PURE__ */ new Date()) {
+    await this.ensureDirectories();
+    const timestamp = now.toISOString();
+    const project = {
+      id: input.id ?? makeId("project", input.name, now),
+      name: input.name,
+      description: input.description ?? "",
+      status: input.status ?? "active",
+      owner: input.owner ?? null,
+      tags: input.tags ?? [],
+      taskIds: [],
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    await writeFile24(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+    return project;
+  }
+  async getProject(id) {
+    try {
+      const raw = await readFile27(this.projectPath(id), "utf-8");
+      return this.parseProject(raw);
+    } catch {
+      return null;
+    }
+  }
+  async listProjects() {
+    await this.ensureDirectories();
+    const entries = await readdir16(this.projectsDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = await readFile27(path38.join(this.projectsDir, entry.name), "utf-8");
+      const project = this.parseProject(raw);
+      if (project) out.push(project);
+    }
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out;
+  }
+  async updateProject(id, patch, now = /* @__PURE__ */ new Date()) {
+    const existing = await this.getProject(id);
+    if (!existing) return null;
+    const next = {
+      ...existing,
+      ...patch,
+      tags: patch.tags ?? existing.tags,
+      taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
+      updatedAt: now.toISOString()
+    };
+    await writeFile24(this.projectPath(id), this.serializeProject(next), "utf-8");
+    return next;
+  }
+  async deleteProject(id) {
+    try {
+      const existing = await this.getProject(id);
+      if (existing) {
+        for (const taskId of existing.taskIds) {
+          await this.updateTask(taskId, { projectId: null });
+        }
+      }
+      await rm3(this.projectPath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async linkTaskToProject(taskId, projectId, now = /* @__PURE__ */ new Date()) {
+    const task = await this.getTask(taskId);
+    if (!task) throw new Error(`task not found: ${taskId}`);
+    const project = await this.getProject(projectId);
+    if (!project) throw new Error(`project not found: ${projectId}`);
+    const updatedTask = await this.updateTask(taskId, { projectId }, now);
+    if (!updatedTask) throw new Error(`task not found after update: ${taskId}`);
+    const updatedProject = await this.getProject(projectId);
+    if (!updatedProject) throw new Error(`project not found after update: ${projectId}`);
+    return { task: updatedTask, project: updatedProject };
+  }
+  async removeTaskIdFromProject(projectId, taskId, now = /* @__PURE__ */ new Date()) {
+    const project = await this.getProject(projectId);
+    if (!project) return;
+    const filtered = project.taskIds.filter((id) => id !== taskId);
+    if (filtered.length === project.taskIds.length) return;
+    await this.updateProject(projectId, { taskIds: filtered }, now);
+  }
+  async addTaskIdToProject(projectId, taskId, now = /* @__PURE__ */ new Date()) {
+    const project = await this.getProject(projectId);
+    if (!project) return;
+    const taskIds = new Set(project.taskIds);
+    taskIds.add(taskId);
+    await this.updateProject(projectId, { taskIds: Array.from(taskIds) }, now);
+  }
+};
+
 // src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -17748,6 +18093,29 @@ function planExactDuplicateDeletions(memories) {
 function planAggressiveDuplicateDeletions(memories) {
   return buildDedupePlan(memories, (memory) => normalizeAggressiveBody(memory.content));
 }
+function normalizeNullableCliValue(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.toLowerCase() === "null") return null;
+  return trimmed;
+}
+function parseTagsCsv(raw, preserveEmpty = false) {
+  if (raw === void 0) return void 0;
+  const tags = raw.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+  if (tags.length === 0) {
+    return preserveEmpty ? [] : void 0;
+  }
+  return tags;
+}
+function isWorkTaskStatus(value) {
+  return value === "todo" || value === "in_progress" || value === "blocked" || value === "done" || value === "cancelled";
+}
+function isWorkTaskPriority(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function isWorkProjectStatus(value) {
+  return value === "active" || value === "on_hold" || value === "completed" || value === "archived";
+}
 async function runArchiveObservationsCliCommand(options) {
   return archiveObservations({
     memoryDir: options.memoryDir,
@@ -17770,6 +18138,128 @@ async function runMigrateObservationsCliCommand(options) {
     now: options.now
   });
 }
+async function runWorkTaskCliCommand(options) {
+  const storage = new WorkStorage(options.memoryDir);
+  if (options.action === "create") {
+    if (!options.title || options.title.trim().length === 0) throw new Error("missing title");
+    if (options.status !== void 0 && !isWorkTaskStatus(options.status)) throw new Error(`invalid task status: ${options.status}`);
+    if (options.priority !== void 0 && !isWorkTaskPriority(options.priority)) {
+      throw new Error(`invalid task priority: ${options.priority}`);
+    }
+    const explicitId = options.id?.trim();
+    if (explicitId && explicitId.length > 0) {
+      const existing = await storage.getTask(explicitId);
+      if (existing) throw new Error(`task already exists: ${explicitId}`);
+    }
+    return storage.createTask({
+      id: explicitId && explicitId.length > 0 ? explicitId : void 0,
+      title: options.title.trim(),
+      description: options.description?.trim(),
+      status: options.status,
+      priority: options.priority,
+      owner: normalizeNullableCliValue(options.owner),
+      assignee: normalizeNullableCliValue(options.assignee),
+      projectId: normalizeNullableCliValue(options.projectId),
+      tags: options.tags,
+      dueAt: normalizeNullableCliValue(options.dueAt)
+    });
+  }
+  if (options.action === "get") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    return storage.getTask(options.id.trim());
+  }
+  if (options.action === "list") {
+    if (options.status !== void 0 && !isWorkTaskStatus(options.status)) throw new Error(`invalid task status: ${options.status}`);
+    return storage.listTasks({
+      status: options.status,
+      owner: options.owner?.trim() || void 0,
+      assignee: options.assignee?.trim() || void 0,
+      projectId: options.projectId?.trim() || void 0
+    });
+  }
+  if (options.action === "update") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    const patch = options.patch ?? {};
+    if (patch.status !== void 0 && !isWorkTaskStatus(patch.status)) throw new Error(`invalid task status: ${patch.status}`);
+    if (patch.priority !== void 0 && !isWorkTaskPriority(patch.priority)) {
+      throw new Error(`invalid task priority: ${patch.priority}`);
+    }
+    const sparsePatch = {};
+    if (Object.prototype.hasOwnProperty.call(patch, "title")) sparsePatch.title = patch.title;
+    if (Object.prototype.hasOwnProperty.call(patch, "description")) sparsePatch.description = patch.description;
+    if (Object.prototype.hasOwnProperty.call(patch, "status")) sparsePatch.status = patch.status;
+    if (Object.prototype.hasOwnProperty.call(patch, "priority")) sparsePatch.priority = patch.priority;
+    if (Object.prototype.hasOwnProperty.call(patch, "owner")) sparsePatch.owner = patch.owner;
+    if (Object.prototype.hasOwnProperty.call(patch, "assignee")) sparsePatch.assignee = patch.assignee;
+    if (Object.prototype.hasOwnProperty.call(patch, "projectId")) sparsePatch.projectId = patch.projectId;
+    if (Object.prototype.hasOwnProperty.call(patch, "tags")) sparsePatch.tags = patch.tags;
+    if (Object.prototype.hasOwnProperty.call(patch, "dueAt")) sparsePatch.dueAt = patch.dueAt;
+    return storage.updateTask(options.id.trim(), sparsePatch);
+  }
+  if (options.action === "transition") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    if (!options.status || !isWorkTaskStatus(options.status)) throw new Error(`invalid task status: ${options.status}`);
+    return storage.transitionTask(options.id.trim(), options.status);
+  }
+  if (options.action === "delete") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    return storage.deleteTask(options.id.trim());
+  }
+  if (options.action === "link") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    if (!options.projectId || options.projectId.trim().length === 0) throw new Error("missing projectId");
+    return storage.linkTaskToProject(options.id.trim(), options.projectId.trim());
+  }
+  throw new Error(`unsupported task action: ${options.action}`);
+}
+async function runWorkProjectCliCommand(options) {
+  const storage = new WorkStorage(options.memoryDir);
+  if (options.action === "create") {
+    if (!options.name || options.name.trim().length === 0) throw new Error("missing name");
+    if (options.status !== void 0 && !isWorkProjectStatus(options.status)) {
+      throw new Error(`invalid project status: ${options.status}`);
+    }
+    const explicitId = options.id?.trim();
+    if (explicitId && explicitId.length > 0) {
+      const existing = await storage.getProject(explicitId);
+      if (existing) throw new Error(`project already exists: ${explicitId}`);
+    }
+    return storage.createProject({
+      id: explicitId && explicitId.length > 0 ? explicitId : void 0,
+      name: options.name.trim(),
+      description: options.description?.trim(),
+      status: options.status,
+      owner: normalizeNullableCliValue(options.owner),
+      tags: options.tags
+    });
+  }
+  if (options.action === "get") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    return storage.getProject(options.id.trim());
+  }
+  if (options.action === "list") {
+    return storage.listProjects();
+  }
+  if (options.action === "update") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    const patch = options.patch ?? {};
+    if (patch.status !== void 0 && !isWorkProjectStatus(patch.status)) {
+      throw new Error(`invalid project status: ${patch.status}`);
+    }
+    const sparsePatch = {};
+    if (Object.prototype.hasOwnProperty.call(patch, "name")) sparsePatch.name = patch.name;
+    if (Object.prototype.hasOwnProperty.call(patch, "description")) sparsePatch.description = patch.description;
+    if (Object.prototype.hasOwnProperty.call(patch, "status")) sparsePatch.status = patch.status;
+    if (Object.prototype.hasOwnProperty.call(patch, "owner")) sparsePatch.owner = patch.owner;
+    if (Object.prototype.hasOwnProperty.call(patch, "tags")) sparsePatch.tags = patch.tags;
+    return storage.updateProject(options.id.trim(), sparsePatch);
+  }
+  if (options.action === "delete") {
+    if (!options.id || options.id.trim().length === 0) throw new Error("missing id");
+    return storage.deleteProject(options.id.trim());
+  }
+  throw new Error(`unsupported project action: ${options.action}`);
+}
 async function withTimeout(promise, timeoutMs, timeoutMessage) {
   let timer;
   try {
@@ -17785,7 +18275,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile27(options.inputPath, "utf-8");
+  const inputRaw = await readFile28(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -17850,7 +18340,7 @@ async function runReplayCliCommand(orchestrator, options) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile27(pkgPath, "utf-8");
+    const raw = await readFile28(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -17869,32 +18359,32 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace) {
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   if (!orchestrator.config.namespacesEnabled) return orchestrator.config.memoryDir;
-  const candidate = path38.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path39.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists2(candidate) ? candidate : orchestrator.config.memoryDir;
   }
   return candidate;
 }
 async function readAllMemoryFiles(memoryDir) {
-  const roots = [path38.join(memoryDir, "facts"), path38.join(memoryDir, "corrections")];
+  const roots = [path39.join(memoryDir, "facts"), path39.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir16(dir, { withFileTypes: true });
+      entries = await readdir17(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path38.join(dir, entryName);
+      const fullPath = path39.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile27(fullPath, "utf-8");
+        const raw = await readFile28(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -18191,6 +18681,82 @@ function registerCli(api, orchestrator) {
         if (result.backupPath) console.log(`Backup path: ${result.backupPath}`);
         console.log("OK");
       });
+      cmd.command("task").description("Manage work tasks").argument("<action>", "create|get|list|update|transition|delete|link").option("--id <id>", "Task ID").option("--title <title>", "Task title").option("--description <description>", "Task description").option("--status <status>", "Task status").option("--priority <priority>", "Task priority").option("--owner <owner>", "Task owner").option("--assignee <assignee>", "Task assignee").option("--project-id <projectId>", "Project ID").option("--tags <csv>", "Comma-separated tags").option("--due-at <iso>", "Due timestamp (ISO)").action(async (...args) => {
+        const actionRaw = typeof args[0] === "string" ? args[0].trim().toLowerCase() : "";
+        const options = args[1] ?? {};
+        const statusOptRaw = typeof options.status === "string" ? options.status.trim().toLowerCase() : void 0;
+        const priorityOptRaw = typeof options.priority === "string" ? options.priority.trim().toLowerCase() : void 0;
+        if (statusOptRaw !== void 0 && !isWorkTaskStatus(statusOptRaw)) {
+          throw new Error(`invalid task status: ${statusOptRaw}`);
+        }
+        if (priorityOptRaw !== void 0 && !isWorkTaskPriority(priorityOptRaw)) {
+          throw new Error(`invalid task priority: ${priorityOptRaw}`);
+        }
+        const patch = {};
+        if (typeof options.title === "string") patch.title = options.title.trim();
+        if (typeof options.description === "string") patch.description = options.description.trim();
+        if (statusOptRaw !== void 0) patch.status = statusOptRaw;
+        if (priorityOptRaw !== void 0) patch.priority = priorityOptRaw;
+        if (typeof options.owner === "string") patch.owner = normalizeNullableCliValue(options.owner) ?? null;
+        if (typeof options.assignee === "string") patch.assignee = normalizeNullableCliValue(options.assignee) ?? null;
+        if (typeof options.projectId === "string") patch.projectId = normalizeNullableCliValue(options.projectId) ?? null;
+        if (typeof options.tags === "string") {
+          patch.tags = parseTagsCsv(options.tags, true);
+        }
+        if (typeof options.dueAt === "string") patch.dueAt = normalizeNullableCliValue(options.dueAt) ?? null;
+        const result = await runWorkTaskCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          action: actionRaw,
+          id: typeof options.id === "string" ? options.id : void 0,
+          title: typeof options.title === "string" ? options.title : void 0,
+          description: typeof options.description === "string" ? options.description : void 0,
+          status: statusOptRaw,
+          priority: priorityOptRaw,
+          owner: typeof options.owner === "string" ? options.owner : void 0,
+          assignee: typeof options.assignee === "string" ? options.assignee : void 0,
+          projectId: typeof options.projectId === "string" ? options.projectId : void 0,
+          tags: typeof options.tags === "string" ? parseTagsCsv(options.tags, true) : void 0,
+          dueAt: typeof options.dueAt === "string" ? options.dueAt : void 0,
+          patch
+        });
+        if (Array.isArray(result)) {
+          console.log(`Count: ${result.length}`);
+        }
+        console.log(JSON.stringify(result, null, 2));
+        console.log("OK");
+      });
+      cmd.command("project").description("Manage work projects").argument("<action>", "create|get|list|update|delete").option("--id <id>", "Project ID").option("--name <name>", "Project name").option("--description <description>", "Project description").option("--status <status>", "Project status").option("--owner <owner>", "Project owner").option("--tags <csv>", "Comma-separated tags").action(async (...args) => {
+        const actionRaw = typeof args[0] === "string" ? args[0].trim().toLowerCase() : "";
+        const options = args[1] ?? {};
+        const statusOptRaw = typeof options.status === "string" ? options.status.trim().toLowerCase() : void 0;
+        if (statusOptRaw !== void 0 && !isWorkProjectStatus(statusOptRaw)) {
+          throw new Error(`invalid project status: ${statusOptRaw}`);
+        }
+        const patch = {};
+        if (typeof options.name === "string") patch.name = options.name.trim();
+        if (typeof options.description === "string") patch.description = options.description.trim();
+        if (statusOptRaw !== void 0) patch.status = statusOptRaw;
+        if (typeof options.owner === "string") patch.owner = normalizeNullableCliValue(options.owner) ?? null;
+        if (typeof options.tags === "string") {
+          patch.tags = parseTagsCsv(options.tags, true);
+        }
+        const result = await runWorkProjectCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          action: actionRaw,
+          id: typeof options.id === "string" ? options.id : void 0,
+          name: typeof options.name === "string" ? options.name : void 0,
+          description: typeof options.description === "string" ? options.description : void 0,
+          status: statusOptRaw,
+          owner: typeof options.owner === "string" ? options.owner : void 0,
+          tags: typeof options.tags === "string" ? parseTagsCsv(options.tags, true) : void 0,
+          patch
+        });
+        if (Array.isArray(result)) {
+          console.log(`Count: ${result.length}`);
+        }
+        console.log(JSON.stringify(result, null, 2));
+        console.log("OK");
+      });
       cmd.command("dedupe-exact").description("Delete exact duplicate memory entries (same body text), keeping highest-confidence/newest copy").option("--dry-run", "Show what would be deleted without deleting files").option("--namespace <ns>", "Namespace to dedupe (v3.0+, default: config defaultNamespace)", "").option("--qmd-sync", "Run QMD update/embed after deletions (default: off)").action(async (...args) => {
         const options = args[0] ?? {};
         const dryRun = options.dryRun === true;
@@ -18431,7 +18997,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path38.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path39.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -18654,8 +19220,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path38.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path38.join(memoryDir, "threads"));
+        const memoryDir = path39.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path39.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -18828,16 +19394,16 @@ function parseDuration(duration) {
 }
 
 // src/index.ts
-import { readFile as readFile28, writeFile as writeFile24 } from "fs/promises";
+import { readFile as readFile29, writeFile as writeFile25 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path39 from "path";
+import path40 from "path";
 import os5 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os5.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path39.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path40.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -19045,11 +19611,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path39.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path40.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile28(cronFilePath, "utf-8");
+          const content = await readFile29(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -19086,7 +19652,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile24(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile25(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
         log.info("auto-registered hourly summary cron job");
       } catch (err) {
         log.error("failed to auto-register hourly summary cron job:", err);