discoclaw 0.5.3 → 0.5.5

package/.env.example.full

@@ -192,14 +192,17 @@ DISCORD_GUILD_ID=
 #DISCOCLAW_DISCORD_ACTIONS_BOT_PROFILE=1
 
 # Allow the AI to defer another invocation (e.g., "check on the forge run in 10 minutes").
-# The scheduler enforces DISCOCLAW_DISCORD_ACTIONS=1, respects the requesting message's channel
-# permissions, and prevents chaining by disabling defer during the follow-up run.
+# The scheduler enforces DISCOCLAW_DISCORD_ACTIONS=1 and respects the requesting message's
+# channel permissions. Nested defers are allowed up to DEFER_MAX_DEPTH (default: 4).
 DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # Optional guard rails keep deferred invocations within safe bounds.
 # Maximum delay (seconds) the scheduler will accept for defer commands (default: 1800 / 30 min).
 #DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS=1800
 # Maximum number of pending deferred invocations allowed at once (default: 5).
 #DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT=5
+# Maximum nesting depth for deferred runs. Depth 0 = original message, depth 1 = first defer, etc.
+# When depth reaches this limit, the defer action is disabled for that run (default: 4).
+#DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH=4
 
 # Allow the AI to spawn parallel sub-agents in target channels.
 # Each spawned agent is a fire-and-forget invocation that posts output to the specified channel.

package/dist/config.js

@@ -2,6 +2,7 @@ import { parseAllowBotIds, parseAllowChannelIds, parseAllowUserIds } from './dis
 export const KNOWN_TOOLS = new Set(['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'WebSearch', 'WebFetch']);
 export const DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS = 1800;
 export const DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT = 5;
+export const DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DEPTH = 4;
 function parseBoolean(env, name, defaultValue) {
     const raw = env[name];
     if (raw == null || raw.trim() === '')
@@ -162,6 +163,7 @@ export function parseConfig(env) {
     const spawnMaxConcurrent = parsePositiveInt(env, 'DISCOCLAW_DISCORD_ACTIONS_SPAWN_MAX_CONCURRENT', 4);
     const deferMaxDelaySeconds = parsePositiveNumber(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS', DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS);
     const deferMaxConcurrent = parsePositiveInt(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT', DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT);
+    const deferMaxDepth = parsePositiveInt(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH', DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DEPTH);
     if (!discordActionsEnabled) {
         const enabledCategories = [
             { name: 'DISCOCLAW_DISCORD_ACTIONS_CHANNELS', enabled: discordActionsChannels },
@@ -366,6 +368,7 @@ export function parseConfig(env) {
             discordActionsVoice,
             discordActionsSpawn,
             deferMaxDelaySeconds,
+            deferMaxDepth,
             deferMaxConcurrent,
             spawnMaxConcurrent,
             messageHistoryBudget: parseNonNegativeInt(env, 'DISCOCLAW_MESSAGE_HISTORY_BUDGET', 3000),

package/dist/config.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { parseConfig, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS, } from './config.js';
+import { parseConfig, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS, DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DEPTH, } from './config.js';
 function env(overrides = {}) {
     return {
         DISCORD_TOKEN: 'token',
@@ -110,16 +110,28 @@ describe('parseConfig', () => {
         expect(config.discordActionsDefer).toBe(true);
         expect(config.deferMaxDelaySeconds).toBe(DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS);
         expect(config.deferMaxConcurrent).toBe(DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT);
+        expect(config.deferMaxDepth).toBe(DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DEPTH);
+        expect(config.deferMaxDepth).toBe(4);
     });
     it('parses defer config overrides', () => {
         const { config } = parseConfig(env({
             DISCOCLAW_DISCORD_ACTIONS_DEFER: '1',
             DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS: '900',
             DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT: '2',
+            DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH: '8',
         }));
         expect(config.discordActionsDefer).toBe(true);
         expect(config.deferMaxDelaySeconds).toBe(900);
         expect(config.deferMaxConcurrent).toBe(2);
+        expect(config.deferMaxDepth).toBe(8);
+    });
+    it('throws on non-positive or non-integer deferMaxDepth', () => {
+        expect(() => parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH: '0' })))
+            .toThrow(/DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH must be a positive number/);
+        expect(() => parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH: '-1' })))
+            .toThrow(/DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH must be a positive number/);
+        expect(() => parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH: '2.5' })))
+            .toThrow(/DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH must be an integer/);
     });
     it('reports ignored action category flags as info-level advisories', () => {
         const { warnings, infos } = parseConfig(env({

package/dist/discord/actions.js

@@ -681,7 +681,7 @@ If an action fails with a "Missing Permissions" or "Missing Access" error, tell
 4. The bot may need to be re-invited with the "moderator" permission profile if the role wasn't granted at invite time.`);
     if (flags.defer) {
         sections.push(`### Deferred self-invocation
-Use a <discord-action>{"type":"defer","channel":"general","delaySeconds":600,"prompt":"Check on the forge run"}</discord-action> block to schedule a follow-up run inside the requested channel without another user prompt. You must specify the channel by name or ID; delaySeconds is how long to wait (capped by DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS) and prompt becomes the user message when the deferred invocation runs. The scheduler enforces DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT pending jobs, respects the same channel permissions as this response, automatically posts the follow-up output, and forces \`defer\` off during that run so no chains can form. If a guard rail rejects the request (too long, too many active defers, missing permissions, or the channel becomes invalid) the action fails with an explanatory message.`);
+Use a <discord-action>{"type":"defer","channel":"general","delaySeconds":600,"prompt":"Check on the forge run"}</discord-action> block to schedule a follow-up run inside the requested channel without another user prompt. You must specify the channel by name or ID; delaySeconds is how long to wait (capped by DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS) and prompt becomes the user message when the deferred invocation runs. The scheduler enforces DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT pending jobs, respects the same channel permissions as this response, automatically posts the follow-up output, and allows nested defers up to the configured depth limit (DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH, default 4); once the limit is reached, \`defer\` is disabled for that run. If a guard rail rejects the request (too long, too many active defers, missing permissions, or the channel becomes invalid) the action fails with an explanatory message.`);
     }
     return sections.join('\n\n');
 }

package/dist/discord/actions.test.js

@@ -626,7 +626,7 @@ describe('discordActionsPromptSection', () => {
         expect(prompt).toContain('without another user prompt');
         expect(prompt).toContain('DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS');
         expect(prompt).toContain('DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT');
-        expect(prompt).toContain('forces `defer` off');
+        expect(prompt).toContain('DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DEPTH');
     });
 });
 // ---------------------------------------------------------------------------

package/dist/discord/deferred-runner.js

@@ -20,7 +20,7 @@ function getThreadParentId(candidate) {
         return null;
     return String(channel.parentId);
 }
-function buildDeferredActionFlags(state) {
+function buildDeferredActionFlags(state, depth, maxDepth) {
     return {
         channels: state.discordActionsChannels,
         messaging: state.discordActionsMessaging,
@@ -35,7 +35,7 @@ function buildDeferredActionFlags(state) {
         // Deferred runs do not carry a user identity, so memory actions stay disabled.
         memory: false,
         config: Boolean(state.discordActionsConfig),
-        defer: false,
+        defer: depth < maxDepth,
         imagegen: Boolean(state.discordActionsImagegen),
         voice: Boolean(state.discordActionsVoice),
     };
@@ -82,7 +82,8 @@ export function configureDeferredScheduler(opts) {
                 opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:context inline failed');
             }
         }
-        const deferredActionFlags = buildDeferredActionFlags(opts.state);
+        const deferDepth = (context.deferDepth ?? 0) + 1;
+        const deferredActionFlags = buildDeferredActionFlags(opts.state, deferDepth, opts.deferMaxDepth);
         const openTasksSection = buildOpenTasksSection(opts.state.taskCtx?.store);
         let prompt = buildPromptPreamble(inlinedContext) + '\n\n' +
             (openTasksSection
@@ -179,6 +180,8 @@ export function configureDeferredScheduler(opts) {
             channelId: channel.id,
             messageId: `defer-${Date.now()}`,
             threadParentId,
+            deferScheduler: context.deferScheduler,
+            deferDepth,
             transport: new DiscordTransportClient(guild, context.client),
             confirmation: {
                 mode: 'automated',

package/dist/discord/deferred-runner.test.js

@@ -76,6 +76,7 @@ function makeOpts(overrides = {}) {
     return {
         maxDelaySeconds: 3600,
         maxConcurrent: 5,
+        deferMaxDepth: 4,
         state: makeState(),
         runtime: makeRuntime([{ type: 'text_final', text: 'Hello' }, { type: 'done' }]),
         runtimeTools: [],
@@ -221,4 +222,81 @@ describe('deferred-runner observability', () => {
         scheduler.schedule({ action: makeAction(), context: makeContext() });
         await expect(vi.advanceTimersByTimeAsync(2000)).resolves.not.toThrow();
     });
+    it('flags have defer: true when depth is below maxDepth', async () => {
+        const { parseDiscordActions } = await import('./actions.js');
+        const mockParse = parseDiscordActions;
+        mockParse.mockClear();
+        mockParse.mockReturnValue({
+            actions: [],
+            cleanText: 'ok',
+            strippedUnrecognizedTypes: [],
+            parseFailures: 0,
+        });
+        const opts = makeOpts({ deferMaxDepth: 4 });
+        const scheduler = configureDeferredScheduler(opts);
+        // context with no deferDepth (defaults to 0) → depth becomes 1, which is < 4
+        scheduler.schedule({ action: makeAction(), context: makeContext() });
+        await vi.advanceTimersByTimeAsync(2000);
+        const flags = mockParse.mock.calls[0][1];
+        expect(flags.defer).toBe(true);
+    });
+    it('flags have defer: false when depth equals maxDepth', async () => {
+        const { parseDiscordActions } = await import('./actions.js');
+        const mockParse = parseDiscordActions;
+        mockParse.mockClear();
+        mockParse.mockReturnValue({
+            actions: [],
+            cleanText: 'ok',
+            strippedUnrecognizedTypes: [],
+            parseFailures: 0,
+        });
+        const opts = makeOpts({ deferMaxDepth: 4 });
+        const scheduler = configureDeferredScheduler(opts);
+        // context with deferDepth 3 → depth becomes 4, which equals maxDepth
+        const ctx = { ...makeContext(), deferDepth: 3 };
+        scheduler.schedule({ action: makeAction(), context: ctx });
+        await vi.advanceTimersByTimeAsync(2000);
+        const flags = mockParse.mock.calls[0][1];
+        expect(flags.defer).toBe(false);
+    });
+    it('actCtx carries deferDepth incremented by 1 from incoming context', async () => {
+        const { parseDiscordActions, executeDiscordActions } = await import('./actions.js');
+        const mockParse = parseDiscordActions;
+        const mockExecute = executeDiscordActions;
+        mockParse.mockClear();
+        mockExecute.mockClear();
+        mockParse.mockReturnValue({
+            actions: [{ type: 'sendMessage', content: 'hi' }],
+            cleanText: '',
+            strippedUnrecognizedTypes: [],
+            parseFailures: 0,
+        });
+        mockExecute.mockResolvedValue([{ ok: true, summary: 'sent' }]);
+        const opts = makeOpts({ deferMaxDepth: 4 });
+        const scheduler = configureDeferredScheduler(opts);
+        const ctx = { ...makeContext(), deferDepth: 2 };
+        scheduler.schedule({ action: makeAction(), context: ctx });
+        await vi.advanceTimersByTimeAsync(2000);
+        const actCtx = mockExecute.mock.calls[0][1];
+        expect(actCtx.deferDepth).toBe(3);
+    });
+    it('deferMaxDepth 1 allows first level but blocks second', async () => {
+        const { parseDiscordActions } = await import('./actions.js');
+        const mockParse = parseDiscordActions;
+        // First level: deferDepth undefined → depth = 1, maxDepth = 1 → defer: false
+        mockParse.mockClear();
+        mockParse.mockReturnValue({
+            actions: [],
+            cleanText: 'ok',
+            strippedUnrecognizedTypes: [],
+            parseFailures: 0,
+        });
+        const opts = makeOpts({ deferMaxDepth: 1 });
+        const scheduler = configureDeferredScheduler(opts);
+        scheduler.schedule({ action: makeAction(), context: makeContext() });
+        await vi.advanceTimersByTimeAsync(2000);
+        // depth = 0 + 1 = 1, maxDepth = 1 → 1 < 1 is false → defer: false
+        const flags = mockParse.mock.calls[0][1];
+        expect(flags.defer).toBe(false);
+    });
 });

package/dist/discord/update-command.js

@@ -97,7 +97,8 @@ export async function handleUpdateCommand(cmd, opts = {}) {
     }
     if (npmMode) {
         progress('Installing latest version from npm...');
-        const install = await run('npm', ['install', '-g', 'discoclaw@latest', '--loglevel=error'], { timeout: 120_000 });
+        const npmEnv = { ...process.env, CFLAGS: '-Wno-incompatible-pointer-types' };
+        const install = await run('npm', ['install', '-g', 'discoclaw@latest', '--loglevel=error'], { timeout: 120_000, env: npmEnv });
         if (install.exitCode !== 0) {
             const detail = (install.stderr || install.stdout).trim().slice(0, 500);
             return { reply: `\`npm install -g discoclaw@latest\` failed:\n\`\`\`\n${detail}\n\`\`\`` };

package/dist/index.js

@@ -866,6 +866,7 @@ if (discordActionsEnabled && cfg.discordActionsDefer) {
     deferOpts = {
         maxDelaySeconds: cfg.deferMaxDelaySeconds,
         maxConcurrent: cfg.deferMaxConcurrent,
+        deferMaxDepth: cfg.deferMaxDepth,
         state: botParams,
         runtime,
         runtimeTools,

package/dist/npm-managed.js

@@ -50,6 +50,7 @@ export async function npmGlobalUpgrade() {
     try {
         const result = await execa('npm', ['install', '-g', 'discoclaw', '--loglevel=error'], {
             timeout: 120_000,
+            env: { ...process.env, CFLAGS: '-Wno-incompatible-pointer-types' },
         });
         return {
             exitCode: result.exitCode ?? 0,

package/dist/npm-managed.test.js

@@ -83,6 +83,7 @@ describe('npmGlobalUpgrade', () => {
         expect(result.stderr).toBe('');
         expect(mockExeca).toHaveBeenCalledWith('npm', ['install', '-g', 'discoclaw', '--loglevel=error'], {
             timeout: 120_000,
+            env: expect.objectContaining({ CFLAGS: '-Wno-incompatible-pointer-types' }),
         });
     });
     it('returns a non-zero exitCode and stderr when npm install fails', async () => {

package/package.json

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