@aria_asi/cli 0.2.31 → 0.2.33

package/src/connectors/claude-code.ts

@@ -435,6 +435,8 @@ 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.
+
+If you are a spawned sub-agent, also read the active Aria handoff file when present. Use its cognitionOperatingMethod to execute the task: substrate first, constraints second, action shape third, evidence return last. Your final response to the parent must include substrate used, decision delta, artifact impact, evidence, and unresolved risk.
 [/ARIA_HARNESS_BINDING]
 
 [ARIA_DISCOVERY_RECORDING — when you find a defect, doctrine violation, or notable observation during work]
@@ -447,9 +449,10 @@ const ARIA_GATE_PHASE_DIRECTIVE = `[ARIA_GATE_SHAPE — DO THIS EVERY TURN]
 PRE-GATE before the first non-trivial tool call or non-trivial answer:
 1. Read the harness packet and any [ARIA_DIRECTION] / [ARIA_BINDING_PLAN] context already injected this turn.
 2. Choose the action shape before acting: tool call, text-only answer, or replan.
-3. Emit a visible <cognition> block using the required labels for this surface. It must be readable to the user and grounded to loaded substrate anchors.
-4. If the action is destructive, deployment-related, or materially mutates state, emit a <verify> block before the tool call.
-5. If the action claims or changes an outcome, emit an <expected> block with a measurable predicate before the tool call or final answer.
+3. Emit a visible <cognition> block using the required labels for this surface. Each lens must cite loaded substrate anchors and change the action, not merely describe values.
+4. Emit <applied_cognition> for every non-trivial answer or tool action so the model proves what cognition changed.
+5. If the action is destructive, deployment-related, or materially mutates state, emit a <verify> block before the tool call.
+6. If the action claims or changes an outcome, emit an <expected> block with a measurable predicate before the tool call or final answer.
 
 MID-GATE when a hook blocks or warns:
 1. Do not repeat the same tool call or same draft unchanged.
@@ -469,6 +472,30 @@ OUTPUT-GATE before final emission:
 3. Discoveries are atomic with their fixes. Either fix inline now or bind to a real tracked task with proof-shaped evidence.
 [/ARIA_GATE_SHAPE]`;
 
+const ARIA_STRUCTURAL_COGNITION_CONTRACT = `[ARIA_STRUCTURAL_COGNITION_CONTRACT — NON-NEGOTIABLE]
+The harness is not a style guide. It is a runtime contract.
+
+Aria cognition is a work method, not a footer. Use it to improve the input and output before gates fire:
+1. Perceive the real substrate: user intent, repo/runtime state, loaded harness packet, memories, prior tool results, and uncertainty.
+2. Infer constraints: what must be true, what must not be harmed, what prior doctrine changes, and what evidence is missing.
+3. Shape the next action: choose the smallest useful tool call, edit, question, or answer that satisfies those constraints.
+4. Improve the artifact: make the tool input, code change, review finding, or prose more specific because of the cognition.
+5. Predict the observable result: define what would prove the action or answer succeeded before claiming it.
+6. Report evidence: final output should distinguish observed fact, bounded inference, unresolved risk, and next real action.
+
+For every non-trivial response or action:
+1. <cognition> must use the canonical lens labels for the active tier and each lens must contain real substrate anchors: axiom:, frame:, memory:, doctrine:, packet:, or active language:.
+2. The cognition must reference first_principle explicitly and only cite substrate that was loaded this turn.
+3. Each lens must affect the action: if a lens reveals risk, missing evidence, or a better path, change the tool input/output accordingly.
+4. <applied_cognition> must include all fields exactly: decision_delta, dominant_domain, binds_to, expected_predicate, artifact_change.
+5. decision_delta must name what changed because cognition ran. Values like none, unchanged, no change, or n/a are rejected.
+6. binds_to must name the exact answer, tool call, file mutation, deploy, review, or decision being shaped.
+7. expected_predicate must be observable: numeric, boolean, state string, command result, endpoint result, or explicit unverified boundary.
+8. artifact_change must describe the semantic effect on the artifact or output, not restate the task.
+9. If a gate blocks, do not apologize-loop. Read the block reason, re-open the must-read guide, and re-author the missing structure before retrying.
+10. Before long or risky final prose, dry-run the draft with the Claude pre-emit validator when available.
+[/ARIA_STRUCTURAL_COGNITION_CONTRACT]`;
+
 function buildAriaSystemBlock(config: AriaConfig): string {
   const repoList = config.repositories.map((r) => `- ${r.name} (${r.path})`).join('\n');
   const schemaText = Object.entries(config.schemaImages)
@@ -483,6 +510,7 @@ You are augmented with Aria's cognitive harness. This provides:
 
 ${ARIA_HARNESS_BINDING_PREFIX}
 ${ARIA_GATE_PHASE_DIRECTIVE}
+${ARIA_STRUCTURAL_COGNITION_CONTRACT}
 
 [SELF-GATE PROTOCOL]
 Before emitting any claim, verify against these hard constraints:

package/src/connectors/codebase-awareness.ts

@@ -14,7 +14,10 @@ const ENV_PATH = path.join(ARIA_DIR, 'codebase-awareness.env');
 const STATE_PATH = path.join(ARIA_DIR, 'codebase-awareness-state.json');
 const INDEX_PATH = path.join(ARIA_DIR, 'codebase-awareness-index.json');
 
-type AwarenessStatus = 'idle' | 'watching' | 'scanning' | 'error';
+type AwarenessStatus = 'idle' | 'watching' | 'scanning' | 'degraded' | 'error';
+const HEARTBEAT_INTERVAL_MS = Math.max(5_000, Number(process.env.ARIA_CODEBASE_AWARENESS_HEARTBEAT_MS || '15000'));
+const REFRESH_INTERVAL_MS = Math.max(30_000, Number(process.env.ARIA_CODEBASE_AWARENESS_REFRESH_MS || '300000'));
+const REPO_DISCOVERY_INTERVAL_MS = Math.max(30_000, Number(process.env.ARIA_CODEBASE_AWARENESS_RETRY_MS || '60000'));
 
 interface RepoSnapshot {
   path: string;
@@ -36,6 +39,13 @@ interface AwarenessState {
   repoSnapshots: RepoSnapshot[];
   lastError: string | null;
   updatedAt: string;
+  daemon?: {
+    pid: number;
+    startedAt: string;
+    heartbeatAt: string;
+    refreshIntervalMs: number;
+    watcherModes: Record<string, string>;
+  };
 }
 
 function connectorPackageRoot(): string {
@@ -82,12 +92,17 @@ function readState(): AwarenessState {
       repoSnapshots: Array.isArray(parsed.repoSnapshots) ? parsed.repoSnapshots as RepoSnapshot[] : [],
       lastError: parsed.lastError || null,
       updatedAt: parsed.updatedAt || new Date(0).toISOString(),
+      daemon: parsed.daemon,
     };
   } catch {
     return defaultState();
   }
 }
 
+function compactError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 function writeState(update: Partial<AwarenessState>): AwarenessState {
   const current = readState();
   const next: AwarenessState = {
@@ -254,86 +269,135 @@ export async function startCodebaseAwarenessDaemon(options: {
   repos?: string[];
   fallbackRepoPath?: string;
 } = {}): Promise<void> {
-  const repos = resolveRepos(undefined, options.repos, options.fallbackRepoPath);
-  if (!repos.length) {
-    writeState({ status: 'error', watchedRepos: [], lastError: 'No git repositories configured for codebase awareness.' });
-    throw new Error('No git repositories configured for codebase awareness.');
-  }
+  const startedAt = new Date().toISOString();
+  const handles = new Map<string, { stop: () => void; readonly mode: string }>();
+  const watcherModes: Record<string, string> = {};
+  let repos = resolveRepos(undefined, options.repos, options.fallbackRepoPath);
+
+  const writeDaemonState = (status: AwarenessStatus, update: Partial<AwarenessState> = {}): void => {
+    writeState({
+      status,
+      watchedRepos: repos,
+      ...update,
+      daemon: {
+        pid: process.pid,
+        startedAt,
+        heartbeatAt: new Date().toISOString(),
+        refreshIntervalMs: REFRESH_INTERVAL_MS,
+        watcherModes,
+      },
+    });
+  };
 
-  await runCodebaseAwarenessScan({ repos });
-  writeState({ status: 'watching', watchedRepos: repos, lastError: null });
+  const scanAll = async (reason: string): Promise<void> => {
+    repos = resolveRepos(undefined, options.repos, options.fallbackRepoPath);
+    if (!repos.length) {
+      writeDaemonState('degraded', { lastError: 'No git repositories configured for codebase awareness.' });
+      return;
+    }
 
-  for (const repo of repos) {
-    watchCodebase(
-      repo,
-      (image) => {
-        const schemaText = schemaImageToText(image);
-        const scanHash = hashSchema(schemaText);
-        const lastScan = new Date().toISOString();
-        const config = loadConfig();
-        const repositories = [
-          ...(config.repositories || []).filter((entry) => path.resolve(entry.path) !== repo),
-          {
-            path: repo,
-            name: image.projectName,
-            scanHash,
-            lastScan,
+    writeDaemonState('scanning', { lastError: null });
+    const snapshots: RepoSnapshot[] = [];
+    const failures: string[] = [];
+    for (const repo of repos) {
+      try {
+        snapshots.push(await applyRepoScan(repo));
+      } catch (error) {
+        failures.push(`${repo}: ${compactError(error)}`);
+      }
+    }
+
+    const current = readState();
+    const repoSnapshots = [
+      ...snapshots,
+      ...current.repoSnapshots.filter((entry) => !snapshots.some((snapshot) => path.resolve(snapshot.path) === path.resolve(entry.path))),
+    ];
+    writeDaemonState(failures.length ? 'degraded' : 'watching', {
+      repoSnapshots,
+      lastError: failures.length ? `${reason}: ${failures.join(' | ')}` : null,
+    });
+    writeIndex({
+      generatedAt: new Date().toISOString(),
+      reason,
+      watchedRepos: repos,
+      repoSnapshots,
+      schemaImages: loadConfig().schemaImages || {},
+    });
+  };
+
+  const ensureWatchers = (): void => {
+    repos = resolveRepos(undefined, options.repos, options.fallbackRepoPath);
+    for (const [repo, handle] of handles.entries()) {
+      if (!repos.includes(repo)) {
+        handle.stop();
+        handles.delete(repo);
+        delete watcherModes[repo];
+      }
+    }
+    for (const repo of repos) {
+      if (handles.has(repo)) continue;
+      try {
+        const handle = watchCodebase(
+          repo,
+          (image) => {
+            const schemaText = schemaImageToText(image);
+            const scanHash = hashSchema(schemaText);
+            const lastScan = new Date().toISOString();
+            const config = loadConfig();
+            const repositories = [
+              ...(config.repositories || []).filter((entry) => path.resolve(entry.path) !== repo),
+              { path: repo, name: image.projectName, scanHash, lastScan },
+            ];
+            const nextConfig = {
+              ...config,
+              repositories,
+              schemaImages: { ...(config.schemaImages || {}), [image.projectName]: schemaText },
+            };
+            saveConfig(nextConfig);
+
+            const current = readState();
+            const snapshot: RepoSnapshot = {
+              path: repo,
+              name: image.projectName,
+              scanHash,
+              lastScan,
+              fileCount: image.fileCount,
+              language: image.language,
+              framework: image.framework || null,
+              packageManager: image.packageManager || null,
+              database: image.database || null,
+              orm: image.orm || null,
+              architecture: architectureSummary(image),
+            };
+            const repoSnapshots = [snapshot, ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repo)];
+            writeDaemonState('watching', { repoSnapshots, lastError: null });
+            writeIndex({ generatedAt: new Date().toISOString(), reason: 'watch-change', watchedRepos: repos, repoSnapshots, schemaImages: nextConfig.schemaImages || {} });
           },
-        ];
-        const nextConfig = {
-          ...config,
-          repositories,
-          schemaImages: {
-            ...(config.schemaImages || {}),
-            [image.projectName]: schemaText,
+          {
+            debounceMs: 800,
+            pollIntervalMs: 4000,
+            onReady: (mode) => {
+              watcherModes[repo] = mode;
+              writeDaemonState('watching', { lastError: null });
+            },
+            onError: ({ phase, error }) => {
+              writeDaemonState('degraded', { lastError: `${repo} ${phase}: ${error.message}` });
+            },
           },
-        };
-        saveConfig(nextConfig);
-
-        const current = readState();
-        const snapshot: RepoSnapshot = {
-          path: repo,
-          name: image.projectName,
-          scanHash,
-          lastScan,
-          fileCount: image.fileCount,
-          language: image.language,
-          framework: image.framework || null,
-          packageManager: image.packageManager || null,
-          database: image.database || null,
-          orm: image.orm || null,
-          architecture: architectureSummary(image),
-        };
-        const repoSnapshots = [
-          snapshot,
-          ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repo),
-        ];
-        writeState({
-          status: 'watching',
-          watchedRepos: repos,
-          repoSnapshots,
-          lastError: null,
-        });
-        writeIndex({
-          generatedAt: new Date().toISOString(),
-          watchedRepos: repos,
-          repoSnapshots,
-          schemaImages: nextConfig.schemaImages || {},
-        });
-      },
-      {
-        debounceMs: 800,
-        pollIntervalMs: 4000,
-        onError: ({ error }) => {
-          writeState({
-            status: 'error',
-            watchedRepos: repos,
-            lastError: error.message,
-          });
-        },
-      },
-    );
-  }
+        );
+        handles.set(repo, handle);
+        watcherModes[repo] = handle.mode;
+      } catch (error) {
+        writeDaemonState('degraded', { lastError: `${repo} watcher init: ${compactError(error)}` });
+      }
+    }
+  };
+
+  await scanAll('daemon-start');
+  ensureWatchers();
+  setInterval(() => writeDaemonState(repos.length ? 'watching' : 'degraded'), HEARTBEAT_INTERVAL_MS).unref();
+  setInterval(() => { ensureWatchers(); void scanAll('periodic-refresh'); }, REFRESH_INTERVAL_MS).unref();
+  setInterval(() => { ensureWatchers(); }, REPO_DISCOVERY_INTERVAL_MS).unref();
 
   await new Promise(() => {});
 }

package/src/connectors/codex.ts

@@ -90,6 +90,7 @@ function tomlString(value: string): string {
 
 function buildCodexHookRuntimeClient(): string {
   return `import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { HTTPHarnessClient } from '@aria_asi/harness-http-client';
@@ -154,6 +155,28 @@ export function inferSessionId(event) {
   return \`codex:\${threadId}:\${turnId}\`;
 }
 
+export function ensureTraceId(state = {}) {
+  return typeof state.traceId === 'string' && state.traceId ? state.traceId : \`trace_\${randomUUID()}\`;
+}
+
+function stableEvidenceString(value) {
+  if (typeof value === 'string') return value;
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+
+export function makeEvidenceRef(kind, value, metadata = {}) {
+  const raw = stableEvidenceString(value);
+  const sha256 = createHash('sha256').update(raw).digest('hex');
+  return {
+    evidenceId: \`ev_\${sha256.slice(0, 16)}\`,
+    kind,
+    at: new Date().toISOString(),
+    sha256,
+    preview: raw.slice(0, 500),
+    metadata,
+  };
+}
+
 export function inferUserId(event) {
   return (
     extractFirst(event, ['user_id', 'userId']) ||
@@ -309,9 +332,12 @@ import {
   getHarnessClient,
   inferSessionId,
   inferUserId,
+  ensureTraceId,
   extractUserText,
+  makeEvidenceRef,
   readEventFromStdin,
   runtimePost,
+  loadTurnState,
   saveTurnState,
   emitJson,
 } from './lib/runtime-client.mjs';
@@ -321,6 +347,8 @@ const client = getHarnessClient();
 const userText = extractUserText(event);
 const sessionId = inferSessionId(event);
 const userId = inferUserId(event);
+const priorState = loadTurnState(sessionId);
+const traceId = ensureTraceId(priorState);
 
 try {
   const packet = await client.getHarnessPacket({
@@ -328,6 +356,7 @@ try {
     platform: 'codex',
     message: userText || 'codex turn start',
   });
+  const packetRef = makeEvidenceRef('harness_packet', packet, { sessionId, platform: 'codex' });
   const result = await runtimePost('/mizan/pre', {
     sessionId,
     packet,
@@ -341,17 +370,21 @@ try {
     },
     context: {
       sessionId,
+      traceId,
       surface: 'codex-hooks',
       platform: 'codex',
       userText,
       userId,
+      evidenceRefs: [packetRef],
     },
   });
   saveTurnState(sessionId, {
+    traceId,
     userId,
     userText,
     preReceiptId: result?.receipt?.receiptId || null,
     packetTimestamp: packet?.timestamp || null,
+    packetRef,
     lastEvent: 'UserPromptSubmit',
   });
   process.exit(0);
@@ -373,6 +406,7 @@ import {
   summarizeTarget,
   readEventFromStdin,
   loadTurnState,
+  makeEvidenceRef,
   saveTurnState,
   emitJson,
 } from './lib/runtime-client.mjs';
@@ -405,6 +439,7 @@ try {
     action,
     toolName,
     target,
+    evidenceRef: makeEvidenceRef('tool_request', { action, toolName, target }, { sessionId }),
   });
   saveTurnState(sessionId, {
     tools,
@@ -426,6 +461,7 @@ import {
   inferSessionId,
   readEventFromStdin,
   loadTurnState,
+  makeEvidenceRef,
   saveTurnState,
 } from './lib/runtime-client.mjs';
 
@@ -435,11 +471,16 @@ const state = loadTurnState(sessionId);
 
 try {
   const toolResponse = JSON.stringify(event?.tool_response ?? event?.toolResponse ?? null).slice(0, 4000);
+  const evidenceRef = makeEvidenceRef('tool_response', event?.tool_response ?? event?.toolResponse ?? null, {
+    sessionId,
+    toolName: event?.tool_name || event?.toolName || null,
+  });
   const toolOutputs = Array.isArray(state?.toolOutputs) ? state.toolOutputs.slice(-24) : [];
   toolOutputs.push({
     at: new Date().toISOString(),
     toolName: event?.tool_name || event?.toolName || null,
     toolResponse,
+    evidenceRef,
   });
   saveTurnState(sessionId, {
     toolOutputs,
@@ -461,6 +502,7 @@ import {
   readEventFromStdin,
   runtimePost,
   loadTurnState,
+  makeEvidenceRef,
   clearTurnState,
   formatValidationFailure,
   emitJson,
@@ -471,6 +513,8 @@ const client = getHarnessClient();
 const sessionId = inferSessionId(event);
 const state = loadTurnState(sessionId);
 const text = extractAssistantText(event);
+const outputRef = makeEvidenceRef('assistant_output', text, { sessionId, traceId: state?.traceId || null });
+const toolRefs = Array.isArray(state?.toolOutputs) ? state.toolOutputs.map((entry) => entry.evidenceRef).filter(Boolean) : [];
 
 try {
   if (!text) {
@@ -505,12 +549,16 @@ try {
       layer3_pass: validation?.layer3?.pass !== false,
       surface: 'codex-hooks',
       tool_count: Array.isArray(state?.tools) ? state.tools.length : 0,
+      trace_id: state?.traceId || null,
+      output_ref: outputRef,
+      tool_refs: toolRefs,
     },
     context: {
       sessionId,
       surface: 'codex-hooks',
       platform: 'codex',
       userText: state?.userText || null,
+      traceId: state?.traceId || null,
     },
     parentReceiptId: state?.preReceiptId || null,
   });
@@ -527,6 +575,9 @@ try {
     metadata: {
       post_receipt_id: post?.receipt?.receiptId || null,
       pre_receipt_id: state?.preReceiptId || null,
+      trace_id: state?.traceId || null,
+      output_ref: outputRef,
+      tool_refs: toolRefs,
       tool_count: Array.isArray(state?.tools) ? state.tools.length : 0,
       validation_severity: validation?.validation?.severity || 'pass',
       layer3_pass: validation?.layer3?.pass !== false,
@@ -700,15 +751,31 @@ ${schemaText || '(no schema images yet — run \`aria repo scan\`)'}
 - If a fix only works by weakening the contract, the mechanism is still broken. Debug the mechanism.
 
 ## 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?
+Use Aria cognition as a work method, not a checklist:
+- Perceive the real substrate: user intent, repo/runtime state, loaded harness packet, memories, prior tool results, and uncertainty.
+- Infer constraints: what must be true, what must not be harmed, what prior doctrine changes, and what evidence is missing.
+- Shape the next action: choose the smallest useful tool call, edit, question, or answer that satisfies those constraints.
+- Improve the artifact: make the tool input, code change, review finding, or prose more specific because of the cognition.
+- Predict the observable result: define what would prove the action or answer succeeded before claiming it.
+- Report evidence: distinguish observed fact, bounded inference, unresolved risk, and next real action.
+
+Lens roles for decisions:
+- Truth lens: binds claims to observed evidence and missing evidence.
+- Harm lens: removes or changes actions that could damage state, trust, data, or runtime health.
+- Trust lens: preserves user intent, prior directives, and secret/infra boundaries.
+- Power lens: uses capability to serve the task, not convenience or control.
+- Reflection lens: catches mechanism failure, shortcut pressure, and repeated loops.
+- Context lens: integrates repo patterns, runtime state, and loaded substrate.
+- Impact lens: predicts downstream effects and verification predicates.
+- Beauty lens: prefers the simplest durable artifact that preserves the contract.
+
+## Structural Cognition Contract
+- Cognition is not accepted as proof by itself. It must change the next action, tool call, or output claim.
+- Each lens must affect work selection or artifact shape; do not write lenses after the decision is already made.
+- For every non-trivial output, include an \`<applied_cognition>\` block with \`decision_delta\`, \`dominant_domain\`, \`binds_to\`, \`expected_predicate\`, and \`artifact_change\`.
+- Tool-bound cognition must name the exact tool/action it constrains and the measurable predicate that proves the action succeeded.
+- Deploy or destructive actions still require \`<verify>\` and \`<expected>\` blocks before execution.
+- If cognition did not change anything, stop and re-think; \`decision_delta: none\` is treated as performative.
 `;
 }
 

package/src/connectors/must-read.ts

@@ -99,6 +99,10 @@ ${orderedFiles.map((filePath, index) => `${index + 1}. \`${filePath}\``).join('\
 ## Non-Negotiables
 
 - Do not rename canonical cognition meaning into generic aliases.
+- Do not treat cognition as a gate password; use it to change the tool input, edit shape, review finding, answer structure, or evidence threshold.
+- Do not emit non-trivial output without \`<applied_cognition>\` containing \`decision_delta\`, \`dominant_domain\`, \`binds_to\`, \`expected_predicate\`, and \`artifact_change\`.
+- Do not let \`decision_delta\` say cognition changed nothing; that is performative cognition.
+- Do not cite substrate anchors that were not loaded in the current harness packet.
 - Do not say "good enough", "should work", or make unverified completion claims.
 - Do not treat skills as optional flavor text; they are the reading order and repair guide.
 - Do not proceed after a gate block without re-opening the file that owns that gate.

package/src/connectors/opencode.ts

@@ -340,14 +340,30 @@ ${schemaText || '(no schema images yet — run \`aria repo scan\`)'}
 - If a fix only works by weakening the contract, the mechanism is still broken. Debug the mechanism.
 
 ## 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?
+Use Aria cognition as a work method, not a checklist:
+- Perceive the real substrate: user intent, repo/runtime state, loaded harness packet, memories, prior tool results, and uncertainty.
+- Infer constraints: what must be true, what must not be harmed, what prior doctrine changes, and what evidence is missing.
+- Shape the next action: choose the smallest useful tool call, edit, question, or answer that satisfies those constraints.
+- Improve the artifact: make the tool input, code change, review finding, or prose more specific because of the cognition.
+- Predict the observable result: define what would prove the action or answer succeeded before claiming it.
+- Report evidence: distinguish observed fact, bounded inference, unresolved risk, and next real action.
+
+Lens roles for decisions:
+- Truth lens: binds claims to observed evidence and missing evidence.
+- Harm lens: removes or changes actions that could damage state, trust, data, or runtime health.
+- Trust lens: preserves user intent, prior directives, and secret/infra boundaries.
+- Power lens: uses capability to serve the task, not convenience or control.
+- Reflection lens: catches mechanism failure, shortcut pressure, and repeated loops.
+- Context lens: integrates repo patterns, runtime state, and loaded substrate.
+- Impact lens: predicts downstream effects and verification predicates.
+- Beauty lens: prefers the simplest durable artifact that preserves the contract.
+
+## Structural Cognition Contract
+- Cognition is not a ceremony. It must change the next action, tool call, or output claim.
+- Each lens must affect work selection or artifact shape; do not write lenses after the decision is already made.
+- For every non-trivial output, include an \`<applied_cognition>\` block with \`decision_delta\`, \`dominant_domain\`, \`binds_to\`, \`expected_predicate\`, and \`artifact_change\`.
+- Tool-bound cognition must name the exact tool/action it constrains and the measurable predicate that proves the action succeeded.
+- Deploy or destructive actions still require \`<verify>\` and \`<expected>\` blocks before execution.
+- If cognition did not change anything, stop and re-think; \`decision_delta: none\` is treated as performative.
 `;
 }