@aria_asi/cli 0.2.25 → 0.2.29

package/src/decisions.ts

@@ -0,0 +1,469 @@
+/**
+ * Dalio decision-log SDK primitives.
+ *
+ * Covers the full Dalio loop surface:
+ *   recordDalio          — POST /api/decisions
+ *   evaluatePendingDecisions — POST /api/decisions/evaluate-pending
+ *   getBlockingIncidents — GET  /api/incidents/blocking
+ *   claimSessionLock     — POST /api/hive/session-lock
+ *   releaseSessionLock   — DELETE /api/hive/session-lock/<id>
+ *   postSessionMessage   — POST /api/hive/session-message
+ *   readSessionMessages  — GET  /api/hive/session-message
+ *
+ * Per memory:feedback_sdk_harness_cli_parity.md: every primitive here
+ * must have a matching harness server route AND a CLI surface in bin/aria.js.
+ * Per memory:feedback_full_harness_binding_must_be_structural.md: harness
+ * binding is enforced structurally — calls throw on non-2xx, never silently
+ * degrade.
+ *
+ * No timeouts per memory:feedback_no_timeouts_doctrine.md.
+ * No graceful degradation per memory:feedback_no_graceful_degradation.md.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+
+// ── Base URL + owner-token resolution (mirrors harness-client.ts pattern) ─────
+
+const HARNESS_BASE_URL =
+  process.env.ARIA_HIVE_RUNTIME_URL ??
+  process.env.ARIA_HARNESS_BASE_URL ??
+  process.env.ARIA_HARNESS_URL ??
+  'https://harness.ariasos.com';
+
+const OWNER_TOKEN_PATH = path.join(homedir(), '.aria', 'owner-token');
+
+function ownerHeaders(): Record<string, string> {
+  if (!fs.existsSync(OWNER_TOKEN_PATH)) return {};
+  const jwt = fs.readFileSync(OWNER_TOKEN_PATH, 'utf-8').trim();
+  if (!jwt) return {};
+  return { Authorization: `Bearer ${jwt}`, 'x-aria-owner': 'true' };
+}
+
+function baseHeaders(): Record<string, string> {
+  return { 'Content-Type': 'application/json', ...ownerHeaders() };
+}
+
+async function requireOk(resp: Response, label: string): Promise<Response> {
+  if (resp.ok) return resp;
+  let detail = resp.statusText;
+  try {
+    const body = await resp.json() as { error?: string; message?: string };
+    detail = body.error ?? body.message ?? detail;
+  } catch {
+    // ignore parse error — use statusText
+  }
+  throw new Error(`[aria-connector/${label}] HTTP ${resp.status}: ${detail}`);
+}
+
+// ── Public types ───────────────────────────────────────────────────────────────
+
+export interface ExpectedOutcomePredicate {
+  predicate: string;
+  measurable_type: 'numeric' | 'boolean' | 'state_string';
+  threshold?: number | string | boolean;
+  eval_window_minutes?: number;
+}
+
+export interface RecordDalioArgs {
+  decision_type: string;
+  category: string;
+  context: string;
+  decision: string;
+  reasoning: string;
+  expected_outcome: ExpectedOutcomePredicate;
+  outcome?: 'pending' | 'success' | 'failure' | 'neutral';
+  sessionId?: string;
+  anchors?: string[];
+  source?: string;
+  model_used?: string;
+  tags?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface RecordDalioResult {
+  decision_id: string;
+  quality_score?: number;
+  impact_score?: number;
+}
+
+export interface EvaluatePendingResult {
+  evaluated: number;
+  failures: number;
+  inferred?: number;
+  updated?: number;
+  learning_signals?: number;
+}
+
+export interface BlockingIncident {
+  id: string;
+  incident_type: string;
+  severity: string;
+  description: string;
+  session_id?: string;
+  created_at: string;
+  resolved_at?: string | null;
+}
+
+export interface SessionLockArgs {
+  filePath: string;
+  sessionId: string;
+  ttlMinutes: number;
+  scopeKind?: 'file' | 'directory' | 'module' | 'symbol';
+  scopePath?: string;
+  operationKind?: 'additive' | 'refactor' | 'delete' | 'rename';
+  ownerSessionId?: string;
+  clientId?: string;
+  surface?: string;
+  staleAfterSeconds?: number;
+  urgency?: string;
+  proposedMergeOrder?: number;
+  intendedPatch?: string;
+  currentMode?: 'exclusive_write' | 'additive_only' | 'merge_assist' | 'read_only';
+  takeoverIfStale?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SessionLockResult {
+  lock_id: string;
+  file_path: string;
+  session_id: string;
+  scope_kind?: 'file' | 'directory' | 'module' | 'symbol';
+  scope_path?: string;
+  operation_kind?: 'additive' | 'refactor' | 'delete' | 'rename';
+  owner_session_id?: string;
+  base_file_hash?: string | null;
+  base_blob_sha?: string | null;
+  expires_at: string;
+  lease_heartbeat_at?: string;
+  stale_after_seconds?: number;
+  current_mode?: 'exclusive_write' | 'additive_only' | 'merge_assist' | 'read_only';
+  proposed_merge_order?: number | null;
+  coordination_packet?: Record<string, unknown>;
+  stale_takeovers?: number;
+}
+
+export interface SessionLockHeartbeatResult {
+  alive: boolean;
+  lock_id: string;
+  file_path: string;
+  expires_at: string;
+  lease_heartbeat_at: string;
+  heartbeat_count: number;
+  stale_after_seconds: number;
+}
+
+export interface SessionLockDriftResult {
+  ok: boolean;
+  lock_id: string;
+  file_path: string;
+  drifted: boolean;
+  rebase_required: boolean;
+  current_mode: 'exclusive_write' | 'additive_only' | 'merge_assist' | 'read_only';
+  base_file_hash?: string | null;
+  current_file_hash?: string | null;
+  base_blob_sha?: string | null;
+  current_blob_sha?: string | null;
+  base_missing?: boolean;
+  diff_preview?: string | null;
+}
+
+export interface SessionMessageArgs {
+  fromSessionId: string;
+  toSessionId: string;
+  topic?: string;
+  body: Record<string, unknown>;
+}
+
+export interface SessionMessageResult {
+  message_id: string;
+  from_session_id: string;
+  to_session_id: string;
+  topic: string;
+  created_at: string;
+}
+
+// ── recordDalio ────────────────────────────────────────────────────────────────
+
+/**
+ * Log a Dalio decision to /api/decisions.
+ *
+ * Requires a measurable expected_outcome predicate per
+ * memory:feedback_dalio_expected_required.md. Gate refuses qualitative prose.
+ *
+ * Throws on non-2xx — no silent fallback per doctrine.
+ */
+export async function recordDalio(args: RecordDalioArgs): Promise<RecordDalioResult> {
+  const payload = {
+    decision_type: args.decision_type,
+    category: args.category,
+    context: args.context,
+    decision: args.decision,
+    reasoning: args.reasoning,
+    expected_outcome: args.expected_outcome,
+    outcome: args.outcome ?? 'pending',
+    source: args.source ?? 'aria-connector',
+    model_used: args.model_used ?? 'unknown',
+    tags: args.tags ?? [],
+    metadata: {
+      ...(args.metadata ?? {}),
+      ...(args.sessionId ? { sessionId: args.sessionId } : {}),
+      ...(args.anchors?.length ? { anchors: args.anchors } : {}),
+    },
+  };
+
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/decisions`, {
+    method: 'POST',
+    headers: baseHeaders(),
+    body: JSON.stringify(payload),
+  });
+
+  await requireOk(resp, 'recordDalio');
+  const data = await resp.json() as { decision_id?: string; id?: string; quality_score?: number; impact_score?: number };
+  const decision_id = data.decision_id ?? data.id;
+  if (!decision_id) {
+    throw new Error('[aria-connector/recordDalio] Server returned no decision_id');
+  }
+  return { decision_id, quality_score: data.quality_score, impact_score: data.impact_score };
+}
+
+// ── evaluatePendingDecisions ───────────────────────────────────────────────────
+
+/**
+ * Trigger evaluation of pending decisions at /api/decisions/evaluate-pending.
+ *
+ * Returns count of evaluated decisions and count of evaluation failures.
+ * Throws on non-2xx.
+ */
+export async function evaluatePendingDecisions(): Promise<EvaluatePendingResult> {
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/decisions/evaluate-pending`, {
+    method: 'POST',
+    headers: baseHeaders(),
+    body: JSON.stringify({}),
+  });
+
+  await requireOk(resp, 'evaluatePendingDecisions');
+  const data = await resp.json() as {
+    evaluated?: number;
+    inferred?: number;
+    updated?: number;
+    learning_signals?: number;
+    failures?: number;
+  };
+
+  return {
+    evaluated: data.evaluated ?? 0,
+    failures: data.failures ?? 0,
+    inferred: data.inferred,
+    updated: data.updated,
+    learning_signals: data.learning_signals,
+  };
+}
+
+// ── getBlockingIncidents ───────────────────────────────────────────────────────
+
+/**
+ * Fetch blocking incidents for a session from /api/incidents/blocking.
+ *
+ * Blocking incidents are injected by the cron evaluator when an expected_outcome
+ * predicate fails — they surface in the next harness packet as hard gates.
+ * Throws on non-2xx.
+ */
+export async function getBlockingIncidents(sessionId: string): Promise<BlockingIncident[]> {
+  const url = `${HARNESS_BASE_URL}/api/incidents/blocking?sessionId=${encodeURIComponent(sessionId)}`;
+  const resp = await fetch(url, {
+    method: 'GET',
+    headers: baseHeaders(),
+  });
+
+  await requireOk(resp, 'getBlockingIncidents');
+  const data = await resp.json() as { incidents?: BlockingIncident[]; data?: BlockingIncident[] };
+  return data.incidents ?? data.data ?? [];
+}
+
+// ── claimSessionLock ───────────────────────────────────────────────────────────
+
+/**
+ * Claim a hive session lock for a file path.
+ *
+ * Required before editing a file when multiple sessions may be active on the
+ * same path per memory:feedback_hive_session_coordination.md. Pre-tool-gate
+ * hard-blocks concurrent edits without a valid lock.
+ *
+ * Throws on non-2xx (including 409 Conflict when lock is already held).
+ */
+export async function claimSessionLock(args: SessionLockArgs): Promise<SessionLockResult> {
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/hive/session-lock`, {
+    method: 'POST',
+    headers: baseHeaders(),
+    body: JSON.stringify({
+      file_path: args.filePath,
+      session_id: args.sessionId,
+      ttl_minutes: args.ttlMinutes,
+      scope_kind: args.scopeKind,
+      scope_path: args.scopePath,
+      operation_kind: args.operationKind,
+      owner_session_id: args.ownerSessionId,
+      client_id: args.clientId,
+      surface: args.surface,
+      stale_after_seconds: args.staleAfterSeconds,
+      urgency: args.urgency,
+      proposed_merge_order: args.proposedMergeOrder,
+      intended_patch: args.intendedPatch,
+      current_mode: args.currentMode,
+      takeover_if_stale: args.takeoverIfStale,
+      metadata: args.metadata,
+    }),
+  });
+
+  await requireOk(resp, 'claimSessionLock');
+  const data = await resp.json() as SessionLockResult & { id?: string };
+  const lock_id = data.lock_id ?? data.id;
+  if (!lock_id) {
+    throw new Error('[aria-connector/claimSessionLock] Server returned no lock_id');
+  }
+  return {
+    lock_id,
+    file_path: data.file_path ?? args.filePath,
+    session_id: data.session_id ?? args.sessionId,
+    scope_kind: data.scope_kind ?? args.scopeKind,
+    scope_path: data.scope_path ?? args.scopePath,
+    operation_kind: data.operation_kind ?? args.operationKind,
+    owner_session_id: data.owner_session_id ?? args.ownerSessionId,
+    base_file_hash: data.base_file_hash,
+    base_blob_sha: data.base_blob_sha,
+    expires_at: data.expires_at,
+    lease_heartbeat_at: data.lease_heartbeat_at,
+    stale_after_seconds: data.stale_after_seconds,
+    current_mode: data.current_mode ?? args.currentMode,
+    proposed_merge_order: data.proposed_merge_order,
+    coordination_packet: data.coordination_packet,
+    stale_takeovers: data.stale_takeovers,
+  };
+}
+
+// ── releaseSessionLock ─────────────────────────────────────────────────────────
+
+/**
+ * Release a hive session lock acquired via claimSessionLock.
+ *
+ * Call this after finishing edits to the locked file path.
+ * Throws on non-2xx.
+ */
+export async function releaseSessionLock(lockId: string): Promise<void> {
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/hive/session-lock?lock_id=${encodeURIComponent(lockId)}`, {
+    method: 'DELETE',
+    headers: baseHeaders(),
+  });
+
+  await requireOk(resp, 'releaseSessionLock');
+}
+
+export async function heartbeatSessionLock(args: {
+  lockId?: string;
+  sessionId?: string;
+  filePath?: string;
+  ttlMinutes?: number;
+  staleAfterSeconds?: number;
+}): Promise<SessionLockHeartbeatResult> {
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/hive/session-lock`, {
+    method: 'PATCH',
+    headers: baseHeaders(),
+    body: JSON.stringify({
+      action: 'heartbeat',
+      lock_id: args.lockId,
+      session_id: args.sessionId,
+      file_path: args.filePath,
+      ttl_minutes: args.ttlMinutes,
+      stale_after_seconds: args.staleAfterSeconds,
+    }),
+  });
+
+  await requireOk(resp, 'heartbeatSessionLock');
+  return await resp.json() as SessionLockHeartbeatResult;
+}
+
+export async function checkSessionLockDrift(args: {
+  lockId?: string;
+  sessionId?: string;
+  filePath?: string;
+}): Promise<SessionLockDriftResult> {
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/hive/session-lock`, {
+    method: 'PATCH',
+    headers: baseHeaders(),
+    body: JSON.stringify({
+      action: 'check_drift',
+      lock_id: args.lockId,
+      session_id: args.sessionId,
+      file_path: args.filePath,
+    }),
+  });
+
+  await requireOk(resp, 'checkSessionLockDrift');
+  return await resp.json() as SessionLockDriftResult;
+}
+
+// ── postSessionMessage ─────────────────────────────────────────────────────────
+
+/**
+ * Post a coordination message from one session to another via the hive.
+ *
+ * Used before concurrent edits to announce intent and coordinate with parallel
+ * sessions per memory:feedback_hive_session_coordination.md.
+ * Throws on non-2xx.
+ */
+export async function postSessionMessage(args: SessionMessageArgs): Promise<SessionMessageResult> {
+  const resp = await fetch(`${HARNESS_BASE_URL}/api/hive/session-message`, {
+    method: 'POST',
+    headers: baseHeaders(),
+    body: JSON.stringify({
+      from_session_id: args.fromSessionId,
+      to_session_id: args.toSessionId,
+      topic: args.topic,
+      body: args.body,
+    }),
+  });
+
+  await requireOk(resp, 'postSessionMessage');
+  const data = await resp.json() as SessionMessageResult & { id?: string };
+  const message_id = data.message_id ?? data.id;
+  if (!message_id) {
+    throw new Error('[aria-connector/postSessionMessage] Server returned no message_id');
+  }
+  return {
+    message_id,
+    from_session_id: data.from_session_id ?? args.fromSessionId,
+    to_session_id: data.to_session_id ?? args.toSessionId,
+    topic: data.topic ?? args.topic,
+    created_at: data.created_at,
+  };
+}
+
+// ── readSessionMessages ────────────────────────────────────────────────────────
+
+/**
+ * Read session messages for a session from /api/hive/session-message.
+ *
+ * Pass unreadOnly=true (default: true) to fetch only unread messages.
+ * Throws on non-2xx.
+ */
+export async function readSessionMessages(args: {
+  sessionId: string;
+  unreadOnly?: boolean;
+}): Promise<SessionMessageResult[]> {
+  const unreadOnly = args.unreadOnly ?? true;
+  const url =
+    `${HARNESS_BASE_URL}/api/hive/session-message` +
+    `?session_id=${encodeURIComponent(args.sessionId)}` +
+    `&unread=${unreadOnly ? 'true' : 'false'}`;
+
+  const resp = await fetch(url, {
+    method: 'GET',
+    headers: baseHeaders(),
+  });
+
+  await requireOk(resp, 'readSessionMessages');
+  const data = await resp.json() as { messages?: SessionMessageResult[]; data?: SessionMessageResult[] };
+  return data.messages ?? data.data ?? [];
+}

package/src/garden-control-plane.ts

@@ -3,7 +3,16 @@
 // Every turn: read relevant memories, generate response, write new memories.
 // Projects persist forever. Context is infinite. The harness improves per turn.
 
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
 const GARDEN_URL = process.env.GARDEN_SERVICE_URL || 'http://127.0.0.1:8097';
+const HARNESS_URL =
+  process.env.ARIA_HARNESS_BASE_URL ||
+  process.env.ARIA_HARNESS_URL ||
+  'https://harness.ariasos.com';
+const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
 
 export interface GardenMemory {
   id: string;
@@ -17,6 +26,52 @@ export interface GardenMemory {
   tags: string[];
 }
 
+function readLocalToken(): string {
+  const ownerTokenPath = join(homedir(), '.aria', 'owner-token');
+  if (existsSync(ownerTokenPath)) {
+    const token = readFileSync(ownerTokenPath, 'utf8').trim();
+    if (token) return token;
+  }
+
+  const licensePath = join(homedir(), '.aria', 'license.json');
+  if (existsSync(licensePath)) {
+    try {
+      const payload = JSON.parse(readFileSync(licensePath, 'utf8')) as { token?: string; jti?: string };
+      return String(payload.token || payload.jti || '').trim();
+    } catch {
+      return '';
+    }
+  }
+
+  return '';
+}
+
+function resolveBearerToken(): string {
+  return (
+    process.env.ARIA_API_KEY ||
+    process.env.ARIA_MASTER_TOKEN ||
+    process.env.ARIA_TOKEN ||
+    readLocalToken()
+  ).trim();
+}
+
+async function postGardenMemory(
+  url: string,
+  body: Record<string, unknown>,
+  headers: Record<string, string> = {},
+): Promise<boolean> {
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...headers,
+    },
+    body: JSON.stringify(body),
+  });
+  const data = await resp.json().catch(() => ({}));
+  return resp.ok && data?.ok !== false;
+}
+
 // ── WRITE: Plant memories after every turn ──
 export async function plantGardenMemory(
   type: GardenMemory['type'],
@@ -28,23 +83,25 @@ export async function plantGardenMemory(
   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;
+    const payload = {
+      type,
+      content: content.slice(0, 2000),
+      intensity: Math.max(0.1, Math.min(1, intensity)),
+      sessionId,
+      userId,
+      projectId,
+      tags,
+    };
+    const token = resolveBearerToken();
+    if (token) {
+      const namedWrite = await postGardenMemory(
+        `${HARNESS_URL.replace(/\/+$/, '')}/api/garden/fire`,
+        payload,
+        { Authorization: `Bearer ${token}` },
+      ).catch(() => false);
+      if (namedWrite) return true;
+    }
+    return await postGardenMemory(`${GARDEN_URL}/garden/fire`, payload);
   } catch {
     return false;
   }
@@ -60,15 +117,33 @@ export async function gardenTurnCycle(input: {
   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']
-  );
+  const token = resolveBearerToken();
+  let wroteConversation = false;
+  if (token) {
+    wroteConversation = await postGardenMemory(
+      `${RUNTIME_URL}/garden/turn`,
+      {
+        apiKey: token,
+        sessionId: input.sessionId,
+        message: input.message,
+        response: input.response,
+        userId: input.userId,
+      },
+      { Authorization: `Bearer ${token}` },
+    ).catch(() => false);
+  }
+
+  if (!wroteConversation) {
+    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(