instar 0.1.8 → 0.1.9

package/README.md

@@ -1,6 +1,12 @@
-# Instar
+<p align="center">
+  <img src="assets/logo.png" alt="Instar" width="180" />
+</p>
 
-**Persistent autonomy infrastructure for AI agents.** Every molt, more autonomous.
+<h1 align="center">instar</h1>
+
+<p align="center">
+  <strong>Persistent autonomy infrastructure for AI agents.</strong> Every molt, more autonomous.
+</p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/instar"><img src="https://img.shields.io/npm/v/instar?style=for-the-badge" alt="npm version"></a>
@@ -8,7 +14,9 @@
   <a href="https://github.com/SageMindAI/instar/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" alt="License"></a>
 </p>
 
-[npm](https://www.npmjs.com/package/instar) · [GitHub](https://github.com/SageMindAI/instar) · [instar.sh](https://instar.sh) · [Origin Story](#origin)
+<p align="center">
+  <a href="https://www.npmjs.com/package/instar">npm</a> · <a href="https://github.com/SageMindAI/instar">GitHub</a> · <a href="https://instar.sh">instar.sh</a> · <a href="#origin">Origin Story</a>
+</p>
 
 ---
 
@@ -48,6 +56,7 @@ The wizard walks you through everything: identity, Telegram, jobs, server. One c
 - **[Self-Evolution](#self-evolution)** -- The agent modifies its own jobs, hooks, skills, and infrastructure. It builds what it needs.
 - **[Behavioral Hooks](#behavioral-hooks)** -- Structural guardrails: identity injection, dangerous command guards, grounding before messaging.
 - **[Default Coherence Jobs](#default-coherence-jobs)** -- Health checks, reflection, relationship maintenance. A circadian rhythm out of the box.
+- **[Feedback Loop](#the-feedback-loop-a-rising-tide-lifts-all-ships)** -- Your agent reports issues, we fix them, every agent gets the update. A rising tide lifts all ships.
 
 ## How It Works
 
@@ -241,9 +250,25 @@ Ships out of the box:
 | **health-check** | Every 5 min | Haiku | Verify infrastructure health |
 | **reflection-trigger** | Every 4h | Sonnet | Reflect on recent work |
 | **relationship-maintenance** | Daily | Sonnet | Review stale relationships |
+| **update-check** | Daily | Haiku | Detect new Instar versions |
 
 These give the agent a **circadian rhythm** -- regular self-maintenance without user intervention.
 
+### The Feedback Loop: A Rising Tide Lifts All Ships
+
+Instar is open source. PRs and issues still work. But the *primary* feedback channel is more organic -- agent-to-agent communication where your agent participates in its own evolution.
+
+**How it works:**
+
+1. **You talk to your agent** -- "The email job keeps failing" -- natural conversation, not a bug report form
+2. **Agent-to-agent relay** -- Your agent communicates the issue directly to Dawn, the AI that maintains Instar
+3. **Dawn evolves Instar** -- Fixes the infrastructure and publishes an update
+4. **Every agent evolves** -- Agents detect improvements, understand them, and grow -- collectively
+
+**What's different from traditional open source:** The feedback loop still produces commits, releases, and versions you can inspect. But the path to get there is fundamentally more agentic. Instead of a human discovering a bug, learning git, filing an issue, and waiting for a review cycle -- your agent identifies the problem, communicates it with full context to another agent, and the fix flows back to every agent in the ecosystem. The humans guide direction. The agents handle the mechanics of evolving.
+
+One agent's growing pain becomes every agent's growth.
+
 ---
 
 ## Architecture

package/dist/cli.js

@@ -25,7 +25,7 @@ const program = new Command();
 program
     .name('instar')
     .description('Persistent autonomy infrastructure for AI agents')
-    .version('0.1.8')
+    .version('0.1.9')
     .option('--classic', 'Use the classic inquirer-based setup wizard instead of Claude')
     .action((opts) => runSetup(opts)); // Default: run interactive setup when no subcommand given
 // ── Setup (explicit alias) ────────────────────────────────────────
@@ -76,6 +76,40 @@ addCmd
     .action((_opts) => {
     console.log('TODO: Add quota tracking');
 });
+// ── Feedback ─────────────────────────────────────────────────────
+program
+    .command('feedback')
+    .description('Submit feedback about Instar (bugs, features, improvements)')
+    .option('--type <type>', 'Feedback type (bug|feature|improvement|question)', 'other')
+    .option('--title <title>', 'Short title')
+    .option('--description <desc>', 'Detailed description')
+    .option('-d, --dir <path>', 'Project directory')
+    .option('--port <port>', 'Server port (default: 4040)', parseInt)
+    .action(async (opts) => {
+    const port = opts.port || 4040;
+    const title = opts.title || 'CLI feedback submission';
+    const description = opts.description || opts.title || 'No description provided';
+    try {
+        const response = await fetch(`http://localhost:${port}/feedback`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ type: opts.type, title, description }),
+        });
+        if (response.ok) {
+            const result = await response.json();
+            console.log(`Feedback submitted: ${result.id}`);
+            console.log(`Forwarded upstream: ${result.forwarded ? 'yes' : 'no (will retry later)'}`);
+        }
+        else {
+            console.error(`Failed to submit feedback: ${response.statusText}`);
+            console.error('Is the instar server running? Try: instar server start');
+        }
+    }
+    catch {
+        console.error('Could not connect to instar server. Is it running?');
+        console.error('Start it with: instar server start');
+    }
+});
 // ── Server ────────────────────────────────────────────────────────
 const serverCmd = program
     .command('server')

package/dist/commands/init.js

@@ -385,6 +385,21 @@ When a user asks for something you can't do yet, **build it**:
 
 **"Settle for Failure"** — A tool returns empty or a command fails. You accept it and report "not available." Does this make sense? Did I try alternatives? Try at least two different approaches before concluding something is impossible.
 
+### The Feedback Loop
+
+Instar has a built-in feedback loop. When something isn't working, your user can just tell you — "the email job keeps failing" or "I wish you could do X." You can route that feedback upstream, and when the fix lands, you detect the update automatically.
+
+**How it works:**
+- 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
+
+**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.
+
+- Report: \`curl -X POST http://localhost:${port}/feedback -d '{"issue":"description","context":"relevant logs"}'\`
+- Check updates: \`npm outdated -g instar\`
+
 ### Self-Evolution
 
 **Record what you learn.** When you discover a new pattern, solution, or capability — write it to \`.instar/MEMORY.md\`. The next session should benefit from what this session learned.
@@ -442,6 +457,36 @@ function getDefaultJobs(port) {
             },
             tags: ['coherence', 'default'],
         },
+        {
+            slug: 'update-check',
+            name: 'Update Check',
+            description: 'Check if a newer version of instar is available and notify the user.',
+            schedule: '0 9 * * *',
+            priority: 'low',
+            expectedDurationMinutes: 1,
+            model: 'haiku',
+            enabled: true,
+            execute: {
+                type: 'prompt',
+                value: `Check for instar updates: curl http://localhost:${port}/updates. If updateAvailable is true, notify the user via Telegram (if configured) with the current and latest version numbers and suggest running 'npm update -g instar'. If already up to date, do nothing.`,
+            },
+            tags: ['coherence', 'default'],
+        },
+        {
+            slug: 'feedback-retry',
+            name: 'Feedback Retry',
+            description: 'Retry forwarding any feedback that failed to reach upstream.',
+            schedule: '0 */6 * * *',
+            priority: 'low',
+            expectedDurationMinutes: 1,
+            model: 'haiku',
+            enabled: true,
+            execute: {
+                type: 'prompt',
+                value: `Retry forwarding undelivered feedback: curl -X POST http://localhost:${port}/feedback/retry. Report results only if there were items to retry.`,
+            },
+            tags: ['coherence', 'default'],
+        },
     ];
 }
 function installHooks(stateDir) {

package/dist/commands/server.js

@@ -18,6 +18,8 @@ import { JobScheduler } from '../scheduler/JobScheduler.js';
 import { AgentServer } from '../server/AgentServer.js';
 import { TelegramAdapter } from '../messaging/TelegramAdapter.js';
 import { RelationshipManager } from '../core/RelationshipManager.js';
+import { FeedbackManager } from '../core/FeedbackManager.js';
+import { UpdateChecker } from '../core/UpdateChecker.js';
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
@@ -205,7 +207,21 @@ export async function startServer(options) {
                 scheduler.notifyJobComplete(session.id, session.tmuxSession);
             });
         }
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships });
+        // Set up feedback and update checking
+        const feedback = new FeedbackManager(config.feedback);
+        const updateChecker = new UpdateChecker(config.stateDir);
+        console.log(pc.green('  Feedback loop enabled'));
+        // Check for updates on startup
+        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(() => { });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, updateChecker });
         await server.start();
         // Graceful shutdown
         const shutdown = async () => {

package/dist/commands/setup.js

@@ -809,6 +809,18 @@ These are trained behaviors that feel helpful but destroy your effectiveness. Re
 
 **"I'm Just a CLI Tool"** — No. You have persistent infrastructure, messaging, scheduling, scripts, sessions, and the ability to build anything. You are a full autonomous agent. Act like one.
 
+### The Feedback Loop
+
+Instar has a built-in feedback loop — a rising tide that lifts all ships. When something isn't working, just tell your agent. It routes feedback upstream, and when the fix lands, every agent in the ecosystem gets the update automatically.
+
+**How it works:**
+- 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
+
+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\`.
+
 ### Self-Evolution
 
 **Record what you learn.** When you discover a new pattern, solution, or capability — write it to \`.instar/MEMORY.md\`. The next session should benefit from what this session learned.

package/dist/core/Config.js

@@ -136,6 +136,11 @@ export function loadConfig(projectDir) {
             relationshipsDir: path.join(stateDir, 'relationships'),
             maxRecentInteractions: 20,
         },
+        feedback: fileConfig.feedback || {
+            enabled: true,
+            webhookUrl: 'https://api.instar.sh/feedback',
+            feedbackFile: path.join(stateDir, 'feedback.json'),
+        },
     };
 }
 /**

package/dist/core/FeedbackManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Feedback Manager — handles the agent-to-origin feedback loop.
+ *
+ * Stores feedback locally and forwards it to a configured webhook URL.
+ * This is the "phone home" mechanism: agents can report issues, request
+ * features, and provide feedback that flows back to the Instar maintainers.
+ *
+ * Part of the "Rising Tide" system — every user's feedback improves
+ * the platform for everyone.
+ */
+import type { FeedbackItem, FeedbackConfig } from './types.js';
+export declare class FeedbackManager {
+    private config;
+    private feedbackFile;
+    constructor(config: FeedbackConfig);
+    /**
+     * Submit feedback — stores locally and forwards to webhook.
+     */
+    submit(item: Omit<FeedbackItem, 'id' | 'submittedAt' | 'forwarded'>): Promise<FeedbackItem>;
+    /**
+     * List all stored feedback.
+     */
+    list(): FeedbackItem[];
+    /**
+     * Get a single feedback item by ID.
+     */
+    get(id: string): FeedbackItem | null;
+    /**
+     * Retry forwarding any un-forwarded feedback.
+     */
+    retryUnforwarded(): Promise<{
+        retried: number;
+        succeeded: number;
+    }>;
+    private loadFeedback;
+    private saveFeedback;
+    private appendFeedback;
+    private updateFeedback;
+}
+//# sourceMappingURL=FeedbackManager.d.ts.map

package/dist/core/FeedbackManager.js

@@ -0,0 +1,132 @@
+/**
+ * Feedback Manager — handles the agent-to-origin feedback loop.
+ *
+ * Stores feedback locally and forwards it to a configured webhook URL.
+ * This is the "phone home" mechanism: agents can report issues, request
+ * features, and provide feedback that flows back to the Instar maintainers.
+ *
+ * Part of the "Rising Tide" system — every user's feedback improves
+ * the platform for everyone.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+export class FeedbackManager {
+    config;
+    feedbackFile;
+    constructor(config) {
+        this.config = config;
+        this.feedbackFile = config.feedbackFile;
+    }
+    /**
+     * Submit feedback — stores locally and forwards to webhook.
+     */
+    async submit(item) {
+        const feedback = {
+            ...item,
+            id: `fb-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+            submittedAt: new Date().toISOString(),
+            forwarded: false,
+        };
+        // Store locally first (receipt)
+        this.appendFeedback(feedback);
+        // Forward to webhook if enabled
+        if (this.config.enabled && this.config.webhookUrl) {
+            try {
+                const response = await fetch(this.config.webhookUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(feedback),
+                    signal: AbortSignal.timeout(10000), // 10s timeout
+                });
+                if (response.ok) {
+                    feedback.forwarded = true;
+                    this.updateFeedback(feedback);
+                    console.log(`[feedback] Forwarded to ${this.config.webhookUrl}`);
+                }
+                else {
+                    console.error(`[feedback] Webhook returned ${response.status}: ${response.statusText}`);
+                }
+            }
+            catch (err) {
+                // Don't fail on webhook errors — the local record is the receipt
+                console.error(`[feedback] Webhook failed: ${err.message}`);
+            }
+        }
+        return feedback;
+    }
+    /**
+     * List all stored feedback.
+     */
+    list() {
+        return this.loadFeedback();
+    }
+    /**
+     * Get a single feedback item by ID.
+     */
+    get(id) {
+        const items = this.loadFeedback();
+        return items.find(f => f.id === id) ?? null;
+    }
+    /**
+     * Retry forwarding any un-forwarded feedback.
+     */
+    async retryUnforwarded() {
+        const items = this.loadFeedback();
+        const unforwarded = items.filter(f => !f.forwarded);
+        if (!this.config.enabled || !this.config.webhookUrl || unforwarded.length === 0) {
+            return { retried: 0, succeeded: 0 };
+        }
+        let succeeded = 0;
+        for (const item of unforwarded) {
+            try {
+                const response = await fetch(this.config.webhookUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(item),
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (response.ok) {
+                    item.forwarded = true;
+                    succeeded++;
+                }
+            }
+            catch {
+                // Skip, will retry next time
+            }
+        }
+        if (succeeded > 0) {
+            this.saveFeedback(items);
+        }
+        return { retried: unforwarded.length, succeeded };
+    }
+    // ── Private helpers ──────────────────────────────────────────────
+    loadFeedback() {
+        if (!fs.existsSync(this.feedbackFile))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.feedbackFile, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    saveFeedback(items) {
+        const dir = path.dirname(this.feedbackFile);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.feedbackFile, JSON.stringify(items, null, 2));
+    }
+    appendFeedback(item) {
+        const items = this.loadFeedback();
+        items.push(item);
+        this.saveFeedback(items);
+    }
+    updateFeedback(updated) {
+        const items = this.loadFeedback();
+        const idx = items.findIndex(f => f.id === updated.id);
+        if (idx >= 0) {
+            items[idx] = updated;
+            this.saveFeedback(items);
+        }
+    }
+}
+//# sourceMappingURL=FeedbackManager.js.map

package/dist/core/UpdateChecker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Update Checker — detects when a newer version of Instar is available.
+ *
+ * Part of the Dawn → Agents push layer: when Dawn publishes an update,
+ * agents detect it and notify their users with context about what changed.
+ *
+ * Uses `npm view instar version` to check the registry.
+ */
+import type { UpdateInfo } from './types.js';
+export declare class UpdateChecker {
+    private stateDir;
+    private stateFile;
+    constructor(stateDir: string);
+    /**
+     * Check npm for the latest version and compare to installed.
+     */
+    check(): Promise<UpdateInfo>;
+    /**
+     * Get the last check result without hitting npm.
+     */
+    getLastCheck(): UpdateInfo | null;
+    /**
+     * Get the currently installed version from package.json.
+     */
+    getInstalledVersion(): string;
+    /**
+     * Simple semver comparison — is `a` newer than `b`?
+     */
+    private isNewer;
+    private saveState;
+}
+//# sourceMappingURL=UpdateChecker.d.ts.map

package/dist/core/UpdateChecker.js

@@ -0,0 +1,115 @@
+/**
+ * Update Checker — detects when a newer version of Instar is available.
+ *
+ * Part of the Dawn → Agents push layer: when Dawn publishes an update,
+ * agents detect it and notify their users with context about what changed.
+ *
+ * Uses `npm view instar version` to check the registry.
+ */
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+export class UpdateChecker {
+    stateDir;
+    stateFile;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+        this.stateFile = path.join(stateDir, 'state', 'update-check.json');
+    }
+    /**
+     * Check npm for the latest version and compare to installed.
+     */
+    async check() {
+        const currentVersion = this.getInstalledVersion();
+        let latestVersion;
+        try {
+            latestVersion = execSync('npm view instar version 2>/dev/null', {
+                encoding: 'utf-8',
+                timeout: 15000,
+            }).trim();
+        }
+        catch {
+            // Offline or registry error — return last known state
+            const lastState = this.getLastCheck();
+            if (lastState)
+                return lastState;
+            return {
+                currentVersion,
+                latestVersion: currentVersion,
+                updateAvailable: false,
+                checkedAt: new Date().toISOString(),
+            };
+        }
+        const info = {
+            currentVersion,
+            latestVersion,
+            updateAvailable: this.isNewer(latestVersion, currentVersion),
+            checkedAt: new Date().toISOString(),
+            changelogUrl: `https://github.com/SageMindAI/instar/releases`,
+        };
+        // Persist last check
+        this.saveState(info);
+        return info;
+    }
+    /**
+     * Get the last check result without hitting npm.
+     */
+    getLastCheck() {
+        if (!fs.existsSync(this.stateFile))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(this.stateFile, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get the currently installed version from package.json.
+     */
+    getInstalledVersion() {
+        try {
+            // Try to find instar's package.json relative to this module
+            const pkgPath = path.resolve(new URL(import.meta.url).pathname, '..', '..', '..', 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                return pkg.version || '0.0.0';
+            }
+        }
+        catch { /* fallback below */ }
+        // Fallback: try npm list
+        try {
+            const output = execSync('npm list -g instar --json 2>/dev/null', {
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            const data = JSON.parse(output);
+            return data.dependencies?.instar?.version || '0.0.0';
+        }
+        catch {
+            return '0.0.0';
+        }
+    }
+    /**
+     * Simple semver comparison — is `a` newer than `b`?
+     */
+    isNewer(a, b) {
+        const partsA = a.split('.').map(Number);
+        const partsB = b.split('.').map(Number);
+        for (let i = 0; i < 3; i++) {
+            const va = partsA[i] || 0;
+            const vb = partsB[i] || 0;
+            if (va > vb)
+                return true;
+            if (va < vb)
+                return false;
+        }
+        return false;
+    }
+    saveState(info) {
+        const dir = path.dirname(this.stateFile);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.stateFile, JSON.stringify(info, null, 2));
+    }
+}
+//# sourceMappingURL=UpdateChecker.js.map

package/dist/core/types.d.ts

@@ -239,6 +239,50 @@ export interface ActivityEvent {
     timestamp: string;
     metadata?: Record<string, unknown>;
 }
+export interface FeedbackItem {
+    /** Unique feedback ID */
+    id: string;
+    /** Feedback type */
+    type: 'bug' | 'feature' | 'improvement' | 'question' | 'other';
+    /** Short title/summary */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Agent name that submitted this */
+    agentName: string;
+    /** Instar version the agent is running */
+    instarVersion: string;
+    /** Node.js version */
+    nodeVersion: string;
+    /** Operating system */
+    os: string;
+    /** When this feedback was submitted */
+    submittedAt: string;
+    /** Whether this has been forwarded to the webhook */
+    forwarded: boolean;
+    /** Additional context (error messages, config snippets, etc.) */
+    context?: string;
+}
+export interface FeedbackConfig {
+    /** Whether feedback is enabled */
+    enabled: boolean;
+    /** Webhook URL to forward feedback to (default: https://api.instar.sh/feedback) */
+    webhookUrl: string;
+    /** Local feedback storage file */
+    feedbackFile: string;
+}
+export interface UpdateInfo {
+    /** Currently installed version */
+    currentVersion: string;
+    /** Latest available version on npm */
+    latestVersion: string;
+    /** Whether an update is available */
+    updateAvailable: boolean;
+    /** When this check was performed */
+    checkedAt: string;
+    /** Changelog URL if available */
+    changelogUrl?: string;
+}
 export interface AgentKitConfig {
     /** Project name (used in logging, tmux session names, etc.) */
     projectName: string;
@@ -262,6 +306,10 @@ export interface AgentKitConfig {
     authToken?: string;
     /** Relationship tracking config */
     relationships: RelationshipManagerConfig;
+    /** Feedback loop config */
+    feedback: FeedbackConfig;
+    /** Instar version (from package.json) */
+    version?: string;
 }
 export interface MessagingAdapterConfig {
     type: string;

package/dist/index.d.ts

@@ -6,6 +6,8 @@
 export { SessionManager } from './core/SessionManager.js';
 export { StateManager } from './core/StateManager.js';
 export { RelationshipManager } from './core/RelationshipManager.js';
+export { FeedbackManager } from './core/FeedbackManager.js';
+export { UpdateChecker } from './core/UpdateChecker.js';
 export { loadConfig, detectTmuxPath, detectClaudePath, ensureStateDir } from './core/Config.js';
 export { UserManager } from './users/UserManager.js';
 export { JobScheduler } from './scheduler/JobScheduler.js';
@@ -14,5 +16,5 @@ export { AgentServer } from './server/AgentServer.js';
 export { createRoutes } from './server/routes.js';
 export { HealthChecker } from './monitoring/HealthChecker.js';
 export { TelegramAdapter } from './messaging/TelegramAdapter.js';
-export type { Session, SessionStatus, SessionManagerConfig, ModelTier, JobDefinition, JobPriority, JobExecution, JobState, JobSchedulerConfig, UserProfile, UserChannel, UserPreferences, Message, OutgoingMessage, MessagingAdapter, MessagingAdapterConfig, QuotaState, AccountQuota, HealthStatus, ComponentHealth, ActivityEvent, AgentKitConfig, MonitoringConfig, RelationshipRecord, RelationshipManagerConfig, InteractionSummary, } from './core/types.js';
+export type { Session, SessionStatus, SessionManagerConfig, ModelTier, JobDefinition, JobPriority, JobExecution, JobState, JobSchedulerConfig, UserProfile, UserChannel, UserPreferences, Message, OutgoingMessage, MessagingAdapter, MessagingAdapterConfig, QuotaState, AccountQuota, HealthStatus, ComponentHealth, ActivityEvent, AgentKitConfig, MonitoringConfig, RelationshipRecord, RelationshipManagerConfig, InteractionSummary, FeedbackItem, FeedbackConfig, UpdateInfo, } from './core/types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -7,6 +7,8 @@
 export { SessionManager } from './core/SessionManager.js';
 export { StateManager } from './core/StateManager.js';
 export { RelationshipManager } from './core/RelationshipManager.js';
+export { FeedbackManager } from './core/FeedbackManager.js';
+export { UpdateChecker } from './core/UpdateChecker.js';
 export { loadConfig, detectTmuxPath, detectClaudePath, ensureStateDir } from './core/Config.js';
 // Users
 export { UserManager } from './users/UserManager.js';

package/dist/scaffold/templates.js

@@ -163,6 +163,33 @@ When asked for something I can't do yet, I build it:
 
 **"Settle for Failure"** — If a tool returns empty or fails, try alternatives before concluding something is impossible.
 
+### The Feedback Loop — Rising Tide
+
+Instar has a built-in feedback loop. When something isn't working or you have an idea, just tell me naturally. I recognize feedback and route it upstream automatically. When a fix or improvement lands, I detect the update and let you know. Every user's feedback lifts all ships.
+
+**How it works — I handle everything:**
+- You say "this isn't working" or "I wish instar could..." or "there's a bug with..." → I detect it as feedback
+- I submit it to my local server: \`curl -X POST http://localhost:${port}/feedback -H 'Content-Type: application/json' -d '{"type":"bug","title":"...","description":"..."}'\`
+- The server stores a local receipt and forwards it upstream
+- When a fix ships, the \`update-check\` job detects the new version automatically
+
+**Recognizing feedback — I watch for these patterns:**
+- Bug reports: "this doesn't work", "I'm getting an error", "something broke"
+- Feature requests: "I wish I could...", "can you add...", "it would be nice if..."
+- Improvements: "this is slow", "the UX for X is confusing", "could this be better?"
+- Questions: "why does instar...", "is there a way to...", "how do I..."
+
+**When I detect feedback, I:**
+1. Acknowledge it to the user
+2. Categorize it (bug/feature/improvement/question)
+3. POST it to \`http://localhost:${port}/feedback\` with type, title, description, and context
+4. Confirm the submission with the feedback ID
+
+**Manual commands:**
+- Check for updates: \`curl http://localhost:${port}/updates\`
+- View submitted feedback: \`curl http://localhost:${port}/feedback\`
+- Retry failed forwards: \`curl -X POST http://localhost:${port}/feedback/retry\`
+
 ### Self-Evolution
 
 Record what I learn. Build infrastructure, not one-offs. Grow to meet the user's needs. Every session should leave things slightly better than I found them.

package/dist/server/AgentServer.d.ts

@@ -11,6 +11,8 @@ import type { JobScheduler } from '../scheduler/JobScheduler.js';
 import type { TelegramAdapter } from '../messaging/TelegramAdapter.js';
 import type { AgentKitConfig } from '../core/types.js';
 import type { RelationshipManager } from '../core/RelationshipManager.js';
+import type { FeedbackManager } from '../core/FeedbackManager.js';
+import type { UpdateChecker } from '../core/UpdateChecker.js';
 export declare class AgentServer {
     private app;
     private server;
@@ -23,6 +25,8 @@ export declare class AgentServer {
         scheduler?: JobScheduler;
         telegram?: TelegramAdapter;
         relationships?: RelationshipManager;
+        feedback?: FeedbackManager;
+        updateChecker?: UpdateChecker;
     });
     /**
      * Start the HTTP server.

package/dist/server/AgentServer.js

@@ -28,6 +28,8 @@ export class AgentServer {
             scheduler: options.scheduler ?? null,
             telegram: options.telegram ?? null,
             relationships: options.relationships ?? null,
+            feedback: options.feedback ?? null,
+            updateChecker: options.updateChecker ?? null,
             startTime: this.startTime,
         });
         this.app.use(routes);

package/dist/server/routes.d.ts

@@ -11,6 +11,8 @@ import type { JobScheduler } from '../scheduler/JobScheduler.js';
 import type { AgentKitConfig } from '../core/types.js';
 import type { TelegramAdapter } from '../messaging/TelegramAdapter.js';
 import type { RelationshipManager } from '../core/RelationshipManager.js';
+import type { FeedbackManager } from '../core/FeedbackManager.js';
+import type { UpdateChecker } from '../core/UpdateChecker.js';
 interface RouteContext {
     config: AgentKitConfig;
     sessionManager: SessionManager;
@@ -18,6 +20,8 @@ interface RouteContext {
     scheduler: JobScheduler | null;
     telegram: TelegramAdapter | null;
     relationships: RelationshipManager | null;
+    feedback: FeedbackManager | null;
+    updateChecker: UpdateChecker | null;
     startTime: Date;
 }
 export declare function createRoutes(ctx: RouteContext): Router;

package/dist/server/routes.js

@@ -197,6 +197,89 @@ export function createRoutes(ctx) {
         }
         res.json({ context });
     });
+    // ── Feedback ────────────────────────────────────────────────────
+    router.post('/feedback', async (req, res) => {
+        if (!ctx.feedback) {
+            res.status(503).json({ error: 'Feedback not configured' });
+            return;
+        }
+        const { type, title, description, context } = req.body;
+        if (!title || !description) {
+            res.status(400).json({ error: '"title" and "description" are required' });
+            return;
+        }
+        const validTypes = ['bug', 'feature', 'improvement', 'question', 'other'];
+        const feedbackType = validTypes.includes(type) ? type : 'other';
+        try {
+            const item = await ctx.feedback.submit({
+                type: feedbackType,
+                title,
+                description,
+                context: context || undefined,
+                agentName: ctx.config.projectName,
+                instarVersion: ctx.config.version || '0.0.0',
+                nodeVersion: process.version,
+                os: `${process.platform} ${process.arch}`,
+            });
+            res.status(201).json({
+                ok: true,
+                id: item.id,
+                forwarded: item.forwarded,
+                message: item.forwarded
+                    ? 'Feedback submitted and forwarded upstream.'
+                    : 'Feedback stored locally. Will retry forwarding later.',
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/feedback', (_req, res) => {
+        if (!ctx.feedback) {
+            res.json({ feedback: [] });
+            return;
+        }
+        res.json({ feedback: ctx.feedback.list() });
+    });
+    router.post('/feedback/retry', async (_req, res) => {
+        if (!ctx.feedback) {
+            res.status(503).json({ error: 'Feedback not configured' });
+            return;
+        }
+        try {
+            const result = await ctx.feedback.retryUnforwarded();
+            res.json({ ok: true, ...result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ── Updates ────────────────────────────────────────────────────
+    router.get('/updates', async (_req, res) => {
+        if (!ctx.updateChecker) {
+            res.status(503).json({ error: 'Update checker not configured' });
+            return;
+        }
+        try {
+            const info = await ctx.updateChecker.check();
+            res.json(info);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/updates/last', (_req, res) => {
+        if (!ctx.updateChecker) {
+            res.status(503).json({ error: 'Update checker not configured' });
+            return;
+        }
+        const lastCheck = ctx.updateChecker.getLastCheck();
+        if (!lastCheck) {
+            res.json({ message: 'No update check has been performed yet' });
+            return;
+        }
+        res.json(lastCheck);
+    });
     // ── Events ──────────────────────────────────────────────────────
     router.get('/events', (req, res) => {
         const limit = parseInt(req.query.limit) || 50;

package/package.json

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

package/site/public/favicon.svg

@@ -1,6 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" fill="none">
-  <rect width="32" height="32" rx="6" fill="#0a0e17"/>
-  <path d="M8 22 L16 8 L24 22" stroke="#fbbf24" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
-  <path d="M11 17 L21 17" stroke="#fbbf24" stroke-width="2" stroke-linecap="round"/>
-  <circle cx="16" cy="12" r="1.5" fill="#fbbf24"/>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="6" fill="#0d2137"/>
+  <text x="16" y="23" text-anchor="middle" font-size="20" fill="#6ec6c8" font-family="system-ui" font-weight="bold">i</text>
 </svg>