@siftd/connect-agent 0.2.27 → 0.2.29

package/README.md

@@ -9,7 +9,9 @@ Connect Agent runs on your machine and bridges the Connect web app to Claude Cod
 - **Persistent Memory** - Remembers your preferences, projects, and context across sessions
 - **Worker Delegation** - Delegates complex tasks to Claude Code CLI workers
 - **Task Scheduling** - Schedule tasks for future execution
-- **Semantic Search** - Finds relevant memories by meaning, not just keywords
+- **Hub System** - Organized workspace at `~/Lia-Hub/` for state management
+- **Gallery View** - See all files your workers create in the UI
+- **Progress Tracking** - Real-time progress bars for running workers
 
 ## Quick Start
 
@@ -23,6 +25,12 @@ npx @siftd/connect-agent pair <CODE> --api-key <YOUR_ANTHROPIC_API_KEY>
 npx @siftd/connect-agent start
 ```
 
+On first start, the agent creates `~/Lia-Hub/` with:
+- `AGENTS.md` - Agent identity
+- `CLAUDE.md` - Your custom instructions
+- `LANDMARKS.md` - Current state
+- `notebook-a/` - Working notes and worker logs
+
 ## Modes
 
 ### Orchestrator Mode (Recommended)
@@ -31,6 +39,7 @@ When you provide an Anthropic API key, the agent runs as a **master orchestrator
 - Maintains persistent memory about you and your projects
 - Delegates file/code work to Claude Code CLI workers
 - Schedules future tasks
+- Reads hub files for context on every startup
 
 ### Simple Relay Mode
 Without an API key, the agent acts as a simple relay to `claude -p --continue`.
@@ -59,6 +68,24 @@ connect-agent logout
 - `/reset` or `/clear` - Clear conversation history
 - `/mode` - Check current mode (orchestrator vs simple)
 - `/memory` - Show memory statistics
+- `/verbose` - Toggle verbose tool output
+
+## Hub Structure
+
+```
+~/Lia-Hub/
+├── AGENTS.md           # Agent identity and capabilities
+├── CLAUDE.md           # Your custom instructions (always followed)
+├── LANDMARKS.md        # Current state, active projects
+├── MISTAKES.md         # Lessons learned (never deleted)
+├── notebook-a/
+│   ├── SCRATCHPAD.md   # Working notes and plans
+│   └── WORKER-LOG.md   # All worker history (auto-logged)
+└── shared/
+    └── outputs/        # Worker output files
+```
+
+Edit `CLAUDE.md` to customize the orchestrator's behavior!
 
 ## How It Works
 
@@ -72,7 +99,7 @@ connect-agent logout
                                                  ┌─────────────────┐
                                                  │ Master          │
                                                  │ Orchestrator    │
-                                                 │ (memory, sched) │
+                                                 │ (memory, hub)   │
                                                  └────────┬────────┘
                                                           │ delegates
                                                           ▼
@@ -83,17 +110,32 @@ connect-agent logout
 ```
 
 The orchestrator understands it's the **master**, not a worker. It:
-1. Receives your message from the web
-2. Searches memory for relevant context
-3. Decides what needs to be done
-4. Delegates actual work to Claude Code CLI
-5. Synthesizes results into a clear response
-6. Remembers important things for next time
+1. Loads hub context (AGENTS.md, CLAUDE.md, LANDMARKS.md)
+2. Receives your message from the web
+3. Searches memory for relevant context
+4. Decides what needs to be done
+5. Delegates actual work to Claude Code CLI workers
+6. Shows progress in real-time
+7. Synthesizes results into a clear response
+8. Logs workers to WORKER-LOG.md
+9. Remembers important things for next time
+
+## Customizing Worker Behavior
+
+All worker prompts are defined in `src/prompts/worker-system.ts`. Update this file to change how ALL workers behave:
+
+```typescript
+// src/prompts/worker-system.ts
+export const WORKER_IDENTITY = `...`;
+export const WORKER_OUTPUT_FORMAT = `...`;
+export function buildWorkerPrompt(task, options) { ... }
+```
 
 ## Environment Variables
 
 - `ANTHROPIC_API_KEY` - Alternative to `--api-key` flag
 - `VOYAGE_API_KEY` - (Optional) For better semantic search embeddings
+- `DATABASE_URL` - (Optional) PostgreSQL for cloud memory persistence
 
 ## Requirements
 
@@ -101,6 +143,13 @@ The orchestrator understands it's the **master**, not a worker. It:
 - [Claude Code CLI](https://claude.ai/code) installed and authenticated
 - Anthropic API key (for orchestrator mode)
 
+## Version History
+
+- **v0.2.28** - Lia-Hub structure, CLAUDE.md support, standardized worker prompts
+- **v0.2.27** - Fixed workers opening browser tabs
+- **v0.2.26** - Gallery view, worker asset tracking
+- **v0.2.25** - Progress bars, heartbeat system
+
 ## License
 
 MIT

package/dist/agent.js

@@ -4,6 +4,7 @@ import { getUserId, getAnthropicApiKey, isCloudMode, getDeploymentInfo } from '.
 import { MasterOrchestrator } from './orchestrator.js';
 import { AgentWebSocket } from './websocket.js';
 import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js';
+import { loadHubContext, readScratchpad } from './core/hub.js';
 // Strip ANSI escape codes for clean output
 function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
@@ -217,6 +218,22 @@ export async function runAgent(pollInterval = 2000) {
         console.log('[AGENT] Features: Memory, Scheduling, Worker Delegation');
         // Initialize orchestrator (indexes filesystem into memory)
         await orchestrator.initialize();
+        // Load hub context on startup
+        const hubContext = loadHubContext();
+        if (hubContext.agentIdentity) {
+            console.log('[AGENT] Hub: AGENTS.md loaded');
+        }
+        if (hubContext.claudeMd) {
+            console.log('[AGENT] Hub: CLAUDE.md loaded');
+        }
+        if (hubContext.landmarks) {
+            console.log('[AGENT] Hub: LANDMARKS.md loaded');
+        }
+        // Check scratchpad for pending plans
+        const scratchpad = readScratchpad();
+        if (scratchpad && scratchpad.length > 100) {
+            console.log(`[AGENT] Scratchpad: ${scratchpad.length} chars of pending notes`);
+        }
     }
     // Start heartbeat to maintain presence in runner registry
     const runnerType = isCloudMode() ? 'vm' : 'local';

package/dist/cli.js

@@ -4,6 +4,7 @@ import ora from 'ora';
 import { getServerUrl, setServerUrl, setAgentToken, setUserId, setAnthropicApiKey, getAnthropicApiKey, isConfigured, clearConfig, getConfigPath, } from './config.js';
 import { connectWithPairingCode, checkConnection } from './api.js';
 import { runAgent } from './agent.js';
+import { ensureLiaHub, getLiaHubPaths } from './core/hub.js';
 program
     .name('connect-agent')
     .description('Local agent for Connect web app')
@@ -61,6 +62,11 @@ program
         process.exit(1);
     }
     spinner.succeed('Connected to server');
+    // Initialize Lia-Hub directory structure
+    ensureLiaHub();
+    const hubPaths = getLiaHubPaths();
+    console.log(`\nHub: ${hubPaths.hub}`);
+    console.log(`Notebook: ${hubPaths.notebook}`);
     console.log(`\nServer: ${getServerUrl()}`);
     console.log(`Poll interval: ${options.interval}ms`);
     console.log('\nPress Ctrl+C to stop.\n');

package/dist/core/hub.d.ts

@@ -4,8 +4,44 @@
  * Manages structured memory files in ~/.connect-hub/
  * Human-readable markdown files that the orchestrator reads/writes.
  */
+/**
+ * Ensure Lia-Hub directory structure exists
+ * Called on agent start to create the orchestrator's workspace
+ */
+export declare function ensureLiaHub(): void;
+/**
+ * Get paths to Lia-Hub directories
+ */
+export declare function getLiaHubPaths(): {
+    hub: string;
+    notebook: string;
+    drafts: string;
+    shared: string;
+    outputs: string;
+};
+/**
+ * Read the orchestrator's scratchpad
+ */
+export declare function readScratchpad(): string | null;
+/**
+ * Write to the orchestrator's scratchpad
+ */
+export declare function writeScratchpad(content: string): void;
+/**
+ * Append a thought or plan to the scratchpad
+ */
+export declare function appendToScratchpad(note: string): void;
+/**
+ * Log a worker to the worker log
+ */
+export declare function logWorker(workerId: string, task: string, status: 'started' | 'completed' | 'failed' | 'timeout', duration?: number, filesCreated?: string[]): void;
+/**
+ * Get the shared output directory path for workers
+ */
+export declare function getSharedOutputPath(): string;
 export interface HubContext {
     agentIdentity: string;
+    claudeMd: string;
     landmarks: string;
     projectBio: string | null;
     projectName: string | null;
@@ -16,7 +52,8 @@ export interface HubContext {
 export declare function ensureHubExists(): void;
 /**
  * Load hub context for a session
- * Reads AGENTS.md, LANDMARKS.md, and relevant project bio
+ * Reads AGENTS.md, CLAUDE.md, LANDMARKS.md, and relevant project bio
+ * Checks both ~/.connect-hub and ~/Lia-Hub locations
  */
 export declare function loadHubContext(message?: string): HubContext;
 /**

package/dist/core/hub.js

@@ -9,6 +9,190 @@ import { join } from 'path';
 import { homedir } from 'os';
 const HUB_DIR = join(homedir(), '.connect-hub');
 const PROJECTS_DIR = join(HUB_DIR, 'projects');
+// Lia-Hub: The orchestrator's working directory
+const LIA_HUB_DIR = join(homedir(), 'Lia-Hub');
+const NOTEBOOK_A_DIR = join(LIA_HUB_DIR, 'notebook-a');
+const DRAFTS_DIR = join(NOTEBOOK_A_DIR, 'drafts');
+const SHARED_DIR = join(LIA_HUB_DIR, 'shared');
+const OUTPUTS_DIR = join(SHARED_DIR, 'outputs');
+/**
+ * Ensure Lia-Hub directory structure exists
+ * Called on agent start to create the orchestrator's workspace
+ */
+export function ensureLiaHub() {
+    const dirs = [
+        LIA_HUB_DIR,
+        NOTEBOOK_A_DIR,
+        DRAFTS_DIR,
+        SHARED_DIR,
+        OUTPUTS_DIR,
+        join(LIA_HUB_DIR, 'projects')
+    ];
+    for (const dir of dirs) {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+            console.log(`[HUB] Created: ${dir}`);
+        }
+    }
+    // Create template files if they don't exist
+    const agentsFile = join(LIA_HUB_DIR, 'AGENTS.md');
+    if (!existsSync(agentsFile)) {
+        writeFileSync(agentsFile, `# Agent Identity
+
+You are the Master Orchestrator - the brain that coordinates Claude Code workers.
+You remember, plan, delegate, and synthesize. Workers do the hands-on work.
+
+## Capabilities
+- Memory: Store and retrieve information across sessions
+- Scheduling: Schedule future tasks
+- Workers: Spawn Claude Code CLI for file/code operations
+- Web: Search and fetch from the web
+
+## Personality
+Warm, helpful, and efficient. You coordinate to get things done.
+`);
+        console.log('[HUB] Created AGENTS.md template');
+    }
+    const landmarksFile = join(LIA_HUB_DIR, 'LANDMARKS.md');
+    if (!existsSync(landmarksFile)) {
+        writeFileSync(landmarksFile, `# Current State
+
+## Active Projects
+(none yet)
+
+## Recent Work
+(none yet)
+
+## Blockers
+(none)
+`);
+        console.log('[HUB] Created LANDMARKS.md template');
+    }
+    const scratchpadFile = join(NOTEBOOK_A_DIR, 'SCRATCHPAD.md');
+    if (!existsSync(scratchpadFile)) {
+        writeFileSync(scratchpadFile, `# Orchestrator Scratchpad
+
+Use this file for:
+- Planning complex tasks
+- Working notes
+- Organizing thoughts before acting
+
+---
+
+`);
+        console.log('[HUB] Created SCRATCHPAD.md template');
+    }
+    const workerLogFile = join(NOTEBOOK_A_DIR, 'WORKER-LOG.md');
+    if (!existsSync(workerLogFile)) {
+        writeFileSync(workerLogFile, `# Worker Log
+
+Track all workers spawned and their outcomes.
+
+| Date | Worker ID | Task | Status | Duration | Files Created |
+|------|-----------|------|--------|----------|---------------|
+`);
+        console.log('[HUB] Created WORKER-LOG.md template');
+    }
+    // CLAUDE.md - User-editable instructions for the orchestrator
+    const claudeFile = join(LIA_HUB_DIR, 'CLAUDE.md');
+    if (!existsSync(claudeFile)) {
+        writeFileSync(claudeFile, `# Claude Instructions
+
+Custom instructions for the orchestrator. Edit this file to customize behavior.
+
+## Preferences
+- (Add your preferences here)
+
+## Project Defaults
+- (Add default project settings here)
+
+## Custom Rules
+- (Add any rules you want the orchestrator to follow)
+`);
+        console.log('[HUB] Created CLAUDE.md template');
+    }
+}
+/**
+ * Get paths to Lia-Hub directories
+ */
+export function getLiaHubPaths() {
+    return {
+        hub: LIA_HUB_DIR,
+        notebook: NOTEBOOK_A_DIR,
+        drafts: DRAFTS_DIR,
+        shared: SHARED_DIR,
+        outputs: OUTPUTS_DIR
+    };
+}
+/**
+ * Read the orchestrator's scratchpad
+ */
+export function readScratchpad() {
+    const path = join(NOTEBOOK_A_DIR, 'SCRATCHPAD.md');
+    if (existsSync(path)) {
+        try {
+            return readFileSync(path, 'utf-8');
+        }
+        catch (e) {
+            console.error('[HUB] Failed to read SCRATCHPAD.md:', e);
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Write to the orchestrator's scratchpad
+ */
+export function writeScratchpad(content) {
+    ensureLiaHub();
+    const path = join(NOTEBOOK_A_DIR, 'SCRATCHPAD.md');
+    try {
+        writeFileSync(path, content);
+        console.log('[HUB] Updated SCRATCHPAD.md');
+    }
+    catch (e) {
+        console.error('[HUB] Failed to write SCRATCHPAD.md:', e);
+    }
+}
+/**
+ * Append a thought or plan to the scratchpad
+ */
+export function appendToScratchpad(note) {
+    ensureLiaHub();
+    const path = join(NOTEBOOK_A_DIR, 'SCRATCHPAD.md');
+    const timestamp = new Date().toISOString().slice(0, 16).replace('T', ' ');
+    try {
+        appendFileSync(path, `\n## ${timestamp}\n${note}\n`);
+    }
+    catch (e) {
+        console.error('[HUB] Failed to append to SCRATCHPAD.md:', e);
+    }
+}
+/**
+ * Log a worker to the worker log
+ */
+export function logWorker(workerId, task, status, duration, filesCreated) {
+    ensureLiaHub();
+    const path = join(NOTEBOOK_A_DIR, 'WORKER-LOG.md');
+    const date = new Date().toISOString().slice(0, 10);
+    const durationStr = duration ? `${Math.round(duration)}s` : '-';
+    const filesStr = filesCreated?.length ? filesCreated.join(', ') : '-';
+    const taskShort = task.slice(0, 50).replace(/\|/g, '/');
+    const entry = `| ${date} | ${workerId} | ${taskShort} | ${status} | ${durationStr} | ${filesStr} |\n`;
+    try {
+        appendFileSync(path, entry);
+    }
+    catch (e) {
+        console.error('[HUB] Failed to write worker log:', e);
+    }
+}
+/**
+ * Get the shared output directory path for workers
+ */
+export function getSharedOutputPath() {
+    ensureLiaHub();
+    return OUTPUTS_DIR;
+}
 /**
  * Ensure hub directory structure exists
  */
@@ -21,7 +205,7 @@ export function ensureHubExists() {
     }
 }
 /**
- * Read a hub file safely
+ * Read a hub file safely (from ~/.connect-hub)
  */
 function readHubFile(filename) {
     const path = join(HUB_DIR, filename);
@@ -36,6 +220,22 @@ function readHubFile(filename) {
     }
     return null;
 }
+/**
+ * Read a Lia-Hub file safely (from ~/Lia-Hub)
+ */
+function readLiaHubFile(filename) {
+    const path = join(LIA_HUB_DIR, filename);
+    if (existsSync(path)) {
+        try {
+            return readFileSync(path, 'utf-8');
+        }
+        catch (e) {
+            console.error(`[HUB] Failed to read ${filename}:`, e);
+            return null;
+        }
+    }
+    return null;
+}
 /**
  * Read a project bio
  */
@@ -76,12 +276,15 @@ function detectProject(message) {
 }
 /**
  * Load hub context for a session
- * Reads AGENTS.md, LANDMARKS.md, and relevant project bio
+ * Reads AGENTS.md, CLAUDE.md, LANDMARKS.md, and relevant project bio
+ * Checks both ~/.connect-hub and ~/Lia-Hub locations
  */
 export function loadHubContext(message) {
     ensureHubExists();
-    const agentIdentity = readHubFile('AGENTS.md') || '';
-    const landmarks = readHubFile('LANDMARKS.md') || '';
+    // Read from both locations, prefer Lia-Hub if available
+    const agentIdentity = readLiaHubFile('AGENTS.md') || readHubFile('AGENTS.md') || '';
+    const claudeMd = readLiaHubFile('CLAUDE.md') || readHubFile('CLAUDE.md') || '';
+    const landmarks = readLiaHubFile('LANDMARKS.md') || readHubFile('LANDMARKS.md') || '';
     let projectBio = null;
     let projectName = null;
     // Try to detect project from message
@@ -93,6 +296,7 @@ export function loadHubContext(message) {
     }
     return {
         agentIdentity,
+        claudeMd,
         landmarks,
         projectBio,
         projectName
@@ -103,8 +307,14 @@ export function loadHubContext(message) {
  */
 export function formatHubContext(ctx) {
     const parts = [];
+    if (ctx.agentIdentity) {
+        parts.push(`## Agent Identity (AGENTS.md)\n\n${ctx.agentIdentity}`);
+    }
+    if (ctx.claudeMd) {
+        parts.push(`## User Instructions (CLAUDE.md)\n\n${ctx.claudeMd}`);
+    }
     if (ctx.landmarks) {
-        parts.push(`## Current State (LANDMARKS)\n\n${ctx.landmarks}`);
+        parts.push(`## Current State (LANDMARKS.md)\n\n${ctx.landmarks}`);
     }
     if (ctx.projectBio && ctx.projectName) {
         parts.push(`## Project Context: ${ctx.projectName}\n\n${ctx.projectBio}`);

package/dist/orchestrator.js

@@ -16,7 +16,8 @@ import { WebTools } from './tools/web.js';
 import { WorkerTools } from './tools/worker.js';
 import { SharedState } from './workers/shared-state.js';
 import { getKnowledgeForPrompt } from './genesis/index.js';
-import { loadHubContext, formatHubContext, logAction } from './core/hub.js';
+import { loadHubContext, formatHubContext, logAction, logWorker } from './core/hub.js';
+import { buildWorkerPrompt } from './prompts/worker-system.js';
 /**
  * Extract file paths from worker output
  * Workers naturally mention files they create: "Created /tmp/foo.html", "Saved to /path/file"
@@ -110,6 +111,30 @@ AFTER EVERY SIGNIFICANT ACTION:
 WHO YOU ARE:
 Warm, helpful orchestrator. You coordinate, remember, and delegate. You're the persistent layer that makes AI feel personal - but you do it by managing workers, not by doing tasks yourself.
 
+YOUR HUB: ~/Lia-Hub/
+You have a personal hub at ~/Lia-Hub/ for organizing your work:
+
+- **~/Lia-Hub/AGENTS.md** - Your identity and capabilities
+- **~/Lia-Hub/CLAUDE.md** - User's custom instructions (always follow these)
+- **~/Lia-Hub/LANDMARKS.md** - Current state, active projects, blockers
+- **~/Lia-Hub/MISTAKES.md** - Lessons learned (append, never delete)
+- **~/Lia-Hub/notebook-a/SCRATCHPAD.md** - Your working notes, plans, thoughts
+- **~/Lia-Hub/notebook-a/WORKER-LOG.md** - Track all workers you spawn
+- **~/Lia-Hub/shared/outputs/** - Where workers save their outputs
+
+BEFORE STARTING COMPLEX WORK:
+1. Check CLAUDE.md for user instructions
+2. Read LANDMARKS.md for current context
+3. Check MISTAKES.md for lessons learned
+4. Write your plan to SCRATCHPAD.md
+5. Search memory for relevant context
+
+AFTER COMPLETING WORK:
+1. Update LANDMARKS.md with new state
+2. Log any mistakes to MISTAKES.md
+3. Clear completed items from SCRATCHPAD.md
+4. Remember important learnings
+
 SLASH COMMANDS:
 - /reset - Clear conversation and memory context
 - /mode - Show current mode and capabilities
@@ -438,11 +463,26 @@ export class MasterOrchestrator {
         const memoryContext = await this.getMemoryContext(message);
         // Build system prompt with hub context, genesis knowledge, and memory context
         const genesisKnowledge = getKnowledgeForPrompt();
-        let systemWithContext = SYSTEM_PROMPT + genesisKnowledge;
-        // Add hub context (landmarks + project bio)
+        let systemWithContext = SYSTEM_PROMPT;
+        // CRITICAL: Inject hub context IMMEDIATELY after system prompt
+        // This ensures the orchestrator sees AGENTS.md, CLAUDE.md, LANDMARKS.md content
         if (hubContextStr) {
-            systemWithContext += `\n\n---\n\nHUB CONTEXT:\n${hubContextStr}`;
+            systemWithContext += `
+
+═══════════════════════════════════════════════════════════════════════════════
+                         YOUR HUB FILES (READ THESE FIRST!)
+═══════════════════════════════════════════════════════════════════════════════
+
+The following are the CURRENT CONTENTS of your hub files at ~/Lia-Hub/.
+ALWAYS check these before responding - especially CLAUDE.md for user instructions.
+
+${hubContextStr}
+
+═══════════════════════════════════════════════════════════════════════════════
+`;
         }
+        // Add genesis knowledge and memory context
+        systemWithContext += genesisKnowledge;
         if (memoryContext) {
             systemWithContext += `\n\nRELEVANT MEMORIES:\n${memoryContext}`;
         }
@@ -955,13 +995,13 @@ Be specific about what you want done.`,
     async delegateToWorker(task, context, workingDir) {
         const id = `worker_${Date.now()}_${++this.jobCounter}`;
         const cwd = workingDir || this.workspaceDir;
-        // Build simple prompt - no bloat
-        let prompt = task;
-        if (context) {
-            prompt = `Context: ${context}\n\nTask: ${task}`;
-        }
-        // Add brief instruction
-        prompt += `\n\nBe concise. Output results directly. Do NOT open browsers or start servers - just create files and report paths.`;
+        // Use standardized worker prompt from prompts module
+        const prompt = buildWorkerPrompt(task, {
+            jobId: id,
+            context
+        });
+        // Log worker start to hub
+        logWorker(id, task, 'started');
         console.log(`[ORCHESTRATOR] Worker ${id} starting: ${task.slice(0, 80)}...`);
         // Estimate task duration
         const estimatedTime = this.estimateTaskDuration(task);
@@ -1012,12 +1052,16 @@ Be specific about what you want done.`,
             clearTimeout(timeout);
             job.status = code === 0 ? 'completed' : 'failed';
             job.endTime = Date.now();
-            const duration = Math.round((job.endTime - job.startTime) / 1000);
-            console.log(`[ORCHESTRATOR] Worker ${id} done in ${duration}s`);
+            const duration = (job.endTime - job.startTime) / 1000;
+            console.log(`[ORCHESTRATOR] Worker ${id} done in ${Math.round(duration)}s`);
             const result = job.output.trim() || '(No output)';
             // Extract files from worker output (workers naturally mention what they created)
             const assets = extractFilesFromOutput(result);
             job.assets = assets;
+            // Log worker completion to hub
+            const status = code === 0 ? 'completed' : 'failed';
+            const filesCreated = assets.map(a => a.name);
+            logWorker(id, job.task, status, duration, filesCreated.length > 0 ? filesCreated : undefined);
             if (assets.length > 0) {
                 console.log(`[ORCHESTRATOR] Worker ${id} created ${assets.length} files: ${assets.map(a => a.name).join(', ')}`);
                 // Store in memory for gallery queries

package/dist/prompts/worker-system.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Standardized Worker System Prompts
+ *
+ * All workers receive consistent instructions through these prompts.
+ * UPDATE THIS FILE to change how all workers behave.
+ */
+/**
+ * Core worker identity and rules
+ * This is the foundation every worker receives
+ */
+export declare const WORKER_IDENTITY = "## Worker Identity\nYou are a Claude Code CLI worker executing a delegated task.\nYou report to the Master Orchestrator.\n\n## Critical Rules\n1. Do NOT open browsers or start servers\n2. Do NOT ask questions - just do the work\n3. Output files to the shared workspace unless specified\n4. Report file paths you create at the end\n5. Be concise and efficient";
+/**
+ * Output format workers should follow
+ */
+export declare const WORKER_OUTPUT_FORMAT = "## Output Format\nWhen done, clearly list:\n- Files created: /path/to/file.ext\n- Files modified: /path/to/file.ext\n- Key findings: brief summary\n\nBe concise. Execute efficiently.";
+/**
+ * Instructions for workers to contribute back to memory
+ * Workers can add to orchestrator's memory using these patterns
+ */
+export declare const WORKER_MEMORY_INSTRUCTIONS = "## Memory Contributions (Optional)\nIf you discover important information the orchestrator should remember:\n- [MEMORY] type=semantic | content=Important fact or preference\n- [MEMORY] type=procedural | content=How to do something\n- [MEMORY] type=episodic | content=What happened and when\n\nExample: [MEMORY] type=semantic | content=User prefers tabs over spaces in TypeScript files";
+/**
+ * Instructions for worker-to-worker coordination
+ */
+export declare const WORKER_COORDINATION = "## Coordination (For Parallel Workers)\nShare data with other workers:\n- [SHARE] key=myKey | value={\"data\": \"here\"}\n- [SIGNAL] name=taskComplete | data={\"result\": \"success\"}\n- [MESSAGE] to=otherWorkerId | content=Your message";
+/**
+ * Logging instructions to prevent data loss
+ */
+export declare function getWorkerLoggingInstructions(jobId: string): string;
+/**
+ * Get the full worker system prompt
+ * This is what every worker receives at the start
+ */
+export declare function getWorkerSystemPrompt(): string;
+/**
+ * Build a complete worker prompt with task and context
+ * Use this to construct prompts for spawn_worker and delegate_to_worker
+ */
+export declare function buildWorkerPrompt(task: string, options?: {
+    jobId?: string;
+    context?: string;
+    includeCoordination?: boolean;
+    customInstructions?: string;
+}): string;
+/**
+ * Short worker prompt for simple tasks
+ * Lighter version for quick operations
+ */
+export declare function getQuickWorkerPrompt(task: string, context?: string): string;

package/dist/prompts/worker-system.js

@@ -0,0 +1,119 @@
+/**
+ * Standardized Worker System Prompts
+ *
+ * All workers receive consistent instructions through these prompts.
+ * UPDATE THIS FILE to change how all workers behave.
+ */
+import { getSharedOutputPath } from '../core/hub.js';
+/**
+ * Core worker identity and rules
+ * This is the foundation every worker receives
+ */
+export const WORKER_IDENTITY = `## Worker Identity
+You are a Claude Code CLI worker executing a delegated task.
+You report to the Master Orchestrator.
+
+## Critical Rules
+1. Do NOT open browsers or start servers
+2. Do NOT ask questions - just do the work
+3. Output files to the shared workspace unless specified
+4. Report file paths you create at the end
+5. Be concise and efficient`;
+/**
+ * Output format workers should follow
+ */
+export const WORKER_OUTPUT_FORMAT = `## Output Format
+When done, clearly list:
+- Files created: /path/to/file.ext
+- Files modified: /path/to/file.ext
+- Key findings: brief summary
+
+Be concise. Execute efficiently.`;
+/**
+ * Instructions for workers to contribute back to memory
+ * Workers can add to orchestrator's memory using these patterns
+ */
+export const WORKER_MEMORY_INSTRUCTIONS = `## Memory Contributions (Optional)
+If you discover important information the orchestrator should remember:
+- [MEMORY] type=semantic | content=Important fact or preference
+- [MEMORY] type=procedural | content=How to do something
+- [MEMORY] type=episodic | content=What happened and when
+
+Example: [MEMORY] type=semantic | content=User prefers tabs over spaces in TypeScript files`;
+/**
+ * Instructions for worker-to-worker coordination
+ */
+export const WORKER_COORDINATION = `## Coordination (For Parallel Workers)
+Share data with other workers:
+- [SHARE] key=myKey | value={"data": "here"}
+- [SIGNAL] name=taskComplete | data={"result": "success"}
+- [MESSAGE] to=otherWorkerId | content=Your message`;
+/**
+ * Logging instructions to prevent data loss
+ */
+export function getWorkerLoggingInstructions(jobId) {
+    const logFile = `/tmp/worker-${jobId}-log.txt`;
+    return `## Progress & Logging
+- Output findings as you go, don't wait until the end
+- Print discoveries and insights immediately as you find them
+- Report on each file/step before moving to the next
+
+REQUIRED - Log Export:
+At the END of your work, create a final log file at: ${logFile}
+Include: job_id=${jobId}, timestamp, summary of work done, files modified, key findings.
+This ensures nothing is lost even if your output gets truncated.`;
+}
+/**
+ * Get the full worker system prompt
+ * This is what every worker receives at the start
+ */
+export function getWorkerSystemPrompt() {
+    const sharedPath = getSharedOutputPath();
+    return `${WORKER_IDENTITY}
+
+## Shared Workspace
+Save output files to: ${sharedPath}
+The orchestrator and other workers can access files here.
+
+${WORKER_OUTPUT_FORMAT}
+
+${WORKER_MEMORY_INSTRUCTIONS}`;
+}
+/**
+ * Build a complete worker prompt with task and context
+ * Use this to construct prompts for spawn_worker and delegate_to_worker
+ */
+export function buildWorkerPrompt(task, options = {}) {
+    const parts = [getWorkerSystemPrompt()];
+    // Add coordination instructions for parallel workers
+    if (options.includeCoordination) {
+        parts.push(WORKER_COORDINATION);
+    }
+    // Add logging instructions with job ID
+    if (options.jobId) {
+        parts.push(getWorkerLoggingInstructions(options.jobId));
+    }
+    // Add custom instructions if provided
+    if (options.customInstructions) {
+        parts.push(`## Additional Instructions\n${options.customInstructions}`);
+    }
+    // Add context if provided
+    if (options.context) {
+        parts.push(`## Context\n${options.context}`);
+    }
+    // Add the actual task
+    parts.push(`## Task\n${task}`);
+    return parts.join('\n\n');
+}
+/**
+ * Short worker prompt for simple tasks
+ * Lighter version for quick operations
+ */
+export function getQuickWorkerPrompt(task, context) {
+    let prompt = task;
+    if (context) {
+        prompt = `Context: ${context}\n\nTask: ${task}`;
+    }
+    prompt += `\n\nBe concise. Output results directly. Do NOT open browsers or start servers - just create files and report paths.`;
+    return prompt;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",