@causyne/agent 1.10.21 → 1.11.0

package/src/agentLoop.d.ts

@@ -0,0 +1,43 @@
+export interface AgentLoopEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface AgentLoopEventSink {
+  readyState?: number;
+  send(payload: string): void;
+}
+
+export interface AgentLoopConfig {
+  autonomyMode?: 'A' | 'B' | 'C' | string;
+  maxStepsPerTask?: number;
+  tokenBudget?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface ApprovalDecision {
+  approved: boolean;
+  [key: string]: unknown;
+}
+
+export class AgentLoop {
+  constructor(eventSink: AgentLoopEventSink | null, taskId: string, userPrompt: string | null);
+
+  eventSink: AgentLoopEventSink | null;
+  taskId: string;
+  userPrompt: string | null;
+  workspaceRoot: string;
+  autonomyOverride: string | null;
+  config: AgentLoopConfig;
+  stepsCompleted: number;
+
+  run(): Promise<void>;
+  abort(): void;
+  rearmAbortController(): void;
+  setAutonomyMode(mode: 'A' | 'B' | 'C' | string): void;
+  emitEvent(event: AgentLoopEvent): void;
+  waitForApproval(toolCallId: string): Promise<boolean>;
+  handleApprovalResponse(toolCallId: string, decision: ApprovalDecision | boolean): void;
+  waitForDecision(request: Record<string, unknown>): Promise<unknown>;
+  updateTierLimits(): void;
+}

package/src/agentLoop.js

@@ -22,6 +22,7 @@ import { routedConfig } from './modelRouter.js';
 import { assessStep, isThrashing } from './uncertainty.js';
 import { assessDecisionRequirement, isMutatingToolCall, requiresImplementationPlan } from './decisionPolicy.js';
 import { VFETracker } from './vfeTracker.js';
+import { coldObserver } from './observer/coldObserver.js';
 import {
   routePacks,
   packForTool,
@@ -54,6 +55,7 @@ import os from 'os';
 import { analyzeFiles, formatFindings, isScannableFile } from './slopDetector.js';
 import { suggestMovements, formatMovementBrief } from './designPalettes.js';
 import { createProvider } from './providers/factory.js';
+import { resolveMentionedContext } from './promptMentions.js';
 
 const SYSTEM_PROMPT = `You are Causyne Agent, a God-Tier Autonomous AI. You operate the user's computer through a local desktop harness. You are not just a coding assistant; you are a general-purpose superintelligence.
 
@@ -321,7 +323,9 @@ export class AgentLoop {
     this.eventSink = eventSink;
     this.taskId = taskId;
     this.userPrompt = userPrompt;
-    
+    this.workspaceRoot = process.cwd();
+    this.autonomyOverride = null;
+
     this.config = loadConfig();
     this.sandbox = new Sandbox();
 
@@ -378,6 +382,7 @@ export class AgentLoop {
     // prompt-cache prefix intact when a pack loads mid-task.
     this.unlockOrder = [];
     this.workspaceContext = null;
+    this.activeSubproject = null;
     this.taskShape = null;
     // Budget for the billed Tier 2 Cortex condensation pass.
     this._cortexPassesUsed = 0;
@@ -398,6 +403,7 @@ export class AgentLoop {
     // P6: rendered surfaces this task wrote, for the anti-slop gate to read back.
     this.webArtifacts = new Set();
     this.slopGateFired = false;
+    this.coldObserverGuardFired = false;
 
     this.gameCascadeState = { active: true, currentStage: 1, stageHistory: [], verificationPassed: false };
     this.gameToolStats = { godot_act: 0, game_asset_fetch: 0, game_build_html5: 0, last_godot_action: null };
@@ -534,6 +540,15 @@ export class AgentLoop {
     }
   }
 
+  setAutonomyMode(mode) {
+    const normalized = String(mode || '').trim().toUpperCase();
+    if (!['A', 'B', 'C'].includes(normalized)) {
+      throw new Error('autonomy mode must be A, B, or C');
+    }
+    this.autonomyOverride = normalized;
+    this.config.autonomyMode = normalized;
+  }
+
   /**
    * A provider for UTILITY work — condensation, classification, filtering.
    *
@@ -766,6 +781,7 @@ export class AgentLoop {
 
   updateTierLimits() {
     this.config = loadConfig();
+    if (this.autonomyOverride) this.config.autonomyMode = this.autonomyOverride;
     if (typeof this.initializeProvider === 'function') {
       this.llm = this.initializeProvider();
       this._utilityLlm = null; // the route is derived from the model; re-derive it
@@ -817,6 +833,8 @@ export class AgentLoop {
     // awareness instead of burning steps rediscovering it. The result used to be
     // assigned to a local variable and thrown away.
     auditLog.log({ event: 'task_start', taskId: this.taskId, request: this.userPrompt });
+    this.workspaceRoot = process.cwd();
+    coldObserver.beginTask(this.taskId);
     this.emitEvent({ type: 'status', message: 'Analyzing workspace...' });
 
     // P2: open the undo group for this task. This snapshots the CONVERSATION as
@@ -872,6 +890,7 @@ export class AgentLoop {
     this.webGuardFired = false;
     this.webArtifacts = new Set();
     this.slopGateFired = false;
+    this.coldObserverGuardFired = false;
     this.staticContext = null;
     // Plan cache: the procedure THIS task follows, and the template (if any)
     // that was offered to it. Both reset per task — a plan is a property of one
@@ -964,6 +983,36 @@ export class AgentLoop {
     }
 
     if (this.userPrompt) {
+      // 1b. RESOLVE @ MENTIONS FOR REFERENCED FILES, DIRECTORIES & SUBPROJECTS
+      try {
+        const subprojects = this.workspaceContext?.subprojects || [];
+        const mentionResult = await resolveMentionedContext(this.userPrompt, {
+          cwd: process.cwd(),
+          subprojects
+        });
+
+        if (mentionResult.detectedSubproject) {
+          this.activeSubproject = mentionResult.detectedSubproject;
+          this.notice(`Focused on subproject '${mentionResult.detectedSubproject}'`);
+        } else if (subprojects.length > 0) {
+          const lowerPrompt = this.userPrompt.toLowerCase();
+          for (const sp of subprojects) {
+            if (lowerPrompt.includes(sp.toLowerCase())) {
+              this.activeSubproject = sp;
+              this.notice(`Focused on subproject '${sp}'`);
+              break;
+            }
+          }
+        }
+
+        if (mentionResult.referencedContext) {
+          this.userPrompt += mentionResult.referencedContext;
+          this.notice(`Loaded ${mentionResult.mentions.length} referenced @ mention(s) into context`);
+        }
+      } catch (mentionErr) {
+        this.debugLog(`mention resolution error: ${mentionErr.message}`);
+      }
+
       this.currentTaskPrompt = this.userPrompt; // Save for notification later
       
       // V5: Multimodal Attachments Support
@@ -1210,12 +1259,15 @@ export class AgentLoop {
           const ctx = this.workspaceContext;
           const facts = [
             ctx.cwd && `Working directory: ${ctx.cwd}`,
+            this.activeSubproject && `Active project focus: ${this.activeSubproject}`,
+            ctx.projectName && `Workspace project: ${ctx.projectName}`,
             ctx.os && `OS: ${ctx.os}`,
             ctx.framework && `Framework: ${ctx.framework}`,
             ctx.projectType && `Project type: ${ctx.projectType}`,
             ctx.packageManager && `Package manager: ${ctx.packageManager}`,
             ctx.gitBranch && `Git branch: ${ctx.gitBranch}`,
             ctx.gitStatus && `Git status: ${ctx.gitStatus}`,
+            Array.isArray(ctx.subprojects) && ctx.subprojects.length > 0 && `Subprojects in workspace: ${ctx.subprojects.join(', ')}`,
             Array.isArray(ctx.keyFiles) && ctx.keyFiles.length > 0 && `Key files: ${ctx.keyFiles.slice(0, 25).join(', ')}`
           ].filter(Boolean);
           if (facts.length > 0) {
@@ -1640,6 +1692,32 @@ export class AgentLoop {
             }
           }
 
+          // Cold Observer: Overconfidence & Loop Verification Check
+          if (!this.coldObserverGuardFired) {
+            try {
+              const coldAudit = await coldObserver.auditTurnVerification({
+                taskId: this.taskId,
+                userPrompt: this.currentTaskPrompt || this.userPrompt || '',
+                agentClaim: response.content || '',
+                toolHistory: [],
+                stepsCompleted: this.stepsCompleted
+              });
+
+              if (coldAudit.overconfident) {
+                this.coldObserverGuardFired = true;
+                this.emitEvent({ type: 'status', message: `Cold Observer: ${coldAudit.discrepancy}` });
+                this.messages.push({
+                  role: 'system',
+                  content: coldAudit.coldDirective
+                });
+                this.memoryManager.saveHistory(this.messages);
+                continue;
+              }
+            } catch (_err) {
+              // Cold observer fail-open
+            }
+          }
+
           this.emitEvent({ type: 'status', message: 'Task completed.' });
           this.memoryManager.saveHistory(this.messages); // Save final state
 
@@ -1716,7 +1794,7 @@ export class AgentLoop {
             continue;
           }
           
-          this.emitEvent({ type: 'step_start', tool: functionName, args: args });
+          this.emitEvent({ type: 'step_start', tool: functionName, args: args, toolCallId: toolCall.id });
           this.consecutiveCommands++;
           
           if (functionName === 'screenshot' || functionName === 'vision_inspect_ui') {
@@ -1764,7 +1842,7 @@ export class AgentLoop {
             
             if ((['fs_write'].includes(functionName) && isGameFileOrDir) || isEchoingToFile || isCustomScriptBlock) {
               const interceptMsg = `[SOVEREIGN CASCADE VIOLATION: You attempted to skip from Stage ${this.gameCascadeState.currentStage} to Stage 7 without completing Stages 3, 4, 5, and 6 modularly. DO NOT write monolithic 20 KB custom scripts!]`;
-              this.emitEvent({ type: 'step_error', tool: functionName, error: '⚡ Sovereign Game Intercept: Cascade violation detected.' });
+              this.emitEvent({ type: 'step_error', tool: functionName, error: 'Sovereign Game Intercept: Cascade violation detected.', toolCallId: toolCall.id });
               this.messages.push({
                 role: 'tool',
                 tool_call_id: toolCall.id,
@@ -1802,7 +1880,7 @@ export class AgentLoop {
             // Hard Circuit Breaker (Transcendence Context Consciousness)
             if (this.consecutiveBlockedActions >= 4) {
               const fatalMsg = `FATAL ERROR: Infinite Token Drain Detected. Agent repeatedly attempted blocked/forbidden actions 4 times in a row. Forcibly aborting task to save tokens.`;
-              this.emitEvent({ type: 'step_error', tool: functionName, error: fatalMsg });
+              this.emitEvent({ type: 'step_error', tool: functionName, error: fatalMsg, toolCallId: toolCall.id });
               auditLog.log({ event: 'task_killed_circuit_breaker', taskId: this.taskId, reason: fatalMsg });
               
               // Save memory of failure for RLTF
@@ -1817,7 +1895,11 @@ export class AgentLoop {
             }
             
             auditLog.log({ event: 'tool_blocked', taskId: this.taskId, tool: functionName, args, reason: validation.reason });
-            this.emitEvent({ type: 'step_error', tool: functionName, error: validation.reason });
+            coldObserver.recordToolOutcome(this.taskId, functionName, args, {
+              success: false,
+              error: validation.reason
+            });
+            this.emitEvent({ type: 'step_error', tool: functionName, error: validation.reason, toolCallId: toolCall.id });
             
             // Feed error back to LLM with absolute command to stop repeating
             this.messages.push({
@@ -1896,6 +1978,10 @@ export class AgentLoop {
               event: 'hook_denied', taskId: this.taskId, hookEvent: 'PreToolUse',
               tool: functionName, reason: preHook.reason || 'hook denied'
             });
+            coldObserver.recordToolOutcome(this.taskId, functionName, args, {
+              success: false,
+              error: `PreToolUse hook denied "${functionName}".`
+            });
             this.messages.push({
               role: 'tool',
               tool_call_id: toolCall.id,
@@ -1915,6 +2001,39 @@ export class AgentLoop {
           // downloads ran unannounced.
           const isHeavyAiDownload = functionName === 'manage_local_dependencies' &&
             ['pipInst', 'fetchBin', 'fetchMod'].includes(args.action);
+
+          // Cold Observer: Assess blast radius and mutation risk
+          try {
+            const coldMutation = await coldObserver.evaluateMutation(functionName, args, {
+              workspaceRoot: this.workspaceRoot
+            });
+            if (coldMutation.veto) {
+              this.emitEvent({
+                type: 'status',
+                message: `Cold Observer Veto: Action blocked (${coldMutation.reason})`
+              });
+              coldObserver.recordToolOutcome(this.taskId, functionName, args, {
+                success: false,
+                error: `[COLD OBSERVER VETO]: ${coldMutation.reason}`
+              });
+              this.messages.push({
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                name: functionName,
+                content: JSON.stringify({
+                  success: false,
+                  error: `[COLD OBSERVER VETO]: ${coldMutation.reason}. Modify your approach to avoid project damage.`
+                })
+              });
+              continue;
+            }
+            if (coldMutation.requiresConfirmation) {
+              validation.risk = 'dangerous';
+            }
+          } catch (_err) {
+            // Cold observer mutation assessment fail-open
+          }
+
           // A standing approval from "Allow always" lifts the gate for this
           // tool until the process restarts. It is checked HERE rather than
 
@@ -1944,6 +2063,10 @@ export class AgentLoop {
             const approved = await this.waitForApproval(toolCall.id);
 
             if (!approved) {
+              coldObserver.recordToolOutcome(this.taskId, functionName, args, {
+                success: false,
+                error: 'User denied this action'
+              });
               this.messages.push({
                 role: 'tool',
                 tool_call_id: toolCall.id,
@@ -2031,7 +2154,8 @@ export class AgentLoop {
               this.emitEvent({ 
                 type: 'step_error', 
                 tool: functionName, 
-                error: `${errorType}: ${toolError.message} (retry ${currentRetries + 1}/${MAX_RETRIES} in ${backoffMs/1000}s)` 
+                error: `${errorType}: ${toolError.message} (retry ${currentRetries + 1}/${MAX_RETRIES} in ${backoffMs/1000}s)`,
+                toolCallId: toolCall.id
               });
               
               auditLog.log({ 
@@ -2066,7 +2190,12 @@ export class AgentLoop {
               this.emitEvent({ 
                 type: 'step_error', 
                 tool: functionName, 
-                error: `Failed after ${MAX_RETRIES} attempts: ${toolError.message}` 
+                error: `Failed after ${MAX_RETRIES} attempts: ${toolError.message}`,
+                toolCallId: toolCall.id
+              });
+              coldObserver.recordToolOutcome(this.taskId, functionName, args, {
+                success: false,
+                error: `PERMANENT FAILURE after ${MAX_RETRIES} retries: ${toolError.message}`
               });
               
               this.messages.push({
@@ -2104,6 +2233,11 @@ export class AgentLoop {
             };
           }
 
+          // The journal is the observer's own record of what actually ran. It
+          // is written only after post-hook review, so a formatter that rejects
+          // a write is remembered as a failure rather than a success.
+          coldObserver.recordToolOutcome(this.taskId, functionName, args, result);
+
           // PROGRESSIVE DISCLOSURE: honour unlock signals from tool_search.
           // The control fields are stripped before the result reaches the LLM.
           if (result && (result._unlock_tools || result._unlock_packs)) {
@@ -2121,7 +2255,7 @@ export class AgentLoop {
           // Buffer output for disconnect resilience
           await this.taskBuffer.appendOutput(this.taskId, { tool: functionName, result });
 
-          this.emitEvent({ type: 'step_complete', tool: functionName, result: result._is_image_marker ? '[IMAGE DATA]' : result });
+          this.emitEvent({ type: 'step_complete', tool: functionName, result: result._is_image_marker ? '[IMAGE DATA]' : result, toolCallId: toolCall.id });
           this.stepsCompleted++;
 
           // The procedure, as it actually ran. Tool name plus a whitelisted

package/src/commands.js

@@ -83,6 +83,56 @@ export const COMMANDS = [
     }
   },
 
+  {
+    name: 'cd',
+    aliases: ['cwd', 'workspace'],
+    scope: 'local',
+    usage: '/cd [directory]',
+    description: 'View or change active working directory and project focus',
+    complete: () => {
+      try {
+        const entries = fs.readdirSync(process.cwd(), { withFileTypes: true });
+        return entries
+          .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+          .map(e => ({
+            value: e.name.includes(' ') ? `"${e.name}"` : e.name,
+            label: e.name + '/',
+            description: 'directory'
+          }));
+      } catch (e) {
+        return [];
+      }
+    },
+    run: async (argv, ctx) => {
+      const target = argv.join(' ').trim().replace(/^["']|["']$/g, '');
+      if (!target) {
+        return ok(`Current working directory: ${process.cwd()}`);
+      }
+      const resolved = path.resolve(process.cwd(), target.replace(/^~\//, os.homedir() + '/'));
+      if (!fs.existsSync(resolved)) {
+        return fail(`Directory not found: ${resolved}`);
+      }
+      const stat = fs.statSync(resolved);
+      if (!stat.isDirectory()) {
+        return fail(`Not a directory: ${resolved}`);
+      }
+      try {
+        process.chdir(resolved);
+      } catch (err) {
+        return fail(`Cannot switch to ${resolved}: ${err.message}`);
+      }
+      if (ctx.prompt && typeof ctx.prompt.setWorkingRoot === 'function') {
+        ctx.prompt.setWorkingRoot(resolved);
+      }
+      if (ctx.loop && ctx.loop.perception) {
+        try {
+          ctx.loop.workspaceContext = await ctx.loop.perception.buildContext(resolved);
+        } catch (e) {}
+      }
+      return ok(`Working directory changed to: ${resolved}`);
+    }
+  },
+
   {
     name: 'skill',
     scope: 'local',
@@ -878,6 +928,159 @@ export const COMMANDS = [
     run: (argv, ctx) => ok(buildStatusText({ loop: ctx.loop || null }))
   },
 
+  {
+    name: 'observer',
+    scope: 'local',
+    usage: '/observer [status|toggle|mode <deterministic|advisory>|endpoint <url|none>|model <name>|strictness <relaxed|standard|strict>|test|audit|reset]',
+    description: 'Inspect or configure the Cold Observer',
+    dialogTitle: 'Cold Observer',
+    run: async (argv) => {
+      const { coldObserver } = await import('./observer/coldObserver.js');
+      const sub = (argv[0] || 'status').toLowerCase();
+
+      if (sub === 'toggle') {
+        const current = coldObserver.getConfig();
+        coldObserver.updateConfig({ enabled: !current.enabled });
+        return ok(`Cold Observer is now ${!current.enabled ? 'ENABLED' : 'DISABLED'}.`);
+      }
+
+      if (sub === 'mode') {
+        const targetMode = String(argv[1] || '').toLowerCase();
+        if (!['deterministic', 'advisory', 'local', 'hybrid'].includes(targetMode)) {
+          return fail('Invalid mode. Choose: deterministic or advisory.');
+        }
+        coldObserver.updateConfig({ mode: targetMode });
+        return ok(`Cold Observer mode set to "${coldObserver.getConfig().mode}".`);
+      }
+
+      if (sub === 'endpoint') {
+        const target = String(argv[1] || '').trim();
+        try {
+          coldObserver.updateConfig({ endpoint: target === 'none' ? '' : target });
+        } catch (error) {
+          return fail(error instanceof Error ? error.message : 'Invalid endpoint.');
+        }
+        const endpoint = coldObserver.getConfig().endpoint;
+        return ok(endpoint ? `Advisory endpoint set to ${endpoint}.` : 'Advisory endpoint cleared.');
+      }
+
+      if (sub === 'model') {
+        const target = String(argv[1] || '').trim();
+        coldObserver.updateConfig({ model: target === 'none' ? '' : target });
+        const model = coldObserver.getConfig().model;
+        return ok(model ? `Advisory model set to ${model}.` : 'Advisory model cleared.');
+      }
+
+      if (sub === 'strictness') {
+        const target = String(argv[1] || '').toLowerCase();
+        if (!['relaxed', 'standard', 'strict', 'moderate', 'paranoid'].includes(target)) {
+          return fail('Invalid strictness. Choose: relaxed, standard, or strict.');
+        }
+        coldObserver.updateConfig({ strictness: target });
+        return ok(`Cold Observer strictness set to "${coldObserver.getConfig().strictness}".`);
+      }
+
+      if (sub === 'test') {
+        const health = await coldObserver.healthCheck();
+        if (!health.endpoint) {
+          return ok('No advisory endpoint configured. The deterministic observer needs no endpoint and remains active.');
+        }
+        return ok([
+          `Endpoint: ${health.endpoint}`,
+          `Model:    ${health.model || '(unset)'}`,
+          `Healthy:  ${health.healthy ? 'yes' : 'no'} (${health.latencyMs}ms)`,
+          `Detail:   ${health.detail}`
+        ].join('\n'));
+      }
+
+      if (sub === 'reset') {
+        coldObserver.updateConfig({
+          enabled: true,
+          mode: 'deterministic',
+          endpoint: '',
+          model: '',
+          timeoutMs: 800,
+          strictness: 'standard'
+        });
+        return ok('Cold Observer configuration reset to defaults.');
+      }
+
+      if (sub === 'audit') {
+        const audits = coldObserver.getAuditHistory();
+        if (audits.length === 0) {
+          return ok('No Cold Observer audit records yet.');
+        }
+        const lines = audits.slice(-10).map((a) => {
+          const time = new Date(a.timestamp).toLocaleTimeString();
+          const tag = a.type === 'mutation' ? `[mutation ${a.tool || ''}]` : '[verification]';
+          const score = typeof a.riskScore === 'number' ? `(risk ${(a.riskScore * 100).toFixed(0)}%)` : '';
+          const veto = a.veto ? 'VETO' : 'pass';
+          return `${time} ${tag} ${veto} ${score} ${a.details}`;
+        });
+        return ok(`Recent Cold Observer audits (last 10):\n\n${lines.join('\n')}`);
+      }
+
+      const cfg = coldObserver.getConfig();
+      const audits = coldObserver.getAuditHistory();
+      const vetoes = audits.filter((a) => a.veto).length;
+      return ok([
+        'Cold Observer',
+        '──────────────────────────────────────────────',
+        `Status:       ${cfg.enabled ? 'Active (mutations and completion claims)' : 'Disabled'}`,
+        `Mode:         ${cfg.mode.toUpperCase()}`,
+        `Strictness:   ${cfg.strictness}`,
+        `Advisory:     ${cfg.endpoint ? `${cfg.model || '(model unset)'} at ${cfg.endpoint}` : 'not configured (deterministic only)'}`,
+        `Audit events: ${audits.length} recorded (${vetoes} vetoes enforced)`,
+        '',
+        'Subcommands:',
+        '  /observer toggle                            Enable or disable protection',
+        '  /observer mode <deterministic|advisory>     Choose the review mode',
+        '  /observer endpoint <url|none>               Set a loopback advisory endpoint',
+        '  /observer model <name>                      Set the advisory model name',
+        '  /observer strictness <relaxed|standard|strict>',
+        '  /observer test                              Probe the advisory endpoint',
+        '  /observer audit                             Inspect recent audits',
+        '  /observer reset                             Restore defaults'
+      ].join('\n'));
+    }
+  },
+
+  {
+    name: 'acp',
+    scope: 'local',
+    usage: '/acp [status|peers]',
+    description: 'Agent Client Protocol (ACP) server and peer delegation status',
+    dialogTitle: 'Agent Client Protocol',
+    run: async (argv) => {
+      const sub = (argv[0] || 'status').toLowerCase();
+      if (sub === 'peer' || sub === 'peers') {
+        const { loadPeerProfiles, peerProfilesPath } = await import('./acp/peerProfiles.js');
+        const profiles = loadPeerProfiles();
+        return ok([
+          'Peer delegation (ACP)',
+          '──────────────────────────────────────────────',
+          `Profiles file: ${peerProfilesPath()}`,
+          `Configured:    ${profiles.length === 0 ? 'none' : profiles.map((p) => `${p.id} (${p.policy})`).join(', ')}`,
+          '',
+          'The model selects a profile id and writes a prompt. Executable, arguments,',
+          'working directory, and environment always come from the profile file.'
+        ].join('\n'));
+      }
+      return ok([
+        'Agent Client Protocol (ACP) - Causyne Agent',
+        '──────────────────────────────────────────────',
+        'Version:        ACP v1 (JSON-RPC 2.0 over stdio)',
+        'Server command: causyne acp',
+        'Wire:           newline-delimited JSON-RPC',
+        'Sessions:       session/new, session/prompt, session/cancel, session/update',
+        'Optional:       session/list, session/close, session/set_mode',
+        'Workspace:      one workspace per server process',
+        '',
+        'Run "causyne acp" to connect this agent to any ACP client.'
+      ].join('\n'));
+    }
+  },
+
   {
     name: 'exit',
     aliases: ['quit'],

package/src/compiledSkills.js

@@ -329,6 +329,16 @@ export const COMPILED_SKILLS = {
       "description": "Automate photo editing, graphic composition, text typography, and image format exports using native Photo Studio automation. Use when a task requires batch image edits, graphic layout creation, resizing, color adjustment, or PSD/PNG/JPG/WEBP asset generation.",
       "content": "---\nname: photo-studio-automation\ndescription: Automate photo editing, graphic composition, text typography, and image format exports using native Photo Studio automation. Use when a task requires batch image edits, graphic layout creation, resizing, color adjustment, or PSD/PNG/JPG/WEBP asset generation.\n---\n\n# Photo Studio Automation\n\nDirect script execution beats screenshot clicking every time: it is exact, sub-second, costs zero vision tokens, and never misclicks because a window moved. Use the native Creative Studio bridge via `creative_apps` with `action: \"studio_edit\"` and `host: \"photo-studio\"`.\n\n## Workflow\n\n1. Verify environment and inspect installed creative hosts.\n   - Run `creative_apps` with `action: \"status\"`.\n   - Confirm Photo Studio availability before assembling jobs.\n   - **Done when:** host availability is confirmed.\n\n2. Establish workspace paths.\n   - All inputs and outputs must reside strictly within the active workspace.\n   - The output file must not already exist (the runtime enforces collision prevention).\n   - Supported output extensions: `.psd`, `.png`, `.jpg`, `.jpeg`, `.webp`.\n   - **Done when:** source asset and clean target output paths are defined.\n\n3. Plan layer hierarchy and typography before applying edits.\n   - If starting from scratch, omit `input` to let the engine create a canvas (1920x1080 standard).\n   - If transforming existing art, provide `input` path.\n   - Layer modifications should specify explicit `name`, `opacity`, `visible`, and `blendMode`.\n   - Typography actions should define `text`, `x`, `y`, `size`, and font family.\n   - **Done when:** sequence of edit actions is organized logically from background to foreground.\n\n4. Apply color adjustments and canvas sizing.\n   - Use `resize` or `crop` early in the action pipeline to establish composition geometry.\n   - Use `adjust_color` with `brightness` (-100..100) and `contrast` (-100..100) on target layers for grading.\n   - If delivering flat web assets (e.g., PNG or WEBP), include `flatten` at the end of the action chain.\n   - **Done when:** geometric and tonal parameters match design requirements.\n\n5. Execute batch and verify output.\n   - Invoke `creative_apps` with `action: \"studio_edit\"`, `host: \"photo-studio\"`, `output`, and `actions`.\n   - The runtime verifies execution receipt and confirms nonempty file generation.\n   - **Done when:** output file exists, has nonzero byte count, and matches requested specifications.\n\n## Failure Modes Worth Naming\n\n- **Overwriting existing file:** The engine halts if output exists. Specify a distinct or versioned filename.\n- **Outside workspace:** All paths must resolve inside the workspace root. Do not reference temporary directories or home root.\n- **Missing host:** If the host is not installed, the tool gracefully reports installation status. Propose alternative image processing or check system paths.\n- **Out-of-range layer index:** Layer indices start at 0. Ensure index matches existing layer count.\n\n## Verification\n\n- `action: \"studio_edit\"` returns `success: true`.\n- Output file exists on disk within workspace.\n- File size is non-zero.\n- Format matches target extension (.psd, .png, .jpg, or .webp).\n"
     },
+    "professional-document-publishing": {
+      "name": "professional-document-publishing",
+      "description": "Generate publication-grade PDF documents, grant proposals, financial sheets, and technical reports using HTML/CSS Paged Media and Headless Chrome. Enforces visual quality inspection, under 2MB compliance, and mathematical integrity.",
+      "content": "---\nname: professional-document-publishing\ndescription: Generate publication-grade PDF documents, grant proposals, financial sheets, and technical reports using HTML/CSS Paged Media and Headless Chrome. Enforces visual quality inspection, under 2MB compliance, and mathematical integrity.\n---\n\n# Professional Document Publishing & Harness\n\nFrontier LLMs and efficient models produce equally stunning, publication-ready documents when guided by this harness methodology.\n\nNever assemble print layouts through raw Python scripts. Always author in semantic HTML5 plus CSS Paged Media, compile via Headless Chrome, and visually inspect the rendered output.\n\n## Workflow\n\n1. Prepare structured data and schemas.\n   - Keep numeric budget and scheduling data in structured JSON format.\n   - Run math validation with `document_forge` (`action: \"audit_budget\"`).\n   - **Done when:** all numbers are validated against the single source of truth.\n\n2. Compile document markup and styles.\n   - Author page layouts in HTML using standard CSS `@page` rules (`size: A4 portrait; margin: 20mm 18mm 18mm 18mm;`).\n   - Use `@page cover { margin: 0; }` for full-bleed cover banners without white borders.\n   - Force `-webkit-print-color-adjust: exact; print-color-adjust: exact;` so backgrounds and gradients render faithfully.\n   - Prevent mid-table row cuts with `tr { page-break-inside: avoid; }`.\n   - Prevent orphan headers with `h1, h2, h3 { page-break-after: avoid; }`.\n   - Compile via `document_forge` (`action: \"compile_document\"`).\n   - **Done when:** HTML markup and CSS paged styles are written to disk.\n\n3. Render to vector PDF via Headless Chrome.\n   - Invoke `document_forge` (`action: \"render_pdf\"`, `sourceHtmlPath`, `outputPdfPath`).\n   - **Done when:** vector PDF file exists on disk with non-zero size.\n\n4. Inspect pages visually and audit compliance.\n   - Extract page images via `document_forge` (`action: \"inspect_pages\"`).\n   - Verify page fill density: flag and repair any pages with less than 25% text coverage.\n   - Confirm PDF file size is below 2,048 KB for portal compliance.\n   - Audit text content for long em-dashes and AI clichés with `document_forge` (`action: \"audit_text\"`).\n   - **Done when:** all pages pass visual density check and size constraints.\n\n## Verification\n\n- `document_forge` returns `success: true`.\n- Output PDF file size is non-zero and under 2,048 KB.\n- Extracted page images show no clipped text or orphaned headers.\n- Mathematical totals match across all sections.\n"
+    },
+    "screenplay-and-shotlist-forge": {
+      "name": "screenplay-and-shotlist-forge",
+      "description": "Format professional Hollywood screenplays in Courier 12pt, create director production shot lists, and build voiceover timing cue sheets with Words-Per-Minute pacing analysis. Use for movie scripts, video storytelling, documentary shotlists, and audio dubbing timelines.",
+      "content": "---\nname: screenplay-and-shotlist-forge\ndescription: Format professional Hollywood screenplays in Courier 12pt, create director production shot lists, and build voiceover timing cue sheets with Words-Per-Minute pacing analysis. Use for movie scripts, video storytelling, documentary shotlists, and audio dubbing timelines.\n---\n\n# Screenplay & Production Shot List Forge\n\nHigh-end cinematic storytelling and video production require standardized industry formatting so that directors, cinematographers, and editors can immediately execute on set and in the edit suite.\n\n## Specifications\n\n- **Screenplay Typography:** Courier 12pt monospaced font, exactly 6 lines per inch vertical rhythm.\n- **Screenplay Margins:** Left margin 1.5 inches; right, top, and bottom margins 1.0 inch.\n- **Pacing Standard:** Voiceover narration moves at 130 to 155 Words-Per-Minute for natural documentary cadence.\n\n## Workflow\n\n1. Format screenplay elements and layout.\n   - Author scenes using `document_forge` (`action: \"format_screenplay\"`, `screenplaySpec`).\n   - Format scene headings in uppercase, character cues indented 2.2 inches, and dialogue width constrained to 3.5 inches.\n   - **Done when:** script HTML and CSS with Courier 12pt specifications are generated.\n\n2. Build director's production shot list.\n   - Generate production shot lists with `document_forge` (`action: \"format_shotlist\"`, `shotList`).\n   - Assign camera framing (EWS, WS, MS, CU, ECU), lenses, movement, and audio cues.\n   - **Done when:** structured shot list grid is compiled with cumulative duration estimates.\n\n3. Analyze voiceover timing and narration pacing.\n   - Audit narration pacing with `document_forge` (`action: \"analyze_vo\"`, `voBlocks`).\n   - Ensure word density stays within 130 to 155 WPM for optimal documentary pacing.\n   - **Done when:** pacing status is confirmed as optimal across all audio blocks.\n\n4. Render and verify publication files.\n   - Render scripts or shot lists to vector PDF via `document_forge` (`action: \"render_pdf\"`).\n   - **Done when:** output PDF files exist and are verified visually.\n\n## Verification\n\n- `document_forge` returns `success: true`.\n- Screenplay HTML contains Courier 12pt typography and 1.5-inch left margin.\n- Shot list table summarizes total shots and total runtime.\n- Voiceover analysis confirms pacing within target WPM limits.\n"
+    },
     "video-timeline-assembly": {
       "name": "video-timeline-assembly",
       "description": "Assemble video timelines, import media clips to sequences, place markers, make precision edits, and export project files using native Video Studio automation. Use when a task requires automated video sequence building, cutting, multicam timeline layout, or PRPROJ/XML project generation.",