discoclaw 0.1.1 → 0.1.4

package/README.md

@@ -136,6 +136,10 @@ Full step-by-step guide: [docs/discord-bot-setup.md](docs/discord-bot-setup.md)
    ```bash
    discoclaw install-daemon
    ```
+   Optional: pass `--service-name <name>` to use a custom service name (useful on macOS when running multiple instances, or to match your own naming convention):
+   ```bash
+   discoclaw install-daemon --service-name personal
+   ```
 
 #### From source (contributors)
 
@@ -157,6 +161,8 @@ pnpm dev
 ```bash
 npm update -g discoclaw
 discoclaw install-daemon   # re-register the service after updating
+# If you used a custom service name, pass it again:
+# discoclaw install-daemon --service-name personal
 ```
 
 **From source:**

package/dist/cli/daemon-installer.js

@@ -21,6 +21,19 @@ export function resolvePackageRoot() {
     const selfDir = path.dirname(fileURLToPath(import.meta.url));
     return path.resolve(selfDir, '..', '..');
 }
+/**
+ * Parses --service-name <name> from argv.
+ * Defaults to 'discoclaw' if not provided.
+ */
+export function parseServiceName(argv = process.argv) {
+    const idx = argv.indexOf('--service-name');
+    if (idx !== -1 && idx + 1 < argv.length) {
+        const name = argv[idx + 1];
+        if (name && !name.startsWith('-'))
+            return name;
+    }
+    return 'discoclaw';
+}
 // ── Rendering helpers ──────────────────────────────────────────────────────
 /**
  * Parses a .env file into key-value pairs.
@@ -71,8 +84,9 @@ export function renderSystemdUnit(packageRoot, cwd) {
  * Since launchd has no EnvironmentFile equivalent, env vars are baked in
  * from the parsed .env at install time.
  */
-export function renderLaunchdPlist(packageRoot, cwd, envVars) {
+export function renderLaunchdPlist(packageRoot, cwd, envVars, serviceName = 'discoclaw') {
     const entryPoint = path.join(packageRoot, 'dist', 'index.js');
+    const label = `com.discoclaw.${serviceName}`;
     const envEntries = Object.entries(envVars)
         .map(([k, v]) => `\t\t<key>${k}</key>\n\t\t<string>${v}</string>`)
         .join('\n');
@@ -82,7 +96,7 @@ export function renderLaunchdPlist(packageRoot, cwd, envVars) {
         '<plist version="1.0">',
         '<dict>',
         '\t<key>Label</key>',
-        '\t<string>com.discoclaw.agent</string>',
+        `\t<string>${label}</string>`,
         '\t<key>ProgramArguments</key>',
         '\t<array>',
         '\t\t<string>/usr/bin/node</string>',
@@ -106,9 +120,9 @@ export function renderLaunchdPlist(packageRoot, cwd, envVars) {
     return lines.join('\n');
 }
 // ── Platform installers ────────────────────────────────────────────────────
-async function installSystemd(packageRoot, cwd, ask) {
+async function installSystemd(packageRoot, cwd, serviceName, ask) {
     const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
-    const servicePath = path.join(serviceDir, 'discoclaw.service');
+    const servicePath = path.join(serviceDir, `${serviceName}.service`);
     if (fs.existsSync(servicePath)) {
         const answer = await ask(`Service file already exists at ${servicePath}. Overwrite? [y/N] `);
         if (answer.trim().toLowerCase() !== 'y') {
@@ -128,9 +142,9 @@ async function installSystemd(packageRoot, cwd, ask) {
         console.error(`systemctl daemon-reload failed: ${err.message}\n`);
         process.exit(1);
     }
-    console.log('Enabling and starting discoclaw service...');
+    console.log(`Enabling and starting ${serviceName} service...`);
     try {
-        execFileSync('systemctl', ['--user', 'enable', '--now', 'discoclaw']);
+        execFileSync('systemctl', ['--user', 'enable', '--now', serviceName]);
     }
     catch (err) {
         console.error(`systemctl enable/start failed: ${err.message}\n`);
@@ -138,14 +152,15 @@ async function installSystemd(packageRoot, cwd, ask) {
     }
     console.log('DiscoClaw daemon installed and started.\n');
     console.log('Useful commands:');
-    console.log('  journalctl --user -u discoclaw.service -f   # tail logs');
-    console.log('  systemctl --user status discoclaw           # check status');
-    console.log('  systemctl --user stop discoclaw             # stop the service');
+    console.log(`  journalctl --user -u ${serviceName}.service -f   # tail logs`);
+    console.log(`  systemctl --user status ${serviceName}           # check status`);
+    console.log(`  systemctl --user stop ${serviceName}             # stop the service`);
     console.log('');
 }
-async function installLaunchd(packageRoot, cwd, envPath, ask) {
+async function installLaunchd(packageRoot, cwd, envPath, serviceName, ask) {
     const agentsDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
-    const plistPath = path.join(agentsDir, 'com.discoclaw.agent.plist');
+    const label = `com.discoclaw.${serviceName}`;
+    const plistPath = path.join(agentsDir, `${label}.plist`);
     if (fs.existsSync(plistPath)) {
         const answer = await ask(`Plist already exists at ${plistPath}. Overwrite? [y/N] `);
         if (answer.trim().toLowerCase() !== 'y') {
@@ -155,14 +170,14 @@ async function installLaunchd(packageRoot, cwd, envPath, ask) {
     }
     const envContent = fs.readFileSync(envPath, 'utf8');
     const envVars = parseEnvFile(envContent);
-    const plist = renderLaunchdPlist(packageRoot, cwd, envVars);
+    const plist = renderLaunchdPlist(packageRoot, cwd, envVars, serviceName);
     fs.mkdirSync(agentsDir, { recursive: true });
     fs.writeFileSync(plistPath, plist, 'utf8');
     console.log(`Wrote ${plistPath}\n`);
     console.log('Note: On macOS, .env changes require re-running `discoclaw install-daemon`.\n' +
         '      Environment variables are baked into the plist at install time.\n');
     const uid = process.getuid();
-    const target = `gui/${uid}/com.discoclaw.agent`;
+    const target = `gui/${uid}/${label}`;
     // Idempotent: bootout first (ignore failure if agent is not currently loaded)
     try {
         execFileSync('launchctl', ['bootout', target]);
@@ -181,7 +196,7 @@ async function installLaunchd(packageRoot, cwd, envPath, ask) {
     console.log('DiscoClaw daemon installed and started.\n');
     console.log('Useful commands:');
     console.log("  log stream --predicate 'process == \"node\"'  # tail logs");
-    console.log('  launchctl list com.discoclaw.agent           # check status');
+    console.log(`  launchctl list ${label}           # check status`);
     console.log(`  launchctl bootout ${target}  # stop and unload`);
     console.log('');
 }
@@ -209,14 +224,15 @@ export async function runDaemonInstaller() {
             'Make sure the package is properly installed (try running `npm install -g discoclaw` again).\n');
         process.exit(1);
     }
+    const serviceName = parseServiceName();
     const rl = readline.createInterface({ input, output });
     const ask = (prompt) => rl.question(prompt);
     try {
         if (platform === 'linux') {
-            await installSystemd(packageRoot, cwd, ask);
+            await installSystemd(packageRoot, cwd, serviceName, ask);
         }
         else {
-            await installLaunchd(packageRoot, cwd, envPath, ask);
+            await installLaunchd(packageRoot, cwd, envPath, serviceName, ask);
         }
     }
     finally {

package/dist/cli/daemon-installer.test.js

@@ -16,7 +16,7 @@ vi.mock('node:readline/promises', () => ({
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
-import { parseEnvFile, renderSystemdUnit, renderLaunchdPlist, runDaemonInstaller, } from './daemon-installer.js';
+import { parseEnvFile, parseServiceName, renderSystemdUnit, renderLaunchdPlist, runDaemonInstaller, } from './daemon-installer.js';
 // ── Test helpers ───────────────────────────────────────────────────────────
 function makeReadline(answers = []) {
     return {
@@ -47,6 +47,21 @@ describe('parseEnvFile', () => {
         expect(parseEnvFile('# just comments\n')).toEqual({});
     });
 });
+// ── parseServiceName ───────────────────────────────────────────────────────
+describe('parseServiceName', () => {
+    it('returns "discoclaw" when --service-name is absent', () => {
+        expect(parseServiceName(['node', 'discoclaw', 'install-daemon'])).toBe('discoclaw');
+    });
+    it('returns the provided name when --service-name is present', () => {
+        expect(parseServiceName(['node', 'discoclaw', 'install-daemon', '--service-name', 'personal'])).toBe('personal');
+    });
+    it('ignores --service-name if the next token starts with a dash', () => {
+        expect(parseServiceName(['node', 'discoclaw', 'install-daemon', '--service-name', '--other-flag'])).toBe('discoclaw');
+    });
+    it('ignores --service-name if it is the last token with no value', () => {
+        expect(parseServiceName(['node', 'discoclaw', 'install-daemon', '--service-name'])).toBe('discoclaw');
+    });
+});
 // ── renderSystemdUnit ──────────────────────────────────────────────────────
 describe('renderSystemdUnit', () => {
     it('produces correct ExecStart with /usr/bin/node and dist/index.js', () => {
@@ -73,10 +88,15 @@ describe('renderSystemdUnit', () => {
 // ── renderLaunchdPlist ─────────────────────────────────────────────────────
 describe('renderLaunchdPlist', () => {
     const envVars = { DISCORD_TOKEN: 'tok', FOO: 'bar' };
-    it('produces valid XML plist with correct label', () => {
+    it('produces valid XML plist with default label', () => {
         const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);
         expect(plist).toContain('<?xml version="1.0"');
-        expect(plist).toContain('<string>com.discoclaw.agent</string>');
+        expect(plist).toContain('<string>com.discoclaw.discoclaw</string>');
+    });
+    it('uses custom service name in label when provided', () => {
+        const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars, 'personal');
+        expect(plist).toContain('<string>com.discoclaw.personal</string>');
+        expect(plist).not.toContain('com.discoclaw.discoclaw');
     });
     it('sets ProgramArguments to /usr/bin/node and dist/index.js', () => {
         const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);

package/dist/cli/index.js

@@ -34,8 +34,10 @@ function printHelp(ver) {
     console.log(`discoclaw v${ver} — Personal AI orchestrator\n` +
         `\nUsage: discoclaw <command>\n` +
         `\nCommands:\n` +
-        `  init              Interactive setup wizard — creates .env and workspace/\n` +
-        `  install-daemon    Register discoclaw as a persistent background service\n` +
+        `  init                                  Interactive setup wizard — creates .env and workspace/\n` +
+        `  install-daemon [--service-name <name>]  Register discoclaw as a persistent background service\n` +
+        `                                          Use --service-name to run multiple instances side-by-side.\n` +
+        `                                          Defaults to "discoclaw".\n` +
         `\nOptions:\n` +
         `  -v, --version   Print version\n` +
         `  -h, --help      Print this help\n`);

package/dist/cron/executor.js

@@ -1,7 +1,7 @@
 import { acquireCronLock, releaseCronLock } from './job-lock.js';
 import { resolveChannel } from '../discord/action-utils.js';
 import * as discordActions from '../discord/actions.js';
-import { sendChunks, appendUnavailableActionTypesNotice } from '../discord/output-common.js';
+import { sendChunks, appendUnavailableActionTypesNotice, appendParseFailureNotice } from '../discord/output-common.js';
 import { buildPromptPreamble, loadWorkspacePaFiles, inlineContextFiles, resolveEffectiveTools } from '../discord/prompt-common.js';
 import { ensureStatusMessage } from './discord-sync.js';
 import { globalMetrics } from '../observability/metrics.js';
@@ -199,11 +199,13 @@ export async function executeCronJob(job, ctx) {
         }
         let processedText = output;
         let strippedUnrecognizedTypes = [];
+        let parseFailuresCount = 0;
         // Handle Discord actions if enabled.
         if (ctx.discordActionsEnabled) {
             const parsed = discordActions.parseDiscordActions(processedText, ctx.actionFlags);
             const { cleanText, actions } = parsed;
             strippedUnrecognizedTypes = parsed.strippedUnrecognizedTypes;
+            parseFailuresCount = parsed.parseFailures;
             if (actions.length > 0) {
                 const actCtx = {
                     guild,
@@ -232,7 +234,7 @@ export async function executeCronJob(job, ctx) {
                     ? cleanText.trimEnd() + '\n\n' + displayLines.join('\n')
                     : cleanText.trimEnd();
                 // When all display lines were suppressed and there's no prose, skip posting.
-                if (!processedText.trim() && anyActionSucceeded && strippedUnrecognizedTypes.length === 0) {
+                if (!processedText.trim() && anyActionSucceeded && strippedUnrecognizedTypes.length === 0 && parseFailuresCount === 0) {
                     ctx.log?.info({ jobId: job.id }, 'cron:reply suppressed (actions-only, no display text)');
                 }
                 if (ctx.status) {
@@ -248,6 +250,7 @@ export async function executeCronJob(job, ctx) {
             }
         }
         processedText = appendUnavailableActionTypesNotice(processedText, strippedUnrecognizedTypes);
+        processedText = appendParseFailureNotice(processedText, parseFailuresCount);
         await sendChunks(channelForSend, processedText, collectedImages);
         ctx.log?.info({ jobId: job.id, name: job.name, channel: job.def.channel }, 'cron:exec done');
         // Record successful run.

package/dist/discord/actions.js

@@ -306,16 +306,17 @@ function collectParsedAction(parsed, flags, validTypes, actions, strippedUnrecog
         strippedUnrecognizedTypes.push(type);
     }
 }
-function parseActionJson(jsonStr, flags, validTypes, actions, strippedUnrecognizedTypes) {
+function parseActionJson(jsonStr, flags, validTypes, actions, strippedUnrecognizedTypes, parseFailuresRef) {
     try {
         const parsed = JSON.parse(jsonStr);
         collectParsedAction(parsed, flags, validTypes, actions, strippedUnrecognizedTypes);
     }
     catch {
+        parseFailuresRef.count++;
         // Malformed JSON — skip silently.
     }
 }
-function stripActionsWithScanner(text, flags, validTypes, actions, strippedUnrecognizedTypes, codeRanges) {
+function stripActionsWithScanner(text, flags, validTypes, actions, strippedUnrecognizedTypes, codeRanges, parseFailuresRef) {
     let result = '';
     let cursor = 0;
     while (cursor < text.length) {
@@ -347,7 +348,7 @@ function stripActionsWithScanner(text, flags, validTypes, actions, strippedUnrec
                 cursor += trailing[0].length;
             continue;
         }
-        parseActionJson(jsonStr, flags, validTypes, actions, strippedUnrecognizedTypes);
+        parseActionJson(jsonStr, flags, validTypes, actions, strippedUnrecognizedTypes, parseFailuresRef);
         // Advance past the JSON object and consume any trailing XML closing tags.
         cursor = afterMarker + jsonStr.length;
         const remaining = text.slice(cursor);
@@ -364,16 +365,18 @@ function stripActionsWithScanner(text, flags, validTypes, actions, strippedUnrec
 function parseWithRegexFallback(text, flags, validTypes, codeRanges) {
     const actions = [];
     const strippedUnrecognizedTypes = [];
+    const parseFailuresRef = { count: 0 };
     const cleaned = text.replace(ACTION_RE, (match, json, offset) => {
         if (isIndexInRanges(offset, codeRanges))
             return match;
-        parseActionJson(json.trim(), flags, validTypes, actions, strippedUnrecognizedTypes);
+        parseActionJson(json.trim(), flags, validTypes, actions, strippedUnrecognizedTypes, parseFailuresRef);
         return '';
     });
     return {
         cleanText: cleaned.replace(/\n{3,}/g, '\n\n').trim(),
         actions,
         strippedUnrecognizedTypes,
+        parseFailures: parseFailuresRef.count,
     };
 }
 export function parseDiscordActions(text, flags) {
@@ -381,11 +384,13 @@ export function parseDiscordActions(text, flags) {
     const actions = [];
     const strippedUnrecognizedTypes = [];
     const codeRanges = computeMarkdownCodeRanges(text);
-    const cleaned = stripActionsWithScanner(text, flags, validTypes, actions, strippedUnrecognizedTypes, codeRanges);
+    const parseFailuresRef = { count: 0 };
+    const cleaned = stripActionsWithScanner(text, flags, validTypes, actions, strippedUnrecognizedTypes, codeRanges, parseFailuresRef);
     const scanned = {
         cleanText: cleaned.replace(/\n{3,}/g, '\n\n').trim(),
         actions,
         strippedUnrecognizedTypes,
+        parseFailures: parseFailuresRef.count,
     };
     // Compatibility fallback: if scanner leaves markers behind or extracts nothing,
     // run the legacy regex parser and prefer it when it captures more actions.
@@ -501,7 +506,7 @@ export async function executeDiscordActions(actions, ctx, log, subs) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            results.push({ ok: false, error: msg });
+            results.push({ ok: false, error: `Failed (${action.type}): ${msg}` });
             log?.error({ err, action }, 'discord:action failed');
         }
     }

package/dist/discord/actions.test.js

@@ -211,6 +211,28 @@ describe('parseDiscordActions', () => {
         expect(actions).toHaveLength(0);
         expect(strippedUnrecognizedTypes).toEqual(['forgeStatus']);
     });
+    it('parses two same-type taskCreate actions and extracts both', () => {
+        const input = '<discord-action>{"type":"taskCreate","title":"First task"}</discord-action>' +
+            '<discord-action>{"type":"taskCreate","title":"Second task"}</discord-action>';
+        const { actions, parseFailures } = parseDiscordActions(input, { ...ALL_FLAGS, tasks: true });
+        expect(actions).toHaveLength(2);
+        expect(actions[0]).toEqual({ type: 'taskCreate', title: 'First task' });
+        expect(actions[1]).toEqual({ type: 'taskCreate', title: 'Second task' });
+        expect(parseFailures).toBe(0);
+    });
+    it('returns parseFailures: 1 and only the valid action when second block has malformed JSON', () => {
+        const input = '<discord-action>{"type":"taskCreate","title":"Valid task"}</discord-action>' +
+            '<discord-action>{bad json}</discord-action>';
+        const { actions, parseFailures } = parseDiscordActions(input, { ...ALL_FLAGS, tasks: true });
+        expect(actions).toHaveLength(1);
+        expect(actions[0]).toEqual({ type: 'taskCreate', title: 'Valid task' });
+        expect(parseFailures).toBe(1);
+    });
+    it('returns parseFailures: 0 for well-formed input', () => {
+        const input = '<discord-action>{"type":"channelList"}</discord-action>';
+        const { parseFailures } = parseDiscordActions(input, ALL_FLAGS);
+        expect(parseFailures).toBe(0);
+    });
 });
 // ---------------------------------------------------------------------------
 // executeDiscordActions — mocked guild
@@ -309,7 +331,7 @@ describe('executeDiscordActions', () => {
         });
         const results = await executeDiscordActions([{ type: 'channelCreate', name: 'test' }], makeCtx(guild));
         expect(results).toHaveLength(1);
-        expect(results[0]).toEqual({ ok: false, error: 'Missing Permissions' });
+        expect(results[0]).toEqual({ ok: false, error: 'Failed (channelCreate): Missing Permissions' });
     });
     it('one failure does not block subsequent actions', async () => {
         const guild = makeMockGuild([
@@ -360,6 +382,16 @@ describe('executeDiscordActions', () => {
         expect(results[0].error).toContain('requires confirmation');
         expect(results[0].error).toContain('!confirm');
     });
+    it('executes two same-type channelCreate actions and returns two results', async () => {
+        const guild = makeMockGuild([]);
+        const results = await executeDiscordActions([
+            { type: 'channelCreate', name: 'alpha' },
+            { type: 'channelCreate', name: 'beta' },
+        ], makeCtx(guild));
+        expect(results).toHaveLength(2);
+        expect(results[0]).toEqual({ ok: true, summary: 'Created #alpha' });
+        expect(results[1]).toEqual({ ok: true, summary: 'Created #beta' });
+    });
     it('allows destructive actions with bypassDestructive confirmation context', async () => {
         const ban = vi.fn(async () => { });
         const guild = {

package/dist/discord/deferred-runner.js

@@ -3,7 +3,7 @@ import { fmtTime, resolveChannel } from './action-utils.js';
 import { NO_MENTIONS } from './allowed-mentions.js';
 import { DeferScheduler as DeferSchedulerImpl } from './defer-scheduler.js';
 import { resolveDiscordChannelContext } from './channel-context.js';
-import { appendUnavailableActionTypesNotice } from './output-common.js';
+import { appendUnavailableActionTypesNotice, appendParseFailureNotice } from './output-common.js';
 import { buildContextFiles, buildPromptPreamble, inlineContextFiles, loadWorkspacePaFiles, resolveEffectiveTools, } from './prompt-common.js';
 import { mapRuntimeErrorToUserMessage } from './user-errors.js';
 import { resolveModel } from '../runtime/model-tiers.js';
@@ -173,6 +173,7 @@ export function configureDeferredScheduler(opts) {
             outgoingText = outgoingText ? `${outgoingText}\n\n${displayLines.join('\n')}` : displayLines.join('\n');
         }
         outgoingText = appendUnavailableActionTypesNotice(outgoingText, parsed.strippedUnrecognizedTypes).trim();
+        outgoingText = appendParseFailureNotice(outgoingText, parsed.parseFailures).trim();
         if (!outgoingText && runtimeError) {
             outgoingText = runtimeError;
         }

package/dist/discord/message-coordinator.js

@@ -30,7 +30,7 @@ import { taskThreadCache } from '../tasks/thread-cache.js';
 import { buildTaskContextSummary } from '../tasks/context-summary.js';
 import { TaskStore } from '../tasks/store.js';
 import { isChannelPublic, appendEntry, buildExcerptSummary } from './shortterm-memory.js';
-import { editThenSendChunks, shouldSuppressFollowUp, appendUnavailableActionTypesNotice } from './output-common.js';
+import { editThenSendChunks, shouldSuppressFollowUp, appendUnavailableActionTypesNotice, appendParseFailureNotice } from './output-common.js';
 import { downloadMessageImages, resolveMediaType } from './image-download.js';
 import { resolveReplyReference } from './reply-reference.js';
 import { resolveThreadContext } from './thread-context.js';
@@ -2017,6 +2017,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                             let actions = [];
                             let actionResults = [];
                             let strippedUnrecognizedTypes = [];
+                            let parseFailuresCount = 0;
                             // Gate action execution on successful stream completion — do not execute
                             // actions against partial or error output, which could cause side effects
                             // based on incomplete model responses.  Relax the hadTextFinal requirement
@@ -2031,6 +2032,10 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                                 && (hadTextFinal || processedText.includes('<discord-action>'));
                             if (params.discordActionsEnabled && msg.guild && canParseActions) {
                                 const parsed = parseDiscordActions(processedText, actionFlags);
+                                parseFailuresCount = parsed.parseFailures;
+                                if (parsed.parseFailures > 0) {
+                                    params.log?.warn(`parseDiscordActions: ${parsed.parseFailures} action block(s) failed to parse (sessionKey=${sessionKey})`);
+                                }
                                 if (parsed.actions.length > 0) {
                                     actions = parsed.actions;
                                     strippedUnrecognizedTypes = parsed.strippedUnrecognizedTypes;
@@ -2045,6 +2050,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                                             mode: 'interactive',
                                             sessionKey,
                                             userId: msg.author.id,
+                                            bypassDestructive: true,
                                         },
                                     };
                                     // Construct per-message memoryCtx with real user ID and Discord metadata.
@@ -2078,7 +2084,8 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                                     if (!processedText.trim()
                                         && anyActionSucceeded
                                         && collectedImages.length === 0
-                                        && strippedUnrecognizedTypes.length === 0) {
+                                        && strippedUnrecognizedTypes.length === 0
+                                        && parseFailuresCount === 0) {
                                         try {
                                             await reply.delete();
                                         }
@@ -2103,6 +2110,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                                 }
                             }
                             processedText = appendUnavailableActionTypesNotice(processedText, strippedUnrecognizedTypes);
+                            processedText = appendParseFailureNotice(processedText, parseFailuresCount);
                             // Suppression: if a follow-up response is trivially short and has no further
                             // actions, suppress it to avoid posting empty messages like "Got it."
                             // Skip suppression when images are present, or when unrecognized action blocks

package/dist/discord/output-common.js

@@ -147,6 +147,21 @@ export function appendUnavailableActionTypesNotice(text, strippedTypes) {
     const base = String(text ?? '').trimEnd();
     return base ? `${base}\n\n${notice}` : notice;
 }
+export function buildParseFailureNotice(count) {
+    if (count <= 0)
+        return '';
+    if (count === 1) {
+        return 'Warning: 1 action block failed to parse (malformed JSON) and was skipped.';
+    }
+    return `Warning: ${count} action blocks failed to parse (malformed JSON) and were skipped.`;
+}
+export function appendParseFailureNotice(text, count) {
+    const notice = buildParseFailureNotice(count);
+    if (!notice)
+        return text;
+    const base = String(text ?? '').trimEnd();
+    return base ? `${base}\n\n${notice}` : notice;
+}
 export async function sendChunks(channel, text, images) {
     const attachments = images && images.length > 0 ? buildAttachments(images) : [];
     const chunks = prepareDiscordOutput(text);

package/dist/discord/output-common.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { buildAttachments, imageMediaTypeToExtension, editThenSendChunks, replyThenSendChunks, sendChunks, shouldSuppressFollowUp, buildUnavailableActionTypesNotice, appendUnavailableActionTypesNotice, } from './output-common.js';
+import { buildAttachments, imageMediaTypeToExtension, editThenSendChunks, replyThenSendChunks, sendChunks, shouldSuppressFollowUp, buildUnavailableActionTypesNotice, appendUnavailableActionTypesNotice, buildParseFailureNotice, appendParseFailureNotice, } from './output-common.js';
 describe('imageMediaTypeToExtension', () => {
     it('maps known types', () => {
         expect(imageMediaTypeToExtension('image/png')).toBe('png');
@@ -196,3 +196,39 @@ describe('sendChunks with images', () => {
         expect(channel.send.mock.calls[0][0].files).toHaveLength(1);
     });
 });
+describe('buildParseFailureNotice', () => {
+    it('returns empty string for zero failures', () => {
+        expect(buildParseFailureNotice(0)).toBe('');
+    });
+    it('returns empty string for negative count', () => {
+        expect(buildParseFailureNotice(-1)).toBe('');
+    });
+    it('returns singular warning for one failure', () => {
+        const out = buildParseFailureNotice(1);
+        expect(out).toContain('1 action block');
+        expect(out).toContain('malformed JSON');
+        expect(out).toContain('skipped');
+    });
+    it('returns plural warning for multiple failures', () => {
+        const out = buildParseFailureNotice(3);
+        expect(out).toContain('3 action blocks');
+        expect(out).toContain('malformed JSON');
+        expect(out).toContain('skipped');
+    });
+});
+describe('appendParseFailureNotice', () => {
+    it('appends the notice under existing text', () => {
+        const out = appendParseFailureNotice('hello', 1);
+        expect(out).toContain('hello');
+        expect(out).toContain('malformed JSON');
+        expect(out.indexOf('hello')).toBeLessThan(out.indexOf('malformed JSON'));
+    });
+    it('returns notice alone when base text is empty', () => {
+        const out = appendParseFailureNotice('', 2);
+        expect(out).toContain('2 action blocks');
+        expect(out.startsWith('Warning:')).toBe(true);
+    });
+    it('returns original text when count is zero', () => {
+        expect(appendParseFailureNotice('hello', 0)).toBe('hello');
+    });
+});

package/dist/discord/reaction-handler.js

@@ -8,7 +8,7 @@ import { tryResolveReactionPrompt } from './reaction-prompts.js';
 import { tryAbortAll } from './abort-registry.js';
 import { getActiveOrchestrator } from './forge-plan-registry.js';
 import { buildContextFiles, inlineContextFiles, buildDurableMemorySection, buildTaskThreadSection, loadWorkspacePaFiles, resolveEffectiveTools, buildPromptPreamble } from './prompt-common.js';
-import { editThenSendChunks, appendUnavailableActionTypesNotice } from './output-common.js';
+import { editThenSendChunks, appendUnavailableActionTypesNotice, appendParseFailureNotice } from './output-common.js';
 import { formatBoldLabel, thinkingLabel, selectStreamingOutput } from './output-utils.js';
 import { NO_MENTIONS } from './allowed-mentions.js';
 import { registerInFlightReply, isShuttingDown } from './inflight-replies.js';
@@ -515,11 +515,13 @@ function createReactionHandler(mode, params, queue, statusRef) {
                             let parsedActions = [];
                             let actionResults = [];
                             let strippedUnrecognizedTypes = [];
+                            let parseFailuresCount = 0;
                             if (params.discordActionsEnabled && msg.guild && canParseActions && !invokeError) {
                                 const parsed = parseDiscordActions(processedText, actionFlags);
                                 parsedActionCount = parsed.actions.length;
                                 parsedActions = parsed.actions;
                                 strippedUnrecognizedTypes = parsed.strippedUnrecognizedTypes;
+                                parseFailuresCount = parsed.parseFailures;
                                 if (parsed.actions.length > 0) {
                                     const actCtx = {
                                         guild: msg.guild,
@@ -564,7 +566,8 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                     if (!processedText.trim()
                                         && anyActionSucceeded
                                         && collectedImages.length === 0
-                                        && strippedUnrecognizedTypes.length === 0) {
+                                        && strippedUnrecognizedTypes.length === 0
+                                        && parseFailuresCount === 0) {
                                         try {
                                             await reply?.delete?.();
                                         }
@@ -587,6 +590,7 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                 }
                             }
                             processedText = appendUnavailableActionTypesNotice(processedText, strippedUnrecognizedTypes);
+                            processedText = appendParseFailureNotice(processedText, parseFailuresCount);
                             // Suppress empty responses and the HEARTBEAT_OK sentinel — delete placeholder and bail.
                             const strippedText = processedText.replace(/\s+/g, ' ').trim();
                             const isSuppressible = strippedText.length === 0 || strippedText === 'HEARTBEAT_OK' || strippedText === '(no output)';

package/dist/discord-followup.test.js

@@ -556,7 +556,7 @@ describe('destructive action confirmation flow', () => {
     afterEach(() => {
         resetDestructiveConfirm();
     });
-    it('requires !confirm token before executing destructive actions', async () => {
+    it('executes destructive actions immediately in interactive mode without !confirm', async () => {
         const ban = vi.fn(async () => { });
         const guild = {
             members: {
@@ -572,17 +572,8 @@ describe('destructive action confirmation flow', () => {
         const handler = createMessageCreateHandler(baseParams(runtime, { discordActionsModeration: true }), makeQueue());
         const msg1 = makeMsg({ guild, content: 'ban that user' });
         await handler(msg1);
-        const firstReply = await msg1.reply.mock.results[0]?.value;
-        const firstContent = String(firstReply?.edit?.mock?.calls?.[firstReply.edit.mock.calls.length - 1]?.[0]?.content ?? '');
-        const token = /!confirm\s+([a-z0-9_-]{6,64})/i.exec(firstContent)?.[1];
-        expect(token).toBeTruthy();
-        expect(ban).not.toHaveBeenCalled();
-        const msg2 = makeMsg({ guild, content: `!confirm ${token}` });
-        await handler(msg2);
         expect(runtime.invoke).toHaveBeenCalledTimes(1);
         expect(ban).toHaveBeenCalledOnce();
-        const confirmReply = msg2.reply.mock.calls[0]?.[0]?.content ?? '';
-        expect(confirmReply).toContain('Confirmed `ban`.');
     });
 });
 // ---------------------------------------------------------------------------

package/dist/tasks/thread-contracts.test.js

@@ -285,6 +285,27 @@ describe('closeTaskThread', () => {
         await closeTaskThread(client, 'missing', task);
         // No error thrown — function completes silently.
     });
+    it('calls thread.edit with correct this context (regression: unbound this)', async () => {
+        let capturedThis;
+        const mockClient = { rest: {} };
+        const thread = {
+            isThread: () => true,
+            archived: false,
+            client: mockClient,
+            fetchStarterMessage: vi.fn(async () => ({
+                author: { id: 'bot-123' },
+                content: buildTaskStarterContent(task),
+                edit: vi.fn(),
+            })),
+            send: vi.fn(),
+            setArchived: vi.fn(),
+            edit: function (_payload) { capturedThis = this; },
+        };
+        const client = makeClient(thread);
+        await closeTaskThread(client, 'thread-1', task);
+        expect(capturedThis).toBe(thread);
+        expect(capturedThis.client).toBe(mockClient);
+    });
 });
 // ---------------------------------------------------------------------------
 // getStatusTagIds
@@ -461,6 +482,20 @@ describe('updateTaskThreadTags', () => {
         });
         expect(thread.edit.mock.calls[0][0].appliedTags).not.toContain('s1');
     });
+    it('calls thread.edit with correct this context (regression: unbound this)', async () => {
+        let capturedThis;
+        const mockClient = { rest: {} };
+        const tagMap = { open: 's1', in_progress: 's2' };
+        const thread = {
+            isThread: () => true,
+            appliedTags: ['s1'],
+            client: mockClient,
+            edit: function (_payload) { capturedThis = this; },
+        };
+        await updateTaskThreadTags(makeClient(thread), '123', task, tagMap);
+        expect(capturedThis).toBe(thread);
+        expect(capturedThis.client).toBe(mockClient);
+    });
 });
 // ---------------------------------------------------------------------------
 // closeTaskThread with tagMap

package/dist/tasks/thread-lifecycle-ops.js

@@ -17,7 +17,7 @@ function asEditableTaskThread(thread) {
     const appliedTags = getThreadAppliedTags(thread);
     return {
         appliedTags: appliedTags.length > 0 ? appliedTags : undefined,
-        edit: candidate.edit,
+        edit: candidate.edit.bind(candidate),
     };
 }
 /** Post a close summary, rename with checkmark, and archive the thread. */

package/dist/workspace-bootstrap.test.js

@@ -370,7 +370,7 @@ describe('template content — AGENTS.md', () => {
     });
     it('contains task creation guidance', async () => {
         agents ??= await fs.readFile(path.join(templatesDir, 'AGENTS.md'), 'utf-8');
-        expect(agents).toContain('Task Creation');
+        expect(agents).toContain('Task Management');
     });
     it('contains git commit hash guidance', async () => {
         agents ??= await fs.readFile(path.join(templatesDir, 'AGENTS.md'), 'utf-8');
@@ -482,13 +482,13 @@ describe('scaffolded workspace contains operational content', () => {
             'Landing the Plane',
             'Plan-Audit-Implement Workflow',
             'Discord Formatting',
-            'Task Creation',
+            'Task Management',
         ];
         for (const section of requiredSections) {
             expect(agents).toContain(section);
         }
     });
-    it('fresh scaffold produces TOOLS.md with all 13 action types', async () => {
+    it('fresh scaffold produces TOOLS.md with all 30 action types', async () => {
         const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-content-'));
         dirs.push(workspace);
         await ensureWorkspaceBootstrapFiles(workspace);
@@ -497,6 +497,8 @@ describe('scaffolded workspace contains operational content', () => {
             'forgeCreate', 'forgeResume', 'forgeStatus', 'forgeCancel',
             'planList', 'planShow', 'planApprove', 'planClose', 'planCreate', 'planRun',
             'memoryRemember', 'memoryForget', 'memoryShow',
+            'taskCreate', 'taskUpdate', 'taskClose', 'taskShow', 'taskList', 'taskSync', 'tagMapReload',
+            'cronCreate', 'cronUpdate', 'cronList', 'cronShow', 'cronPause', 'cronResume', 'cronDelete', 'cronTrigger', 'cronSync', 'cronTagMapReload',
         ];
         for (const action of allActionTypes) {
             expect(tools).toContain(action);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discoclaw",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Minimal Discord bridge routing messages to AI runtimes",
   "license": "MIT",
   "repository": {

package/templates/workspace/AGENTS.md

@@ -141,13 +141,13 @@ Plans are stored in `workspace/plans/plan-NNN-slug.md`. The user must explicitly
 
 **Canonical reference:** See `docs/plan-and-forge.md` for full command syntax, the forge orchestration loop, phase manager details, configuration options, and end-to-end workflows.
 
-## Forge, Plan & Memory Action Types
+## Discord Action Types
 
-See TOOLS.md for the full reference of forge, plan, and memory `<discord-action>` types. Never send `!forge`/`!plan`/`!memory` as text messages — bot-sent messages don't trigger command handlers. Use the action blocks instead.
+See TOOLS.md for the full reference of forge, plan, memory, task, and cron `<discord-action>` types. Never send `!forge`/`!plan`/`!memory` as text messages — bot-sent messages don't trigger command handlers. Use the action blocks instead.
 
-## Task Creation
+## Task Management
 
-After creating a task, always post a link to its Discord thread so the user can jump straight to it.
+Discoclaw has a built-in task tracker backed by Discord forum threads. Use `taskCreate` for tracking work items (TODOs, follow-ups, bugs, feature requests) — not GitHub issues, not manual thread creation. After creating a task, always post a link to its Discord thread so the user can jump straight to it. See TOOLS.md for action syntax.
 
 ## Discord Action Batching
 
@@ -196,9 +196,9 @@ This is a starting point. Add your own conventions, style, and rules as you figu
 
 **MANDATORY WORKFLOW:**
 
-1. **File issues for remaining work** - Create issues for anything that needs follow-up
+1. **Track remaining work** - Use `taskCreate` for anything that needs follow-up
 2. **Run quality gates** (if code changed) - Tests, linters, builds
-3. **Update issue status** - Close finished work, update in-progress items
+3. **Update task status** - Use `taskClose`/`taskUpdate` to close finished work and update in-progress items
 4. **PUSH TO REMOTE** - This is MANDATORY:
    ```bash
    git pull --rebase

package/templates/workspace/TOOLS.md

@@ -177,7 +177,19 @@ Plans are stored in `workspace/plans/plan-NNN-slug.md`. Complex plans can be dec
 
 **Canonical reference:** See `docs/plan-and-forge.md` for full command syntax, the forge orchestration loop, phase manager details, configuration options, and end-to-end workflows.
 
-## Discord Action Types for Forge, Plan & Memory
+## Task Management
+
+Discoclaw has a built-in task tracker backed by Discord forum threads. Use `taskCreate` for tracking work items — not GitHub issues and not manual thread creation.
+
+**When to create a task:**
+- TODOs or action items that come up in conversation
+- Follow-up work the user mentions but isn't ready to start
+- Bug reports, feature requests, or things to revisit later
+- Any work item the user wants tracked
+
+After creating a task, always post a link to its Discord thread so the user can jump straight to it.
+
+## Discord Action Types
 
 Use these as `<discord-action>` blocks in responses — never send `!forge`/`!plan`/`!memory` as text messages (bot-sent messages don't trigger command handlers).
 
@@ -270,6 +282,122 @@ Use planList to check existing plans before creating duplicates. Use forgeCreate
 
 Use memoryRemember to proactively store important facts (preferences, projects, tools, constraints). Pick the most specific `kind` that fits. Memory items persist across sessions, channels, and restarts.
 
+### Task Actions
+
+**taskCreate** — Create a new task:
+```
+<discord-action>{"type":"taskCreate","title":"Task title","description":"Optional details","priority":2,"tags":"feature,work"}</discord-action>
+```
+- `title` (required): Task title.
+- `description` (optional): Detailed description.
+- `priority` (optional): 0-4 (0=highest, default 2).
+- `tags` (optional): Comma-separated labels/tags.
+
+**taskUpdate** — Update a task's fields:
+```
+<discord-action>{"type":"taskUpdate","taskId":"ws-001","status":"in_progress","priority":1}</discord-action>
+```
+- `taskId` (required): Task ID.
+- `title`, `description`, `priority`, `status` (optional): Fields to update.
+
+**taskClose** — Close a task:
+```
+<discord-action>{"type":"taskClose","taskId":"ws-001","reason":"Done"}</discord-action>
+```
+
+**taskShow** — Show task details:
+```
+<discord-action>{"type":"taskShow","taskId":"ws-001"}</discord-action>
+```
+
+**taskList** — List tasks:
+```
+<discord-action>{"type":"taskList","status":"open","limit":10}</discord-action>
+```
+- `status` (optional): Filter by status (open, in_progress, blocked, closed, all).
+- `label` (optional): Filter by label.
+- `limit` (optional): Max results.
+
+**taskSync** — Run full sync between local task store and Discord threads:
+```
+<discord-action>{"type":"taskSync"}</discord-action>
+```
+
+**tagMapReload** — Reload tag map from disk (hot-reload without restart):
+```
+<discord-action>{"type":"tagMapReload"}</discord-action>
+```
+
+#### Task Quality Guidelines
+- **Title**: imperative mood, specific, <60 chars. Good: "Add retry logic to webhook handler", "Plan March Denver trip". Bad: "fix stuff".
+- **Description** should answer what/why/scope. Use markdown for structure. Include what "done" looks like for larger tasks. Max 1900 characters — the system will reject longer descriptions with an error.
+- **Priority**: P0=urgent, P1=important, P2=normal (default), P3=nice-to-have, P4=someday.
+- If the user explicitly asks to create a task, always create it.
+- Apply the same description quality standards when using taskUpdate to backfill details.
+
+Use taskList to check existing tasks before creating duplicates. Use taskShow/taskUpdate/taskClose to interact with existing tasks by ID rather than channel-name messaging.
+
+### Cron Actions (Automations)
+
+**Automations** is the user-facing name for crons. Each automation lives as a thread in a dedicated Discord forum channel (typically called "automations"). When a user says "create an automation," "set up a scheduled task," or "run X every morning/weekly/etc.," respond with `cronCreate`. Use `cronList` to check what's already running before creating a new one.
+
+**cronCreate** — Create a new scheduled task:
+```
+<discord-action>{"type":"cronCreate","name":"Morning Report","schedule":"0 7 * * 1-5","timezone":"America/Los_Angeles","channel":"general","prompt":"Generate a brief morning status update","model":"fast"}</discord-action>
+```
+- `name` (required): Human-readable name.
+- `schedule` (required): 5-field cron expression (e.g., "0 7 * * 1-5").
+- `channel` (required): Target channel name or ID.
+- `prompt` (required): The instruction text.
+- `timezone` (optional, default: system timezone, or DEFAULT_TIMEZONE env if set): IANA timezone.
+- `tags` (optional): Comma-separated purpose tags.
+- `model` (optional): "fast" or "capable" (auto-classified if omitted).
+
+**cronUpdate** — Update a cron's settings:
+```
+<discord-action>{"type":"cronUpdate","cronId":"cron-a1b2c3d4","schedule":"0 9 * * *","model":"capable"}</discord-action>
+```
+- `cronId` (required): The stable cron ID.
+- `schedule`, `timezone`, `channel`, `prompt`, `model`, `tags` (optional).
+
+**cronList** — List all cron jobs:
+```
+<discord-action>{"type":"cronList"}</discord-action>
+```
+
+**cronShow** — Show full details for a cron:
+```
+<discord-action>{"type":"cronShow","cronId":"cron-a1b2c3d4"}</discord-action>
+```
+
+**cronPause** / **cronResume** — Pause or resume a cron:
+```
+<discord-action>{"type":"cronPause","cronId":"cron-a1b2c3d4"}</discord-action>
+<discord-action>{"type":"cronResume","cronId":"cron-a1b2c3d4"}</discord-action>
+```
+
+**cronDelete** — Remove a cron job and archive its thread:
+```
+<discord-action>{"type":"cronDelete","cronId":"cron-a1b2c3d4"}</discord-action>
+```
+Note: cronDelete **archives** the thread (reversible) — it does not permanently delete it. The thread history is preserved and can be unarchived later via the Discord UI, which will re-register the cron job automatically.
+
+**cronTrigger** — Immediately execute a cron (manual fire):
+```
+<discord-action>{"type":"cronTrigger","cronId":"cron-a1b2c3d4"}</discord-action>
+```
+Note: `force` overrides are disabled in Discord actions.
+
+**cronSync** — Run full bidirectional sync:
+```
+<discord-action>{"type":"cronSync"}</discord-action>
+```
+
+**cronTagMapReload** — Reload tag map from disk and optionally trigger sync:
+```
+<discord-action>{"type":"cronTagMapReload"}</discord-action>
+```
+
 ### Model Configuration
 
 **modelShow** — Show current model assignments for all roles: