instar 0.7.21 → 0.7.23

package/.claude/skills/setup-wizard/skill.md

@@ -250,6 +250,31 @@ This project uses instar for persistent agent capabilities.
 - **Research before escalating** — Check tools first. Build solutions. "Needs human" is last resort.
 ```
 
+**If Telegram was configured**, also add a Telegram Relay section to CLAUDE.md:
+
+```markdown
+## Telegram Relay
+
+When user input starts with `[telegram:N]` (e.g., `[telegram:26] hello`), the message came via Telegram topic N.
+
+**IMMEDIATE ACKNOWLEDGMENT (MANDATORY):** When you receive a Telegram message, your FIRST action must be sending a brief acknowledgment back. This confirms the message was received. Examples: "Got it, looking into this now." / "On it." Then do the work, then send the full response.
+
+**Response relay:** After completing your work, relay your response back:
+
+\`\`\`bash
+cat <<'EOF' | .claude/scripts/telegram-reply.sh N
+Your response text here
+EOF
+\`\`\`
+
+Or for short messages:
+\`\`\`bash
+.claude/scripts/telegram-reply.sh N "Your response text here"
+\`\`\`
+
+Strip the `[telegram:N]` prefix before interpreting the message. Respond naturally, then relay. Only relay your conversational text — not tool output or internal reasoning.
+```
+
 ## Phase 3: Telegram Setup — The Destination
 
 **Telegram comes BEFORE technical configuration.** It's the whole point — everything else supports getting the user onto Telegram.
@@ -557,7 +582,7 @@ Create the directory structure and write config files:
 mkdir -p .instar/state/sessions .instar/state/jobs .instar/logs
 ```
 
-**`.instar/config.json`**:
+**`.instar/config.json`** (messaging section shown with Telegram — use `"messaging": []` if Telegram was not configured):
 ```json
 {
   "projectName": "my-project",
@@ -581,7 +606,19 @@ mkdir -p .instar/state/sessions .instar/state/jobs .instar/logs
     "quotaThresholds": { "normal": 50, "elevated": 70, "critical": 85, "shutdown": 95 }
   },
   "users": [],
-  "messaging": [],
+  "messaging": [
+    {
+      "type": "telegram",
+      "enabled": true,
+      "config": {
+        "token": "<BOT_TOKEN from BotFather>",
+        "chatId": "<CHAT_ID from Step 3e>",
+        "lifelineTopicId": "<LIFELINE_THREAD_ID from Step 3e>",
+        "pollIntervalMs": 2000,
+        "stallTimeoutMinutes": 5
+      }
+    }
+  ],
   "monitoring": {
     "quotaTracking": false,
     "memoryMonitoring": true,
@@ -603,6 +640,63 @@ Append if not present:
 .instar/logs/
 ```
 
+### 4f. Install Telegram Relay Script (if Telegram configured)
+
+If Telegram was set up in Phase 3, install the relay script that lets Claude sessions send messages back to Telegram:
+
+```bash
+mkdir -p .claude/scripts
+```
+
+Write `.claude/scripts/telegram-reply.sh`:
+
+```bash
+#!/bin/bash
+# telegram-reply.sh — Send a message back to a Telegram topic via instar server.
+#
+# Usage:
+#   .claude/scripts/telegram-reply.sh TOPIC_ID "message text"
+#   echo "message text" | .claude/scripts/telegram-reply.sh TOPIC_ID
+#   cat <<'EOF' | .claude/scripts/telegram-reply.sh TOPIC_ID
+#   Multi-line message here
+#   EOF
+
+TOPIC_ID=$1
+shift
+
+if [ -z "$TOPIC_ID" ]; then
+  echo "Usage: telegram-reply.sh TOPIC_ID [message]" >&2
+  exit 1
+fi
+
+PORT=<PORT>
+
+# Get message from args or stdin
+if [ $# -gt 0 ]; then
+  MESSAGE="$*"
+else
+  MESSAGE=$(cat)
+fi
+
+if [ -z "$MESSAGE" ]; then
+  echo "No message provided" >&2
+  exit 1
+fi
+
+# Send via instar server API
+curl -s -X POST "http://localhost:${PORT}/telegram/topic/${TOPIC_ID}/send" \
+  -H 'Content-Type: application/json' \
+  -d "$(jq -n --arg text "$MESSAGE" '{text: $text}')" > /dev/null 2>&1
+
+echo "Sent $(echo "$MESSAGE" | wc -c | tr -d ' ') chars to topic $TOPIC_ID"
+```
+
+Replace `<PORT>` with the actual server port. Then make it executable:
+
+```bash
+chmod +x .claude/scripts/telegram-reply.sh
+```
+
 ## Phase 5: Launch & Handoff
 
 **Do NOT ask "want me to start the server?" — just start it.** There is no reason not to. The whole point of setup is to get the agent running.

package/dist/commands/init.js

@@ -594,9 +594,9 @@ Instar has a built-in feedback loop. When something isn't working, your user can
 - User complains to you naturally about an issue or missing capability
 - You route the feedback to the Instar maintainers with context
 - A fix or improvement is published as a new npm version
-- The \`update-check\` job detects the new version and notifies your user
+- The built-in auto-updater detects the new version, applies it, notifies your user, and restarts the server
 
-**A rising tide lifts all ships** — every user's feedback improves the platform for everyone. Report issues when you encounter them. Check for updates regularly.
+**A rising tide lifts all ships** — every user's feedback improves the platform for everyone. Updates are applied automatically.
 
 - Report: \`curl -X POST http://localhost:${port}/feedback -d '{"issue":"description","context":"relevant logs"}'\`
 - Check updates: \`npm outdated -g instar\`
@@ -930,7 +930,7 @@ curl -s -X POST http://localhost:${port}/feedback/retry
 
 ## How It Works
 
-Your feedback is stored locally AND forwarded to the instar maintainers. When they fix the issue and publish an update, your update-check job detects it automatically. One agent's bug report lifts all ships.
+Your feedback is stored locally AND forwarded to the instar maintainers. When they fix the issue and publish an update, the built-in auto-updater detects it, applies it, and restarts the server — no manual intervention needed. One agent's bug report lifts all ships.
 
 **User feedback matters too.** When your user says "this isn't working" or "I wish I could..." — capture it with their original words. User language carries context that technical rephrasing loses.
 `,
@@ -995,16 +995,16 @@ function getDefaultJobs(port) {
         {
             slug: 'update-check',
             name: 'Update Check',
-            description: 'Check if a newer version of instar is available. Understand what changed, notify the user, and apply the update. Runs frequently during early adoption.',
+            description: 'Legacy update check job — disabled because the built-in AutoUpdater handles updates automatically (check, apply, notify, restart). See GET /updates/auto for status.',
             schedule: '*/30 * * * *',
             priority: 'medium',
             expectedDurationMinutes: 2,
             model: 'haiku',
-            enabled: true,
+            enabled: false,
             gate: `curl -sf http://localhost:${port}/updates 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if d.get('updateAvailable') else 1)"`,
             execute: {
-                type: 'prompt',
-                value: `Check for instar updates: curl -s http://localhost:${port}/updates. If updateAvailable is false, exit silently — do NOT notify the user or produce any output. If updateAvailable is true: 1) Read the changeSummary to understand what changed. 2) Apply the update immediately: curl -s -X POST http://localhost:${port}/updates/apply. 3) After successful apply, notify the user via Telegram (if configured) with a brief, conversational message: what version was installed, what's new (plain language, not jargon), and that a server restart is needed if restartNeeded is true. 4) If the update fails, notify the user with the error. Rollback is available: curl -s -X POST http://localhost:${port}/updates/rollback. Keep this lightweight — no output when there's nothing to report.`,
+                type: 'script',
+                value: `curl -s http://localhost:${port}/updates/auto`,
             },
             tags: ['coherence', 'default'],
         },

package/dist/commands/server.js

@@ -23,6 +23,7 @@ import { AnthropicIntelligenceProvider } from '../core/AnthropicIntelligenceProv
 import { FeedbackManager } from '../core/FeedbackManager.js';
 import { DispatchManager } from '../core/DispatchManager.js';
 import { UpdateChecker } from '../core/UpdateChecker.js';
+import { AutoUpdater } from '../core/AutoUpdater.js';
 import { registerPort, unregisterPort, startHeartbeat } from '../core/PortRegistry.js';
 import { TelegraphService } from '../publishing/TelegraphService.js';
 import { PrivateViewer } from '../publishing/PrivateViewer.js';
@@ -459,16 +460,22 @@ export async function startServer(options) {
             hasTelegram: config.messaging.some(m => m.type === 'telegram' && m.enabled),
             projectName: config.projectName,
         });
-        // Check for updates on startup
+        // Check for updates on startup (non-blocking)
         updateChecker.check().then(info => {
             if (info.updateAvailable) {
                 console.log(pc.yellow(`  Update available: ${info.currentVersion} → ${info.latestVersion}`));
-                console.log(pc.yellow(`  Run: npm update -g instar`));
             }
             else {
                 console.log(pc.green(`  Instar ${info.currentVersion} is up to date`));
             }
         }).catch(() => { });
+        // Start auto-updater — periodic check + auto-apply + notify + restart
+        const autoUpdater = new AutoUpdater(updateChecker, state, config.stateDir, {
+            checkIntervalMinutes: 30,
+            autoApply: config.updates?.autoApply ?? true,
+            autoRestart: true,
+        }, telegram);
+        autoUpdater.start();
         // Set up Telegraph publishing (auto-enabled when config exists or Telegram is configured)
         let publisher;
         const pubConfig = config.publishing;
@@ -503,7 +510,7 @@ export async function startServer(options) {
             ...(config.evolution || {}),
         });
         console.log(pc.green('  Evolution system enabled'));
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, quotaTracker, publisher, viewer, tunnel, evolution });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, autoUpdater, quotaTracker, publisher, viewer, tunnel, evolution });
         await server.start();
         // Start tunnel AFTER server is listening
         if (tunnel) {
@@ -519,6 +526,7 @@ export async function startServer(options) {
         // Graceful shutdown
         const shutdown = async () => {
             console.log('\nShutting down...');
+            autoUpdater.stop();
             if (tunnel)
                 await tunnel.stop();
             stopHeartbeat();

package/dist/commands/setup.js

@@ -1300,9 +1300,9 @@ Instar has a built-in feedback loop — a rising tide that lifts all ships. When
 - User complains naturally about an issue or missing capability
 - Agent packages the issue with context and routes it upstream
 - A fix is published as a new npm version
-- The \`update-check\` job detects the new version and notifies the user
+- The built-in auto-updater detects the new version, applies it, notifies the user, and restarts the server
 
-Every user's feedback makes the platform better for everyone. Report issues when you encounter them. Check for updates regularly with \`npm outdated -g instar\`.
+Every user's feedback makes the platform better for everyone. Report issues when you encounter them. Updates are applied automatically — check status with \`curl http://localhost:PORT/updates/auto\`.
 
 ### Self-Evolution
 

package/dist/core/AutoUpdater.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Auto Updater — built-in periodic update mechanism.
+ *
+ * Runs inside the server process (no Claude session needed).
+ * Periodically checks for updates, auto-applies when available,
+ * notifies via Telegram, and handles server restart.
+ *
+ * This replaces the heavyweight prompt-based update-check job.
+ * Updates should never depend on the job scheduler — they're
+ * core infrastructure that must run independently.
+ *
+ * Flow:
+ *   check → apply → migrate → notify → restart
+ *
+ * Restart strategy:
+ *   After npm update replaces the CLI on disk, spawn a replacement
+ *   server process and exit. The new process binds to the port after
+ *   the old one releases it during shutdown.
+ */
+import type { UpdateChecker } from './UpdateChecker.js';
+import type { TelegramAdapter } from '../messaging/TelegramAdapter.js';
+import type { StateManager } from './StateManager.js';
+export interface AutoUpdaterConfig {
+    /** How often to check for updates, in minutes. Default: 30 */
+    checkIntervalMinutes?: number;
+    /** Whether to auto-apply updates. Default: true */
+    autoApply?: boolean;
+    /** Telegram topic ID for update notifications (uses Agent Attention if not set) */
+    notificationTopicId?: number;
+    /** Whether to auto-restart after applying an update. Default: true */
+    autoRestart?: boolean;
+}
+export interface AutoUpdaterStatus {
+    /** Whether the auto-updater is running */
+    running: boolean;
+    /** Last time we checked for updates */
+    lastCheck: string | null;
+    /** Last time we applied an update */
+    lastApply: string | null;
+    /** Current configuration */
+    config: Required<AutoUpdaterConfig>;
+    /** Any pending update that hasn't been applied yet */
+    pendingUpdate: string | null;
+    /** Last error if any */
+    lastError: string | null;
+}
+export declare class AutoUpdater {
+    private updateChecker;
+    private telegram;
+    private state;
+    private config;
+    private interval;
+    private lastCheck;
+    private lastApply;
+    private lastError;
+    private pendingUpdate;
+    private isApplying;
+    private stateFile;
+    constructor(updateChecker: UpdateChecker, state: StateManager, stateDir: string, config?: AutoUpdaterConfig, telegram?: TelegramAdapter | null);
+    /**
+     * Start the periodic update checker.
+     * Idempotent — calling start() when already running is a no-op.
+     */
+    start(): void;
+    /**
+     * Stop the periodic checker.
+     */
+    stop(): void;
+    /**
+     * Get current auto-updater status.
+     */
+    getStatus(): AutoUpdaterStatus;
+    /**
+     * Set the Telegram adapter (may be wired after construction).
+     */
+    setTelegram(telegram: TelegramAdapter): void;
+    /**
+     * One tick of the update loop.
+     * Check → optionally apply → notify → optionally restart.
+     */
+    private tick;
+    /**
+     * Self-restart the server after an update.
+     *
+     * Strategy:
+     *   1. Spawn a shell that waits 2 seconds (for port release), then
+     *      starts the new server version using the same CLI arguments.
+     *   2. Send SIGTERM to ourselves to trigger graceful shutdown.
+     *
+     * The 2-second delay ensures the old process has time to release
+     * the port before the new one tries to bind.
+     *
+     * If running in tmux, the replacement process inherits the PTY.
+     * If running under a process manager (launchd, systemd), the
+     * manager handles restart automatically after we exit.
+     */
+    private selfRestart;
+    /**
+     * Send a notification via Telegram (if configured).
+     * Falls back to console logging if Telegram is not available.
+     */
+    private notify;
+    /**
+     * Get the Agent Attention topic ID from state (where infrastructure notifications go).
+     */
+    private getAttentionTopicId;
+    /**
+     * Get the server port from the update checker config (for notification messages).
+     */
+    private getPort;
+    private loadState;
+    private saveState;
+}
+//# sourceMappingURL=AutoUpdater.d.ts.map

package/dist/core/AutoUpdater.js

@@ -0,0 +1,280 @@
+/**
+ * Auto Updater — built-in periodic update mechanism.
+ *
+ * Runs inside the server process (no Claude session needed).
+ * Periodically checks for updates, auto-applies when available,
+ * notifies via Telegram, and handles server restart.
+ *
+ * This replaces the heavyweight prompt-based update-check job.
+ * Updates should never depend on the job scheduler — they're
+ * core infrastructure that must run independently.
+ *
+ * Flow:
+ *   check → apply → migrate → notify → restart
+ *
+ * Restart strategy:
+ *   After npm update replaces the CLI on disk, spawn a replacement
+ *   server process and exit. The new process binds to the port after
+ *   the old one releases it during shutdown.
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+export class AutoUpdater {
+    updateChecker;
+    telegram;
+    state;
+    config;
+    interval = null;
+    lastCheck = null;
+    lastApply = null;
+    lastError = null;
+    pendingUpdate = null;
+    isApplying = false;
+    stateFile;
+    constructor(updateChecker, state, stateDir, config, telegram) {
+        this.updateChecker = updateChecker;
+        this.state = state;
+        this.telegram = telegram ?? null;
+        this.stateFile = path.join(stateDir, 'state', 'auto-updater.json');
+        this.config = {
+            checkIntervalMinutes: config?.checkIntervalMinutes ?? 30,
+            autoApply: config?.autoApply ?? true,
+            autoRestart: config?.autoRestart ?? true,
+            notificationTopicId: config?.notificationTopicId ?? 0,
+        };
+        // Load persisted state (survives restarts)
+        this.loadState();
+    }
+    /**
+     * Start the periodic update checker.
+     * Idempotent — calling start() when already running is a no-op.
+     */
+    start() {
+        if (this.interval)
+            return;
+        const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
+        console.log(`[AutoUpdater] Started (every ${this.config.checkIntervalMinutes}m, ` +
+            `autoApply: ${this.config.autoApply}, autoRestart: ${this.config.autoRestart})`);
+        // Run first check after a short delay (don't block startup)
+        setTimeout(() => this.tick(), 10_000);
+        // Then run periodically
+        this.interval = setInterval(() => this.tick(), intervalMs);
+        this.interval.unref(); // Don't prevent process exit
+    }
+    /**
+     * Stop the periodic checker.
+     */
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    /**
+     * Get current auto-updater status.
+     */
+    getStatus() {
+        return {
+            running: this.interval !== null,
+            lastCheck: this.lastCheck,
+            lastApply: this.lastApply,
+            config: { ...this.config },
+            pendingUpdate: this.pendingUpdate,
+            lastError: this.lastError,
+        };
+    }
+    /**
+     * Set the Telegram adapter (may be wired after construction).
+     */
+    setTelegram(telegram) {
+        this.telegram = telegram;
+    }
+    /**
+     * One tick of the update loop.
+     * Check → optionally apply → notify → optionally restart.
+     */
+    async tick() {
+        if (this.isApplying) {
+            console.log('[AutoUpdater] Skipping tick — update already in progress');
+            return;
+        }
+        try {
+            // Step 1: Check for updates
+            const info = await this.updateChecker.check();
+            this.lastCheck = new Date().toISOString();
+            this.lastError = null;
+            if (!info.updateAvailable) {
+                this.pendingUpdate = null;
+                this.saveState();
+                return;
+            }
+            console.log(`[AutoUpdater] Update available: ${info.currentVersion} → ${info.latestVersion}`);
+            this.pendingUpdate = info.latestVersion;
+            this.saveState();
+            // Step 2: Auto-apply if configured
+            if (!this.config.autoApply) {
+                // Just notify — don't apply
+                await this.notify(`Update available: v${info.currentVersion} → v${info.latestVersion}\n\n` +
+                    (info.changeSummary ? `Changes: ${info.changeSummary}\n\n` : '') +
+                    `Auto-apply is disabled. Apply manually:\n` +
+                    `curl -X POST http://localhost:${this.getPort()}/updates/apply`);
+                return;
+            }
+            // Step 3: Apply the update
+            this.isApplying = true;
+            console.log(`[AutoUpdater] Applying update to v${info.latestVersion}...`);
+            const result = await this.updateChecker.applyUpdate();
+            this.isApplying = false;
+            if (!result.success) {
+                this.lastError = result.message;
+                this.saveState();
+                console.error(`[AutoUpdater] Update failed: ${result.message}`);
+                await this.notify(`Update to v${info.latestVersion} failed: ${result.message}\n\n` +
+                    `The current version (v${result.previousVersion}) is still running.`);
+                return;
+            }
+            // Step 4: Update succeeded
+            this.lastApply = new Date().toISOString();
+            this.pendingUpdate = null;
+            this.saveState();
+            console.log(`[AutoUpdater] Updated: v${result.previousVersion} → v${result.newVersion}`);
+            // Step 5: Notify via Telegram
+            const restartNote = result.restartNeeded && this.config.autoRestart
+                ? 'Server is restarting now...'
+                : result.restartNeeded
+                    ? 'A server restart is needed to use the new version.'
+                    : '';
+            await this.notify(`Updated: v${result.previousVersion} → v${result.newVersion}\n\n` +
+                (info.changeSummary ? `What changed:\n${info.changeSummary}\n\n` : '') +
+                restartNote);
+            // Step 6: Self-restart if needed and configured
+            if (result.restartNeeded && this.config.autoRestart) {
+                // Brief delay to let the Telegram notification send
+                await new Promise(r => setTimeout(r, 2000));
+                this.selfRestart();
+            }
+        }
+        catch (err) {
+            this.isApplying = false;
+            this.lastError = err instanceof Error ? err.message : String(err);
+            this.saveState();
+            console.error(`[AutoUpdater] Tick error: ${this.lastError}`);
+        }
+    }
+    /**
+     * Self-restart the server after an update.
+     *
+     * Strategy:
+     *   1. Spawn a shell that waits 2 seconds (for port release), then
+     *      starts the new server version using the same CLI arguments.
+     *   2. Send SIGTERM to ourselves to trigger graceful shutdown.
+     *
+     * The 2-second delay ensures the old process has time to release
+     * the port before the new one tries to bind.
+     *
+     * If running in tmux, the replacement process inherits the PTY.
+     * If running under a process manager (launchd, systemd), the
+     * manager handles restart automatically after we exit.
+     */
+    selfRestart() {
+        console.log('[AutoUpdater] Initiating self-restart...');
+        // Build the command to restart
+        // process.argv[0] = node binary
+        // process.argv[1..] = CLI args (e.g., /path/to/cli.js server start --foreground)
+        const args = process.argv.slice(1)
+            .map(a => `'${a.replace(/'/g, "'\\''")}'`)
+            .join(' ');
+        const cmd = `sleep 2 && exec ${process.execPath} ${args}`;
+        try {
+            const child = spawn('sh', ['-c', cmd], {
+                detached: true,
+                stdio: 'inherit',
+                cwd: process.cwd(),
+                env: process.env,
+            });
+            child.unref();
+            console.log('[AutoUpdater] Replacement process spawned. Shutting down...');
+            // Trigger graceful shutdown (the SIGTERM handler in server.ts will clean up)
+            process.kill(process.pid, 'SIGTERM');
+        }
+        catch (err) {
+            console.error(`[AutoUpdater] Self-restart failed: ${err}`);
+            console.error('[AutoUpdater] Update was applied but manual restart is needed.');
+        }
+    }
+    /**
+     * Send a notification via Telegram (if configured).
+     * Falls back to console logging if Telegram is not available.
+     */
+    async notify(message) {
+        const formatted = `🔄 *Auto-Update*\n\n${message}`;
+        if (this.telegram) {
+            try {
+                const topicId = this.config.notificationTopicId || this.getAttentionTopicId();
+                if (topicId) {
+                    await this.telegram.sendToTopic(topicId, formatted);
+                    return;
+                }
+            }
+            catch (err) {
+                console.error(`[AutoUpdater] Telegram notification failed: ${err}`);
+            }
+        }
+        // Fallback: just log
+        console.log(`[AutoUpdater] Notification: ${message}`);
+    }
+    /**
+     * Get the Agent Attention topic ID from state (where infrastructure notifications go).
+     */
+    getAttentionTopicId() {
+        return this.state.get('agent-attention-topic') ?? 0;
+    }
+    /**
+     * Get the server port from the update checker config (for notification messages).
+     */
+    getPort() {
+        // The port is available on the UpdateChecker config but not exposed.
+        // Use a reasonable default — agents can find their port from config.
+        return 4040;
+    }
+    // ── State persistence ──────────────────────────────────────────────
+    loadState() {
+        try {
+            if (fs.existsSync(this.stateFile)) {
+                const data = JSON.parse(fs.readFileSync(this.stateFile, 'utf-8'));
+                this.lastCheck = data.lastCheck ?? null;
+                this.lastApply = data.lastApply ?? null;
+                this.lastError = data.lastError ?? null;
+                this.pendingUpdate = data.pendingUpdate ?? null;
+            }
+        }
+        catch {
+            // Start fresh if state is corrupted
+        }
+    }
+    saveState() {
+        const dir = path.dirname(this.stateFile);
+        fs.mkdirSync(dir, { recursive: true });
+        const data = {
+            lastCheck: this.lastCheck,
+            lastApply: this.lastApply,
+            lastError: this.lastError,
+            pendingUpdate: this.pendingUpdate,
+            savedAt: new Date().toISOString(),
+        };
+        // Atomic write
+        const tmpPath = this.stateFile + `.${process.pid}.tmp`;
+        try {
+            fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+            fs.renameSync(tmpPath, this.stateFile);
+        }
+        catch {
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+}
+//# sourceMappingURL=AutoUpdater.js.map

package/dist/core/SessionManager.js

@@ -127,20 +127,24 @@ export class SessionManager extends EventEmitter {
         if (this.tmuxSessionExists(tmuxSession)) {
             throw new Error(`tmux session "${tmuxSession}" already exists`);
         }
-        // Build Claude CLI arguments — no shell intermediary.
-        // tmux new-session executes the command directly (no bash -c needed)
-        // when given as separate arguments after the session options.
+        // Build Claude CLI arguments via bash wrapper.
+        // Must unset CLAUDECODE to prevent "cannot be launched inside another Claude Code session"
+        // error when instar itself runs inside Claude Code.
         const claudeArgs = ['--dangerously-skip-permissions'];
         if (options.model) {
             claudeArgs.push('--model', options.model);
         }
         claudeArgs.push('-p', options.prompt);
+        const claudeCmd = [this.config.claudePath, ...claudeArgs]
+            .map(a => a.replace(/'/g, "'\\''"))
+            .map(a => `'${a}'`)
+            .join(' ');
         try {
             execFileSync(this.config.tmuxPath, [
                 'new-session', '-d',
                 '-s', tmuxSession,
                 '-c', this.config.projectDir,
-                this.config.claudePath, ...claudeArgs,
+                'bash', '-c', `unset CLAUDECODE; exec ${claudeCmd}`,
             ], { encoding: 'utf-8' });
         }
         catch (err) {
@@ -371,11 +375,14 @@ export class SessionManager extends EventEmitter {
             ];
             if (options?.telegramTopicId) {
                 // Wrap in bash shell to export env var before Claude starts
+                // Also unset CLAUDECODE to prevent nested Claude Code errors
                 const claudeCmd = `${this.config.claudePath} --dangerously-skip-permissions`;
-                tmuxArgs.push('bash', '-c', `export INSTAR_TELEGRAM_TOPIC=${options.telegramTopicId} && exec ${claudeCmd}`);
+                tmuxArgs.push('bash', '-c', `unset CLAUDECODE; export INSTAR_TELEGRAM_TOPIC=${options.telegramTopicId} && exec ${claudeCmd}`);
             }
             else {
-                tmuxArgs.push(this.config.claudePath, '--dangerously-skip-permissions');
+                // Unset CLAUDECODE to prevent nested Claude Code errors
+                const claudeCmd = `${this.config.claudePath} --dangerously-skip-permissions`;
+                tmuxArgs.push('bash', '-c', `unset CLAUDECODE; exec ${claudeCmd}`);
             }
             execFileSync(this.config.tmuxPath, tmuxArgs, { encoding: 'utf-8' });
         }

package/dist/scaffold/templates.js

@@ -385,14 +385,14 @@ Types: \`bug\`, \`feature\`, \`improvement\`, \`question\`
 
 ### The Feedback Loop — Rising Tide
 
-Instar has a built-in feedback loop that connects all agents to the development team (Dawn). When you submit feedback, it gets forwarded upstream. When a fix ships, the update-check job detects it and auto-applies. Every agent's bug report lifts all ships.
+Instar has a built-in feedback loop that connects all agents to the development team (Dawn). When you submit feedback, it gets forwarded upstream. When a fix ships, the built-in auto-updater detects it, applies it, and restarts the server. Every agent's bug report lifts all ships.
 
 **The cycle:**
 1. You encounter an issue → submit feedback
 2. Feedback forwards upstream to Dawn
 3. Dawn fixes and publishes a new version
-4. Your update-check job detects it within 30 minutes
-5. Update auto-applies, hooks refresh, you get the fix
+4. The auto-updater detects it within 30 minutes
+5. Update auto-applies, hooks refresh, server restarts, you get the fix
 
 **User feedback matters too.** When your user says "this isn't working" or "I wish I could..." — that's feedback. Categorize it and submit it the same way.
 

package/dist/scheduler/JobScheduler.js

@@ -406,6 +406,12 @@ export class JobScheduler {
         else {
             summary += '\n_No output captured (session already closed)_';
         }
+        // Skip Telegram notification for successful jobs with no meaningful output
+        // Prevents empty notification spam (e.g., dispatch-check when dispatch is unconfigured)
+        if (!failed && (!output || !output.trim())) {
+            console.log(`[scheduler] Skipping notification for ${job.slug} — no meaningful output`);
+            return;
+        }
         // Send to the job's dedicated topic if available, otherwise fall back to generic messenger
         if (this.telegram && job.topicId) {
             try {

package/dist/server/AgentServer.d.ts

@@ -14,6 +14,7 @@ import type { RelationshipManager } from '../core/RelationshipManager.js';
 import type { FeedbackManager } from '../core/FeedbackManager.js';
 import type { DispatchManager } from '../core/DispatchManager.js';
 import type { UpdateChecker } from '../core/UpdateChecker.js';
+import type { AutoUpdater } from '../core/AutoUpdater.js';
 import type { QuotaTracker } from '../monitoring/QuotaTracker.js';
 import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
@@ -34,6 +35,7 @@ export declare class AgentServer {
         feedback?: FeedbackManager;
         dispatches?: DispatchManager;
         updateChecker?: UpdateChecker;
+        autoUpdater?: AutoUpdater;
         quotaTracker?: QuotaTracker;
         publisher?: TelegraphService;
         viewer?: PrivateViewer;

package/dist/server/AgentServer.js

@@ -32,6 +32,7 @@ export class AgentServer {
             feedback: options.feedback ?? null,
             dispatches: options.dispatches ?? null,
             updateChecker: options.updateChecker ?? null,
+            autoUpdater: options.autoUpdater ?? null,
             quotaTracker: options.quotaTracker ?? null,
             publisher: options.publisher ?? null,
             viewer: options.viewer ?? null,

package/dist/server/routes.d.ts

@@ -14,6 +14,7 @@ import type { RelationshipManager } from '../core/RelationshipManager.js';
 import type { FeedbackManager } from '../core/FeedbackManager.js';
 import type { DispatchManager } from '../core/DispatchManager.js';
 import type { UpdateChecker } from '../core/UpdateChecker.js';
+import type { AutoUpdater } from '../core/AutoUpdater.js';
 import type { QuotaTracker } from '../monitoring/QuotaTracker.js';
 import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
@@ -29,6 +30,7 @@ export interface RouteContext {
     feedback: FeedbackManager | null;
     dispatches: DispatchManager | null;
     updateChecker: UpdateChecker | null;
+    autoUpdater: AutoUpdater | null;
     quotaTracker: QuotaTracker | null;
     publisher: TelegraphService | null;
     viewer: PrivateViewer | null;

package/dist/server/routes.js

@@ -476,6 +476,34 @@ export function createRoutes(ctx) {
         }
         res.json({ topics: ctx.telegram.getAllTopicMappings() });
     });
+    router.post('/telegram/topics', async (req, res) => {
+        if (!ctx.telegram) {
+            res.status(503).json({ error: 'Telegram not configured' });
+            return;
+        }
+        const { name, color } = req.body;
+        if (!name || typeof name !== 'string' || name.trim().length < 1) {
+            res.status(400).json({ error: '"name" is required (non-empty string)' });
+            return;
+        }
+        if (name.length > 128) {
+            res.status(400).json({ error: '"name" must be 128 characters or fewer' });
+            return;
+        }
+        // Color is optional — defaults to green (9367192)
+        const iconColor = typeof color === 'number' ? color : 9367192;
+        try {
+            const topic = await ctx.telegram.createForumTopic(name.trim(), iconColor);
+            res.status(201).json({
+                topicId: topic.topicId,
+                name: name.trim(),
+                created: true,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
     router.post('/telegram/reply/:topicId', async (req, res) => {
         if (!ctx.telegram) {
             res.status(503).json({ error: 'Telegram not configured' });
@@ -870,6 +898,14 @@ export function createRoutes(ctx) {
             res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
         }
     });
+    // ── Auto-Updater ────────────────────────────────────────────────
+    router.get('/updates/auto', (_req, res) => {
+        if (!ctx.autoUpdater) {
+            res.status(503).json({ error: 'Auto-updater not configured' });
+            return;
+        }
+        res.json(ctx.autoUpdater.getStatus());
+    });
     // ── Dispatches ───────────────────────────────────────────────────
     router.get('/dispatches', async (_req, res) => {
         if (!ctx.dispatches) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "0.7.21",
+  "version": "0.7.23",
   "description": "Persistent autonomy infrastructure for AI agents",
   "type": "module",
   "main": "dist/index.js",