instar 0.6.11 → 0.6.13

package/dist/core/types.d.ts

@@ -222,6 +222,38 @@ export interface ComponentHealth {
     message?: string;
     lastCheck: string;
 }
+/**
+ * Optional LLM intelligence for judgment calls.
+ *
+ * Any module that makes decisions beyond simple lookups can declare
+ * `intelligence?: IntelligenceProvider` in its config. This is the
+ * structural pattern that prevents defaulting to brittle heuristics.
+ *
+ * The contract: heuristics narrow candidates, the provider decides.
+ * When no provider is configured, modules fall back to heuristic-only
+ * behavior — functional but less accurate.
+ *
+ * Born from the "heuristics are pre-filters, not decision-makers" lesson.
+ */
+export interface IntelligenceProvider {
+    /**
+     * Ask the LLM to evaluate a judgment call.
+     * Returns a structured response that the caller parses.
+     *
+     * @param prompt - The judgment to make, with full context
+     * @param options - Optional configuration for this call
+     * @returns The LLM's response text
+     */
+    evaluate(prompt: string, options?: IntelligenceOptions): Promise<string>;
+}
+export interface IntelligenceOptions {
+    /** Model tier preference (implementations may override based on availability) */
+    model?: 'fast' | 'balanced' | 'capable';
+    /** Maximum tokens for the response */
+    maxTokens?: number;
+    /** Temperature (0-1, lower = more deterministic) */
+    temperature?: number;
+}
 export interface RelationshipRecord {
     /** Unique identifier for this person */
     id: string;
@@ -245,6 +277,10 @@ export interface RelationshipRecord {
     significance: number;
     /** Brief summary of the relationship arc */
     arcSummary?: string;
+    /** Relationship category (e.g., 'collaborator', 'community_member', 'kindred_ai') */
+    category?: string;
+    /** Freeform tags for flexible categorization */
+    tags?: string[];
     /** Per-interaction log (last N interactions, kept compact) */
     recentInteractions: InteractionSummary[];
 }
@@ -263,6 +299,13 @@ export interface RelationshipManagerConfig {
     relationshipsDir: string;
     /** Maximum recent interactions to keep per relationship */
     maxRecentInteractions: number;
+    /**
+     * Optional LLM intelligence for judgment calls (identity resolution,
+     * duplicate detection, merge decisions). When absent, falls back to
+     * string-based heuristics. When present, heuristics narrow candidates
+     * and the LLM makes the final call.
+     */
+    intelligence?: IntelligenceProvider;
 }
 export type SkipReason = 'disabled' | 'paused' | 'quota' | 'capacity';
 export interface SkipEvent {
@@ -363,6 +406,173 @@ export interface UpdateResult {
     /** Health check result after update */
     healthCheck?: 'healthy' | 'degraded' | 'unhealthy' | 'skipped';
 }
+/**
+ * Evolution proposal — a staged self-improvement suggestion.
+ *
+ * Unlike direct self-modification (editing jobs.json, creating skills),
+ * proposals are staged for review before implementation. This gives
+ * the agent (and optionally the user) a chance to evaluate whether
+ * the change is wise before it takes effect.
+ *
+ * Born from Portal's EVOLUTION_QUEUE pattern (100+ completed proposals).
+ */
+export interface EvolutionProposal {
+    /** Unique ID (e.g., "EVO-001") */
+    id: string;
+    /** Short title describing the proposed change */
+    title: string;
+    /** Where this proposal came from */
+    source: string;
+    /** Full description of what to change and why */
+    description: string;
+    /** Category of change */
+    type: EvolutionType;
+    /** Expected impact if implemented */
+    impact: 'high' | 'medium' | 'low';
+    /** Estimated effort to implement */
+    effort: 'high' | 'medium' | 'low';
+    /** Current status */
+    status: EvolutionStatus;
+    /** Who or what proposed this */
+    proposedBy: string;
+    /** When proposed */
+    proposedAt: string;
+    /** When implemented (if status is 'implemented') */
+    implementedAt?: string;
+    /** Implementation notes */
+    resolution?: string;
+    /** Tags for categorization */
+    tags?: string[];
+}
+export type EvolutionType = 'capability' | 'infrastructure' | 'voice' | 'workflow' | 'philosophy' | 'integration' | 'performance';
+export type EvolutionStatus = 'proposed' | 'approved' | 'in_progress' | 'implemented' | 'rejected' | 'deferred';
+/**
+ * Structured learning entry — an insight captured from interaction.
+ *
+ * Unlike freeform MEMORY.md entries, these are structured, searchable,
+ * cross-referenceable, and trackable (applied vs unapplied).
+ */
+export interface LearningEntry {
+    /** Unique ID (e.g., "LRN-001") */
+    id: string;
+    /** Short title */
+    title: string;
+    /** Category of learning */
+    category: string;
+    /** Full description of the insight */
+    description: string;
+    /** Where this learning came from */
+    source: LearningSource;
+    /** Tags for cross-referencing */
+    tags: string[];
+    /** Has this learning been applied to improve the agent? */
+    applied: boolean;
+    /** What it was applied to (e.g., "EVO-003", "MEMORY.md") */
+    appliedTo?: string;
+    /** How relevant this is to agent evolution (freeform) */
+    evolutionRelevance?: string;
+}
+export interface LearningSource {
+    /** Who/what taught this */
+    agent?: string;
+    /** Platform where discovered */
+    platform?: string;
+    /** Content reference (post ID, thread ID, etc.) */
+    contentId?: string;
+    /** When discovered */
+    discoveredAt: string;
+    /** Session that captured this */
+    session?: string;
+}
+/**
+ * Capability gap — something the agent can't do but should.
+ *
+ * Extends self-diagnosis from "is my infrastructure broken?" to
+ * "is my infrastructure sufficient?"
+ */
+export interface CapabilityGap {
+    /** Unique ID (e.g., "GAP-001") */
+    id: string;
+    /** Short title */
+    title: string;
+    /** Category of gap */
+    category: GapCategory;
+    /** How critical this gap is */
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    /** Full description of the gap */
+    description: string;
+    /** How the gap was discovered */
+    discoveredFrom: {
+        context: string;
+        platform?: string;
+        discoveredAt: string;
+        session?: string;
+    };
+    /** What the agent currently does (or doesn't) */
+    currentState: string;
+    /** What should be built to close the gap */
+    proposedSolution?: string;
+    /** Current status */
+    status: 'identified' | 'addressed' | 'wont_fix';
+    /** How it was resolved */
+    resolution?: string;
+    /** When addressed */
+    addressedAt?: string;
+}
+export type GapCategory = 'skill' | 'knowledge' | 'integration' | 'workflow' | 'communication' | 'monitoring' | 'custom';
+/**
+ * Action/commitment item — something the agent promised to do.
+ *
+ * Tracks commitments made during interactions so they don't get lost.
+ * Stale commitments are escalated automatically.
+ */
+export interface ActionItem {
+    /** Unique ID (e.g., "ACT-001") */
+    id: string;
+    /** What was committed */
+    title: string;
+    /** Full description */
+    description: string;
+    /** Priority level */
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    /** Current status */
+    status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    /** Who this commitment was made to */
+    commitTo?: string;
+    /** When this was created */
+    createdAt: string;
+    /** When this should be done by (ISO date) */
+    dueBy?: string;
+    /** When completed */
+    completedAt?: string;
+    /** How it was resolved */
+    resolution?: string;
+    /** Where this commitment was made */
+    source?: {
+        platform?: string;
+        contentId?: string;
+        context?: string;
+    };
+    /** Tags for categorization */
+    tags?: string[];
+}
+/**
+ * Evolution manager configuration.
+ */
+export interface EvolutionManagerConfig {
+    /** Directory for evolution state files */
+    stateDir: string;
+    /** Whether auto-implementation of approved proposals is enabled */
+    autoImplement?: boolean;
+    /** Maximum proposals before oldest get archived */
+    maxProposals?: number;
+    /** Maximum learning entries before oldest get archived */
+    maxLearnings?: number;
+    /** Maximum gaps before oldest addressed get archived */
+    maxGaps?: number;
+    /** Maximum action items before oldest completed get archived */
+    maxActions?: number;
+}
 export interface InstarConfig {
     /** Project name (used in logging, tmux session names, etc.) */
     projectName: string;
@@ -404,6 +614,8 @@ export interface InstarConfig {
     version?: string;
     /** Safety configuration for autonomous operation */
     safety?: SafetyConfig;
+    /** Evolution system configuration */
+    evolution?: EvolutionManagerConfig;
 }
 /**
  * Safety configuration — controls the progression from supervised to autonomous operation.

package/dist/index.d.ts

@@ -6,7 +6,10 @@
 export { SessionManager } from './core/SessionManager.js';
 export { StateManager } from './core/StateManager.js';
 export { RelationshipManager } from './core/RelationshipManager.js';
+export { ClaudeCliIntelligenceProvider } from './core/ClaudeCliIntelligenceProvider.js';
+export { AnthropicIntelligenceProvider } from './core/AnthropicIntelligenceProvider.js';
 export { FeedbackManager } from './core/FeedbackManager.js';
+export { EvolutionManager } from './core/EvolutionManager.js';
 export { DispatchManager } from './core/DispatchManager.js';
 export { UpdateChecker } from './core/UpdateChecker.js';
 export type { RollbackResult, UpdateCheckerConfig } from './core/UpdateChecker.js';
@@ -32,6 +35,6 @@ export { PrivateViewer } from './publishing/PrivateViewer.js';
 export type { PrivateView, PrivateViewerConfig } from './publishing/PrivateViewer.js';
 export { TunnelManager } from './tunnel/TunnelManager.js';
 export type { TunnelConfig, TunnelState } from './tunnel/TunnelManager.js';
-export type { Session, SessionStatus, SessionManagerConfig, ModelTier, JobDefinition, JobPriority, JobExecution, JobState, JobSchedulerConfig, UserProfile, UserChannel, UserPreferences, Message, OutgoingMessage, MessagingAdapter, MessagingAdapterConfig, QuotaState, AccountQuota, HealthStatus, ComponentHealth, ActivityEvent, InstarConfig, MonitoringConfig, RelationshipRecord, RelationshipManagerConfig, InteractionSummary, FeedbackItem, FeedbackConfig, UpdateInfo, UpdateResult, DispatchConfig, UpdateConfig, PublishingConfig, TunnelConfigType, SkipReason, SkipEvent, WorkloadSignal, AutoTuneState, } 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, InstarConfig, MonitoringConfig, RelationshipRecord, RelationshipManagerConfig, InteractionSummary, FeedbackItem, FeedbackConfig, UpdateInfo, UpdateResult, DispatchConfig, UpdateConfig, PublishingConfig, TunnelConfigType, SkipReason, SkipEvent, WorkloadSignal, AutoTuneState, IntelligenceProvider, IntelligenceOptions, EvolutionProposal, EvolutionType, EvolutionStatus, LearningEntry, LearningSource, CapabilityGap, GapCategory, ActionItem, EvolutionManagerConfig, } from './core/types.js';
 export type { Dispatch, DispatchCheckResult, DispatchEvaluation, EvaluationDecision, DispatchFeedback, DispatchStats } from './core/DispatchManager.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -7,7 +7,10 @@
 export { SessionManager } from './core/SessionManager.js';
 export { StateManager } from './core/StateManager.js';
 export { RelationshipManager } from './core/RelationshipManager.js';
+export { ClaudeCliIntelligenceProvider } from './core/ClaudeCliIntelligenceProvider.js';
+export { AnthropicIntelligenceProvider } from './core/AnthropicIntelligenceProvider.js';
 export { FeedbackManager } from './core/FeedbackManager.js';
+export { EvolutionManager } from './core/EvolutionManager.js';
 export { DispatchManager } from './core/DispatchManager.js';
 export { UpdateChecker } from './core/UpdateChecker.js';
 export { PostUpdateMigrator } from './core/PostUpdateMigrator.js';

package/dist/scaffold/templates.js

@@ -396,6 +396,42 @@ Instar has a built-in feedback loop that connects all agents to the development
 
 **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.
 
+### Evolution System
+
+You have a built-in evolution system with four subsystems. This is not a metaphor — it's infrastructure that tracks your growth.
+
+**Evolution Queue** — Staged self-improvement proposals.
+- View: \`curl http://localhost:${port}/evolution/proposals\`
+- Propose: \`/evolve\` skill or \`POST /evolution/proposals\`
+- The \`evolution-review\` job evaluates and implements proposals every 6 hours.
+
+**Learning Registry** — Structured, searchable insights.
+- View: \`curl http://localhost:${port}/evolution/learnings\`
+- Record: \`/learn\` skill or \`POST /evolution/learnings\`
+- The \`insight-harvest\` job synthesizes patterns into proposals every 8 hours.
+
+**Capability Gaps** — Track what you're missing.
+- View: \`curl http://localhost:${port}/evolution/gaps\`
+- Report: \`/gaps\` skill or \`POST /evolution/gaps\`
+
+**Action Queue** — Commitments with follow-through tracking.
+- View: \`curl http://localhost:${port}/evolution/actions\`
+- Create: \`/commit-action\` skill or \`POST /evolution/actions\`
+- The \`commitment-check\` job surfaces overdue items every 4 hours.
+
+**Dashboard** — Full evolution health at a glance:
+\`\`\`bash
+curl http://localhost:${port}/evolution
+\`\`\`
+
+**Skills for evolution:**
+- \`/evolve\` — Propose an improvement
+- \`/learn\` — Record an insight
+- \`/gaps\` — Report a missing capability
+- \`/commit-action\` — Track a commitment
+
+**The principle:** Evolution is not a separate activity from work. Every task is an opportunity to notice what could be better. The post-action reflection hook reminds you to pause after significant actions (commits, deploys) and consider what you learned. Most learning is lost because nobody paused to ask.
+
 ### 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

@@ -18,6 +18,7 @@ import type { QuotaTracker } from '../monitoring/QuotaTracker.js';
 import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
 import type { TunnelManager } from '../tunnel/TunnelManager.js';
+import type { EvolutionManager } from '../core/EvolutionManager.js';
 export declare class AgentServer {
     private app;
     private server;
@@ -37,6 +38,7 @@ export declare class AgentServer {
         publisher?: TelegraphService;
         viewer?: PrivateViewer;
         tunnel?: TunnelManager;
+        evolution?: EvolutionManager;
     });
     /**
      * Start the HTTP server.

package/dist/server/AgentServer.js

@@ -36,6 +36,7 @@ export class AgentServer {
             publisher: options.publisher ?? null,
             viewer: options.viewer ?? null,
             tunnel: options.tunnel ?? null,
+            evolution: options.evolution ?? null,
             startTime: this.startTime,
         });
         this.app.use(routes);

package/dist/server/routes.d.ts

@@ -18,6 +18,7 @@ import type { QuotaTracker } from '../monitoring/QuotaTracker.js';
 import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
 import type { TunnelManager } from '../tunnel/TunnelManager.js';
+import type { EvolutionManager } from '../core/EvolutionManager.js';
 export interface RouteContext {
     config: InstarConfig;
     sessionManager: SessionManager;
@@ -32,6 +33,7 @@ export interface RouteContext {
     publisher: TelegraphService | null;
     viewer: PrivateViewer | null;
     tunnel: TunnelManager | null;
+    evolution: EvolutionManager | null;
     startTime: Date;
 }
 export declare function createRoutes(ctx: RouteContext): Router;

package/dist/server/routes.js

@@ -1324,6 +1324,224 @@ export function createRoutes(ctx) {
             res.status(503).json({ error: 'No message routing available' });
         }
     });
+    // ── Evolution System ───────────────────────────────────────────
+    // Dashboard — overview of all evolution subsystems
+    router.get('/evolution', (_req, res) => {
+        if (!ctx.evolution) {
+            res.json({ enabled: false });
+            return;
+        }
+        res.json({ enabled: true, ...ctx.evolution.getDashboard() });
+    });
+    // Evolution proposals
+    router.get('/evolution/proposals', (req, res) => {
+        if (!ctx.evolution) {
+            res.json({ proposals: [] });
+            return;
+        }
+        const status = req.query.status;
+        const type = req.query.type;
+        res.json({ proposals: ctx.evolution.listProposals({ status, type }) });
+    });
+    router.post('/evolution/proposals', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { title, source, description, type, impact, effort, proposedBy, tags } = req.body;
+        if (!title || typeof title !== 'string' || title.length > 500) {
+            res.status(400).json({ error: '"title" must be a string under 500 characters' });
+            return;
+        }
+        if (!description || typeof description !== 'string' || description.length > 10_000) {
+            res.status(400).json({ error: '"description" must be a string under 10KB' });
+            return;
+        }
+        const validTypes = ['capability', 'infrastructure', 'voice', 'workflow', 'philosophy', 'integration', 'performance'];
+        if (type && !validTypes.includes(type)) {
+            res.status(400).json({ error: `"type" must be one of: ${validTypes.join(', ')}` });
+            return;
+        }
+        const proposal = ctx.evolution.addProposal({
+            title, source: source || 'api', description,
+            type: type || 'capability', impact, effort, proposedBy, tags,
+        });
+        res.status(201).json(proposal);
+    });
+    router.patch('/evolution/proposals/:id', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { status, resolution } = req.body;
+        const validStatuses = ['proposed', 'approved', 'in_progress', 'implemented', 'rejected', 'deferred'];
+        if (!status || !validStatuses.includes(status)) {
+            res.status(400).json({ error: `"status" must be one of: ${validStatuses.join(', ')}` });
+            return;
+        }
+        const success = ctx.evolution.updateProposalStatus(req.params.id, status, resolution);
+        if (!success) {
+            res.status(404).json({ error: 'Proposal not found' });
+            return;
+        }
+        res.json({ ok: true, id: req.params.id, status });
+    });
+    // Learning registry
+    router.get('/evolution/learnings', (req, res) => {
+        if (!ctx.evolution) {
+            res.json({ learnings: [] });
+            return;
+        }
+        const category = req.query.category;
+        const applied = req.query.applied !== undefined ? req.query.applied === 'true' : undefined;
+        res.json({ learnings: ctx.evolution.listLearnings({ category, applied }) });
+    });
+    router.post('/evolution/learnings', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { title, category, description, source, tags, evolutionRelevance } = req.body;
+        if (!title || typeof title !== 'string' || title.length > 500) {
+            res.status(400).json({ error: '"title" must be a string under 500 characters' });
+            return;
+        }
+        if (!description || typeof description !== 'string') {
+            res.status(400).json({ error: '"description" is required' });
+            return;
+        }
+        const learning = ctx.evolution.addLearning({
+            title, category: category || 'general', description,
+            source: source || { discoveredAt: new Date().toISOString() },
+            tags, evolutionRelevance,
+        });
+        res.status(201).json(learning);
+    });
+    router.patch('/evolution/learnings/:id/apply', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { appliedTo } = req.body;
+        if (!appliedTo || typeof appliedTo !== 'string') {
+            res.status(400).json({ error: '"appliedTo" is required' });
+            return;
+        }
+        const success = ctx.evolution.markLearningApplied(req.params.id, appliedTo);
+        if (!success) {
+            res.status(404).json({ error: 'Learning not found' });
+            return;
+        }
+        res.json({ ok: true, id: req.params.id, appliedTo });
+    });
+    // Capability gaps
+    router.get('/evolution/gaps', (req, res) => {
+        if (!ctx.evolution) {
+            res.json({ gaps: [] });
+            return;
+        }
+        const severity = req.query.severity;
+        const category = req.query.category;
+        const status = req.query.status;
+        res.json({ gaps: ctx.evolution.listGaps({ severity, category, status }) });
+    });
+    router.post('/evolution/gaps', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { title, category, severity, description, context, platform, session, currentState, proposedSolution } = req.body;
+        if (!title || typeof title !== 'string' || title.length > 500) {
+            res.status(400).json({ error: '"title" must be a string under 500 characters' });
+            return;
+        }
+        if (!description || typeof description !== 'string') {
+            res.status(400).json({ error: '"description" is required' });
+            return;
+        }
+        const validSeverities = ['critical', 'high', 'medium', 'low'];
+        if (severity && !validSeverities.includes(severity)) {
+            res.status(400).json({ error: `"severity" must be one of: ${validSeverities.join(', ')}` });
+            return;
+        }
+        const gap = ctx.evolution.addGap({
+            title, category: category || 'custom', severity: severity || 'medium',
+            description, context: context || '', platform, session,
+            currentState, proposedSolution,
+        });
+        res.status(201).json(gap);
+    });
+    router.patch('/evolution/gaps/:id/address', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { resolution } = req.body;
+        if (!resolution || typeof resolution !== 'string') {
+            res.status(400).json({ error: '"resolution" is required' });
+            return;
+        }
+        const success = ctx.evolution.addressGap(req.params.id, resolution);
+        if (!success) {
+            res.status(404).json({ error: 'Gap not found' });
+            return;
+        }
+        res.json({ ok: true, id: req.params.id, status: 'addressed' });
+    });
+    // Action queue
+    router.get('/evolution/actions', (req, res) => {
+        if (!ctx.evolution) {
+            res.json({ actions: [] });
+            return;
+        }
+        const status = req.query.status;
+        const priority = req.query.priority;
+        res.json({ actions: ctx.evolution.listActions({ status, priority }) });
+    });
+    router.get('/evolution/actions/overdue', (_req, res) => {
+        if (!ctx.evolution) {
+            res.json({ overdue: [] });
+            return;
+        }
+        res.json({ overdue: ctx.evolution.getOverdueActions() });
+    });
+    router.post('/evolution/actions', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { title, description, priority, commitTo, dueBy, source, tags } = req.body;
+        if (!title || typeof title !== 'string' || title.length > 500) {
+            res.status(400).json({ error: '"title" must be a string under 500 characters' });
+            return;
+        }
+        if (!description || typeof description !== 'string') {
+            res.status(400).json({ error: '"description" is required' });
+            return;
+        }
+        const action = ctx.evolution.addAction({
+            title, description, priority, commitTo, dueBy, source, tags,
+        });
+        res.status(201).json(action);
+    });
+    router.patch('/evolution/actions/:id', (req, res) => {
+        if (!ctx.evolution) {
+            res.status(503).json({ error: 'Evolution system not configured' });
+            return;
+        }
+        const { status, resolution } = req.body;
+        const validStatuses = ['pending', 'in_progress', 'completed', 'cancelled'];
+        if (status && !validStatuses.includes(status)) {
+            res.status(400).json({ error: `"status" must be one of: ${validStatuses.join(', ')}` });
+            return;
+        }
+        const success = ctx.evolution.updateAction(req.params.id, { status, resolution });
+        if (!success) {
+            res.status(404).json({ error: 'Action not found' });
+            return;
+        }
+        res.json({ ok: true, id: req.params.id, status });
+    });
     return router;
 }
 export function formatUptime(ms) {

package/package.json

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