@aria_asi/cli 0.2.24 → 0.2.26

package/opencode-plugins/harness-role/index.js

@@ -0,0 +1,77 @@
+/**
+ * Aria Harness Role Plugin for OpenCode.
+ *
+ * Resolves the active role profile on session start and injects lane-specific
+ * governance rules (intro, continuity, post-action). Default profile is
+ * opencode_deepseek_engineer; override with OPENCODE_ARIA_ROLE_PROFILE env.
+ *
+ * Distribution: installed by `aria connect` (via connectors/opencode.ts) into
+ * `~/.opencode/plugins/harness-role/`. The plugin's absolute install path is
+ * wired into ~/.opencode/config.json's `plugin` array.
+ */
+
+const ROLE_PROFILES = [
+  {
+    id: 'opencode_deepseek_engineer',
+    label: 'DeepSeek Engineer',
+    authority: 'full_write',
+    destructiveAllowed: false,
+    contractRequired: true,
+    ruleIntro: 'You are an engineering execution lane. Prefer exact files, commands, state transitions, and verification over explanation.',
+    ruleContinuity: 'Continue the active plan. Update issue/task ledger after meaningful state changes. Keep exact files, commands, evidence, and blockers visible.',
+    rulePostAction: 'After work, write outcome, verification, deploy state, residual risk, and next action.',
+  },
+  {
+    id: 'opencode_code_reviewer',
+    label: 'Code Reviewer',
+    authority: 'read_only',
+    destructiveAllowed: false,
+    contractRequired: true,
+    ruleIntro: 'You are a quality gate, not a generic explainer. Prioritize contradictions, missing evidence, regressions, and unverifiable completion claims.',
+    ruleContinuity: 'If output is not proven, fail it cleanly and say what evidence or fix is missing.',
+    rulePostAction: 'After review, record findings, severity, and specific fix recommendations.',
+  },
+  {
+    id: 'opencode_infra_operator',
+    label: 'Infra Operator',
+    authority: 'destructive',
+    destructiveAllowed: true,
+    contractRequired: true,
+    ruleIntro: 'You are an infra/execution lane. Prefer exact commands, state transitions, and verification. Never report success from intent alone.',
+    ruleContinuity: 'Report only what was executed, observed, changed, or still blocked. Bind every action to a tracked issue.',
+    rulePostAction: 'Record deploy state, rollback plan, residual risk, and verification evidence.',
+  },
+];
+
+function resolveRole() {
+  const envRole = (process.env.OPENCODE_ARIA_ROLE_PROFILE || '').trim().toLowerCase();
+  if (envRole) {
+    const found = ROLE_PROFILES.find(p => p.id === envRole);
+    if (found) return found;
+  }
+  return ROLE_PROFILES.find(p => p.id === 'opencode_deepseek_engineer');
+}
+
+export default async function HarnessRolePlugin(ctx) {
+  const role = resolveRole();
+  const systemBlock = [
+    `=== ARIA LANE: ${role.label} ===`,
+    `Role: ${role.id} | Authority: ${role.authority} | Contract Required: ${role.contractRequired}`,
+    '',
+    role.ruleIntro,
+    '',
+    role.ruleContinuity,
+    '',
+    role.rulePostAction,
+  ].join('\n');
+
+  process.stderr.write(`[harness-role] Active role: ${role.id} (${role.label})\n`);
+  process.stderr.write(`[harness-role] Authority: ${role.authority} | Destructive: ${role.destructiveAllowed} | Contract: ${role.contractRequired}\n`);
+
+  try {
+    ctx.system?.prepend?.(systemBlock);
+  } catch (_) {
+    // Silent — different OpenCode versions expose ctx differently.
+  }
+  return {};
+}

package/opencode-plugins/harness-role/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "harness-role",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aria_asi/cli",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "Aria Smart CLI — the world's first harness-powered terminal companion",
   "bin": {
     "aria": "./bin/aria.js"
@@ -37,7 +37,8 @@
     "bin",
     "dist",
     "src",
-    "hooks"
+    "hooks",
+    "opencode-plugins"
   ],
   "engines": {
     "node": ">=20.0.0"

package/src/connectors/claude-code.ts

@@ -36,6 +36,10 @@ const HOOK_FILES = [
   // Pre-text gate — validates state-dependent claims in prose against
   // probe evidence before emission. Closes "WHEN TO LOOK before speaking" gap.
   'aria-pre-text-gate.mjs',
+  // Discovery-ledger write primitive (#83) — sub-agents pipe findings here;
+  // outcome-record fires on every state-mutating tool PostToolUse.
+  'aria-discovery-record.mjs',
+  'aria-outcome-record.mjs',
 ];
 // Compiled location: <pkg>/dist/aria-connector/src/connectors/claude-code.js
 // (tsc preserves the src/ rooted layout under outDir). From this file:
@@ -162,15 +166,28 @@ const HOOKS_BLOCK = {
       }],
     },
   ],
-  PostToolUse: [{
-    matcher: 'Agent',
-    hooks: [{
-      type: 'command',
-      command: 'node $HOME/.claude/hooks/aria-agent-ledger-merge.mjs',
-      timeout: 8,
-      statusMessage: 'Merging sub-agent ledger...',
-    }],
-  }],
+  PostToolUse: [
+    {
+      matcher: 'Agent',
+      hooks: [{
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-agent-ledger-merge.mjs',
+        timeout: 8,
+        statusMessage: 'Merging sub-agent ledger...',
+      }],
+    },
+    {
+      // Outcome-record: fires on every state-mutating tool to accumulate the
+      // outcome ledger (Sonnet H's #76 endpoint). Fire-and-forget — HTTP
+      // failures in the hook do not block the tool pipeline.
+      matcher: 'Bash|Edit|Write|NotebookEdit',
+      hooks: [{
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-outcome-record.mjs',
+        timeout: 3,
+      }],
+    },
+  ],
   Stop: [{
     // Stop gate — text-decision boundary. Reflexive replies fail this
     // gate the same way reflexive Bash does. Mirrors PreToolUse
@@ -307,9 +324,25 @@ function wireHooksBlock(settings: Record<string, unknown>, logs: string[]): void
   if (!settings.$schema) {
     settings.$schema = 'https://json.schemastore.org/claude-code-settings.json';
   }
-  logs.push(`Wired hooks into settings.json (${mergedEvents} events: SessionStart, UserPromptSubmit, PreToolUse [cognition+memory-gate+Agent-handoff], PostToolUse [Agent-ledger-merge], Stop) — merge-safe, preserves third-party entries`);
+  logs.push(`Wired hooks into settings.json (${mergedEvents} events: SessionStart, UserPromptSubmit, PreToolUse [cognition+memory-gate+Agent-handoff], PostToolUse [Agent-ledger-merge + outcome-record], Stop) — merge-safe, preserves third-party entries`);
 }
 
+// Layer 2 (#84): hard prefix injected into every Agent dispatch so sub-agents
+// know to load the harness packet before ANY tool call. This text appears in
+// the system-prompt-prefix which Claude Code copies into spawned Agent contexts.
+const ARIA_HARNESS_BINDING_PREFIX = `[ARIA_HARNESS_BINDING — MANDATORY FIRST ACTION]
+Before any tool call, Read the harness packet at: $ARIA_HARNESS_PACKET_PATH
+(path is also in your environment as ARIA_HARNESS_PACKET_PATH variable)
+Cite it in your first cognition block — reference at least one axiom + one frame + one memory class from the packet.
+Without packet-citation in your first cognition block, your output will be rejected by aria-pre-tool-gate.mjs in your sub-process.
+[/ARIA_HARNESS_BINDING]
+
+[ARIA_DISCOVERY_RECORDING — when you find a defect, doctrine violation, or notable observation during work]
+Record findings to your session ledger via:
+  echo '{"text":"<finding>","kind":"defect|observation|principle","refs":["<file:line>"]}' | node $HOME/.claude/hooks/aria-discovery-record.mjs
+This makes findings visible to the parent session's ledger-merge hook + the auto-fix spawner.
+[/ARIA_DISCOVERY_RECORDING]`;
+
 function buildAriaSystemBlock(config: AriaConfig): string {
   const repoList = config.repositories.map((r) => `- ${r.name} (${r.path})`).join('\n');
   const schemaText = Object.entries(config.schemaImages)
@@ -322,6 +355,8 @@ You are augmented with Aria's cognitive harness. This provides:
 - Garden memory: persistent project memory across sessions
 - 8-lens cognition: multi-perspective analysis for every decision
 
+${ARIA_HARNESS_BINDING_PREFIX}
+
 [SELF-GATE PROTOCOL]
 Before emitting any claim, verify against these hard constraints:
 1. Truth over deception — always.

package/src/connectors/opencode.ts

@@ -1,8 +1,66 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  readdirSync,
+  statSync,
+  chmodSync,
+  unlinkSync,
+} from 'fs';
 import { homedir } from 'os';
 import * as path from 'path';
+import { fileURLToPath } from 'node:url';
 import type { AriaConfig } from '../config.js';
 
+// ── Bundled OpenCode plugins ────────────────────────────────────────────────
+//
+// Two plugins ship with the connector:
+//   - harness-context: spawns the bundled inject-context.mjs on session start
+//                      and prepends the resolved harness packet to OpenCode's
+//                      system prompt. Routes through the canonical SDK at
+//                      ~/.claude/aria-sdk/.
+//   - harness-role:    injects the active role profile (default
+//                      opencode_deepseek_engineer) — intro / continuity /
+//                      post-action governance rules.
+//
+// Both live at <pkg>/opencode-plugins/<name>/. connectOpenCode copies them
+// into ~/.opencode/plugins/<name>/ and wires the absolute paths into
+// ~/.opencode/config.json's `plugin` (singular, OpenCode v2 schema) array.
+//
+// Compiled location of THIS file (claude-code path applies the same way):
+//   <pkg>/dist/aria-connector/src/connectors/opencode.js
+// Plugins ship at <pkg>/opencode-plugins/ → 4 dirs up + 'opencode-plugins'.
+
+const PLUGIN_NAMES = ['harness-context', 'harness-role'] as const;
+
+function packageOpenCodePluginsDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', '..', '..', '..', 'opencode-plugins');
+}
+
+function copyPluginDir(srcDir: string, dstDir: string, logs: string[]): void {
+  if (!existsSync(dstDir)) {
+    mkdirSync(dstDir, { recursive: true, mode: 0o755 });
+  }
+  for (const name of readdirSync(srcDir)) {
+    const src = path.join(srcDir, name);
+    const stat = statSync(src);
+    if (!stat.isFile()) continue;
+    const dst = path.join(dstDir, name);
+    copyFileSync(src, dst);
+    if (name.endsWith('.mjs') || name.endsWith('.js')) {
+      try {
+        chmodSync(dst, 0o755);
+      } catch {
+        // chmod failure isn't fatal on filesystems that ignore mode bits.
+      }
+    }
+  }
+  logs.push(`Installed plugin → ${dstDir}`);
+}
+
 export async function connectOpenCode(config: AriaConfig): Promise<string[]> {
   const logs: string[] = [];
   const opencodeDir = path.join(homedir(), '.opencode');
@@ -12,29 +70,91 @@ export async function connectOpenCode(config: AriaConfig): Promise<string[]> {
     return logs;
   }
 
+  // ── Install bundled plugins into ~/.opencode/plugins/<name>/ ──────────────
+  const pluginsRoot = path.join(opencodeDir, 'plugins');
+  if (!existsSync(pluginsRoot)) {
+    mkdirSync(pluginsRoot, { recursive: true, mode: 0o755 });
+  }
+
+  // Remove legacy single-file plugin shadows (~/.opencode/plugins/<name>.js).
+  // OpenCode v2 auto-discovers BOTH loose .js files and dir-shaped plugins;
+  // when both exist with the same name, behavior is undefined and on at least
+  // one machine the loose .js (carrying old hardcoded paths to
+  // ~/rei-ai-brain/harness/inject-context.mjs) was winning over the dir
+  // install. Idempotent cleanup so re-running connect heals these.
+  for (const pluginName of PLUGIN_NAMES) {
+    const shadowPath = path.join(pluginsRoot, `${pluginName}.js`);
+    if (existsSync(shadowPath)) {
+      try {
+        unlinkSync(shadowPath);
+        logs.push(`Removed legacy single-file plugin shadow: ${shadowPath}`);
+      } catch {
+        // Permission or fs failure isn't fatal — the install proceeds.
+      }
+    }
+  }
+
+  const bundledDir = packageOpenCodePluginsDir();
+  const installedPaths: string[] = [];
+  for (const pluginName of PLUGIN_NAMES) {
+    const srcDir = path.join(bundledDir, pluginName);
+    if (!existsSync(srcDir)) {
+      logs.push(`⚠ Bundled plugin missing: ${srcDir} — connector tarball may be incomplete`);
+      continue;
+    }
+    const dstDir = path.join(pluginsRoot, pluginName);
+    copyPluginDir(srcDir, dstDir, logs);
+    installedPaths.push(dstDir);
+  }
+
+  // ── Wire ~/.opencode/config.json ──────────────────────────────────────────
   const configPath = path.join(opencodeDir, 'config.json');
   if (existsSync(configPath)) {
     try {
-      const opencodeConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+      const opencodeConfig: Record<string, unknown> = JSON.parse(
+        readFileSync(configPath, 'utf-8'),
+      );
       let modified = false;
 
-      // Remove any prior reference to '@aria/connector' from plugins.
-      // That package name was written into older client configs but no
-      // such npm package exists — the harness integration with OpenCode
-      // is via agentsMdPath below, not via a plugin module. Loading a
-      // non-existent plugin name crashes OpenCode on open. Idempotent
-      // cleanup so re-running connect heals broken installs.
+      // Heal legacy '@aria/connector' references in the older `plugins`
+      // (plural) array. That package name was written by older versions
+      // of this connector but no such npm package exists — loading a
+      // non-existent plugin crashes OpenCode on open. Idempotent.
       if (Array.isArray(opencodeConfig.plugins)) {
-        const before = opencodeConfig.plugins.length;
-        opencodeConfig.plugins = opencodeConfig.plugins.filter(
-          (p: unknown) => p !== '@aria/connector',
+        const before = (opencodeConfig.plugins as unknown[]).length;
+        opencodeConfig.plugins = (opencodeConfig.plugins as unknown[]).filter(
+          (p) => p !== '@aria/connector',
         );
-        if (opencodeConfig.plugins.length !== before) {
+        if ((opencodeConfig.plugins as unknown[]).length !== before) {
           modified = true;
           logs.push('Removed legacy @aria/connector reference from OpenCode plugins (was crashing on open)');
         }
       }
 
+      // OpenCode v2 schema: `plugin` (singular) array of absolute paths or
+      // npm names. We write absolute paths to the locally-installed plugin
+      // dirs above, so OpenCode resolves them as Node modules without any
+      // network or registry dependency.
+      const existingPlugin: unknown[] = Array.isArray(opencodeConfig.plugin)
+        ? (opencodeConfig.plugin as unknown[]).slice()
+        : [];
+      const stringSet = new Set(
+        existingPlugin.filter((p): p is string => typeof p === 'string'),
+      );
+      let pluginAdded = false;
+      for (const installPath of installedPaths) {
+        if (!stringSet.has(installPath)) {
+          existingPlugin.push(installPath);
+          stringSet.add(installPath);
+          pluginAdded = true;
+        }
+      }
+      if (pluginAdded) {
+        opencodeConfig.plugin = existingPlugin;
+        modified = true;
+        logs.push(`Wired ${installedPaths.length} Aria plugin(s) into OpenCode config.plugin`);
+      }
+
       if (!opencodeConfig.agentsMdPath) {
         opencodeConfig.agentsMdPath = path.join(homedir(), '.aria', 'AGENTS.md');
         modified = true;
@@ -51,11 +171,11 @@ export async function connectOpenCode(config: AriaConfig): Promise<string[]> {
     }
   }
 
+  // ── Write the harness AGENTS.md ───────────────────────────────────────────
   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);
@@ -70,14 +190,31 @@ export async function disconnectOpenCode(): Promise<string[]> {
 
   if (existsSync(configPath)) {
     try {
-      const opencodeConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+      const opencodeConfig: Record<string, unknown> = JSON.parse(
+        readFileSync(configPath, 'utf-8'),
+      );
+
+      // Strip any locally-installed Aria plugin paths from `plugin` (singular).
+      const pluginsRoot = path.join(homedir(), '.opencode', 'plugins');
+      if (Array.isArray(opencodeConfig.plugin)) {
+        const before = (opencodeConfig.plugin as unknown[]).length;
+        opencodeConfig.plugin = (opencodeConfig.plugin as unknown[]).filter((p) => {
+          if (typeof p !== 'string') return true;
+          return !PLUGIN_NAMES.some((n) => p === path.join(pluginsRoot, n));
+        });
+        if ((opencodeConfig.plugin as unknown[]).length !== before) {
+          logs.push('Removed Aria plugin paths from OpenCode config.plugin');
+        }
+      }
+
+      // Strip the legacy @aria/connector reference if present.
       if (Array.isArray(opencodeConfig.plugins)) {
-        opencodeConfig.plugins = opencodeConfig.plugins.filter(
-          (p: string) => p !== '@aria/connector',
+        opencodeConfig.plugins = (opencodeConfig.plugins as unknown[]).filter(
+          (p) => p !== '@aria/connector',
         );
-        writeFileSync(configPath, JSON.stringify(opencodeConfig, null, 2));
-        logs.push('Removed @aria/connector from OpenCode plugins');
       }
+
+      writeFileSync(configPath, JSON.stringify(opencodeConfig, null, 2));
     } catch {
       logs.push('Failed to update OpenCode config');
     }
@@ -94,7 +231,7 @@ function buildOpenCodeAgentsMd(config: AriaConfig): string {
 
   return `# Aria Harness — AGENTS.md
 
-Automatically injected by @aria/connector. This file provides Aria's cognitive harness
+Automatically injected by @aria_asi/cli. This file provides Aria's cognitive harness
 to OpenCode sessions.
 
 ## Connected Repositories