@soleri/forge 5.2.0 → 5.4.0

package/src/templates/domain-facade.ts

@@ -1,6 +1,10 @@
 /**
  * Generate a domain-specific facade for the agent.
  * Each domain gets a facade with search, get_patterns, and list ops.
+ *
+ * @deprecated v4 legacy only — v5 agents use createDomainFacade() from
+ * @soleri/core which includes governance gating. This template is only
+ * used by domain-manager.ts for pre-v5 agents.
  */
 export function generateDomainFacade(agentId: string, domain: string): string {
   const facadeName = `${agentId}_${domain.replace(/-/g, '_')}`;

package/src/templates/entry-point.ts

@@ -143,6 +143,37 @@ async function main(): Promise<void> {
         if (s.totalEntries === 0) {
           recommendations.push('Vault is empty — add intelligence data or capture knowledge via domain facades');
         }
+
+        // Check hook status
+        const { readdirSync } = await import('node:fs');
+        const agentClaudeDir = joinPath(__dirname, '..', '.claude');
+        const globalClaudeDir = joinPath(homedir(), '.claude');
+
+        const hookStatus = { agent: [] as string[], global: [] as string[], missing: [] as string[] };
+
+        if (existsSync(agentClaudeDir)) {
+          try {
+            const agentHooks = readdirSync(agentClaudeDir)
+              .filter((f: string) => f.startsWith('hookify.') && f.endsWith('.local.md'))
+              .map((f: string) => f.replace('hookify.', '').replace('.local.md', ''));
+            hookStatus.agent = agentHooks;
+
+            for (const hook of agentHooks) {
+              if (existsSync(joinPath(globalClaudeDir, \`hookify.\${hook}.local.md\`))) {
+                hookStatus.global.push(hook);
+              } else {
+                hookStatus.missing.push(hook);
+              }
+            }
+          } catch {
+            // ignore read errors
+          }
+        }
+
+        if (hookStatus.missing.length > 0) {
+          recommendations.push(\`\${hookStatus.missing.length} hook(s) not installed globally — run scripts/setup.sh\`);
+        }
+
         if (recommendations.length === 0) {
           recommendations.push('${config.name} is fully set up and ready!');
         }
@@ -154,6 +185,7 @@ async function main(): Promise<void> {
             global: { exists: globalExists, has_agent_section: globalHasAgent },
           },
           vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
+          hooks: hookStatus,
           recommendations,
         };
       },

package/src/templates/setup-script.ts

@@ -101,7 +101,34 @@ else
   fi
 fi
 
-echo ""
+${
+  config.hookPacks?.length
+    ? `# Install hook packs to global ~/.claude/
+AGENT_CLAUDE_DIR="$AGENT_DIR/.claude"
+GLOBAL_CLAUDE_DIR="$HOME/.claude"
+
+if [ -d "$AGENT_CLAUDE_DIR" ]; then
+  echo ""
+  echo "Installing hook packs..."
+  mkdir -p "$GLOBAL_CLAUDE_DIR"
+  installed=0
+  skipped=0
+  for hook_file in "$AGENT_CLAUDE_DIR"/hookify.*.local.md; do
+    [ -f "$hook_file" ] || continue
+    dest="$GLOBAL_CLAUDE_DIR/$(basename "$hook_file")"
+    if [ -f "$dest" ]; then
+      skipped=$((skipped + 1))
+    else
+      cp "$hook_file" "$dest"
+      installed=$((installed + 1))
+    fi
+  done
+  echo "[ok] Hooks: $installed installed, $skipped already present"
+fi
+
+`
+    : ''
+}echo ""
 echo "=== Setup Complete ==="
 echo ""
 echo "Next:"

package/src/templates/test-facades.ts

@@ -126,6 +126,29 @@ ${domainDescribes}
             if (stats.totalEntries === 0) {
               recommendations.push('Vault is empty');
             }
+            // Check hook status
+            const { readdirSync } = await import('node:fs');
+            const agentClaudeDir = joinPath(__dirname, '..', '.claude');
+            const globalClaudeDir = joinPath(homedir(), '.claude');
+            const hookStatus = { agent: [] as string[], global: [] as string[], missing: [] as string[] };
+            if (exists(agentClaudeDir)) {
+              try {
+                const agentHooks = readdirSync(agentClaudeDir)
+                  .filter((f: string) => f.startsWith('hookify.') && f.endsWith('.local.md'))
+                  .map((f: string) => f.replace('hookify.', '').replace('.local.md', ''));
+                hookStatus.agent = agentHooks;
+                for (const hook of agentHooks) {
+                  if (exists(joinPath(globalClaudeDir, \`hookify.\${hook}.local.md\`))) {
+                    hookStatus.global.push(hook);
+                  } else {
+                    hookStatus.missing.push(hook);
+                  }
+                }
+              } catch { /* ignore */ }
+            }
+            if (hookStatus.missing.length > 0) {
+              recommendations.push(\`\${hookStatus.missing.length} hook(s) not installed globally — run scripts/setup.sh\`);
+            }
             if (recommendations.length === 0) {
               recommendations.push('${config.name} is fully set up and ready!');
             }
@@ -136,6 +159,7 @@ ${domainDescribes}
                 global: { exists: exists(globalClaudeMd), has_agent_section: hasAgentMarker(globalClaudeMd) },
               },
               vault: { entries: stats.totalEntries, domains: Object.keys(stats.byDomain) },
+              hooks: hookStatus,
               recommendations,
             };
           },
@@ -172,6 +196,10 @@ ${domainDescribes}
       expect(opNames).toContain('brain_archive_sessions');
       expect(opNames).toContain('brain_promote_proposals');
       expect(opNames).toContain('brain_lifecycle');
+      // Enhanced brain ops (3)
+      expect(opNames).toContain('brain_feedback');
+      expect(opNames).toContain('brain_feedback_stats');
+      expect(opNames).toContain('brain_reset_extracted');
       // Agent-specific ops (5)
       expect(opNames).toContain('health');
       expect(opNames).toContain('identity');
@@ -187,8 +215,122 @@ ${domainDescribes}
       expect(opNames).toContain('route_intent');
       expect(opNames).toContain('morph');
       expect(opNames).toContain('get_behavior_rules');
-      // Total: 50
-      expect(facade.ops.length).toBe(50);
+      // Cognee ops (5)
+      expect(opNames).toContain('cognee_status');
+      expect(opNames).toContain('cognee_search');
+      expect(opNames).toContain('cognee_add');
+      expect(opNames).toContain('cognee_cognify');
+      expect(opNames).toContain('cognee_config');
+      // LLM ops (2)
+      expect(opNames).toContain('llm_rotate');
+      expect(opNames).toContain('llm_call');
+      // Governance ops (5)
+      expect(opNames).toContain('governance_policy');
+      expect(opNames).toContain('governance_proposals');
+      expect(opNames).toContain('governance_stats');
+      expect(opNames).toContain('governance_expire');
+      expect(opNames).toContain('governance_dashboard');
+      // Planning Extra ops (9)
+      expect(opNames).toContain('plan_iterate');
+      expect(opNames).toContain('plan_split');
+      expect(opNames).toContain('plan_reconcile');
+      expect(opNames).toContain('plan_complete_lifecycle');
+      expect(opNames).toContain('plan_dispatch');
+      expect(opNames).toContain('plan_review');
+      expect(opNames).toContain('plan_archive');
+      expect(opNames).toContain('plan_list_tasks');
+      expect(opNames).toContain('plan_stats');
+      // Memory Extra ops (8)
+      expect(opNames).toContain('memory_delete');
+      expect(opNames).toContain('memory_stats');
+      expect(opNames).toContain('memory_export');
+      expect(opNames).toContain('memory_import');
+      expect(opNames).toContain('memory_prune');
+      expect(opNames).toContain('memory_deduplicate');
+      expect(opNames).toContain('memory_topics');
+      expect(opNames).toContain('memory_by_project');
+      // Vault Extra ops (12)
+      expect(opNames).toContain('vault_get');
+      expect(opNames).toContain('vault_update');
+      expect(opNames).toContain('vault_remove');
+      expect(opNames).toContain('vault_bulk_add');
+      expect(opNames).toContain('vault_bulk_remove');
+      expect(opNames).toContain('vault_tags');
+      expect(opNames).toContain('vault_domains');
+      expect(opNames).toContain('vault_recent');
+      expect(opNames).toContain('vault_import');
+      expect(opNames).toContain('vault_seed');
+      expect(opNames).toContain('vault_backup');
+      expect(opNames).toContain('vault_age_report');
+      // Admin ops (8)
+      expect(opNames).toContain('admin_health');
+      expect(opNames).toContain('admin_tool_list');
+      expect(opNames).toContain('admin_config');
+      expect(opNames).toContain('admin_vault_size');
+      expect(opNames).toContain('admin_uptime');
+      expect(opNames).toContain('admin_version');
+      expect(opNames).toContain('admin_reset_cache');
+      expect(opNames).toContain('admin_diagnostic');
+      // Loop ops (7)
+      expect(opNames).toContain('loop_start');
+      expect(opNames).toContain('loop_iterate');
+      expect(opNames).toContain('loop_status');
+      expect(opNames).toContain('loop_cancel');
+      expect(opNames).toContain('loop_history');
+      expect(opNames).toContain('loop_is_active');
+      expect(opNames).toContain('loop_complete');
+      // Orchestrate ops (5)
+      expect(opNames).toContain('orchestrate_plan');
+      expect(opNames).toContain('orchestrate_execute');
+      expect(opNames).toContain('orchestrate_complete');
+      expect(opNames).toContain('orchestrate_status');
+      expect(opNames).toContain('orchestrate_quick_capture');
+      // Capture ops (4)
+      expect(opNames).toContain('capture_knowledge');
+      expect(opNames).toContain('capture_quick');
+      expect(opNames).toContain('search_intelligent');
+      expect(opNames).toContain('search_feedback');
+      // Grading ops (5)
+      expect(opNames).toContain('plan_grade');
+      expect(opNames).toContain('plan_check_history');
+      expect(opNames).toContain('plan_latest_check');
+      expect(opNames).toContain('plan_meets_grade');
+      expect(opNames).toContain('plan_auto_improve');
+      // Admin Extra ops (10)
+      expect(opNames).toContain('admin_telemetry');
+      expect(opNames).toContain('admin_telemetry_recent');
+      expect(opNames).toContain('admin_telemetry_reset');
+      expect(opNames).toContain('admin_permissions');
+      expect(opNames).toContain('admin_vault_analytics');
+      expect(opNames).toContain('admin_search_insights');
+      expect(opNames).toContain('admin_module_status');
+      expect(opNames).toContain('admin_env');
+      expect(opNames).toContain('admin_gc');
+      expect(opNames).toContain('admin_export_config');
+      // Curator Extra ops (4)
+      expect(opNames).toContain('curator_entry_history');
+      expect(opNames).toContain('curator_record_snapshot');
+      expect(opNames).toContain('curator_queue_stats');
+      expect(opNames).toContain('curator_enrich');
+      // Project ops (12)
+      expect(opNames).toContain('project_get');
+      expect(opNames).toContain('project_list');
+      expect(opNames).toContain('project_unregister');
+      expect(opNames).toContain('project_get_rules');
+      expect(opNames).toContain('project_list_rules');
+      expect(opNames).toContain('project_add_rule');
+      expect(opNames).toContain('project_remove_rule');
+      expect(opNames).toContain('project_link');
+      expect(opNames).toContain('project_unlink');
+      expect(opNames).toContain('project_get_links');
+      expect(opNames).toContain('project_linked_projects');
+      expect(opNames).toContain('project_touch');
+      // Cross-project memory ops (3)
+      expect(opNames).toContain('memory_promote_to_global');
+      expect(opNames).toContain('memory_configure');
+      expect(opNames).toContain('memory_cross_project_search');
+      // Total: 152 (147 core + 5 agent-specific)
+      expect(facade.ops.length).toBe(152);
     });
 
     it('search should query across all domains with ranked results', async () => {
@@ -280,7 +422,9 @@ ${domainDescribes}
       const setupOp = facade.ops.find((o) => o.name === 'setup')!;
       const result = (await setupOp.handler({ projectPath: '/tmp/nonexistent-test' })) as {
         agent: { name: string };
+        claude_md: { project: { exists: boolean; has_agent_section: boolean }; global: { exists: boolean; has_agent_section: boolean } };
         vault: { entries: number };
+        hooks: { agent: string[]; global: string[]; missing: string[] };
         recommendations: string[];
       };
       expect(result.agent.name).toBe('${escapeQuotes(config.name)}');
@@ -330,6 +474,32 @@ ${domainDescribes}
       const result = (await healthOp.handler({})) as { score: number };
       expect(result.score).toBeGreaterThan(0);
     });
+
+    it('governance_policy get should return default policy', async () => {
+      const facade = buildCoreFacade();
+      const policyOp = facade.ops.find((o) => o.name === 'governance_policy')!;
+      const result = (await policyOp.handler({ action: 'get', projectPath: '/test' })) as {
+        projectPath: string;
+        quotas: { maxEntriesTotal: number };
+        autoCapture: { enabled: boolean };
+      };
+      expect(result.projectPath).toBe('/test');
+      expect(result.quotas.maxEntriesTotal).toBe(500);
+      expect(result.autoCapture.enabled).toBe(true);
+    });
+
+    it('governance_dashboard should return combined view', async () => {
+      const facade = buildCoreFacade();
+      const dashOp = facade.ops.find((o) => o.name === 'governance_dashboard')!;
+      const result = (await dashOp.handler({ projectPath: '/test' })) as {
+        vaultSize: number;
+        quotaPercent: number;
+        pendingProposals: number;
+      };
+      expect(typeof result.vaultSize).toBe('number');
+      expect(typeof result.quotaPercent).toBe('number');
+      expect(result.pendingProposals).toBe(0);
+    });
   });
 });
 `;
@@ -387,7 +557,7 @@ function generateDomainDescribe(agentId: string, domain: string): string {
         severity: 'warning',
         description: 'A captured pattern.',
         tags: ['captured'],
-      })) as { captured: boolean };
+      })) as { captured: boolean; governance?: { action: string } };
       expect(result.captured).toBe(true);
       const entry = runtime.vault.get('${domain}-cap1');
       expect(entry).not.toBeNull();