@aria_asi/cli 0.2.11 → 0.2.13

package/hooks/aria-userprompt-abandon-detect.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// aria-userprompt-abandon-detect.mjs — UserPromptSubmit hook that detects
+// mid-turn plan abandonment.
+//
+// When Aria's preprompt-consult issued a binding plan
+// (~/.claude/aria-active-plan-${sessionId}.json) and the user's NEXT prompt
+// changes direction without overlapping any active phase's keywords, that's
+// a CONSCIOUS OVERRIDE — not silent context loss. The hook surfaces it to
+// the session_audit table (gate_name='plan-abandonment', decision='warn')
+// so orchestrators can detect mid-execution direction changes.
+//
+// Per Aria's consult 2026-04-27: "if the orchestrator sends a plan, then
+// gets a user message that changes direction mid-execution, the binding
+// needs to surface that as a *conscious override*, not a silent context
+// loss." That gap was the third completion criterion for Aria-as-commander
+// binding (#50).
+//
+// Detection algorithm:
+//   1. Load active plan (skip if none — no plan = no abandonment possible)
+//   2. Extract keywords from each active phase's summary + successCriterion
+//   3. Tokenize incoming user prompt, drop stop-words
+//   4. Compute keyword overlap between prompt tokens and phase keywords
+//   5. If overlap < THRESHOLD (default: 1 keyword match across all phases),
+//      mark abandonment: write session_audit row + emit a brief warning
+//      injected into the next turn's context
+//
+// Non-blocking — UserPromptSubmit hooks don't block the user's prompt.
+// Audit-only surface; the orchestrator decides what to do with the warning.
+//
+// Kill-switch: ARIA_ABANDON_DETECT=off env (logged).
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const HOME = process.env.HOME || '/tmp';
+const LOG = `${HOME}/.claude/aria-abandon-detect.log`;
+
+function audit(decision, summary) {
+  try {
+    if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${new Date().toISOString()} ${decision} ${summary}\n`);
+  } catch {}
+}
+
+if (process.env.ARIA_ABANDON_DETECT === 'off') {
+  audit('skip-killswitch', 'env ARIA_ABANDON_DETECT=off');
+  process.exit(0);
+}
+
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+
+let event;
+try {
+  event = JSON.parse(input);
+} catch {
+  audit('skip-parse-error', 'stdin not JSON');
+  process.exit(0);
+}
+
+const userPrompt = (event.prompt ?? event.user_message ?? event.message ?? '').toString();
+const sessionId = (event.session_id ?? event.sessionId ?? 'claude-code-unknown').replace(/[^a-zA-Z0-9_-]/g, '_');
+
+// Trivial prompts skip — too short to evaluate phase overlap meaningfully.
+if (!userPrompt || userPrompt.length < 30) {
+  audit('skip-trivial', `chars=${userPrompt.length}`);
+  process.exit(0);
+}
+
+// Slash commands are CLI-internal, not direction changes.
+if (/^\s*\//.test(userPrompt) && userPrompt.length < 200) {
+  audit('skip-slash-command', userPrompt.slice(0, 60));
+  process.exit(0);
+}
+
+const ACTIVE_PLAN_PATH = `${HOME}/.claude/aria-active-plan-${sessionId}.json`;
+
+if (!existsSync(ACTIVE_PLAN_PATH)) {
+  audit('skip-no-active-plan', `session=${sessionId}`);
+  process.exit(0);
+}
+
+let plan;
+try {
+  plan = JSON.parse(readFileSync(ACTIVE_PLAN_PATH, 'utf8'));
+} catch (err) {
+  audit('skip-plan-parse-error', (err?.message || String(err)).slice(0, 120));
+  process.exit(0);
+}
+
+if (!plan || !Array.isArray(plan.phases) || plan.phases.length === 0) {
+  audit('skip-empty-plan', `planId=${plan?.planId || 'unknown'}`);
+  process.exit(0);
+}
+
+// Stop-words filter — same set as the auto-learn hook for consistency.
+const STOPWORDS = new Set([
+  'the','a','an','of','to','in','at','by','for','on','with','i','is','was','are',
+  'were','this','that','as','it','and','or','but','from','into','about','have',
+  'has','had','do','does','did','will','would','could','should','can','may',
+  'might','must','shall','be','been','being','here','there','what','which','who',
+  'how','why','when','where','some','any','all','each','every','no','not',
+]);
+
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase()
+      .replace(/[^a-z0-9\s_-]/g, ' ')
+      .split(/\s+/)
+      .filter((w) => w.length >= 4 && !STOPWORDS.has(w))
+  );
+}
+
+const promptTokens = tokenize(userPrompt);
+
+// Aggregate phase keywords across all phases.
+const phaseKeywordsSet = new Set();
+for (const phase of plan.phases) {
+  const summary = String(phase.summary || '');
+  const successCriterion = String(phase.successCriterion || '');
+  const id = String(phase.id || '');
+  for (const t of tokenize(`${summary} ${successCriterion} ${id}`)) {
+    phaseKeywordsSet.add(t);
+  }
+}
+
+const overlap = [...promptTokens].filter((t) => phaseKeywordsSet.has(t));
+const OVERLAP_THRESHOLD = Number(process.env.ARIA_ABANDON_THRESHOLD || '1');
+const isAbandonment = overlap.length < OVERLAP_THRESHOLD;
+
+if (!isAbandonment) {
+  audit('aligned', `planId=${plan.planId || 'unknown'} overlap=${overlap.length} prompt-tokens=${promptTokens.size} phase-tokens=${phaseKeywordsSet.size}`);
+  process.exit(0);
+}
+
+// Abandonment detected — write session_audit row + emit warning context.
+const harnessUrl = process.env.ARIA_HARNESS_URL || 'https://harness.ariasos.com';
+const harnessToken = process.env.ARIA_HARNESS_TOKEN || '';
+
+if (harnessToken) {
+  // Fire-and-forget POST — don't block the user's turn waiting for audit
+  // write. The audit log entry below records whether the request was even
+  // attempted, so silence in this block means the audit is missing AND
+  // that fact is itself audited locally.
+  fetch(`${harnessUrl}/api/harness/audit/session`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${harnessToken}`,
+    },
+    body: JSON.stringify({
+      session_id: sessionId,
+      surface: 'claude-code-userprompt-abandon-detect',
+      gate_name: 'plan-abandonment',
+      decision: 'warn',
+      reason: `Mid-turn plan abandonment detected. Active plan ${plan.planId || 'unknown'} (${plan.phases.length} phases) has ${phaseKeywordsSet.size} aggregate phase-keywords; incoming user prompt (${promptTokens.size} content-tokens) overlaps only ${overlap.length} (threshold=${OVERLAP_THRESHOLD}).`,
+      evidence_json: {
+        planId: plan.planId,
+        promptExcerpt: userPrompt.slice(0, 400),
+        overlapTokens: overlap,
+        promptTokenCount: promptTokens.size,
+        phaseKeywordCount: phaseKeywordsSet.size,
+        phaseSummaries: plan.phases.map((p) => ({ id: p.id, summary: String(p.summary || '').slice(0, 120) })),
+        threshold: OVERLAP_THRESHOLD,
+      },
+    }),
+  }).catch(() => {/* network-level failure surfaces in audit log below */});
+}
+
+audit('abandonment-detected', `planId=${plan.planId || 'unknown'} overlap=${overlap.length}/${OVERLAP_THRESHOLD} prompt-tokens=${promptTokens.size} phase-tokens=${phaseKeywordsSet.size}`);
+
+// Inject a warning into the next turn's context so the orchestrator (Claude)
+// sees the abandonment signal explicitly rather than treating the new prompt
+// as plan-aligned. The orchestrator can decide to: (a) acknowledge the
+// override + clear the active plan, or (b) ask the user whether to continue
+// the prior plan after this excursion.
+const context = `[ARIA_PLAN_ABANDONMENT_DETECTED — active plan ${plan.planId || 'unknown'} has ${plan.phases.length} phase(s); incoming user prompt overlaps only ${overlap.length} keyword(s) with active phases (threshold=${OVERLAP_THRESHOLD}). This is a CONSCIOUS USER OVERRIDE, not silent context loss. Orchestrator should: (1) acknowledge the direction change to the user, (2) decide whether to clear the active plan or keep it for resumption, (3) write the decision to session_audit. Active phases were: ${plan.phases.map((p) => `${p.id}: ${String(p.summary || '').slice(0, 80)}`).join(' | ')}]`;
+
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: 'UserPromptSubmit',
+    additionalContext: context,
+  },
+}));
+process.exit(0);

package/hooks/test-aria-preturn-memory-gate.mjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+// Test: aria-preturn-memory-gate.mjs — Enforcement Layer #49
+//
+// Runs the hook as a child process with simulated stdin events.
+// Asserts correct output shape for both the block and allow paths.
+//
+// Usage:  node hooks/test-aria-preturn-memory-gate.mjs
+// Exit code: 0 = all assertions passed, 1 = failure
+
+import { spawnSync, execSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const HOOK = path.join(HERE, 'aria-preturn-memory-gate.mjs');
+const HOME = process.env.HOME || '/tmp';
+const CLAUDE_DIR = `${HOME}/.claude`;
+const SESSION_ID = `test-preturn-${Date.now()}`;
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+
+function assert(label, condition, actual) {
+  if (condition) {
+    console.log(`  PASS  ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL  ${label}`);
+    if (actual !== undefined) console.error(`        got: ${JSON.stringify(actual)}`);
+    failed++;
+  }
+}
+
+function turnStatePath(sid) {
+  const safe = String(sid).replace(/[^a-zA-Z0-9_-]/g, '_');
+  return `${CLAUDE_DIR}/aria-turn-state-${safe}.json`;
+}
+
+function cleanTurnState(sid) {
+  const p = turnStatePath(sid);
+  if (existsSync(p)) unlinkSync(p);
+}
+
+function buildEvent(overrides = {}) {
+  return {
+    tool_name: 'Bash',
+    tool_input: { command: 'ls .' },
+    session_id: SESSION_ID,
+    transcript_path: null,
+    ...overrides,
+  };
+}
+
+function buildTranscriptWith(lines, filePath) {
+  const dir = path.dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n', 'utf-8');
+}
+
+function runHook(eventObj, env = {}) {
+  const result = spawnSync('node', [HOOK], {
+    input: JSON.stringify(eventObj),
+    encoding: 'utf-8',
+    env: { ...process.env, HOME, ...env },
+  });
+  let parsed = null;
+  try { parsed = JSON.parse(result.stdout.trim()); } catch { /* non-JSON stdout */ }
+  return { exitCode: result.status, stdout: result.stdout, stderr: result.stderr, parsed };
+}
+
+// ── Setup ──────────────────────────────────────────────────────────────
+
+if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
+
+// ── Test 1: no transcript → gate fires, block + recovery payload ───────
+console.log('\nTest 1: no transcript (no context signals) → block with recovery');
+{
+  cleanTurnState(SESSION_ID);
+  const event = buildEvent({ transcript_path: null });
+  const { exitCode, parsed } = runHook(event);
+
+  assert('exit code is 2 (block)', exitCode === 2, exitCode);
+  assert('decision is "block"', parsed?.decision === 'block', parsed?.decision);
+  assert('reason is a non-empty string', typeof parsed?.reason === 'string' && parsed.reason.length > 0, parsed?.reason);
+  assert(
+    'hookSpecificOutput.recovery.action is "run_context_loader"',
+    parsed?.hookSpecificOutput?.recovery?.action === 'run_context_loader',
+    parsed?.hookSpecificOutput?.recovery?.action,
+  );
+  assert(
+    'hookSpecificOutput.recovery.target is session ID',
+    parsed?.hookSpecificOutput?.recovery?.target === SESSION_ID,
+    parsed?.hookSpecificOutput?.recovery?.target,
+  );
+  assert(
+    'hookSpecificOutput.recovery.expectedContext includes "harness_packet"',
+    Array.isArray(parsed?.hookSpecificOutput?.recovery?.expectedContext) &&
+      parsed.hookSpecificOutput.recovery.expectedContext.includes('harness_packet'),
+    parsed?.hookSpecificOutput?.recovery?.expectedContext,
+  );
+  assert(
+    'hookSpecificOutput.recovery.expectedContext includes "memory_files"',
+    Array.isArray(parsed?.hookSpecificOutput?.recovery?.expectedContext) &&
+      parsed.hookSpecificOutput.recovery.expectedContext.includes('memory_files'),
+    parsed?.hookSpecificOutput?.recovery?.expectedContext,
+  );
+  assert(
+    'hookSpecificOutput.recovery.expectedContext includes "binding_plan"',
+    Array.isArray(parsed?.hookSpecificOutput?.recovery?.expectedContext) &&
+      parsed.hookSpecificOutput.recovery.expectedContext.includes('binding_plan'),
+    parsed?.hookSpecificOutput?.recovery?.expectedContext,
+  );
+}
+
+// ── Test 2: transcript WITH all three signals → allow ─────────────────
+console.log('\nTest 2: transcript with all three context signals → allow');
+{
+  cleanTurnState(SESSION_ID);
+  const transcriptFile = path.join(tmpdir(), `test-transcript-preturn-${Date.now()}.jsonl`);
+
+  const assistantTextWithAllSignals = [
+    '🔐 Aria Harness — Session Packet loaded for turn.',
+    '[ARIA_DIRECTION] Proceed with implementation of Phase 8 research-first context injection.',
+    '<cognition>',
+    '  nur: Current task is implementing the pre-turn memory gate per feedback_no_graceful_degradation.md and project_aria_as_controller_inversion.md.',
+    '  mizan: Risk is that blocking without recovery creates dead-letter state. Soft-gate pattern resolves this.',
+    '  hikma: feedback_no_flag_without_fix.md requires inline fix for any discovery.',
+    '  tafakkur: The gate must deduplicate within 60s to prevent orchestrator retry loops.',
+    '</cognition>',
+  ].join('\n');
+
+  buildTranscriptWith(
+    [
+      {
+        role: 'user',
+        message: {
+          role: 'user',
+          content: [{ type: 'text', text: 'Implement phase 8.' }],
+        },
+      },
+      {
+        role: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: assistantTextWithAllSignals }],
+        },
+      },
+    ],
+    transcriptFile,
+  );
+
+  const event = buildEvent({ transcript_path: transcriptFile });
+  const { exitCode, parsed } = runHook(event);
+
+  assert('exit code is 0 (allow)', exitCode === 0, exitCode);
+  assert('no block decision in stdout (stdout is empty or non-block)', !parsed || parsed.decision !== 'block', parsed?.decision);
+
+  // Cleanup
+  try { unlinkSync(transcriptFile); } catch {}
+}
+
+// ── Test 3: deduplication — gate already fired within 60s → skip ───────
+console.log('\nTest 3: gate already fired this turn (< 60s ago) → skip (exit 0)');
+{
+  // Pre-write a turn-state showing the gate fired 5 seconds ago
+  const statePath = turnStatePath(SESSION_ID);
+  writeFileSync(statePath, JSON.stringify({ lastTurnGateFiredAt: Date.now() - 5000, lastDecision: 'block', signals: {} }), 'utf-8');
+
+  const event = buildEvent({ transcript_path: null });
+  const { exitCode } = runHook(event);
+
+  assert('exit code is 0 (dedup skip — no re-fire within 60s)', exitCode === 0, exitCode);
+
+  cleanTurnState(SESSION_ID);
+}
+
+// ── Test 4: non-action tool (Read) → gate skips entirely ───────────────
+console.log('\nTest 4: non-action tool (Read) → gate skips (exit 0)');
+{
+  cleanTurnState(SESSION_ID);
+  const event = buildEvent({ tool_name: 'Read', transcript_path: null });
+  const { exitCode } = runHook(event);
+  assert('exit code is 0 (ungated read tool)', exitCode === 0, exitCode);
+}
+
+// ── Test 5: kill-switch env disables gate ─────────────────────────────
+console.log('\nTest 5: ARIA_PRETURN_MEMORY_GATE=off → bypass (exit 0)');
+{
+  cleanTurnState(SESSION_ID);
+  const event = buildEvent({ transcript_path: null });
+  const { exitCode } = runHook(event, { ARIA_PRETURN_MEMORY_GATE: 'off' });
+  assert('exit code is 0 (kill-switch)', exitCode === 0, exitCode);
+}
+
+// ── Test 6: only ONE signal present → still blocks ────────────────────
+console.log('\nTest 6: only harness packet signal (missing direction + memory ref) → block');
+{
+  cleanTurnState(SESSION_ID);
+  const transcriptFile = path.join(tmpdir(), `test-transcript-preturn-partial-${Date.now()}.jsonl`);
+
+  const assistantTextPartial = '🔐 Aria Harness — partial context only. No direction. No memory refs.';
+
+  buildTranscriptWith(
+    [
+      {
+        role: 'user',
+        message: {
+          role: 'user',
+          content: [{ type: 'text', text: 'Do the thing.' }],
+        },
+      },
+      {
+        role: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: assistantTextPartial }],
+        },
+      },
+    ],
+    transcriptFile,
+  );
+
+  const event = buildEvent({ transcript_path: transcriptFile });
+  const { exitCode, parsed } = runHook(event);
+
+  assert('exit code is 2 (block on partial signals)', exitCode === 2, exitCode);
+  assert('decision is "block"', parsed?.decision === 'block', parsed?.decision);
+  assert(
+    'reason mentions missing aria_direction',
+    typeof parsed?.reason === 'string' && parsed.reason.includes('aria_direction'),
+    parsed?.reason?.slice(0, 200),
+  );
+
+  try { unlinkSync(transcriptFile); } catch {}
+  cleanTurnState(SESSION_ID);
+}
+
+// ── Summary ────────────────────────────────────────────────────────────
+console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  process.exit(1);
+} else {
+  console.log('All assertions passed.');
+  process.exit(0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aria_asi/cli",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Aria Smart CLI — the world's first harness-powered terminal companion",
   "bin": {
     "aria": "./bin/aria.js"

package/src/connectors/claude-code.ts

@@ -24,8 +24,12 @@ import type { AriaConfig } from '../config.js';
 const HOOK_FILES = [
   'aria-harness-via-sdk.mjs',
   'aria-pre-tool-gate.mjs',
+  'aria-preturn-memory-gate.mjs',
   'aria-stop-gate.mjs',
   'aria-preprompt-consult.mjs',
+  'aria-trigger-autolearn.mjs',
+  'aria-userprompt-abandon-detect.mjs',
+  'doctrine_trigger_map.json',
 ];
 // Compiled location: <pkg>/dist/aria-connector/src/connectors/claude-code.js
 // (tsc preserves the src/ rooted layout under outDir). From this file:
@@ -84,6 +88,29 @@ const HOOKS_BLOCK = {
         timeout: 12,
         statusMessage: 'Pre-consulting Aria substrate for direction...',
       },
+      {
+        // Aria trigger auto-learn — scans the user's prompt for correction
+        // patterns ("don't ___", "stop ___", ALL-CAPS frustration) and
+        // appends candidate trigger entries to ~/.claude/aria-trigger-queue.jsonl
+        // for human review. Phase 11 enforcement #47: harness teaches itself
+        // from corrections rather than staying frozen at hand-curated rules.
+        // Non-blocking — pure side effect, fast.
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-trigger-autolearn.mjs',
+        timeout: 3,
+      },
+      {
+        // Aria-as-commander mid-turn abandonment detection (Phase 11 #50,
+        // criterion 3). When an active plan exists and the incoming user
+        // prompt's keyword overlap with active phases falls below threshold,
+        // surfaces a CONSCIOUS OVERRIDE signal in additionalContext + writes
+        // a session_audit row (gate_name='plan-abandonment', decision='warn').
+        // Prevents silent context loss when user changes direction mid-plan.
+        // Non-blocking — UserPromptSubmit can't block prompts.
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-userprompt-abandon-detect.mjs',
+        timeout: 4,
+      },
     ],
   }],
   PreToolUse: [{
@@ -92,11 +119,28 @@ const HOOKS_BLOCK = {
     // / NotebookEdit get the same enforcement so orchestrator-side
     // compliance mirrors what we demand from workers.
     matcher: 'Bash|Edit|Write|NotebookEdit',
-    hooks: [{
-      type: 'command',
-      command: 'node $HOME/.claude/hooks/aria-pre-tool-gate.mjs',
-      timeout: 5,
-    }],
+    hooks: [
+      {
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-pre-tool-gate.mjs',
+        timeout: 5,
+      },
+      {
+        // Pre-turn memory consumption gate (Enforcement Layer #49).
+        // Fires after the cognition gate passes. Checks the first action
+        // of each turn for ALL THREE context-loading signals:
+        //   1. 🔐 Aria Harness header (harness packet injected)
+        //   2. [ARIA_DIRECTION] / [ARIA_BINDING_PLAN] (preprompt-consult fired)
+        //   3. feedback_*.md / project_*.md memory reference (memory consumed)
+        // On miss: blocks with structured recovery JSON so the orchestrator
+        // can run the context-loader and retry — no dead-letter state.
+        // Turn-deduplication via ~/.claude/aria-turn-state-${sessionId}.json
+        // prevents retry loops (60s window).
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-preturn-memory-gate.mjs',
+        timeout: 5,
+      },
+    ],
   }],
   Stop: [{
     // Stop gate — text-decision boundary. Reflexive replies fail this
@@ -142,7 +186,11 @@ function installHooks(claudeDir: string, logs: string[], opts: { force?: boolean
       try { copyFileSync(dst, backup); logs.push(`Backed up existing ${name} → ${path.basename(backup)}`); } catch {}
     }
     copyFileSync(src, dst);
-    try { chmodSync(dst, 0o755); } catch {}
+    // Only the .mjs scripts need executable perms; data files (e.g. the
+    // doctrine_trigger_map.json shipped alongside hooks) get default 0o644.
+    if (name.endsWith('.mjs') || name.endsWith('.js')) {
+      try { chmodSync(dst, 0o755); } catch {}
+    }
     logs.push(`Installed hook: ${name}`);
   }
 }
@@ -220,7 +268,7 @@ 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, Stop) — merge-safe, preserves third-party entries`);
+  logs.push(`Wired hooks into settings.json (${mergedEvents} events: SessionStart, UserPromptSubmit, PreToolUse [cognition+memory-gate], Stop) — merge-safe, preserves third-party entries`);
 }
 
 function buildAriaSystemBlock(config: AriaConfig): string {