@rubytech/taskmaster 1.0.88 → 1.0.90

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.88",
-  "commit": "09801d064e3c5ec3d028dd4aaa38a18397e1cbc6",
-  "builtAt": "2026-02-20T23:50:07.354Z"
+  "version": "1.0.90",
+  "commit": "d12721761c03ecc5631483c59e1696d0ddba08a3",
+  "builtAt": "2026-02-21T00:10:58.623Z"
 }

package/dist/cli/provision-cli.js

@@ -10,6 +10,7 @@ import os from "node:os";
 import path from "node:path";
 import { loadConfig, writeConfigFile } from "../config/io.js";
 import { resolveConfigPath, DEFAULT_GATEWAY_PORT } from "../config/paths.js";
+import { ensureMemoryLayout } from "../memory/layout.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { resolveTaskmasterPackageRoot } from "../infra/taskmaster-root.js";
 import { buildSeedConfig, buildDefaultAgentList } from "./provision-seed.js";
@@ -47,6 +48,8 @@ async function runProvision(opts) {
     await copyTemplateWorkspace(workspace, force);
     // Step 3: Write agent list to config
     await writeAgentList(workspace);
+    // Step 3b: Set up shared memory layout with per-subfolder symlinks
+    await setupMemoryLayout(workspace);
     // Step 4-6: Linux-only mDNS setup
     if (skipPlatform) {
         console.log("[4/7] Avahi: handled by install script");
@@ -154,6 +157,23 @@ async function writeAgentList(workspace) {
     console.log("[3/7] Agent list: written (public + admin)");
 }
 // ---------------------------------------------------------------------------
+// Step 3b: Memory layout
+// ---------------------------------------------------------------------------
+async function setupMemoryLayout(workspace) {
+    const agents = buildDefaultAgentList(workspace);
+    const agentDirs = agents.map((a) => ({
+        dir: a.workspace ?? path.join(workspace, "agents", a.id),
+        id: a.id,
+    }));
+    try {
+        await ensureMemoryLayout(workspace, agentDirs);
+        console.log("[3b/7] Memory layout: shared public/shared with per-agent symlinks");
+    }
+    catch (err) {
+        console.error(`[3b/7] Memory layout failed: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
 // Step 4: Install avahi/mDNS (Linux only)
 // ---------------------------------------------------------------------------
 async function installAvahi() {

package/dist/gateway/server-methods/workspaces.js

@@ -168,9 +168,10 @@ function resolveTemplateDir() {
 /** Copy directory tree recursively, skipping symlink targets for memory (recreates symlinks). */
 async function cloneWorkspaceStructure(sourceDir, destDir) {
     await fs.mkdir(destDir, { recursive: true });
-    // Copy agents/ (recreate memory symlinks)
+    // Copy agents/ (skip memory — handled by ensureMemoryLayout)
     const agentsSrc = path.join(sourceDir, "agents");
     const agentsDest = path.join(destDir, "agents");
+    const clonedAgents = [];
     try {
         const agentEntries = await fs.readdir(agentsSrc, { withFileTypes: true });
         for (const entry of agentEntries) {
@@ -179,32 +180,20 @@ async function cloneWorkspaceStructure(sourceDir, destDir) {
             const srcAgentDir = path.join(agentsSrc, entry.name);
             const destAgentDir = path.join(agentsDest, entry.name);
             await fs.mkdir(destAgentDir, { recursive: true });
-            // Copy files in agent dir (skip memory symlink — we'll recreate it)
+            clonedAgents.push({ dir: destAgentDir, id: entry.name });
+            // Copy non-symlink, non-memory files from agent dir
             const agentFiles = await fs.readdir(srcAgentDir, { withFileTypes: true });
-            let hasMemoryLink = false;
             for (const file of agentFiles) {
+                if (file.name === "memory")
+                    continue;
+                if (file.isSymbolicLink())
+                    continue;
                 const srcPath = path.join(srcAgentDir, file.name);
                 const destPath = path.join(destAgentDir, file.name);
-                if (file.isSymbolicLink()) {
-                    // Memory symlink — recreate pointing to same relative target
-                    const target = await fs.readlink(srcPath);
-                    await fs.symlink(target, destPath).catch(() => {
-                        /* ignore if exists */
-                    });
-                    if (file.name === "memory")
-                        hasMemoryLink = true;
-                }
-                else if (file.isFile()) {
+                if (file.isFile()) {
                     await fs.copyFile(srcPath, destPath);
                 }
             }
-            // Always ensure memory symlink exists (templates may not include them)
-            if (!hasMemoryLink) {
-                const memoryLink = path.join(destAgentDir, "memory");
-                await fs.symlink("../../memory", memoryLink).catch(() => {
-                    /* ignore if exists */
-                });
-            }
         }
     }
     catch {
@@ -224,12 +213,11 @@ async function cloneWorkspaceStructure(sourceDir, destDir) {
     catch {
         /* source has no skills/ — skip */
     }
-    // Create empty memory structure
-    const memoryDir = path.join(destDir, "memory");
-    await fs.mkdir(path.join(memoryDir, "public"), { recursive: true });
-    await fs.mkdir(path.join(memoryDir, "shared"), { recursive: true });
-    await fs.mkdir(path.join(memoryDir, "admin"), { recursive: true });
-    await fs.mkdir(path.join(memoryDir, "users"), { recursive: true });
+    // Create shared memory structure with per-subfolder symlinks
+    if (clonedAgents.length > 0) {
+        const { ensureMemoryLayout } = await import("../../memory/layout.js");
+        await ensureMemoryLayout(destDir, clonedAgents);
+    }
 }
 async function copyDirRecursive(src, dest) {
     await fs.mkdir(dest, { recursive: true });

package/dist/gateway/server-startup.js

@@ -1,7 +1,9 @@
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
+import { listAgentIds, resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
 import { loadModelCatalog } from "../agents/model-catalog.js";
 import { getModelRefStatus, resolveConfiguredModelRef, resolveHooksGmailModel, } from "../agents/model-selection.js";
 import { isTruthyEnvValue } from "../infra/env.js";
+import { ensureMemoryLayout } from "../memory/layout.js";
 import { startGmailWatcher } from "../hooks/gmail-watcher.js";
 import { clearInternalHooks, createInternalHookEvent, triggerInternalHook, } from "../hooks/internal-hooks.js";
 import { loadInternalHooks } from "../hooks/loader.js";
@@ -25,6 +27,9 @@ export async function startGatewaySidecars(params) {
     void recoverOrphanedSessions()
         .then(() => stripBase64FromTranscripts())
         .catch(() => { });
+    // Ensure memory directory layout: shared public/shared with per-agent symlinks.
+    // Self-healing — fixes broken/missing symlinks from prior versions.
+    void ensureMemoryLayoutFromConfig(params.cfg).catch(() => { });
     // Start Gmail watcher if configured (hooks.gmail.account).
     if (!isTruthyEnvValue(process.env.TASKMASTER_SKIP_GMAIL_WATCHER)) {
         try {
@@ -129,3 +134,18 @@ export async function startGatewaySidecars(params) {
     }
     return { browserControl, pluginServices };
 }
+async function ensureMemoryLayoutFromConfig(cfg) {
+    const agentIds = listAgentIds(cfg);
+    if (agentIds.length < 2)
+        return; // Single-agent — no shared layout needed
+    const agentDirs = agentIds.map((id) => ({
+        dir: resolveAgentWorkspaceDir(cfg, id),
+        id,
+    }));
+    // Derive workspace root from agent dirs (strip /agents/{id} suffix)
+    const first = agentDirs[0].dir.replace(/\/+$/, "");
+    const match = first.match(/^(.+)\/agents\/[^/]+$/);
+    if (!match)
+        return; // Not a multi-agent workspace layout
+    await ensureMemoryLayout(match[1], agentDirs);
+}

package/dist/memory/internal.js

@@ -34,6 +34,22 @@ async function walkDir(dir, files) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         const full = path.join(dir, entry.name);
+        // Symlinks need fs.stat to determine the target type
+        if (entry.isSymbolicLink()) {
+            try {
+                const stat = await fs.stat(full);
+                if (stat.isDirectory()) {
+                    await walkDir(full, files);
+                }
+                else if (stat.isFile() && entry.name.endsWith(".md")) {
+                    files.push(full);
+                }
+            }
+            catch {
+                // Broken symlink — skip
+            }
+            continue;
+        }
         if (entry.isDirectory()) {
             await walkDir(full, files);
             continue;

package/dist/memory/layout.js

@@ -0,0 +1,224 @@
+/**
+ * Memory directory layout management.
+ *
+ * Architecture:
+ *   ~/taskmaster/memory/           ← shared canonical location
+ *     public/                      ← shared: both agents read/write
+ *     shared/                      ← shared: both agents read/write
+ *   ~/taskmaster/agents/admin/memory/  ← physical directory
+ *     admin/                       ← physical: admin-only data
+ *     public → ../../../memory/public  (symlink to shared)
+ *     shared → ../../../memory/shared  (symlink to shared)
+ *     users/                       ← physical: admin's per-user data
+ *   ~/taskmaster/agents/public/memory/ ← physical directory
+ *     public → ../../../memory/public  (symlink to shared)
+ *     shared → ../../../memory/shared  (symlink to shared)
+ *     users/                       ← physical: public's per-user data
+ *
+ * Only `public/` and `shared/` are symlinked.
+ * `admin/` only exists in the admin agent workspace.
+ * `users/` is per-agent (each agent has its own user data).
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("memory-layout");
+/** Shared scope folders symlinked from each agent workspace. */
+const SHARED_FOLDERS = ["public", "shared"];
+/** Agent-specific folders that belong in per-agent memory, not at the shared root. */
+const AGENT_SPECIFIC_FOLDERS = ["admin", "users", "groups"];
+/** The relative symlink target from agents/{id}/memory/{scope} → ../../../memory/{scope} */
+const SYMLINK_TARGET_PREFIX = "../../../memory";
+async function exists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isSymlink(p) {
+    try {
+        const stat = await fs.lstat(p);
+        return stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(p) {
+    try {
+        const stat = await fs.lstat(p);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isEmptyDir(p) {
+    try {
+        const entries = await fs.readdir(p);
+        return entries.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Move all files from src directory into dest directory (non-destructive merge).
+ * Only moves files/dirs that don't already exist in dest.
+ */
+async function mergeDir(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (await exists(destPath))
+            continue;
+        await fs.rename(srcPath, destPath);
+    }
+}
+/**
+ * Ensure the correct memory layout for a multi-agent workspace.
+ *
+ * - Creates the shared `memory/public` and `memory/shared` at workspace root
+ * - For each agent dir, ensures `memory/` is a physical directory with
+ *   symlinks for `public/` and `shared/`, and physical dirs for agent-specific data
+ * - Migrates from the old full-symlink layout if found
+ * - Consolidates data from broken physical dirs into the shared location
+ *
+ * @param workspaceRoot  The workspace root (e.g. ~/taskmaster)
+ * @param agentDirs      Agent workspace directories (e.g. [~/taskmaster/agents/admin, ~/taskmaster/agents/public])
+ */
+export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
+    const sharedMemoryDir = path.join(workspaceRoot, "memory");
+    // Create shared canonical directories
+    for (const folder of SHARED_FOLDERS) {
+        await fs.mkdir(path.join(sharedMemoryDir, folder), { recursive: true });
+    }
+    for (const { dir: agentDir, id: agentId } of agentDirs) {
+        const memoryPath = path.join(agentDir, "memory");
+        const isAdmin = agentId.toLowerCase() === "admin" || agentId.toLowerCase().endsWith("-admin");
+        // Case 1: Full memory symlink (old layout) — migrate to per-subfolder
+        if (await isSymlink(memoryPath)) {
+            log.info(`migrating full memory symlink to per-subfolder layout: ${agentDir}`);
+            // The symlink points to the shared memory dir — data is already there.
+            // Remove the full symlink and create a physical dir with per-subfolder symlinks.
+            await fs.unlink(memoryPath);
+            await fs.mkdir(memoryPath, { recursive: true });
+            // Data is already in the shared location, just create symlinks and physical dirs
+        }
+        // Ensure memory/ is a physical directory
+        if (!(await isDirectory(memoryPath))) {
+            await fs.mkdir(memoryPath, { recursive: true });
+        }
+        // For each shared folder: consolidate any physical data, then symlink
+        for (const folder of SHARED_FOLDERS) {
+            const subPath = path.join(memoryPath, folder);
+            const sharedPath = path.join(sharedMemoryDir, folder);
+            if (await isSymlink(subPath)) {
+                // Already a symlink — correct state
+                continue;
+            }
+            if (await isDirectory(subPath)) {
+                // Physical dir exists — merge data into shared location, then replace with symlink
+                if (!(await isEmptyDir(subPath))) {
+                    log.info(`consolidating ${folder}/ data from ${agentDir} into shared location`);
+                    await mergeDir(subPath, sharedPath);
+                }
+                await fs.rm(subPath, { recursive: true });
+            }
+            // Create symlink
+            const target = `${SYMLINK_TARGET_PREFIX}/${folder}`;
+            await fs.symlink(target, subPath).catch(() => {
+                /* ignore if race */
+            });
+        }
+        // Ensure physical dirs for agent-specific data
+        if (isAdmin) {
+            await fs.mkdir(path.join(memoryPath, "admin"), { recursive: true });
+        }
+        await fs.mkdir(path.join(memoryPath, "users"), { recursive: true });
+        await fs.mkdir(path.join(memoryPath, "groups"), { recursive: true });
+        // Remove admin/ from non-admin agent workspaces (it should never exist there)
+        if (!isAdmin) {
+            const adminPath = path.join(memoryPath, "admin");
+            if ((await isDirectory(adminPath)) && !(await isSymlink(adminPath))) {
+                if (await isEmptyDir(adminPath)) {
+                    await fs.rm(adminPath, { recursive: true }).catch(() => { });
+                }
+                else {
+                    log.warn(`non-admin agent has data in memory/admin/ — moving to admin agent`);
+                    // Find admin agent dir and merge there
+                    const adminAgent = agentDirs.find((a) => a.id.toLowerCase() === "admin" || a.id.toLowerCase().endsWith("-admin"));
+                    if (adminAgent) {
+                        const adminMemAdmin = path.join(adminAgent.dir, "memory", "admin");
+                        await fs.mkdir(adminMemAdmin, { recursive: true });
+                        await mergeDir(adminPath, adminMemAdmin);
+                    }
+                    await fs.rm(adminPath, { recursive: true }).catch(() => { });
+                }
+            }
+        }
+    }
+    // Sweep orphaned agent-specific data from the shared root.
+    // After full-symlink migration, admin/, users/, groups/, notes/, and loose files
+    // remain at ~/taskmaster/memory/ but are no longer accessible via per-subfolder symlinks.
+    // Move them to the admin agent's workspace (most privileged, owns historical data).
+    await migrateOrphanedSharedData(sharedMemoryDir, agentDirs);
+}
+/**
+ * Move agent-specific data that was left at the shared memory root
+ * (from the old full-symlink layout) into the admin agent's workspace.
+ *
+ * Only `public/` and `shared/` belong at the shared root.
+ * Everything else is orphaned and needs to move to a per-agent location.
+ */
+async function migrateOrphanedSharedData(sharedMemoryDir, agentDirs) {
+    const adminAgent = agentDirs.find((a) => a.id.toLowerCase() === "admin" || a.id.toLowerCase().endsWith("-admin"));
+    if (!adminAgent)
+        return; // No admin agent — nothing to migrate to
+    const adminMemoryPath = path.join(adminAgent.dir, "memory");
+    let entries;
+    try {
+        entries = await fs.readdir(sharedMemoryDir);
+    }
+    catch {
+        return; // Shared dir doesn't exist
+    }
+    const sharedSet = new Set(SHARED_FOLDERS);
+    for (const name of entries) {
+        // Skip shared folders — they belong here
+        if (sharedSet.has(name))
+            continue;
+        // Skip .DS_Store and other hidden files
+        if (name.startsWith("."))
+            continue;
+        const srcPath = path.join(sharedMemoryDir, name);
+        if (await isDirectory(srcPath)) {
+            const destPath = path.join(adminMemoryPath, name);
+            if (await isEmptyDir(srcPath)) {
+                // Empty orphan dir — just remove it
+                await fs.rm(srcPath, { recursive: true }).catch(() => { });
+                continue;
+            }
+            // Merge into admin agent's workspace
+            log.info(`migrating orphaned ${name}/ from shared root to admin agent`);
+            await mergeDir(srcPath, destPath);
+            // Remove source if now empty
+            if (await isEmptyDir(srcPath)) {
+                await fs.rm(srcPath, { recursive: true }).catch(() => { });
+            }
+        }
+        else if (name.endsWith(".md")) {
+            // Loose .md files — move to admin agent's memory root
+            const destPath = path.join(adminMemoryPath, name);
+            if (!(await exists(destPath))) {
+                log.info(`migrating orphaned ${name} from shared root to admin agent`);
+                await fs.rename(srcPath, destPath);
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"