@rubytech/taskmaster 1.0.90 → 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.90",
+  "version": "1.0.91",
   "commit": "d12721761c03ecc5631483c59e1696d0ddba08a3",
-  "builtAt": "2026-02-21T00:10:58.623Z"
+  "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/layout.js

@@ -5,28 +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"];
-/** Agent-specific folders that belong in per-agent memory, not at the shared root. */
-const AGENT_SPECIFIC_FOLDERS = ["admin", "users", "groups"];
+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) {
@@ -83,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");
@@ -104,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))) {
@@ -136,12 +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 });
-        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");
@@ -151,7 +148,6 @@ export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
                 }
                 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");
@@ -163,57 +159,52 @@ export async function ensureMemoryLayout(workspaceRoot, agentDirs) {
             }
         }
     }
-    // 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).
+    // 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 agent-specific data that was left at the shared memory root
+ * Move admin-only 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.
+ * 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; // No admin agent — nothing to migrate to
+        return;
     const adminMemoryPath = path.join(adminAgent.dir, "memory");
     let entries;
     try {
         entries = await fs.readdir(sharedMemoryDir);
     }
     catch {
-        return; // Shared dir doesn't exist
+        return;
     }
     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
+        // 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)) {
-                // 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`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.90",
+  "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 ""