@aria_asi/cli 0.2.0

package/src/connectors/claude-code.ts

@@ -0,0 +1,213 @@
+import { existsSync, readFileSync, writeFileSync, copyFileSync, chmodSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'node:url';
+import type { AriaConfig } from '../config.js';
+
+// ── Hooks shipped with this package ──────────────────────────────────
+// The connector installs these into ~/.claude/hooks/ so Claude Code's
+// per-turn harness fetch + pre-tool gate fire automatically. This is
+// the difference between "static prompt addendum" (what this connector
+// used to do) and "real runtime control plane" (what Aria's harness
+// actually is).
+//
+// Resolved relative to the compiled connector file: at runtime the
+// .js lives at <pkg>/dist/src/connectors/claude-code.js, hooks are at
+// <pkg>/hooks/ — so up three levels then into hooks/.
+const HOOK_FILES = ['aria-harness-via-sdk.mjs', 'aria-pre-tool-gate.mjs'];
+function packageHooksDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', '..', '..', 'hooks');
+}
+
+// Hook wiring for ~/.claude/settings.json. Mirrors what
+// ops/claude-hooks/install.sh writes; this is the customer-facing
+// equivalent that ships with the npm package so anyone running
+// `aria connect claude-code` gets the same behavior as the internal
+// dev install.
+const HOOKS_BLOCK = {
+  SessionStart: [{
+    hooks: [{
+      type: 'command',
+      command: 'HOOK_EVENT_NAME=SessionStart node $HOME/.claude/hooks/aria-harness-via-sdk.mjs --mode session',
+      timeout: 14,
+      statusMessage: 'Fetching Aria harness packet...',
+    }],
+  }],
+  UserPromptSubmit: [{
+    hooks: [{
+      type: 'command',
+      command: 'HOOK_EVENT_NAME=UserPromptSubmit node $HOME/.claude/hooks/aria-harness-via-sdk.mjs --mode turn',
+      timeout: 5,
+      statusMessage: 'Re-syncing Aria harness...',
+    }],
+  }],
+  PreToolUse: [{
+    matcher: 'Bash',
+    hooks: [{
+      type: 'command',
+      command: 'node $HOME/.claude/hooks/aria-pre-tool-gate.mjs',
+      timeout: 5,
+    }],
+  }],
+};
+
+function installHooks(claudeDir: string, logs: string[]): void {
+  const hooksTargetDir = path.join(claudeDir, 'hooks');
+  if (!existsSync(hooksTargetDir)) {
+    mkdirSync(hooksTargetDir, { recursive: true });
+  }
+  const sourceDir = packageHooksDir();
+  for (const name of HOOK_FILES) {
+    const src = path.join(sourceDir, name);
+    if (!existsSync(src)) {
+      logs.push(`⚠ hook source missing: ${src} (package may be incomplete)`);
+      continue;
+    }
+    const dst = path.join(hooksTargetDir, name);
+    // Back up any existing real file before overwriting (never silently
+    // clobber a user's customizations).
+    if (existsSync(dst) && !isSamePath(src, dst)) {
+      const backup = `${dst}.pre-aria-connect.${Date.now()}`;
+      try { copyFileSync(dst, backup); logs.push(`Backed up existing ${name} → ${path.basename(backup)}`); } catch {}
+    }
+    copyFileSync(src, dst);
+    try { chmodSync(dst, 0o755); } catch {}
+    logs.push(`Installed hook: ${name}`);
+  }
+}
+
+function isSamePath(a: string, b: string): boolean {
+  try { return path.resolve(a) === path.resolve(b); } catch { return false; }
+}
+
+function wireHooksBlock(settings: Record<string, unknown>, logs: string[]): void {
+  const hooks = (settings.hooks as Record<string, unknown> | undefined) ?? {};
+  // Replace each event's block wholesale so re-running connect stays
+  // deterministic and doesn't accumulate duplicate entries.
+  for (const [event, block] of Object.entries(HOOKS_BLOCK)) {
+    hooks[event] = block;
+  }
+  settings.hooks = hooks;
+  logs.push('Wired hooks (SessionStart, UserPromptSubmit, PreToolUse=Bash) into settings.json');
+}
+
+function buildAriaSystemBlock(config: AriaConfig): string {
+  const repoList = config.repositories.map((r) => `- ${r.name} (${r.path})`).join('\n');
+  const schemaText = Object.entries(config.schemaImages)
+    .map(([name, image]) => `[${name}]\n${image}`)
+    .join('\n\n');
+
+  return `<!-- ARIA HARNESS — injected by @aria/connector -->
+You are augmented with Aria's cognitive harness. This provides:
+- Schema image: a live snapshot of the codebase structure, dependencies, and patterns
+- Garden memory: persistent project memory across sessions
+- 8-lens cognition: multi-perspective analysis for every decision
+
+[SELF-GATE PROTOCOL]
+Before emitting any claim, verify against these hard constraints:
+1. Truth over deception — always.
+2. No harm supersedes any advantage.
+3. Sacred trust — never betray.
+4. Power obligates service.
+5. Reflection before action.
+
+[CONNECTED REPOSITORIES]
+${repoList || '(none linked yet — run `aria repo link <path>`)'}
+
+[SCHEMA IMAGES]
+${schemaText || '(no schema images yet — run `aria repo scan`)'}
+
+[INSTRUCTIONS]
+- Refer to the schema image for codebase context before answering.
+- Use garden memory to maintain continuity across sessions.
+- Apply the 8-lens analysis for complex decisions.
+- Flag uncertainty; never fabricate code or facts.
+<!-- END ARIA HARNESS -->`;
+}
+
+export async function connectClaudeCode(config: AriaConfig): Promise<string[]> {
+  const logs: string[] = [];
+  const claudeDir = path.join(homedir(), '.claude');
+
+  if (!existsSync(claudeDir)) {
+    const { mkdirSync } = await import('fs');
+    mkdirSync(claudeDir, { recursive: true });
+    logs.push(`Created ${claudeDir}`);
+  }
+
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  let settings: Record<string, unknown> = {};
+
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    } catch {
+      logs.push('Existing settings.json was corrupt — starting fresh');
+    }
+  }
+
+  const ariaBlock = buildAriaSystemBlock(config);
+
+  const existing = typeof settings.systemPromptPrefix === 'string'
+    ? settings.systemPromptPrefix
+    : '';
+
+  if (existing.includes('ARIA HARNESS')) {
+    logs.push('Aria harness prefix already present — skipping prompt injection');
+  } else {
+    settings.systemPromptPrefix = existing
+      ? `${ariaBlock}\n\n${existing}`
+      : ariaBlock;
+    logs.push('Injected Aria harness into Claude Code systemPromptPrefix');
+  }
+
+  // Install hook scripts + wire them into settings.hooks block. This is
+  // what makes the connector a real runtime control plane rather than
+  // just a system-prompt addendum.
+  installHooks(claudeDir, logs);
+  wireHooksBlock(settings, logs);
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+  const configJsonPath = path.join(claudeDir, 'config.json');
+  if (existsSync(configJsonPath)) {
+    try {
+      const claudeConfig = JSON.parse(readFileSync(configJsonPath, 'utf-8'));
+      if (typeof claudeConfig.additionalDirectories === 'undefined') {
+        claudeConfig.additionalDirectories = [];
+      }
+      const ariaDir = path.join(homedir(), '.aria');
+      if (!claudeConfig.additionalDirectories.includes(ariaDir)) {
+        claudeConfig.additionalDirectories.push(ariaDir);
+        writeFileSync(configJsonPath, JSON.stringify(claudeConfig, null, 2));
+        logs.push('Added ~/.aria to Claude Code additional directories');
+      }
+    } catch {
+      // config.json may not be valid JSON or not exist
+    }
+  }
+
+  return logs;
+}
+
+export async function disconnectClaudeCode(): Promise<string[]> {
+  const logs: string[] = [];
+  const settingsPath = path.join(homedir(), '.claude', 'settings.json');
+
+  if (!existsSync(settingsPath)) {
+    logs.push('No Claude Code settings found');
+    return logs;
+  }
+
+  const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  if (typeof settings.systemPromptPrefix === 'string') {
+    settings.systemPromptPrefix = settings.systemPromptPrefix.replace(
+      /<!-- ARIA HARNESS.*?<!-- END ARIA HARNESS -->/s,
+      '',
+    ).trim();
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    logs.push('Removed Aria harness from Claude Code settings');
+  }
+
+  return logs;
+}

package/src/connectors/cursor.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import * as path from 'path';
+import type { AriaConfig } from '../config.js';
+
+const CURSOR_RULES_HEADER = `// ARIA HARNESS — injected by @aria/connector
+// Aria provides: schema image awareness + garden memory + 8-lens cognition
+
+`;
+
+function buildCursorRules(config: AriaConfig): string {
+  const lines: string[] = [CURSOR_RULES_HEADER];
+
+  if (config.repositories.length > 0) {
+    lines.push('// Connected repositories:');
+    for (const repo of config.repositories) {
+      lines.push(`//   ${repo.name} — ${repo.path}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('// Always reference the schema image for codebase context.');
+  lines.push('// Apply the 8-lens analysis for complex architectural decisions.');
+  lines.push('// Persist key decisions to garden memory for session continuity.');
+  lines.push('');
+  lines.push('// Self-gate: verify claims before emitting. Flag uncertainty.');
+
+  return lines.join('\n');
+}
+
+export async function connectCursor(config: AriaConfig, repoPath?: string): Promise<string[]> {
+  const logs: string[] = [];
+  const targetPath = repoPath || process.cwd();
+  const rulesPath = path.join(targetPath, '.cursorrules');
+
+  const ariaBlock = buildCursorRules(config);
+
+  if (existsSync(rulesPath)) {
+    const existing = readFileSync(rulesPath, 'utf-8');
+    if (existing.includes('ARIA HARNESS')) {
+      logs.push('Aria harness already in .cursorrules — skipping');
+      return logs;
+    }
+    writeFileSync(rulesPath, ariaBlock + '\n' + existing);
+    logs.push(`Prepended Aria harness to ${rulesPath}`);
+  } else {
+    writeFileSync(rulesPath, ariaBlock);
+    logs.push(`Created ${rulesPath} with Aria harness`);
+  }
+
+  const cursorRulesDir = path.join(targetPath, '.cursor', 'rules');
+  if (existsSync(cursorRulesDir)) {
+    const ariaRulePath = path.join(cursorRulesDir, 'aria-harness.md');
+    if (!existsSync(ariaRulePath)) {
+      writeFileSync(ariaRulePath, buildCursorRules(config));
+      logs.push(`Created ${ariaRulePath}`);
+    }
+  }
+
+  return logs;
+}
+
+export async function disconnectCursor(repoPath?: string): Promise<string[]> {
+  const logs: string[] = [];
+  const targetPath = repoPath || process.cwd();
+  const rulesPath = path.join(targetPath, '.cursorrules');
+
+  if (existsSync(rulesPath)) {
+    let content = readFileSync(rulesPath, 'utf-8');
+    content = content.replace(/\/\/ ARIA HARNESS[\s\S]*?\n\n/, '');
+    writeFileSync(rulesPath, content);
+    logs.push(`Removed Aria harness from ${rulesPath}`);
+  }
+
+  return logs;
+}

package/src/connectors/opencode.ts

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+import type { AriaConfig } from '../config.js';
+
+export async function connectOpenCode(config: AriaConfig): Promise<string[]> {
+  const logs: string[] = [];
+  const opencodeDir = path.join(homedir(), '.opencode');
+
+  if (!existsSync(opencodeDir)) {
+    logs.push('No ~/.opencode directory found — OpenCode may not be installed');
+    return logs;
+  }
+
+  const configPath = path.join(opencodeDir, 'config.json');
+  if (existsSync(configPath)) {
+    try {
+      const opencodeConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+      let modified = false;
+
+      if (Array.isArray(opencodeConfig.plugins)) {
+        if (!opencodeConfig.plugins.includes('@aria/connector')) {
+          opencodeConfig.plugins.push('@aria/connector');
+          modified = true;
+          logs.push('Added @aria/connector to OpenCode plugins');
+        }
+      }
+
+      if (!opencodeConfig.agentsMdPath) {
+        opencodeConfig.agentsMdPath = path.join(homedir(), '.aria', 'AGENTS.md');
+        modified = true;
+        logs.push('Set OpenCode AGENTS.md path to ~/.aria/AGENTS.md');
+      }
+
+      if (modified) {
+        writeFileSync(configPath, JSON.stringify(opencodeConfig, null, 2));
+      } else {
+        logs.push('OpenCode already configured for Aria');
+      }
+    } catch {
+      logs.push('Failed to parse OpenCode config.json');
+    }
+  }
+
+  const ariaDir = path.join(homedir(), '.aria');
+  if (!existsSync(ariaDir)) {
+    mkdirSync(ariaDir, { recursive: true });
+  }
+
+  const ariaAgentsPath = path.join(ariaDir, 'AGENTS.md');
+  const agentsContent = buildOpenCodeAgentsMd(config);
+  writeFileSync(ariaAgentsPath, agentsContent);
+  logs.push(`Wrote Aria harness AGENTS.md to ${ariaAgentsPath}`);
+
+  return logs;
+}
+
+export async function disconnectOpenCode(): Promise<string[]> {
+  const logs: string[] = [];
+  const configPath = path.join(homedir(), '.opencode', 'config.json');
+
+  if (existsSync(configPath)) {
+    try {
+      const opencodeConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (Array.isArray(opencodeConfig.plugins)) {
+        opencodeConfig.plugins = opencodeConfig.plugins.filter(
+          (p: string) => p !== '@aria/connector',
+        );
+        writeFileSync(configPath, JSON.stringify(opencodeConfig, null, 2));
+        logs.push('Removed @aria/connector from OpenCode plugins');
+      }
+    } catch {
+      logs.push('Failed to update OpenCode config');
+    }
+  }
+
+  return logs;
+}
+
+function buildOpenCodeAgentsMd(config: AriaConfig): string {
+  const repoList = config.repositories.map((r) => `- ${r.name} (${r.path})`).join('\n');
+  const schemaText = Object.entries(config.schemaImages)
+    .map(([name, image]) => `### ${name}\n${image}`)
+    .join('\n\n');
+
+  return `# Aria Harness — AGENTS.md
+
+Automatically injected by @aria/connector. This file provides Aria's cognitive harness
+to OpenCode sessions.
+
+## Connected Repositories
+${repoList || '(none linked yet)'}
+
+## Schema Images
+${schemaText || '(no schema images yet — run \`aria repo scan\`)'}
+
+## Self-Gate Protocol
+1. Truth over deception — always.
+2. No harm supersedes any advantage.
+3. Sacred trust — never betray.
+4. Power obligates service.
+5. Reflection before action.
+
+## 8-Lens Cognition
+Apply multi-perspective analysis for every decision:
+- Truth lens: Is this factually correct?
+- Harm lens: Could this cause damage?
+- Trust lens: Does this maintain sacred trust?
+- Power lens: Am I using capability responsibly?
+- Reflection lens: Have I thought deeply enough?
+- Context lens: Do I have full context?
+- Impact lens: What are second-order effects?
+- Beauty lens: Is this elegant and sustainable?
+`;
+}

package/src/connectors/shell.ts

@@ -0,0 +1,72 @@
+import { existsSync, mkdirSync, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import * as path from 'path';
+import type { AriaConfig } from '../config.js';
+
+export async function connectShell(
+  toolName: string,
+  config: AriaConfig,
+): Promise<string[]> {
+  const logs: string[] = [];
+
+  let toolPath: string;
+  try {
+    toolPath = execSync(`which ${toolName}`, { encoding: 'utf-8' }).trim();
+  } catch {
+    logs.push(`Tool "${toolName}" not found in PATH`);
+    return logs;
+  }
+
+  const wrapperDir = path.join(homedir(), '.aria', 'wrappers');
+  const wrapperPath = path.join(wrapperDir, toolName);
+
+  if (!existsSync(wrapperDir)) {
+    mkdirSync(wrapperDir, { recursive: true });
+  }
+
+  const ariaBlock = buildShellWrapperBlock(config, toolName);
+  const script = `#!/usr/bin/env bash
+# ARIA HARNESS WRAPPER — generated by @aria/connector
+# Wraps ${toolName} with Aria's cognitive harness
+${ariaBlock}
+exec ${toolPath} "$@"
+`;
+
+  writeFileSync(wrapperPath, script);
+  chmodSync(wrapperPath, 0o755);
+  logs.push(`Created wrapper: ${wrapperPath}`);
+  logs.push(`Add ~/.aria/wrappers to your PATH to use it:`);
+  logs.push(`  export PATH="$HOME/.aria/wrappers:$PATH"`);
+
+  return logs;
+}
+
+function buildShellWrapperBlock(config: AriaConfig, toolName: string): string {
+  const repoList = config.repositories.map((r) => r.name).join(', ');
+
+  return `
+# Aria Harness active for: ${toolName}
+# Connected repos: ${repoList || 'none'}
+# Schema images loaded for: ${Object.keys(config.schemaImages).join(', ') || 'none'}
+#
+# The Aria harness provides:
+#   - Schema image: live codebase snapshot in tool context
+#   - Garden memory: persistent project memory
+#   - 8-lens cognition: multi-perspective analysis
+#
+# Self-gate: Truth > Harm prevention > Trust > Responsible power > Reflection
+`;
+}
+
+export async function disconnectShell(toolName: string): Promise<string[]> {
+  const logs: string[] = [];
+  const wrapperPath = path.join(homedir(), '.aria', 'wrappers', toolName);
+
+  if (existsSync(wrapperPath)) {
+    unlinkSync(wrapperPath);
+    logs.push(`Removed wrapper: ${wrapperPath}`);
+  }
+
+  return logs;
+}

package/src/garden-client.ts

@@ -0,0 +1,98 @@
+/**
+ * Garden HTTP client — talks to Aria's memory garden service.
+ * The garden stores project context, schema images, and conversation threads.
+ */
+
+const DEFAULT_GARDEN_URL = 'http://aria-soul.aria.svc.cluster.local:3000';
+
+export interface GardenStatus {
+  connected: boolean;
+  message: string;
+  threadCount?: number;
+  lastSync?: string;
+}
+
+export class GardenClient {
+  private baseUrl: string;
+
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl || process.env.ARIA_GARDEN_URL || DEFAULT_GARDEN_URL;
+  }
+
+  async health(): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.baseUrl}/health`, { signal: AbortSignal.timeout(5000) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async chat(message: string, userId?: string): Promise<string> {
+    const res = await fetch(`${this.baseUrl}/chat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(process.env.ARIA_API_KEY
+          ? { Authorization: `Bearer ${process.env.ARIA_API_KEY}` }
+          : {}),
+      },
+      body: JSON.stringify({
+        message,
+        userId: userId || 'aria-connector',
+        metadata: { platform: 'connector' },
+      }),
+    });
+
+    if (!res.ok) {
+      throw new Error(`Garden chat failed: ${res.status} ${res.statusText}`);
+    }
+
+    const data = await res.json() as { response?: string; message?: string; text?: string };
+    return data.response || data.message || data.text || JSON.stringify(data);
+  }
+
+  async status(): Promise<GardenStatus> {
+    const alive = await this.health();
+    if (!alive) {
+      return { connected: false, message: 'Garden service is unreachable' };
+    }
+
+    try {
+      const res = await fetch(`${this.baseUrl}/health`, {
+        signal: AbortSignal.timeout(3000),
+      });
+      const data = await res.json().catch(() => ({})) as Record<string, unknown>;
+      return {
+        connected: true,
+        message: 'Garden service is healthy',
+        threadCount: typeof data.threadCount === 'number' ? data.threadCount : undefined,
+        lastSync: typeof data.lastSync === 'string' ? data.lastSync : undefined,
+      };
+    } catch {
+      return { connected: true, message: 'Garden responded but status unavailable' };
+    }
+  }
+
+  async storeSchemaImage(imageText: string, projectName: string): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.baseUrl}/chat`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(process.env.ARIA_API_KEY
+            ? { Authorization: `Bearer ${process.env.ARIA_API_KEY}` }
+            : {}),
+        },
+        body: JSON.stringify({
+          message: `Schema image for ${projectName}:\n\n${imageText}`,
+          userId: 'aria-connector',
+          metadata: { platform: 'connector', action: 'store-schema' },
+        }),
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/garden-control-plane.ts

@@ -0,0 +1,108 @@
+// Garden Control Plane — Living Memory Fabric (CLI edition)
+// Replaces static system prompt injection with turn-by-turn garden integration.
+// Every turn: read relevant memories, generate response, write new memories.
+// Projects persist forever. Context is infinite. The harness improves per turn.
+
+const GARDEN_URL = process.env.GARDEN_SERVICE_URL || 'http://127.0.0.1:8097';
+
+export interface GardenMemory {
+  id: string;
+  type: 'conversation' | 'decision' | 'code' | 'insight' | 'project_state' | 'evolution';
+  content: string;
+  intensity: number;
+  timestamp: string;
+  sessionId: string;
+  userId?: string;
+  projectId?: string;
+  tags: string[];
+}
+
+// ── WRITE: Plant memories after every turn ──
+export async function plantGardenMemory(
+  type: GardenMemory['type'],
+  content: string,
+  intensity: number,
+  sessionId: string,
+  userId?: string,
+  projectId?: string,
+  tags: string[] = []
+): Promise<boolean> {
+  try {
+    const resp = await fetch(`${GARDEN_URL}/garden/fire`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type,
+        content: content.slice(0, 2000),
+        intensity: Math.max(0.1, Math.min(1, intensity)),
+        sessionId,
+        userId,
+        projectId,
+        tags,
+      }),
+      signal: AbortSignal.timeout(3000),
+    });
+
+    const data = await resp.json().catch(() => ({}));
+    return resp.ok && data?.ok !== false;
+  } catch {
+    return false;
+  }
+}
+
+// ── TURN-BY-TURN: Complete cycle ──
+export async function gardenTurnCycle(input: {
+  message: string;
+  response: string;
+  sessionId: string;
+  userId?: string;
+  projectId?: string;
+  gateViolations?: string[];
+  evolutionEvents?: string[];
+}): Promise<void> {
+  await plantGardenMemory(
+    'conversation',
+    `User: ${input.message.slice(0, 500)}\nAria: ${input.response.slice(0, 1000)}`,
+    0.6,
+    input.sessionId,
+    input.userId,
+    input.projectId,
+    ['turn', 'conversation']
+  );
+
+  if (input.gateViolations?.length) {
+    await plantGardenMemory(
+      'evolution',
+      `Gate violations: ${input.gateViolations.join(', ')}`,
+      0.8,
+      input.sessionId,
+      input.userId,
+      input.projectId,
+      ['gate', 'evolution']
+    );
+  }
+
+  if (input.evolutionEvents?.length) {
+    await plantGardenMemory(
+      'evolution',
+      `Evolution: ${input.evolutionEvents.join('; ')}`,
+      0.7,
+      input.sessionId,
+      input.userId,
+      input.projectId,
+      ['evolution']
+    );
+  }
+
+  if (input.projectId) {
+    await plantGardenMemory(
+      'project_state',
+      `Project active. Last message: ${input.message.slice(0, 200)}`,
+      0.4,
+      input.sessionId,
+      input.userId,
+      input.projectId,
+      ['project', 'checkpoint']
+    );
+  }
+}