@rubytech/taskmaster 1.2.1 → 1.3.0

package/dist/media-understanding/sherpa-onnx-local.js

@@ -0,0 +1,223 @@
+/**
+ * Local speech-to-text using sherpa-onnx-node (optional dependency).
+ *
+ * Model: NeMo CTC English Conformer Small (int8)
+ * Storage: ~/.taskmaster/lib/sherpa-onnx/nemo-ctc-en-conformer-small/
+ *
+ * Requires: sherpa-onnx-node (optional dep), ffmpeg (for OGG→WAV conversion)
+ */
+import { execFile as execFileCb, spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCb);
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const LIB_DIR = path.join(os.homedir(), ".taskmaster", "lib", "sherpa-onnx");
+const MODEL_DIR_NAME = "nemo-ctc-en-conformer-small";
+const MODEL_DIR = path.join(LIB_DIR, MODEL_DIR_NAME);
+const MODEL_FILE = "model.int8.onnx";
+const TOKENS_FILE = "tokens.txt";
+const MODEL_ARCHIVE_URL = "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-ctc-en-conformer-small.tar.bz2";
+const ARCHIVE_INNER_DIR = "sherpa-onnx-nemo-ctc-en-conformer-small";
+export const MODEL_LABEL = "sherpa-onnx/nemo-ctc-en-conformer-small-int8";
+let sherpaModule = null;
+let sherpaModuleError = null;
+async function importSherpaOnnx() {
+    if (sherpaModule)
+        return sherpaModule;
+    if (sherpaModuleError)
+        throw sherpaModuleError;
+    try {
+        const mod = await import("sherpa-onnx-node");
+        // ESM dynamic import puts named exports under .default
+        sherpaModule = (mod.default ?? mod);
+        return sherpaModule;
+    }
+    catch (err) {
+        sherpaModuleError = err instanceof Error ? err : new Error(String(err));
+        throw sherpaModuleError;
+    }
+}
+// ---------------------------------------------------------------------------
+// Availability checks
+// ---------------------------------------------------------------------------
+let ffmpegAvailable = null;
+function checkFfmpeg() {
+    if (ffmpegAvailable !== null)
+        return ffmpegAvailable;
+    const result = spawnSync("ffmpeg", ["-version"], { stdio: "ignore", timeout: 5_000 });
+    ffmpegAvailable = result.status === 0;
+    return ffmpegAvailable;
+}
+async function fileExists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isModelDownloaded() {
+    return ((await fileExists(path.join(MODEL_DIR, MODEL_FILE))) &&
+        (await fileExists(path.join(MODEL_DIR, TOKENS_FILE))));
+}
+/**
+ * Returns true when both the npm package and ffmpeg are available.
+ * Does NOT check whether the model is downloaded (use isReady for that).
+ */
+export async function isAvailable() {
+    try {
+        await importSherpaOnnx();
+    }
+    catch {
+        return false;
+    }
+    return checkFfmpeg();
+}
+/**
+ * Returns true when everything is ready for immediate transcription:
+ * npm package + ffmpeg + model files on disk.
+ */
+export async function isReady() {
+    return (await isAvailable()) && (await isModelDownloaded());
+}
+// ---------------------------------------------------------------------------
+// Model download
+// ---------------------------------------------------------------------------
+let downloadInFlight = null;
+/**
+ * Download and extract the model if not already present.
+ * Deduplicates concurrent calls.
+ */
+export async function ensureModel() {
+    if (await isModelDownloaded())
+        return MODEL_DIR;
+    if (!downloadInFlight) {
+        downloadInFlight = downloadModelOnce().finally(() => {
+            downloadInFlight = null;
+        });
+    }
+    await downloadInFlight;
+    return MODEL_DIR;
+}
+async function downloadModelOnce() {
+    console.log("[sherpa-onnx] Downloading speech recognition model…");
+    await fs.mkdir(LIB_DIR, { recursive: true });
+    const archivePath = path.join(LIB_DIR, `${MODEL_DIR_NAME}.tar.bz2`);
+    try {
+        // Download archive using curl (available on macOS and Linux)
+        await execFile("curl", ["-fsSL", "-o", archivePath, MODEL_ARCHIVE_URL], {
+            timeout: 300_000,
+        });
+        // Extract — archive contains sherpa-onnx-nemo-ctc-en-conformer-small/{files}
+        await execFile("tar", ["-xjf", archivePath, "-C", LIB_DIR], {
+            timeout: 120_000,
+        });
+        // Rename extracted directory to our standard name (remove sherpa-onnx- prefix)
+        const extractedDir = path.join(LIB_DIR, ARCHIVE_INNER_DIR);
+        if ((await fileExists(extractedDir)) && extractedDir !== MODEL_DIR) {
+            // If target already exists (partial state), remove it first
+            if (await fileExists(MODEL_DIR)) {
+                await fs.rm(MODEL_DIR, { recursive: true });
+            }
+            await fs.rename(extractedDir, MODEL_DIR);
+        }
+        // Clean up: remove archive and unnecessary files to save disk space
+        await fs.unlink(archivePath).catch(() => { });
+        // Remove full-precision model (keep only int8 — saves ~37MB)
+        await fs.unlink(path.join(MODEL_DIR, "model.onnx")).catch(() => { });
+        // Remove test wav files
+        await fs
+            .rm(path.join(MODEL_DIR, "test_wavs"), { recursive: true, force: true })
+            .catch(() => { });
+        console.log("[sherpa-onnx] Model installed");
+    }
+    catch (err) {
+        // Clean up partial download
+        await fs.unlink(archivePath).catch(() => { });
+        await fs.rm(MODEL_DIR, { recursive: true, force: true }).catch(() => { });
+        throw new Error(`sherpa-onnx model download failed: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Audio conversion (OGG/Opus → WAV 16kHz mono)
+// ---------------------------------------------------------------------------
+async function convertToWav(inputPath, outputPath) {
+    await execFile("ffmpeg", [
+        "-i",
+        inputPath,
+        "-ar",
+        "16000",
+        "-ac",
+        "1",
+        "-sample_fmt",
+        "s16",
+        "-f",
+        "wav",
+        "-y",
+        outputPath,
+    ], { timeout: 30_000 });
+}
+// ---------------------------------------------------------------------------
+// Recognizer (cached singleton)
+// ---------------------------------------------------------------------------
+let recognizer = null;
+async function getRecognizer() {
+    if (recognizer)
+        return recognizer;
+    const sherpa = await importSherpaOnnx();
+    const modelDir = await ensureModel();
+    const config = {
+        featConfig: { sampleRate: 16000, featureDim: 80 },
+        modelConfig: {
+            nemoCtc: {
+                model: path.join(modelDir, MODEL_FILE),
+            },
+            tokens: path.join(modelDir, TOKENS_FILE),
+            numThreads: 2,
+            provider: "cpu",
+            debug: 0,
+        },
+    };
+    recognizer = new sherpa.OfflineRecognizer(config);
+    return recognizer;
+}
+// ---------------------------------------------------------------------------
+// Public transcription API
+// ---------------------------------------------------------------------------
+/**
+ * Transcribe an audio buffer (any format ffmpeg can read) to text.
+ * Returns the transcription text, or throws on failure.
+ */
+export async function transcribeLocal(buffer, fileName) {
+    const sherpa = await importSherpaOnnx();
+    const rec = await getRecognizer();
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sherpa-stt-"));
+    try {
+        const inputPath = path.join(tmpDir, fileName || "audio.ogg");
+        await fs.writeFile(inputPath, buffer);
+        const wavPath = path.join(tmpDir, "audio.wav");
+        await convertToWav(inputPath, wavPath);
+        const wave = sherpa.readWave(wavPath);
+        const stream = rec.createStream();
+        stream.acceptWaveform({ sampleRate: wave.sampleRate, samples: wave.samples });
+        rec.decode(stream);
+        const result = rec.getResult(stream);
+        const text = result?.text?.trim() ?? "";
+        if (!text) {
+            throw new Error("sherpa-onnx returned empty transcription");
+        }
+        return { text, model: MODEL_LABEL };
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+// ---------------------------------------------------------------------------
+// Exported paths (for postinstall and diagnostics)
+// ---------------------------------------------------------------------------
+export { LIB_DIR, MODEL_DIR, MODEL_DIR_NAME, MODEL_FILE, TOKENS_FILE, MODEL_ARCHIVE_URL, ARCHIVE_INNER_DIR, };

package/dist/records/records-manager.js

@@ -90,3 +90,13 @@ export function deleteRecordField(id, key) {
     writeFile(data);
     return record;
 }
+export function setRecordName(id, name) {
+    const data = readFile();
+    const record = data.records[id];
+    if (!record)
+        return null;
+    record.name = name;
+    record.updatedAt = new Date().toISOString();
+    writeFile(data);
+    return record;
+}

package/dist/tts/tts.js

@@ -5,11 +5,13 @@ import { completeSimple } from "@mariozechner/pi-ai";
 import { EdgeTTS } from "node-edge-tts";
 import { normalizeChannelId } from "../channels/plugins/index.js";
 import { logVerbose } from "../globals.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { isVoiceCompatibleAudio } from "../media/audio.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
-import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
+import { getApiKeyForModel, requireApiKey, resolveApiKeyForProvider, } from "../agents/model-auth.js";
 import { buildModelAliasIndex, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../agents/model-selection.js";
 import { resolveModel } from "../agents/pi-embedded-runner/model.js";
+const log = createSubsystemLogger("gateway/tts");
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_TTS_MAX_LENGTH = 1500;
 const DEFAULT_TTS_SUMMARIZE = true;
@@ -133,6 +135,11 @@ export function resolveTtsConfig(cfg) {
             proxy: raw.edge?.proxy?.trim() || undefined,
             timeoutMs: raw.edge?.timeoutMs,
         },
+        hume: {
+            apiKey: raw.hume?.apiKey,
+            voice: raw.hume?.voice?.trim() || "KORA",
+            description: raw.hume?.description?.trim() || undefined,
+        },
         prefsPath: raw.prefsPath,
         maxTextLength: raw.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH,
         timeoutMs: raw.timeoutMs ?? DEFAULT_TIMEOUT_MS,
@@ -173,15 +180,15 @@ export function buildTtsSystemPromptHint(cfg) {
     const maxLength = getTtsMaxLength(prefsPath);
     const summarize = isSummarizationEnabled(prefsPath) ? "on" : "off";
     const autoHint = autoMode === "inbound"
-        ? "Only use TTS when the user's last message includes audio/voice."
+        ? "Your replies are automatically converted to voice notes when the user sends audio/voice."
         : autoMode === "tagged"
-            ? "Only use TTS when you include [[tts]] or [[tts:text]] tags."
-            : undefined;
+            ? "Your replies are converted to voice notes when you include [[tts]] or [[tts:text]] tags."
+            : "Your replies are automatically converted to voice notes and sent as audio messages.";
     return [
-        "Voice (TTS) is enabled.",
+        "Voice replies are enabled — you CAN send voice notes.",
         autoHint,
+        "Write naturally as if speaking. Do not tell the user you cannot send voice messages — you can.",
         `Keep spoken text ≤${maxLength} chars to avoid auto-summary (summary ${summarize}).`,
-        "Use [[tts:...]] and optional [[tts:text]]...[[/tts:text]] to control voice/expressiveness.",
     ]
         .filter(Boolean)
         .join("\n");
@@ -291,15 +298,20 @@ export function resolveTtsApiKey(config, provider) {
     if (provider === "openai") {
         return config.openai.apiKey || process.env.OPENAI_API_KEY;
     }
+    if (provider === "hume") {
+        return config.hume.apiKey || process.env.HUME_API_KEY;
+    }
     return undefined;
 }
-export const TTS_PROVIDERS = ["openai", "elevenlabs", "edge"];
+export const TTS_PROVIDERS = ["openai", "elevenlabs", "hume", "edge"];
 export function resolveTtsProviderOrder(primary) {
     return [primary, ...TTS_PROVIDERS.filter((provider) => provider !== primary)];
 }
 export function isTtsProviderConfigured(config, provider) {
     if (provider === "edge")
         return config.edge.enabled;
+    if (provider === "hume")
+        return Boolean(resolveTtsApiKey(config, provider));
     return Boolean(resolveTtsApiKey(config, provider));
 }
 function isValidVoiceId(voiceId) {
@@ -350,6 +362,14 @@ function normalizeSeed(seed) {
     }
     return next;
 }
+/** Strip emoji characters so TTS engines don't read them aloud by name. */
+function stripEmoji(text) {
+    // Unicode emoji ranges: emoticons, dingbats, symbols, flags, components
+    return text
+        .replace(/[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu, "")
+        .replace(/  +/g, " ")
+        .trim();
+}
 function parseBooleanValue(value) {
     const normalized = value.trim().toLowerCase();
     if (["true", "1", "yes", "on"].includes(normalized))
@@ -777,6 +797,50 @@ async function openaiTTS(params) {
         clearTimeout(timeout);
     }
 }
+// ---------------------------------------------------------------------------
+// Hume Octave TTS — REST API
+// POST https://api.hume.ai/v0/tts
+// ---------------------------------------------------------------------------
+const HUME_TTS_BASE_URL = "https://api.hume.ai/v0/tts";
+async function humeTTS(params) {
+    const { text, apiKey, voice, description, timeoutMs } = params;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(voice);
+        const voiceSpec = isUuid ? { id: voice } : { name: voice, provider: "HUME_AI" };
+        const utterance = { text, voice: voiceSpec };
+        if (description) {
+            utterance.description = description;
+        }
+        const response = await fetch(HUME_TTS_BASE_URL, {
+            method: "POST",
+            headers: {
+                "X-Hume-Api-Key": apiKey,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                utterances: [utterance],
+                format: { type: "mp3" },
+                strip_headers: true,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Hume TTS API error (${response.status}): ${body.slice(0, 200)}`);
+        }
+        const json = (await response.json());
+        const audio64 = json.generations?.[0]?.audio;
+        if (!audio64) {
+            throw new Error("Hume TTS: no audio in response");
+        }
+        return Buffer.from(audio64, "base64");
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 function inferEdgeExtension(outputFormat) {
     const normalized = outputFormat.toLowerCase();
     if (normalized.includes("webm"))
@@ -888,7 +952,17 @@ export async function textToSpeech(params) {
                     voiceCompatible,
                 };
             }
-            const apiKey = resolveTtsApiKey(config, provider);
+            let apiKey = resolveTtsApiKey(config, provider);
+            // Hume keys are stored in auth profiles (API Keys UI). Fall back to async lookup.
+            if (!apiKey && provider === "hume") {
+                try {
+                    const auth = await resolveApiKeyForProvider({ provider: "hume", cfg: params.cfg });
+                    apiKey = auth.apiKey?.trim() || undefined;
+                }
+                catch {
+                    // No auth profile key available
+                }
+            }
             if (!apiKey) {
                 lastError = `No API key for ${provider}`;
                 continue;
@@ -918,6 +992,15 @@ export async function textToSpeech(params) {
                     timeoutMs: config.timeoutMs,
                 });
             }
+            else if (provider === "hume") {
+                audioBuffer = await humeTTS({
+                    text: params.text,
+                    apiKey,
+                    voice: config.hume.voice,
+                    description: config.hume.description,
+                    timeoutMs: config.timeoutMs,
+                });
+            }
             else {
                 const openaiModelOverride = params.overrides?.openai?.model;
                 const openaiVoiceOverride = params.overrides?.openai?.voice;
@@ -931,6 +1014,7 @@ export async function textToSpeech(params) {
                 });
             }
             const latencyMs = Date.now() - providerStart;
+            log.info(`success via ${provider} (${latencyMs}ms, ${audioBuffer.length} bytes)`);
             const tempDir = mkdtempSync(path.join(tmpdir(), "tts-"));
             const audioPath = path.join(tempDir, `voice-${Date.now()}${output.extension}`);
             writeFileSync(audioPath, audioBuffer);
@@ -940,7 +1024,7 @@ export async function textToSpeech(params) {
                 audioPath,
                 latencyMs,
                 provider,
-                outputFormat: provider === "openai" ? output.openai : output.elevenlabs,
+                outputFormat: provider === "openai" ? output.openai : provider === "hume" ? "mp3" : output.elevenlabs,
                 voiceCompatible: output.voiceCompatible,
             };
         }
@@ -952,8 +1036,10 @@ export async function textToSpeech(params) {
             else {
                 lastError = `${provider}: ${error.message}`;
             }
+            log.error(`${provider} failed: ${lastError}`);
         }
     }
+    log.error(`all providers failed: ${lastError || "none available"}`);
     return {
         success: false,
         error: `TTS conversion failed: ${lastError || "no providers available"}`,
@@ -1033,8 +1119,10 @@ export async function textToSpeechTelephony(params) {
             else {
                 lastError = `${provider}: ${error.message}`;
             }
+            log.error(`telephony: ${provider} failed: ${lastError}`);
         }
     }
+    log.error(`telephony: all providers failed: ${lastError || "none available"}`);
     return {
         success: false,
         error: `TTS conversion failed: ${lastError || "no providers available"}`,
@@ -1081,7 +1169,7 @@ export async function maybeApplyTtsToPayload(params) {
     if (ttsText.trim().length < 10)
         return nextPayload;
     const maxLength = getTtsMaxLength(prefsPath);
-    let textForAudio = ttsText.trim();
+    let textForAudio = stripEmoji(ttsText.trim());
     let wasSummarized = false;
     if (textForAudio.length > maxLength) {
         if (!isSummarizationEnabled(prefsPath)) {

package/dist/web/auto-reply/monitor/process-message.js

@@ -233,6 +233,7 @@ export async function processMessage(params) {
         MediaPath: params.msg.mediaPath,
         MediaUrl: params.msg.mediaUrl,
         MediaType: params.msg.mediaType,
+        MediaDownloadFailed: params.msg.mediaDownloadFailed,
         ChatType: params.msg.chatType,
         ConversationLabel: params.msg.chatType === "group" ? conversationId : params.msg.from,
         GroupSubject: params.msg.groupSubject,

package/dist/web/inbound/monitor.js

@@ -230,6 +230,7 @@ export async function monitorWebInbox(options) {
             const replyContext = describeReplyContext(msg.message);
             let mediaPath;
             let mediaType;
+            let mediaDownloadFailed = false;
             try {
                 const inboundMedia = await downloadInboundMedia(msg, sock);
                 if (inboundMedia) {
@@ -241,9 +242,15 @@ export async function monitorWebInbox(options) {
                     mediaPath = saved.path;
                     mediaType = inboundMedia.mimetype;
                 }
+                else if (body.includes("<media:")) {
+                    // downloadInboundMedia returned undefined — media was expected but unavailable
+                    mediaDownloadFailed = true;
+                    inboundLogger.warn({ id, from, body }, "media download returned empty");
+                }
             }
             catch (err) {
-                logVerbose(`Inbound media download failed: ${String(err)}`);
+                mediaDownloadFailed = body.includes("<media:");
+                inboundLogger.warn({ id, from, error: String(err) }, "media download failed");
             }
             const chatJid = remoteJid;
             const sendComposing = async () => {
@@ -294,6 +301,7 @@ export async function monitorWebInbox(options) {
                 sendMedia,
                 mediaPath,
                 mediaType,
+                mediaDownloadFailed,
             };
             try {
                 const task = Promise.resolve(debouncer.enqueue(inboundMessage));

package/extensions/googlechat/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/googlechat/package.json

@@ -31,9 +31,9 @@
     "google-auth-library": "^10.5.0"
   },
   "devDependencies": {
-    "taskmaster": "workspace:*"
+    "@rubytech/taskmaster": "workspace:*"
   },
   "peerDependencies": {
-    "taskmaster": "workspace:*"
+    "@rubytech/taskmaster": "workspace:*"
   }
 }

package/extensions/line/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/line/package.json

@@ -24,6 +24,6 @@
     }
   },
   "devDependencies": {
-    "taskmaster": "workspace:*"
+    "@rubytech/taskmaster": "workspace:*"
   }
 }

package/extensions/matrix/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/matrix/package.json

@@ -31,6 +31,6 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "taskmaster": "workspace:*"
+    "@rubytech/taskmaster": "workspace:*"
   }
 }

package/extensions/msteams/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/msteams/package.json

@@ -29,7 +29,7 @@
     "@microsoft/agents-hosting": "^1.2.2",
     "@microsoft/agents-hosting-express": "^1.2.2",
     "@microsoft/agents-hosting-extensions-teams": "^1.2.2",
-    "taskmaster": "workspace:*",
+    "@rubytech/taskmaster": "workspace:*",
     "express": "^5.2.1",
     "proper-lockfile": "^4.1.2"
   }

package/extensions/nostr/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/nostr/package.json

@@ -24,7 +24,7 @@
     }
   },
   "dependencies": {
-    "taskmaster": "workspace:*",
+    "@rubytech/taskmaster": "workspace:*",
     "nostr-tools": "^2.20.0",
     "zod": "^4.3.6"
   }

package/extensions/zalo/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/zalo/package.json

@@ -27,7 +27,7 @@
     }
   },
   "dependencies": {
-    "taskmaster": "workspace:*",
+    "@rubytech/taskmaster": "workspace:*",
     "undici": "7.19.0"
   }
 }

package/extensions/zalouser/node_modules/.bin/taskmaster

@@ -15,7 +15,7 @@ else
   export NODE_PATH="/Users/neo/taskmaster-dev/dist/node_modules:/Users/neo/taskmaster-dev/node_modules:/Users/neo/node_modules:/Users/node_modules:/node_modules:/Users/neo/taskmaster-dev/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec "$basedir/node"  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 else
-  exec node  "$basedir/../taskmaster/dist/entry.js" "$@"
+  exec node  "$basedir/../@rubytech/taskmaster/dist/entry.js" "$@"
 fi

package/extensions/zalouser/package.json

@@ -4,7 +4,7 @@
   "type": "module",
   "description": "Taskmaster Zalo Personal Account plugin via zca-cli",
   "dependencies": {
-    "taskmaster": "workspace:*",
+    "@rubytech/taskmaster": "workspace:*",
     "@sinclair/typebox": "0.34.47"
   },
   "taskmaster": {