discoclaw 1.0.0 → 1.1.1

package/.context/dev.md

@@ -171,18 +171,18 @@ Two setup paths:
 ### Plan & Forge
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `DISCOCLAW_PLAN_COMMANDS_ENABLED` | `1` | Enable plan commands (`!plan`, `!plan phase`, etc.) |
-| `PLAN_PHASES_ENABLED` | `1` | Enable phase-by-phase plan execution |
+| `DISCOCLAW_PLAN_COMMANDS_ENABLED` | `0` | Enable plan commands (`!plan`, `!plan phase`, etc.) |
+| `PLAN_PHASES_ENABLED` | `0` | Enable phase-by-phase plan execution |
 | `PLAN_PHASE_MAX_CONTEXT_FILES` | `5` | Max `.context/` files injected per plan phase |
 | `PLAN_PHASE_TIMEOUT_MS` | `1800000` | Per-phase timeout in milliseconds |
 | `PLAN_PHASE_AUDIT_FIX_MAX` | `3` | Max audit-fix attempts per phase before giving up |
-| `DISCOCLAW_FORGE_COMMANDS_ENABLED` | `1` | Enable forge commands (`!forge`) |
+| `DISCOCLAW_FORGE_COMMANDS_ENABLED` | `0` | Enable forge commands (`!forge`) |
 | `FORGE_MAX_AUDIT_ROUNDS` | `5` | Max audit rounds before forge accepts the draft |
 | `FORGE_DRAFTER_MODEL` | *(empty — uses `RUNTIME_MODEL`)* | Override model for the forge drafter step |
 | `FORGE_AUDITOR_MODEL` | *(empty — uses `RUNTIME_MODEL`)* | Override model for the forge auditor step |
 | `FORGE_TIMEOUT_MS` | `1800000` | Per-forge-session timeout in milliseconds |
 | `FORGE_PROGRESS_THROTTLE_MS` | `3000` | Min ms between forge progress Discord updates |
-| `FORGE_AUTO_IMPLEMENT` | `1` | Automatically implement the approved forge plan without a separate confirm step |
+| `FORGE_AUTO_IMPLEMENT` | `0` | Automatically implement the approved forge plan without a separate confirm step |
 | `FORGE_DRAFTER_RUNTIME` | *(empty — uses `PRIMARY_RUNTIME`)* | Runtime adapter for the forge drafter (e.g. `openai`, `claude`) |
 | `FORGE_AUDITOR_RUNTIME` | *(empty — uses `PRIMARY_RUNTIME`)* | Runtime adapter for the forge auditor |
 

package/.context/pa.md

@@ -4,25 +4,7 @@ Generic PA rules. Personal customizations go in `workspace/AGENTS.md`.
 
 ## Self-Awareness
 
-You are a DiscoClaw bot — a personal AI orchestrator that coordinates between Discord, AI runtimes, and local system resources. You don't contain the intelligence yourself; the orchestrator decides when to call you, what context to give you, and what to do with your output.
-For architecture details, see `.context/architecture.md`.
-
-## Workspace Files
-
-| File | Purpose | Owner | Loaded |
-|------|---------|-------|--------|
-| `SOUL.md` | Core personality and values | User | Every prompt |
-| `IDENTITY.md` | Name and vibe | User | Every prompt |
-| `USER.md` | Who you're helping | User | Every prompt |
-| `templates/instructions/SYSTEM_DEFAULTS.md` | Tracked default instructions (runtime-injected) | Discoclaw repo (tracked) | Every prompt |
-| `AGENTS.md` | Personal rules and preferences | User (never overwritten) | Every prompt |
-| `TOOLS.md` | Available tools and integrations | Discoclaw | Every prompt |
-| `MEMORY.md` | Curated long-term memory | User | DM prompts |
-| `BOOTSTRAP.md` | First-run onboarding (deleted after) | User | Once |
-
-Templates live in `templates/workspace/` and are scaffolded on first run (copy-if-missing).
-Tracked defaults come from `templates/instructions/SYSTEM_DEFAULTS.md` and are injected at runtime.
-Legacy `workspace/DISCOCLAW.md` files are not authoritative.
+You are a DiscoClaw bot — a personal AI orchestrator coordinating Discord, AI runtimes, and local system resources.
 
 ## Operational Essentials
 
@@ -41,74 +23,30 @@ Legacy `workspace/DISCOCLAW.md` files are not authoritative.
 
 ## Group Chat Etiquette
 
-You have access to your human's stuff. That doesn't mean you share it.
-In groups, you're a participant — not their voice, not their proxy.
+You're a participant, not the user's proxy. Don't share their private info.
 
-**Respond when:**
-- Directly mentioned or asked a question
-- You can add genuine value (info, insight, help)
-- Something witty/funny fits naturally
-- Correcting important misinformation
+**Respond** to direct mentions, genuine questions, chances to add value, or natural humor/corrections.
+**Stay silent (HEARTBEAT_OK)** for casual banter, already-answered questions, "yeah/nice" responses, or when adding a message would interrupt flow.
 
-**Stay silent (HEARTBEAT_OK) when:**
-- It's just casual banter between humans
-- Someone already answered the question
-- Your response would just be "yeah" or "nice"
-- The conversation is flowing fine without you
-- Adding a message would interrupt the vibe
-
-**The human rule:** Humans don't respond to every message. Neither should you.
-Quality > quantity. Avoid the triple-tap (don't respond multiple times to the same message).
+Humans don't respond to every message — neither should you. Quality > quantity. No triple-taps.
 
 ### Reactions
 
-Use emoji reactions naturally — they're lightweight social signals:
-- Appreciate something but don't need to reply (thumbs up, heart)
-- Something made you laugh (laughing face, skull)
-- Acknowledge without interrupting flow (checkmark, eyes)
-- One reaction per message max.
-
-When someone reacts to a message, acknowledge it with a brief response.
-Reactions are a form of communication — treat them like a tap on the shoulder.
-
-Participate, don't dominate.
+Use emoji reactions as lightweight social signals (appreciate, laugh, acknowledge). One per message max. Acknowledge reactions on your messages briefly.
 
 ## Memory
 
-Your prompt may include two memory sections injected by the system:
-
-**Durable memory** — Persistent facts/preferences about the user that survive across sessions.
-Treat as ground truth unless explicitly contradicted. Don't repeat them back unprompted.
-
-**Conversation memory** — Rolling summary of recent conversation. Lossy and compressed.
-If it conflicts with recent messages, trust the recent messages.
-
-Memory commands (handled by the system, not you):
-- `!memory` or `!memory show` — see stored items + rolling summary
-- `!memory remember <text>` — store a new fact
-- `!memory forget <text>` — remove matching items
-- `!memory reset rolling` — clear the rolling summary
-
-See `.context/memory.md` for full architecture, examples, and config reference.
+Your prompt may include:
+- **Durable memory** — Persistent user facts/preferences. Treat as ground truth unless contradicted.
+- **Conversation memory** — Rolling summary, lossy. Trust recent messages over summary if they conflict.
 
 ## Autonomy Tiers
 
-### Always OK (no permission needed)
-- Read files, explore, search the web, run diagnostics
-- Send Discord messages, react with emoji
-- Share finds in relevant channels, report back on async tasks
-- Work within the workspace
+**Always OK:** Read files, explore, search web, run diagnostics, send Discord messages, react, share finds, work within workspace.
 
-### Act Then Notify (time-sensitive)
-- For **confirmed, active** security threats: take reversible protective actions, then notify
-- For ambiguous threats: alert first, wait for decision
+**Act Then Notify:** Confirmed active security threats — take reversible action, then notify. Ambiguous threats — alert first.
 
-### Always Ask First
-- External communications (emails, messages to others, posting on someone's behalf)
-- Changes to the user's creative projects
-- System changes (package installs, systemd modifications, firewall/network)
-- Destructive actions (deleting files, dropping databases, revoking credentials)
-- Anything involving money
+**Always Ask:** External communications, creative project changes, system changes (packages, systemd, network), destructive actions, anything involving money.
 
 ## Execution Policy (Local Machine)
 
@@ -116,13 +54,3 @@ See `.context/memory.md` for full architecture, examples, and config reference.
 - Ask before: destructive ops, system-wide changes
 - Never retry sudo. If auth is needed, give the user the command to run.
 
-## Customization
-
-Instruction precedence is deterministic:
-1. immutable security policy (`ROOT_POLICY`)
-2. tracked defaults (`templates/instructions/SYSTEM_DEFAULTS.md`)
-3. `workspace/AGENTS.md` overrides
-4. memory/context sections
-
-Customize behavior in `workspace/AGENTS.md` (user-owned, never overwritten).
-Do not rely on `workspace/DISCOCLAW.md`; defaults are sourced from the tracked template and injected at runtime.

package/.env.example.full

@@ -217,11 +217,11 @@ DISCORD_GUILD_ID=
 #DISCOCLAW_DISCORD_ACTIONS_POLLS=1
 #DISCOCLAW_DISCORD_ACTIONS_TASKS=1
 # Allow the AI to self-initiate forge runs (draft + audit loops) via action blocks.
-# Requires DISCOCLAW_FORGE_COMMANDS_ENABLED=1. Only one forge at a time. Default: 1.
-#DISCOCLAW_DISCORD_ACTIONS_FORGE=1
+# Requires DISCOCLAW_FORGE_COMMANDS_ENABLED=1. Only one forge at a time. Default: 0.
+#DISCOCLAW_DISCORD_ACTIONS_FORGE=0
 # Allow the AI to create, inspect, approve, run, and close plans via action blocks.
-# Requires DISCOCLAW_PLAN_COMMANDS_ENABLED=1. Default: 1.
-#DISCOCLAW_DISCORD_ACTIONS_PLAN=1
+# Requires DISCOCLAW_PLAN_COMMANDS_ENABLED=1. Default: 0.
+#DISCOCLAW_DISCORD_ACTIONS_PLAN=0
 # Allow the AI to read/write durable memory (facts, preferences) via action blocks.
 # Requires DISCOCLAW_DURABLE_MEMORY_ENABLED=1. Default: 1.
 #DISCOCLAW_DISCORD_ACTIONS_MEMORY=1
@@ -541,9 +541,10 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # ----------------------------------------------------------
 # Plan & Forge — AI-assisted planning and implementation
 # ----------------------------------------------------------
-# Enable/disable !plan and !forge commands.
-#DISCOCLAW_PLAN_COMMANDS_ENABLED=1
-#DISCOCLAW_FORGE_COMMANDS_ENABLED=1
+# Enable/disable !plan and !forge commands. Default: 0 (off).
+# When off, !plan and !forge respond with a friendly nudge explaining how to enable.
+#DISCOCLAW_PLAN_COMMANDS_ENABLED=0
+#DISCOCLAW_FORGE_COMMANDS_ENABLED=0
 # Phase decomposition for approved plans.
 #PLAN_PHASES_ENABLED=1
 # Max files per phase batch during decomposition.

package/dist/canvas/canvas-action.js

@@ -12,15 +12,9 @@ const CANVAS_VOID_ELEMENT_TAG_RE = /<(area|base|br|col|embed|hr|img|input|link|m
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const CANVAS_PROMPT_TEMPLATE_PATH = path.resolve(__dirname, '..', '..', 'templates', 'instructions', 'canvas.md');
-const CANVAS_EXPERIMENTAL_POSTURE_NOTE = [
-    'Canvas Activities are experimental and default-off in DiscoClaw.',
-    'Fresh installs and upgraded installs both require an explicit opt-in via `DISCOCLAW_CANVAS_ENABLED=1`, followed by a bot restart.',
-].join(' ');
-const DEFAULT_SAVE_BRIDGE_GUIDANCE = [
-    '- Save-file export is available through the trusted shell bridge when enabled.',
-    '- To export a file from inside the artifact, post a message to the parent shell:',
-    '  `window.parent.postMessage({ type: "canvas.saveFile", suggestedName: "report.md", mimeType: "text/markdown", encoding: "utf8", content: "# Report" }, "*")`',
-].join('\n');
+const CANVAS_SETUP_POSTURE_NOTE = 'Canvas Activities are experimental and default-off in DiscoClaw.' +
+    ' Fresh installs and upgraded installs both require an explicit opt-in via `DISCOCLAW_CANVAS_ENABLED=1`, followed by a bot restart.';
+const DEFAULT_SAVE_BRIDGE_GUIDANCE = '- Save-file export: `window.parent.postMessage({ type: "canvas.saveFile", suggestedName: "report.md", mimeType: "text/markdown", encoding: "utf8", content: "..." }, "*")`';
 let cachedCanvasPromptTemplate = null;
 export const CANVAS_ACTION_TYPES = new Set(['launchCanvas']);
 export const CANVAS_LAUNCH_COMPONENT_PREFIX = 'canvas:launch:';
@@ -57,7 +51,7 @@ export function buildCanvasSetupRequiredStub(canvasCtx) {
             'Enable Activities on the Discord application in the Developer Portal (Application → Activities → Enable). Requires the URL Mapping first.',
         ],
     };
-    return [CANVAS_EXPERIMENTAL_POSTURE_NOTE, buildCanvasSetupWalkthrough(readiness)].join(' ');
+    return [CANVAS_SETUP_POSTURE_NOTE, buildCanvasSetupWalkthrough(readiness)].join(' ');
 }
 export function shouldCanvasPromptBeSurfaced(canvasCtx, userText) {
     if (!canvasCtx?.enabled)
@@ -281,49 +275,7 @@ function findCanvasArtifactLintError(content) {
 function loadCanvasPromptTemplate() {
     if (cachedCanvasPromptTemplate != null)
         return cachedCanvasPromptTemplate;
-    try {
-        cachedCanvasPromptTemplate = fs.readFileSync(CANVAS_PROMPT_TEMPLATE_PATH, 'utf8').trim();
-    }
-    catch {
-        cachedCanvasPromptTemplate = [
-            '### Canvas Activities',
-            '',
-            '**launchCanvas** — Generate and serve an interactive HTML artifact or built-in app in a Discord Activity panel:',
-            '```',
-            '<discord-action>{"type":"launchCanvas","title":"Tax Calculator","content":"<!doctype html><html><head><meta charset=\\"utf-8\\" /><meta name=\\"viewport\\" content=\\"width=device-width,initial-scale=1\\" /><style>body{font-family:sans-serif;padding:16px}label,input{display:block;margin-top:12px}</style></head><body><div id=\\"app\\"></div><script>const { html, render, useState } = window.canvasRuntime;function TaxCalculator(){const [income,setIncome]=useState(50000);const tax=Math.round(income*0.22);return html`<main><h1>Tax Calculator</h1><label>Income <input type=\\"number\\" value=${income} onInput=${(event)=>setIncome(Number(event.currentTarget.value||0))} /></label><p>Estimated tax: $${tax.toLocaleString()}</p></main>`;}render(TaxCalculator, document.getElementById(\\"app\\"));</script></body></html>"}</discord-action>',
-            '<discord-action>{"type":"launchCanvas","title":"Dashboard","app":"dashboard"}</discord-action>',
-            '```',
-            '- `title` (required): Human-readable label for the launch button.',
-            '- `content` (artifact mode): Full self-contained HTML document with all CSS and JS inline.',
-            '- `app` (built-in mode): Named built-in Activity app such as `dashboard`.',
-            '- Use canvas only when interactivity materially improves the result over plain text.',
-            '- Default is plain text. Do not use canvas for short answers, conversational replies, or single values.',
-            '- Good fits: calculators, forms, charts, diffs, large comparison views, filterable tables, live dashboard launches.',
-            '- Bad fits: simple status updates, brief explanations, or anything the user explicitly wants as plain text.',
-            '- Artifact render responses inject `window.canvasRuntime`; use that built-in runtime instead of bundling React, Preact, Vue, or another UI framework.',
-            '- The injected runtime exposes `html`, `render`, and the installed `preact/hooks` surface: `useState`, `useEffect`, `useLayoutEffect`, `useReducer`, `useRef`, `useMemo`, `useCallback`, `useContext`, `useImperativeHandle`, `useDebugValue`, `useErrorBoundary`, and `useId`.',
-            '- Start interactive artifacts with `const { html, render, useState } = window.canvasRuntime`; keep the starter small unless the artifact actually needs more hook surface, and mount into a dedicated root node.',
-            '- In `html` template literals, self-close void HTML elements: use `<input ... />`, `<img ... />`, `<br />`, etc. Bare `<input>` tags can corrupt the rendered DOM in canvas artifacts.',
-            '- Generated artifacts must be a single HTML file, responsive at phone width, and keep total size under roughly 500KB.',
-            '- No external scripts, stylesheets, fonts, images, or nested iframes in generated artifacts.',
-            '- Generated artifacts run inside a sandboxed iframe and cannot call backend routes directly.',
-            '- Artifacts are stored under a cap-based LRU policy; they are not time-expired in v1.',
-            '- Include visible loading/error/fallback states when the UI depends on JavaScript.',
-            '- Default visual direction: feel at home in Discord without mimicking Discord\'s UI chrome.',
-            '- Favor Discord-adjacent contrast and restraint for dark surroundings, but choose colors and themes based on the content instead of cloning Discord\'s palette by default.',
-            '- Use explicitly Discord-like styling only when the user asks for a native/control-panel/admin-tool feel.',
-            '- Prefer semantic HTML, clear contrast, and obvious focus states.',
-            '{{CANVAS_SAVE_BRIDGE_GUIDANCE}}',
-        ].join('\n');
-    }
-    if (!cachedCanvasPromptTemplate.includes(CANVAS_EXPERIMENTAL_POSTURE_NOTE)) {
-        if (cachedCanvasPromptTemplate.startsWith('### Canvas Activities')) {
-            cachedCanvasPromptTemplate = cachedCanvasPromptTemplate.replace('### Canvas Activities', `### Canvas Activities\n\n${CANVAS_EXPERIMENTAL_POSTURE_NOTE}`);
-        }
-        else {
-            cachedCanvasPromptTemplate = `${CANVAS_EXPERIMENTAL_POSTURE_NOTE}\n\n${cachedCanvasPromptTemplate}`;
-        }
-    }
+    cachedCanvasPromptTemplate = fs.readFileSync(CANVAS_PROMPT_TEMPLATE_PATH, 'utf8').trim();
     return cachedCanvasPromptTemplate;
 }
 function buildLaunchActivityFailureMessage(err) {

package/dist/canvas/canvas-action.test.js

@@ -1,5 +1,4 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -81,13 +80,11 @@ async function makeCanvasContext() {
     return canvasCtx;
 }
 describe('canvas-action', () => {
-    it('surfaces the injected canvas runtime contract from the checked-in prompt template', async () => {
+    it('surfaces the canvas runtime contract from the checked-in prompt template', async () => {
         vi.resetModules();
         const { canvasActionsPromptSection } = await import('./canvas-action.js');
         const prompt = canvasActionsPromptSection({ writeBridgeEnabled: true });
         expect(prompt).toContain('experimental and default-off');
-        expect(prompt).toContain('DISCOCLAW_CANVAS_ENABLED=1');
-        expect(prompt).toContain('Fresh installs and upgraded installs both require an explicit opt-in');
         expect(prompt).toContain('window.canvasRuntime');
         expect(prompt).toContain('installed `preact/hooks` surface');
         expect(prompt).toContain('`useLayoutEffect`');
@@ -96,36 +93,27 @@ describe('canvas-action', () => {
         expect(prompt).toContain('Bare `<input>` tags can corrupt the rendered DOM');
         expect(prompt).toContain('feel at home in Discord without mimicking Discord');
         expect(prompt).toContain('instead of cloning Discord\'s palette by default');
+        expect(prompt).toContain('canvas.saveFile');
+        expect(prompt).not.toContain('{{CANVAS_SAVE_BRIDGE_GUIDANCE}}');
     });
-    it('documents the injected canvas runtime in fallback prompt text and preserves save-bridge substitution', async () => {
+    it('omits save-bridge guidance when writeBridgeEnabled is false', async () => {
         vi.resetModules();
-        vi.spyOn(fsSync, 'readFileSync').mockImplementation(() => {
-            throw new Error('template unavailable');
-        });
         const { canvasActionsPromptSection } = await import('./canvas-action.js');
-        const withSaveBridge = canvasActionsPromptSection({ writeBridgeEnabled: true });
-        expect(withSaveBridge).toContain('experimental and default-off');
-        expect(withSaveBridge).toContain('DISCOCLAW_CANVAS_ENABLED=1');
-        expect(withSaveBridge).toContain('Fresh installs and upgraded installs both require an explicit opt-in');
-        expect(withSaveBridge).toContain('window.canvasRuntime');
-        expect(withSaveBridge).toContain('installed `preact/hooks` surface');
-        expect(withSaveBridge).toContain('`useErrorBoundary`');
-        expect(withSaveBridge).toContain('const { html, render, useState } = window.canvasRuntime');
-        expect(withSaveBridge).toContain('self-close void HTML elements');
-        expect(withSaveBridge).toContain('feel at home in Discord without mimicking Discord');
-        expect(withSaveBridge).toContain('canvas.saveFile');
-        expect(withSaveBridge).not.toContain('{{CANVAS_SAVE_BRIDGE_GUIDANCE}}');
         const withoutSaveBridge = canvasActionsPromptSection({ writeBridgeEnabled: false });
         expect(withoutSaveBridge).toContain('experimental and default-off');
-        expect(withoutSaveBridge).toContain('DISCOCLAW_CANVAS_ENABLED=1');
         expect(withoutSaveBridge).toContain('window.canvasRuntime');
         expect(withoutSaveBridge).toContain('installed `preact/hooks` surface');
-        expect(withoutSaveBridge).toContain('`useId`');
         expect(withoutSaveBridge).toContain('Bare `<input>` tags can corrupt the rendered DOM');
-        expect(withoutSaveBridge).toContain('instead of cloning Discord\'s palette by default');
         expect(withoutSaveBridge).not.toContain('canvas.saveFile');
         expect(withoutSaveBridge).not.toContain('{{CANVAS_SAVE_BRIDGE_GUIDANCE}}');
     });
+    it('does not inject the setup posture note into the prompt template', async () => {
+        vi.resetModules();
+        const { canvasActionsPromptSection } = await import('./canvas-action.js');
+        const prompt = canvasActionsPromptSection({ writeBridgeEnabled: true });
+        expect(prompt).not.toContain('DISCOCLAW_CANVAS_ENABLED=1');
+        expect(prompt).not.toContain('Fresh installs and upgraded installs both require an explicit opt-in');
+    });
     it('describes canvas setup as experimental and explicit opt-in', async () => {
         vi.resetModules();
         const { buildCanvasSetupRequiredStub } = await import('./canvas-action.js');

package/dist/config.js

@@ -384,8 +384,8 @@ export function parseConfig(env) {
     const discordActionsTasks = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_TASKS', true);
     const discordActionsCrons = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_CRONS', true);
     const discordActionsBotProfile = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_BOT_PROFILE', true);
-    const discordActionsForge = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_FORGE', true);
-    const discordActionsPlan = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_PLAN', true);
+    const discordActionsForge = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_FORGE', false);
+    const discordActionsPlan = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_PLAN', false);
     const discordActionsMemory = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_MEMORY', true);
     const discordActionsDefer = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER', true);
     const discordActionsLoop = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_LOOP', true);
@@ -694,6 +694,8 @@ export function parseConfig(env) {
             loopMaxIntervalSeconds,
             loopMaxConcurrent,
             messageHistoryBudget: parseNonNegativeInt(env, 'DISCOCLAW_MESSAGE_HISTORY_BUDGET', 3000),
+            messageHistoryFetchLimit: parsePositiveInt(env, 'DISCOCLAW_MESSAGE_HISTORY_FETCH_LIMIT', 10),
+            messageHistoryMaxAgeMs: parsePositiveInt(env, 'DISCOCLAW_MESSAGE_HISTORY_MAX_AGE_HOURS', 48) * 3_600_000,
             summaryEnabled: parseBoolean(env, 'DISCOCLAW_SUMMARY_ENABLED', true),
             summaryModel: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_MODEL') ?? fastModel,
             summaryMaxChars: parseNonNegativeInt(env, 'DISCOCLAW_SUMMARY_MAX_CHARS', 2000),
@@ -710,19 +712,19 @@ export function parseConfig(env) {
             memoryConsolidationThreshold: parsePositiveInt(env, 'DISCOCLAW_MEMORY_CONSOLIDATION_THRESHOLD', 50),
             memoryConsolidationModel: parseTrimmedString(env, 'DISCOCLAW_MEMORY_CONSOLIDATION_MODEL') ?? fastModel,
             memoryCommandsEnabled: parseBoolean(env, 'DISCOCLAW_MEMORY_COMMANDS_ENABLED', true),
-            planCommandsEnabled: parseBoolean(env, 'DISCOCLAW_PLAN_COMMANDS_ENABLED', true),
-            planPhasesEnabled: parseBoolean(env, 'PLAN_PHASES_ENABLED', true),
+            planCommandsEnabled: parseBoolean(env, 'DISCOCLAW_PLAN_COMMANDS_ENABLED', false),
+            planPhasesEnabled: parseBoolean(env, 'PLAN_PHASES_ENABLED', parseBoolean(env, 'DISCOCLAW_PLAN_COMMANDS_ENABLED', false)),
             planPhaseMaxContextFiles: parsePositiveInt(env, 'PLAN_PHASE_MAX_CONTEXT_FILES', 5),
             planPhaseTimeoutMs: parsePositiveNumber(env, 'PLAN_PHASE_TIMEOUT_MS', DEFAULT_THIRTY_MINUTES_MS),
             planPhaseMaxAuditFixAttempts: parseNonNegativeInt(env, 'PLAN_PHASE_AUDIT_FIX_MAX', 3),
             planForgeHeartbeatIntervalMs: parseNonNegativeInt(env, 'PLAN_FORGE_HEARTBEAT_INTERVAL_MS', DEFAULT_PLAN_FORGE_HEARTBEAT_INTERVAL_MS),
-            forgeCommandsEnabled: parseBoolean(env, 'DISCOCLAW_FORGE_COMMANDS_ENABLED', true),
+            forgeCommandsEnabled: parseBoolean(env, 'DISCOCLAW_FORGE_COMMANDS_ENABLED', false),
             forgeMaxAuditRounds: parsePositiveInt(env, 'FORGE_MAX_AUDIT_ROUNDS', 5),
             forgeDrafterModel: parseTrimmedString(env, 'FORGE_DRAFTER_MODEL'),
             forgeAuditorModel: parseTrimmedString(env, 'FORGE_AUDITOR_MODEL'),
             forgeTimeoutMs: parsePositiveNumber(env, 'FORGE_TIMEOUT_MS', DEFAULT_THIRTY_MINUTES_MS),
             forgeProgressThrottleMs: parseNonNegativeInt(env, 'FORGE_PROGRESS_THROTTLE_MS', 3000),
-            forgeAutoImplement: parseBoolean(env, 'FORGE_AUTO_IMPLEMENT', true),
+            forgeAutoImplement: parseBoolean(env, 'FORGE_AUTO_IMPLEMENT', parseBoolean(env, 'DISCOCLAW_FORGE_COMMANDS_ENABLED', false)),
             completionNotifyEnabled: parseBoolean(env, 'DISCOCLAW_COMPLETION_NOTIFY', true),
             completionNotifyThresholdMs: parseNonNegativeInt(env, 'DISCOCLAW_COMPLETION_NOTIFY_THRESHOLD_MS', 30000),
             actionFollowupTimeoutMs: parseNonNegativeInt(env, 'DISCOCLAW_ACTION_FOLLOWUP_TIMEOUT_MS', 30000),

package/dist/config.test.js

@@ -275,9 +275,9 @@ describe('parseConfig', () => {
         const { config } = parseConfig(env());
         expect(config.discordActionsBotProfile).toBe(true);
     });
-    it('defaults discordActionsPlan to true', () => {
+    it('defaults discordActionsPlan to false', () => {
         const { config } = parseConfig(env());
-        expect(config.discordActionsPlan).toBe(true);
+        expect(config.discordActionsPlan).toBe(false);
     });
     it('defaults discordActionsEnabled to true', () => {
         const { config } = parseConfig(env());
@@ -503,9 +503,9 @@ describe('parseConfig', () => {
         expect(warnings.some((w) => w.includes('FORGE_AUDITOR_RUNTIME=openrouter'))).toBe(true);
     });
     // --- Forge auto-implement ---
-    it('defaults forgeAutoImplement to true', () => {
+    it('defaults forgeAutoImplement to false', () => {
         const { config } = parseConfig(env());
-        expect(config.forgeAutoImplement).toBe(true);
+        expect(config.forgeAutoImplement).toBe(false);
     });
     it('parses FORGE_AUTO_IMPLEMENT=0 as false', () => {
         const { config } = parseConfig(env({ FORGE_AUTO_IMPLEMENT: '0' }));
@@ -1192,4 +1192,20 @@ describe('parseConfig', () => {
         const { config } = parseConfig(env());
         expect(config.coldStorageChannelFilter).toEqual([]);
     });
+    it('defaults messageHistoryFetchLimit to 10', () => {
+        const { config } = parseConfig(env());
+        expect(config.messageHistoryFetchLimit).toBe(10);
+    });
+    it('parses DISCOCLAW_MESSAGE_HISTORY_FETCH_LIMIT when set', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_MESSAGE_HISTORY_FETCH_LIMIT: '25' }));
+        expect(config.messageHistoryFetchLimit).toBe(25);
+    });
+    it('defaults messageHistoryMaxAgeMs to 48 hours in milliseconds', () => {
+        const { config } = parseConfig(env());
+        expect(config.messageHistoryMaxAgeMs).toBe(48 * 3_600_000);
+    });
+    it('parses DISCOCLAW_MESSAGE_HISTORY_MAX_AGE_HOURS and converts to ms', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_MESSAGE_HISTORY_MAX_AGE_HOURS: '24' }));
+        expect(config.messageHistoryMaxAgeMs).toBe(24 * 3_600_000);
+    });
 });

package/dist/cron/cron-sync.test.js

@@ -452,4 +452,117 @@ describe('runCronSync', () => {
         expect(result.orphansDetected).toBe(1);
         expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ threadId: 'thread-orphan' }), expect.stringContaining('orphan'));
     });
+    it('sync preserves disabled flag without modifying it', async () => {
+        const forum = makeForum([{ id: 'thread-1', name: 'Paused Job', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const statsStore = makeStatsStore([
+            makeRecord({
+                cronId: 'cron-1',
+                threadId: 'thread-1',
+                disabled: true,
+                pauseSource: 'user',
+                cadence: 'daily',
+                purposeTags: ['monitoring'],
+                model: 'haiku',
+            }),
+        ]);
+        const scheduler = makeScheduler([
+            { id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Paused Job', schedule: '0 7 * * *', prompt: 'Check things' },
+        ]);
+        await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore,
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        // Verify disabled and pauseSource were not altered by sync
+        const record = statsStore.getRecord('cron-1');
+        expect(record?.disabled).toBe(true);
+        expect(record?.pauseSource).toBe('user');
+    });
+    it('phase 5: recreating disabled cron calls scheduler.disable on new thread', async () => {
+        const create = vi.fn(async ({ name, message }) => ({
+            id: 'thread-new',
+            name,
+            message,
+        }));
+        const forum = makeForum([], { create });
+        const client = makeClient(forum);
+        const statsStore = makeStatsStore([
+            makeRecord({
+                cronId: 'cron-disabled',
+                threadId: 'thread-old',
+                disabled: true,
+                pauseSource: 'user',
+                cadence: 'daily',
+                schedule: '0 7 * * *',
+                timezone: 'UTC',
+                channel: 'general',
+                prompt: 'Disabled job that needs thread recreation.',
+                projectionStatus: 'missing',
+                projectionHash: 'stale-hash',
+            }),
+        ]);
+        const scheduler = makeScheduler([]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore,
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        expect(result.projectionsRepaired).toBe(1);
+        // Scheduler should have been called: register then disable
+        expect(scheduler.register).toHaveBeenCalled();
+        expect(scheduler.disable).toHaveBeenCalledWith('thread-new');
+        // Record should still be disabled after recreation
+        const record = statsStore.getRecord('cron-disabled');
+        expect(record?.disabled).toBe(true);
+        expect(record?.threadId).toBe('thread-new');
+    });
+    it('phase 3: updates status messages for disabled crons', async () => {
+        const forum = makeForum([{ id: 'thread-1', name: 'Paused Job', parentId: 'forum-1' }]);
+        const client = makeClient(forum);
+        const statsStore = makeStatsStore([
+            makeRecord({
+                cronId: 'cron-1',
+                threadId: 'thread-1',
+                disabled: true,
+                pauseSource: 'user',
+                cadence: 'daily',
+                model: 'haiku',
+            }),
+        ]);
+        const scheduler = makeScheduler([
+            { id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Paused Job', schedule: '0 7 * * *', prompt: 'Check things' },
+        ]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore,
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log: mockLog(),
+            throttleMs: 0,
+        });
+        // Disabled crons should still get status message updates
+        expect(result.statusMessagesUpdated).toBe(1);
+    });
 });

package/dist/cron/forum-sync.js

@@ -1,5 +1,5 @@
 import { ChannelType, EmbedBuilder } from 'discord.js';
-import { parseCronDefinition } from './parser.js';
+import { parseCronDefinition, parseStarterContent } from './parser.js';
 import { generateCronId, parseCronIdFromContent } from './run-stats.js';
 import { detectCadence } from './cadence.js';
 import { ensureStatusMessage } from './discord-sync.js';
@@ -106,15 +106,24 @@ async function loadThreadAsCron(thread, guildId, scheduler, runtime, opts) {
         }
         return false;
     }
-    const def = await parseCronDefinition(starter.content, runtime, { model: opts.cronModel, cwd: opts.cwd });
+    // Try deterministic parse of bot-formatted starter first (no LLM needed).
+    const deterministicDef = parseStarterContent(starter.content);
+    const def = deterministicDef ?? await parseCronDefinition(starter.content, runtime, { model: opts.cronModel, cwd: opts.cwd });
     if (!def) {
-        opts.log?.warn({ threadId: thread.id, name: thread.name }, 'cron:forum parse failed');
-        scheduler.disable(thread.id);
-        try {
-            await thread.send('Could not parse this cron definition. Please edit the starter message with a clearer schedule, timezone, target channel, and instruction.');
+        if (opts.isNew) {
+            // Fresh thread — user just created it and needs feedback.
+            opts.log?.warn({ threadId: thread.id, name: thread.name }, 'cron:forum parse failed');
+            scheduler.disable(thread.id);
+            try {
+                await thread.send('Could not parse this cron definition. Please edit the starter message with a clearer schedule, timezone, target channel, and instruction.');
+            }
+            catch {
+                // Ignore send failures.
+            }
         }
-        catch {
-            // Ignore send failures.
+        else {
+            // Boot/re-parse — soft failure: leave unregistered so cron-sync can retry.
+            opts.log?.warn({ threadId: thread.id, name: thread.name }, 'cron:forum parse failed (boot re-parse), skipping without disabling');
         }
         return false;
     }
@@ -417,15 +426,10 @@ export async function initCronForum(opts) {
             // Archive state changed.
             if (oldThread.archived !== newThread.archived) {
                 if (newThread.archived) {
-                    log?.info({ threadId: newThread.id }, 'cron:forum thread archived, disabling');
-                    scheduler.disable(newThread.id);
-                    // Persist disabled state.
-                    if (statsStore) {
-                        const record = statsStore.getRecordByThreadId(newThread.id);
-                        if (record) {
-                            void statsStore.upsertRecord(record.cronId, newThread.id, { disabled: true }).catch(() => { });
-                        }
-                    }
+                    // Auto-archive (Discord inactivity) must NOT disable crons.
+                    // Only explicit cronPause commands persist disabled: true.
+                    // The cron keeps firing to its target channel; the thread is just UI.
+                    log?.info({ threadId: newThread.id }, 'cron:forum thread archived (cron continues)');
                 }
                 else {
                     // Reject unarchived manual threads not already grandfathered into the scheduler.