@rubytech/taskmaster 1.0.89 → 1.0.91

package/dist/agents/apply-patch.js

@@ -19,7 +19,9 @@ const applyPatchSchema = Type.Object({
         description: "Patch content using the *** Begin Patch/End Patch format.",
     }),
 });
-export function createApplyPatchTool(options = {}) {
+export function createApplyPatchTool(options = {}
+// biome-ignore lint/suspicious/noExplicitAny: TypeBox schema type from pi-agent-core uses a different module instance.
+) {
     const cwd = options.cwd ?? process.cwd();
     const sandboxRoot = options.sandboxRoot;
     return {

package/dist/agents/bash-tools.exec.js

@@ -513,7 +513,9 @@ async function runExecProcess(opts) {
         kill: () => killSession(session),
     };
 }
-export function createExecTool(defaults) {
+export function createExecTool(defaults
+// biome-ignore lint/suspicious/noExplicitAny: TypeBox schema type from pi-agent-core uses a different module instance.
+) {
     const defaultBackgroundMs = clampNumber(defaults?.backgroundMs ?? readEnvInt("PI_BASH_YIELD_MS"), 10_000, 10, 120_000);
     const allowBackground = defaults?.allowBackground ?? true;
     const defaultTimeoutSec = typeof defaults?.timeoutSec === "number" && defaults.timeoutSec > 0

package/dist/agents/bash-tools.process.js

@@ -15,7 +15,9 @@ const processSchema = Type.Object({
     offset: Type.Optional(Type.Number({ description: "Log offset" })),
     limit: Type.Optional(Type.Number({ description: "Log length" })),
 });
-export function createProcessTool(defaults) {
+export function createProcessTool(defaults
+// biome-ignore lint/suspicious/noExplicitAny: TypeBox schema type from pi-agent-core uses a different module instance.
+) {
     if (defaults?.cleanupMs !== undefined) {
         setJobTtlMs(defaults.cleanupMs);
     }

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.89",
+  "version": "1.0.91",
   "commit": "d12721761c03ecc5631483c59e1696d0ddba08a3",
-  "builtAt": "2026-02-21T00:01:17.386Z"
+  "builtAt": "2026-02-21T00:30:04.834Z"
 }

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

@@ -1,6 +1,6 @@
 import { loadConfig } from "../../config/config.js";
 import { resolveTaskmasterPackageRoot } from "../../infra/taskmaster-root.js";
-import { scheduleGatewaySigusr1Restart, triggerTaskmasterRestart } from "../../infra/restart.js";
+import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { formatDoctorNonInteractiveHint, readRestartSentinel, writeRestartSentinel, } from "../../infra/restart-sentinel.js";
 import { checkUpdateStatus, compareSemverStrings } from "../../infra/update-check.js";
 import { normalizeUpdateChannel, resolveEffectiveUpdateChannel, } from "../../infra/update-channels.js";
@@ -248,12 +248,13 @@ export const updateHandlers = {
                         // Non-critical — unit file just won't have watchdog directives
                         // until the next `daemon install --force`.
                     }
-                    const attempt = triggerTaskmasterRestart();
-                    if (!attempt.ok) {
-                        log.error(`daemon restart failed: ${attempt.detail ?? "unknown"}`);
-                        // Fall back to in-process restart
-                        scheduleGatewaySigusr1Restart({ delayMs: 0, reason: "update.run (fallback)" });
-                    }
+                    // Exit cleanly and let the supervisor (systemd Restart=always /
+                    // launchd KeepAlive) restart us with the new code on disk.
+                    // This avoids a race condition where spawnSync("systemctl restart")
+                    // returns before our SIGTERM handler releases the port, causing the
+                    // new process to fail with "port already in use" and crash-loop.
+                    log.info("exiting for supervisor restart after global update");
+                    process.exit(0);
                 })();
             }, delayMs);
             restart = { ok: true };

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

@@ -5,26 +5,30 @@
  *   ~/taskmaster/memory/           ← shared canonical location
  *     public/                      ← shared: both agents read/write
  *     shared/                      ← shared: both agents read/write
+ *     users/                       ← shared: both agents read/write (app-layer scoped)
+ *     groups/                      ← shared: both agents read/write (app-layer scoped)
  *   ~/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
+ *     users  → ../../../memory/users   (symlink to shared)
+ *     groups → ../../../memory/groups  (symlink to shared)
  *   ~/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
+ *     users  → ../../../memory/users   (symlink to shared)
+ *     groups → ../../../memory/groups  (symlink to shared)
  *
- * 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).
+ * public/, shared/, users/, and groups/ are symlinked — both agents share
+ * the same data. Access control is enforced by the application layer (scope config).
+ * admin/ only exists in the admin agent workspace.
  */
 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"];
+const SHARED_FOLDERS = ["public", "shared", "users", "groups"];
 /** The relative symlink target from agents/{id}/memory/{scope} → ../../../memory/{scope} */
 const SYMLINK_TARGET_PREFIX = "../../../memory";
 async function exists(p) {
@@ -81,14 +85,14 @@ async function mergeDir(src, dest) {
 /**
  * Ensure the correct memory layout for a multi-agent workspace.
  *
- * - Creates the shared `memory/public` and `memory/shared` at workspace root
+ * - Creates the shared canonical directories 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
+ *   symlinks for shared folders and a physical `admin/` for the admin agent
  * - Migrates from the old full-symlink layout if found
- * - Consolidates data from broken physical dirs into the shared location
+ * - Consolidates data from physical dirs back 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])
+ * @param agentDirs      Agent workspace directories
  */
 export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
     const sharedMemoryDir = path.join(workspaceRoot, "memory");
@@ -102,11 +106,8 @@ export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
         // 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))) {
@@ -134,11 +135,10 @@ export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
                 /* ignore if race */
             });
         }
-        // Ensure physical dirs for agent-specific data
+        // admin/ is the only per-agent physical directory — exists only in admin workspace
         if (isAdmin) {
             await fs.mkdir(path.join(memoryPath, "admin"), { recursive: true });
         }
-        await fs.mkdir(path.join(memoryPath, "users"), { recursive: true });
         // Remove admin/ from non-admin agent workspaces (it should never exist there)
         if (!isAdmin) {
             const adminPath = path.join(memoryPath, "admin");
@@ -147,13 +147,69 @@ export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
                     await fs.rm(adminPath, { recursive: true }).catch(() => { });
                 }
                 else {
-                    log.warn(`non-admin agent has data in memory/admin/ — moving to shared admin location`);
-                    const sharedAdminPath = path.join(sharedMemoryDir, "admin");
-                    await fs.mkdir(sharedAdminPath, { recursive: true });
-                    await mergeDir(adminPath, sharedAdminPath);
+                    log.warn(`non-admin agent has data in memory/admin/ — moving to admin agent`);
+                    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 admin-only data from the shared root.
+    // After full-symlink migration, admin/, notes/, and loose files may remain
+    // at the shared root. These belong in the admin agent's workspace.
+    await migrateOrphanedSharedData(sharedMemoryDir, agentDirs);
+}
+/**
+ * Move admin-only data that was left at the shared memory root
+ * (from the old full-symlink layout) into the admin agent's workspace.
+ *
+ * Shared folders (public, shared, users, groups) belong at the shared root.
+ * Everything else (admin, notes, loose .md files) is admin-only.
+ */
+async function migrateOrphanedSharedData(sharedMemoryDir, agentDirs) {
+    const adminAgent = agentDirs.find((a) => a.id.toLowerCase() === "admin" || a.id.toLowerCase().endsWith("-admin"));
+    if (!adminAgent)
+        return;
+    const adminMemoryPath = path.join(adminAgent.dir, "memory");
+    let entries;
+    try {
+        entries = await fs.readdir(sharedMemoryDir);
+    }
+    catch {
+        return;
+    }
+    const sharedSet = new Set(SHARED_FOLDERS);
+    for (const name of entries) {
+        // Skip shared folders — they belong here
+        if (sharedSet.has(name))
+            continue;
+        // Skip 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)) {
+                await fs.rm(srcPath, { recursive: true }).catch(() => { });
+                continue;
+            }
+            log.info(`migrating orphaned ${name}/ from shared root to admin agent`);
+            await mergeDir(srcPath, destPath);
+            if (await isEmptyDir(srcPath)) {
+                await fs.rm(srcPath, { recursive: true }).catch(() => { });
+            }
+        }
+        else if (name.endsWith(".md")) {
+            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.89",
+  "version": "1.0.91",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"

package/scripts/install.sh

@@ -105,6 +105,28 @@ if ! check_node; then
   install_node
 fi
 
+# ── Stop existing daemon before upgrade ──────────────────────────────────────
+# The old gateway process holds the port. It must be stopped before npm
+# replaces the files on disk, otherwise the new daemon cannot bind.
+
+if command -v taskmaster >/dev/null 2>&1; then
+  echo ""
+  echo "Stopping existing gateway daemon..."
+  if [ "$PLATFORM" = "linux" ] && [ "$(id -u)" = "0" ] && [ "${SUDO_USER:-}" != "" ]; then
+    # Running as root via sudo — must run as the real user for systemctl --user
+    _STOP_USER="${SUDO_USER}"
+    _STOP_UID=$(id -u "$_STOP_USER")
+    sudo -u "$_STOP_USER" \
+      XDG_RUNTIME_DIR="/run/user/$_STOP_UID" \
+      DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/$_STOP_UID/bus" \
+      taskmaster gateway stop 2>/dev/null || true
+  else
+    taskmaster gateway stop 2>/dev/null || true
+  fi
+  # Give the process a moment to release the port
+  sleep 2
+fi
+
 # ── Install Taskmaster via npm ───────────────────────────────────────────────
 
 echo ""