blun-king-cli 9.1.587 → 9.1.588

package/bin/cognitive-turn-lifecycle.cjs

@@ -1,624 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-const { openCognitiveMemoryAdapter } = require('./cognitive-memory-adapter.cjs');
-const { loadConfiguredCognitiveMemoryAdapter } = require('./cognitive-memory-provider.cjs');
-const { buildCognitiveContextProjection } = require('./cognitive-context-projection.cjs');
-const {
-  buildCognitiveFocusSelection,
-  evaluateCognitiveDecisionBasis,
-} = require('./cognitive-focus-projection.cjs');
-const { cognitiveEntityKey, focusAccessObservation } = require('./cognitive-salience-policy.cjs');
-const { authorizeAttentionCandidate } = require('./cognitive-attention-runtime.cjs');
-
-const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const RIGHTS_AUTHORITIES = new Set(['runtime_user_prompt_hook', 'runtime_tool_policy']);
-const RIGHTS_DECISIONS = new Set(['passed', 'blocked', 'not_applicable']);
-const TOOL_POLICY_DECISIONS = new Set(['passed', 'blocked', 'error']);
-const TOOL_OUTCOMES = new Set(['success', 'error', 'cancelled']);
-const TURN_REASONS = new Set(['completed', 'cancelled', 'filtered', 'failed']);
-const FOCUS_DOMAINS = new Set([
-  'self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'knowledge_gap',
-  'next_trigger', 'expected_evidence',
-]);
-const FOCUS_EPISTEMIC_STATES = new Set([
-  'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
-]);
-const AUTHORITY_KEY_RE = /(?:^|:|_)(?:acl|api[_-]?key|capability|password|permission|secret|token)(?::|_|$)/iu;
-
-function fail(code) {
-  const error = new Error(code);
-  error.code = code;
-  throw error;
-}
-
-function exactKeys(value, keys) {
-  return value && typeof value === 'object' && !Array.isArray(value)
-    && Object.keys(value).every((key) => keys.has(key));
-}
-
-function safeId(value) {
-  const text = String(value ?? '').trim();
-  return SAFE_ID_RE.test(text) ? text : '';
-}
-
-function safeTurnId(value) {
-  return Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-
-function cleanLabel(value, max = 128) {
-  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
-  return text && text.length <= max ? text : '';
-}
-
-function digestId(prefix, values) {
-  const digest = crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40);
-  return `${prefix}-${digest}`;
-}
-
-function identityFromManifest(home) {
-  const root = fs.realpathSync(path.resolve(String(home ?? '')));
-  const identityRoot = path.join(root, 'identity');
-  const manifestPath = path.join(identityRoot, 'manifest.json');
-  try {
-    const identityStat = fs.lstatSync(identityRoot);
-    const manifestStat = fs.lstatSync(manifestPath);
-    if (!identityStat.isDirectory() || identityStat.isSymbolicLink()
-        || !manifestStat.isFile() || manifestStat.isSymbolicLink() || manifestStat.size > 64 * 1024) return null;
-    if (fs.realpathSync(identityRoot) !== identityRoot || fs.realpathSync(manifestPath) !== manifestPath) return null;
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    const tenantId = safeId(manifest?.tenant_id);
-    const agentId = safeId(manifest?.active_agent_id);
-    return manifest?.version === 1 && tenantId && agentId ? { tenantId, agentId } : null;
-  } catch {
-    return null;
-  }
-}
-
-function createCognitiveTurnLifecycle({
-  home,
-  tenantId,
-  agentId,
-  runtimeId,
-  memoryAdapter,
-  memoryMode = memoryAdapter === undefined ? 'profile-local-fallback' : 'injected-adapter',
-  identityMode = 'shared-identity',
-  now = () => new Date().toISOString(),
-} = {}) {
-  const tenant = safeId(tenantId);
-  const agent = safeId(agentId);
-  const runtime = safeId(runtimeId ?? `runtime-${process.pid}-${Date.now()}`);
-  const memoryModes = new Set(['profile-local-fallback', 'configured-provider', 'injected-adapter']);
-  const identityModes = new Set(['shared-identity', 'profile-derived']);
-  if (!tenant || !agent || !runtime || typeof now !== 'function'
-      || !memoryModes.has(memoryMode) || !identityModes.has(identityMode)) {
-    fail('COGNITIVE_LIFECYCLE_INVALID');
-  }
-  const store = openCognitiveMemoryAdapter({ home, adapter: memoryAdapter });
-  const internalMemoryAccess = Object.freeze({
-    tenantId: tenant,
-    userId: agent,
-    actorId: agent,
-    agentId: agent,
-    portalId: 'cli',
-    channelId: 'runtime',
-    conversationId: runtime,
-    requestedScope: 'agent:memory',
-    permissionContext: Object.freeze({
-      authority: 'runtime_internal',
-      decision: 'passed',
-      receiptId: runtime,
-    }),
-  });
-  const stageTimes = new Map();
-  const stageResults = new Map();
-
-  function stageTime(stageKey) {
-    if (!stageTimes.has(stageKey)) {
-      const occurredAt = String(now());
-      if (Number.isNaN(Date.parse(occurredAt))) fail('COGNITIVE_LIFECYCLE_INVALID');
-      stageTimes.set(stageKey, occurredAt);
-    }
-    return stageTimes.get(stageKey);
-  }
-
-  function commitStage(stageKey, observations) {
-    if (stageResults.has(stageKey)) return { ...stageResults.get(stageKey), idempotent: true };
-    const occurredAt = stageTime(stageKey);
-    const eventId = digestId('cycle', [tenant, agent, runtime, stageKey]);
-    const normalized = observations.map((item, index) => ({
-      observation_id: digestId('cycleobs', [eventId, String(index)]),
-      epistemic_state: 'verified',
-      ...item,
-    }));
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-      const expectedVersion = store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess).version;
-      try {
-        const result = store.commit({
-          tenantId: tenant,
-          agentId: agent,
-          eventId,
-          expectedVersion,
-          occurredAt,
-          receivedAt: occurredAt,
-          retentionClass: 'operational',
-          source: {
-            provider: 'runtime',
-            channel_id: 'runtime',
-            actor_id: agent,
-            context_id: runtime,
-            message_id: stageKey,
-          },
-          observations: normalized,
-        }, internalMemoryAccess);
-        stageResults.set(stageKey, result);
-        return result;
-      } catch (error) {
-        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 3) throw error;
-      }
-    }
-    fail('COGNITIVE_VERSION_CONFLICT');
-  }
-
-  function commitDurableStage(stageKey, observations) {
-    if (stageResults.has(stageKey)) return { ...stageResults.get(stageKey), idempotent: true };
-    const eventId = digestId('durable', [tenant, agent, stageKey]);
-    if (store.hasEvent({
-      eventId, tenantId: tenant, agentId: agent, visibilityScope: 'agent:memory',
-    }, internalMemoryAccess)) {
-      const result = { idempotent: true };
-      stageResults.set(stageKey, result);
-      return result;
-    }
-    const occurredAt = stageTime(`durable:${stageKey}`);
-    const normalized = observations.map((item, index) => ({
-      observation_id: digestId('durableobs', [eventId, String(index)]),
-      ...item,
-    }));
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-      if (store.hasEvent({
-        eventId, tenantId: tenant, agentId: agent, visibilityScope: 'agent:memory',
-      }, internalMemoryAccess)) {
-        const result = { idempotent: true };
-        stageResults.set(stageKey, result);
-        return result;
-      }
-      const expectedVersion = store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess).version;
-      try {
-        const result = store.commit({
-          tenantId: tenant,
-          agentId: agent,
-          eventId,
-          expectedVersion,
-          occurredAt,
-          receivedAt: occurredAt,
-          retentionClass: 'durable',
-          source: {
-            provider: 'runtime',
-            channel_id: 'runtime',
-            actor_id: agent,
-            context_id: 'durable-focus',
-            message_id: stageKey,
-          },
-          observations: normalized,
-        }, internalMemoryAccess);
-        stageResults.set(stageKey, result);
-        return result;
-      } catch (error) {
-        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 3) throw error;
-      }
-    }
-    fail('COGNITIVE_VERSION_CONFLICT');
-  }
-
-  function startTurn(input) {
-    if (!exactKeys(input, new Set(['turnId', 'originKind']))) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const turnId = safeTurnId(input.turnId);
-    const originKind = safeId(input.originKind);
-    if (turnId === null || !originKind) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const key = `turn:${turnId}`;
-    return commitStage(`turn-${turnId}-start`, [
-      { domain: 'open_thread', key: `${key}:phase`, value: 'perceived', confidence: 1, scope: 'runtime' },
-      { domain: 'assumption', key: `${key}:classification`, value: `origin:${originKind}`, confidence: 1, scope: 'runtime' },
-      { domain: 'goal', key: `${key}:plan`, value: 'run-bounded-model-turn', confidence: 1, scope: 'runtime' },
-      { domain: 'next_trigger', key: `${key}:next`, value: 'runtime-policy-check', confidence: 1, scope: 'runtime' },
-      { domain: 'expected_evidence', key: `${key}:evidence`, value: 'turn.ended-event', confidence: 1, scope: 'runtime' },
-    ]);
-  }
-
-  function recordRightsCheck(input) {
-    if (!exactKeys(input, new Set(['turnId', 'decision', 'authority']))) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const turnId = safeTurnId(input.turnId);
-    const decision = String(input.decision ?? '');
-    const authority = String(input.authority ?? '');
-    if (turnId === null || !RIGHTS_DECISIONS.has(decision)) fail('COGNITIVE_LIFECYCLE_INVALID');
-    if (!RIGHTS_AUTHORITIES.has(authority)) fail('COGNITIVE_RIGHTS_AUTHORITY_REQUIRED');
-    return commitStage(`turn-${turnId}-rights-${authority}`, [{
-      domain: 'world',
-      key: `turn:${turnId}:rights-check`,
-      value: `${decision}:${authority}`,
-      confidence: 1,
-      scope: 'runtime',
-    }]);
-  }
-
-  function endTurn(input) {
-    if (!exactKeys(input, new Set(['turnId', 'reason', 'durationMs']))) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const turnId = safeTurnId(input.turnId);
-    const reason = String(input.reason ?? '');
-    const durationMs = Number(input.durationMs);
-    if (turnId === null || !TURN_REASONS.has(reason) || !Number.isSafeInteger(durationMs) || durationMs < 0) {
-      fail('COGNITIVE_LIFECYCLE_INVALID');
-    }
-    const key = `turn:${turnId}`;
-    return commitStage(`turn-${turnId}-end`, [
-      { domain: 'open_thread', key: `${key}:phase`, value: reason, confidence: 1, scope: 'runtime' },
-      { domain: 'expected_evidence', key: `${key}:result`, value: `turn.ended:${reason}:${durationMs}ms`, confidence: 1, scope: 'runtime' },
-      { domain: 'next_trigger', key: `${key}:next`, value: reason === 'completed' ? 'await-next-input' : 'inspect-turn-outcome', confidence: 1, scope: 'runtime' },
-    ]);
-  }
-
-  function recordFocusSnapshot(input) {
-    if (!exactKeys(input, new Set(['snapshotId', 'observations']))
-        || !safeId(input.snapshotId) || !Array.isArray(input.observations)
-        || input.observations.length < 1 || input.observations.length > 16) {
-      fail('COGNITIVE_FOCUS_INVALID');
-    }
-    const observations = input.observations.map((item) => {
-      if (!exactKeys(item, new Set(['domain', 'key', 'value', 'confidence', 'epistemicState', 'scope']))) fail('COGNITIVE_FOCUS_INVALID');
-      const domain = String(item.domain ?? '');
-      const key = cleanLabel(item.key, 128);
-      const value = cleanLabel(item.value, 512);
-      const confidence = Number(item.confidence);
-      const epistemicState = item.epistemicState === undefined
-        ? 'legacy_unknown' : String(item.epistemicState);
-      const scope = cleanLabel(item.scope, 128);
-      if (!FOCUS_DOMAINS.has(domain) || !key || AUTHORITY_KEY_RE.test(key) || !value
-          || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
-          || !FOCUS_EPISTEMIC_STATES.has(epistemicState)
-          || !scope || scope === 'runtime') fail('COGNITIVE_FOCUS_INVALID');
-      return { domain, key, value, confidence, epistemic_state: epistemicState, scope };
-    });
-    return commitDurableStage(`focus-${input.snapshotId}`, observations);
-  }
-
-  function commitExplicitFocusRevision(kind, input) {
-    const correction = kind === 'correction';
-    const allowed = correction
-      ? new Set(['requestId', 'targetObservationId', 'domain', 'key', 'value', 'scope', 'authority', 'confirmation', 'occurredAt', 'source'])
-      : new Set(['requestId', 'targetObservationId', 'domain', 'key', 'scope', 'authority', 'confirmation', 'occurredAt', 'source']);
-    if (!exactKeys(input, allowed)) fail('COGNITIVE_REVISION_INVALID');
-    const requestId = safeId(input.requestId);
-    const targetObservationId = safeId(input.targetObservationId);
-    const domain = String(input.domain ?? '');
-    const key = cleanLabel(input.key, 128);
-    const scope = cleanLabel(input.scope, 128);
-    const occurredAt = String(input.occurredAt ?? '').trim();
-    const source = input.source;
-    if (input.authority !== 'runtime_user_prompt_hook' || input.confirmation !== 'explicit_user_request') {
-      fail('COGNITIVE_REVISION_EXPLICIT_USER_REQUIRED');
-    }
-    if (!requestId || !targetObservationId || !FOCUS_DOMAINS.has(domain) || !key
-        || AUTHORITY_KEY_RE.test(key) || !scope || scope === 'runtime'
-        || Number.isNaN(Date.parse(occurredAt))
-        || !exactKeys(source, new Set(['provider', 'channelId', 'actorId', 'contextId', 'messageId']))) {
-      fail('COGNITIVE_REVISION_INVALID');
-    }
-    const normalizedSource = {
-      provider: safeId(source.provider),
-      channel_id: safeId(source.channelId),
-      actor_id: safeId(source.actorId),
-      context_id: safeId(source.contextId),
-      message_id: safeId(source.messageId),
-    };
-    if (Object.values(normalizedSource).some((value) => !value)) fail('COGNITIVE_REVISION_INVALID');
-    const value = correction ? cleanLabel(input.value, 512) : 'withdrawn';
-    if (!value) fail('COGNITIVE_REVISION_INVALID');
-    const eventId = digestId('revision', [tenant, agent, kind, requestId]);
-    const observationId = digestId('revisionobs', [eventId]);
-    const observation = {
-      observation_id: observationId,
-      domain,
-      key,
-      value,
-      confidence: 1,
-      epistemic_state: 'verified',
-      scope,
-      ...(correction ? { supersedes: targetObservationId } : { withdraws: targetObservationId }),
-    };
-    const normalizedOccurredAt = new Date(occurredAt).toISOString();
-    const receivedAt = stageTime(`revision:${kind}:${requestId}`);
-    const revisionMemoryAccess = {
-      tenantId: tenant,
-      userId: normalizedSource.actor_id,
-      actorId: normalizedSource.actor_id,
-      agentId: agent,
-      portalId: normalizedSource.provider,
-      channelId: normalizedSource.channel_id,
-      conversationId: normalizedSource.context_id,
-      requestedScope: scope,
-      permissionContext: {
-        authority: input.authority,
-        decision: 'passed',
-        receiptId: requestId,
-      },
-    };
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-      const current = store.read({ tenantId: tenant, agentId: agent }, revisionMemoryAccess);
-      const existing = current.observations.find((item) => item.observation_id === observationId);
-      if (existing) {
-        const matches = existing.domain === observation.domain && existing.key === observation.key
-          && existing.value === observation.value && existing.confidence === 1
-          && existing.scope === observation.scope && existing.occurred_at === normalizedOccurredAt
-          && existing.supersedes === (observation.supersedes ?? null)
-          && existing.withdraws === (observation.withdraws ?? null)
-          && existing.source.provider === normalizedSource.provider
-          && existing.source.channel_id === normalizedSource.channel_id
-          && existing.source.actor_id === normalizedSource.actor_id
-          && existing.source.context_id === normalizedSource.context_id
-          && existing.source.message_id === normalizedSource.message_id;
-        if (!matches) fail('COGNITIVE_REVISION_REQUEST_REUSE');
-        return { version: current.version, idempotent: true };
-      }
-      const target = current.observations.find((item) => item.observation_id === targetObservationId);
-      if (target && Date.parse(normalizedOccurredAt) < Date.parse(target.occurred_at)) {
-        fail('COGNITIVE_REVISION_TIME_ORDER');
-      }
-      try {
-        return store.commit({
-          tenantId: tenant,
-          agentId: agent,
-          eventId,
-          expectedVersion: current.version,
-          occurredAt: normalizedOccurredAt,
-          receivedAt,
-          retentionClass: 'durable',
-          source: normalizedSource,
-          observations: [observation],
-        }, revisionMemoryAccess);
-      } catch (error) {
-        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 3) throw error;
-      }
-    }
-    fail('COGNITIVE_VERSION_CONFLICT');
-  }
-
-  function correctFocusObservation(input) {
-    return commitExplicitFocusRevision('correction', input);
-  }
-
-  function withdrawFocusObservation(input) {
-    return commitExplicitFocusRevision('withdrawal', input);
-  }
-
-  function toolFields(input, allowedKeys) {
-    if (!exactKeys(input, allowedKeys)) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const turnId = safeTurnId(input.turnId);
-    const toolCallId = cleanLabel(input.toolCallId, 256);
-    const toolName = cleanLabel(input.toolName, 128);
-    if (turnId === null || !toolCallId || !toolName) fail('COGNITIVE_LIFECYCLE_INVALID');
-    return { turnId, toolCallId, toolName, callKey: digestId('call', [toolCallId]).slice(0, 21) };
-  }
-
-  function recordToolPolicy(input) {
-    const { turnId, toolCallId, toolName, callKey } = toolFields(input, new Set(['turnId', 'toolCallId', 'toolName', 'decision']));
-    const decision = String(input.decision ?? '');
-    if (!TOOL_POLICY_DECISIONS.has(decision)) fail('COGNITIVE_LIFECYCLE_INVALID');
-    return commitStage(`turn-${turnId}-${callKey}-policy`, [{
-      domain: 'world',
-      key: `turn:${turnId}:${callKey}:tool-policy`,
-      value: `${decision}:runtime_tool_policy:${toolName}`,
-      confidence: 1,
-      scope: 'runtime',
-    }]);
-  }
-
-  function recordToolResult(input) {
-    const { turnId, toolCallId, toolName, callKey } = toolFields(input, new Set(['turnId', 'toolCallId', 'toolName', 'outcome', 'durationMs']));
-    const outcome = String(input.outcome ?? '');
-    const durationMs = Number(input.durationMs);
-    if (!TOOL_OUTCOMES.has(outcome) || !Number.isSafeInteger(durationMs) || durationMs < 0) fail('COGNITIVE_LIFECYCLE_INVALID');
-    return commitStage(`turn-${turnId}-${callKey}-result`, [
-      { domain: 'expected_evidence', key: `turn:${turnId}:${callKey}:tool-result`, value: `${outcome}:${durationMs}ms:${toolName}`, confidence: 1, scope: 'runtime' },
-      { domain: 'next_trigger', key: `turn:${turnId}:${callKey}:tool-next`, value: outcome === 'success' ? 'continue-after-tool' : 'inspect-tool-failure', confidence: 1, scope: 'runtime' },
-    ]);
-  }
-
-  function recordToolBatch(input) {
-    if (!exactKeys(input, new Set(['turnId', 'entries']))) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const turnId = safeTurnId(input.turnId);
-    if (turnId === null || !Array.isArray(input.entries) || input.entries.length < 1 || input.entries.length > 10) {
-      fail('COGNITIVE_LIFECYCLE_INVALID');
-    }
-    const observations = [];
-    const stageParts = [];
-    for (const entry of input.entries) {
-      const { toolCallId, toolName, callKey } = toolFields(
-        { turnId, ...entry },
-        new Set(['turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs']),
-      );
-      const decision = String(entry.decision ?? '');
-      const outcome = String(entry.outcome ?? '');
-      const durationMs = Number(entry.durationMs);
-      if (!TOOL_POLICY_DECISIONS.has(decision) || !TOOL_OUTCOMES.has(outcome)
-          || !Number.isSafeInteger(durationMs) || durationMs < 0) fail('COGNITIVE_LIFECYCLE_INVALID');
-      stageParts.push(`${toolCallId}:${decision}:${outcome}:${durationMs}`);
-      observations.push({
-        domain: 'world',
-        key: `turn:${turnId}:${callKey}:tool-policy`,
-        value: `${decision}:runtime_tool_policy:${toolName}`,
-        confidence: 1,
-        scope: 'runtime',
-      }, {
-        domain: 'expected_evidence',
-        key: `turn:${turnId}:${callKey}:tool-result`,
-        value: `${outcome}:${durationMs}ms:${toolName}`,
-        confidence: 1,
-        scope: 'runtime',
-      }, {
-        domain: 'next_trigger',
-        key: `turn:${turnId}:${callKey}:tool-next`,
-        value: outcome === 'success' ? 'continue-after-tool' : 'inspect-tool-failure',
-        confidence: 1,
-        scope: 'runtime',
-      });
-    }
-    const batchKey = digestId('toolbatch', stageParts);
-    const result = commitStage(`turn-${turnId}-${batchKey}`, observations);
-    return { ...result, events: 1, entries: input.entries.length };
-  }
-
-  function projectForTurn(input) {
-    if (!exactKeys(input, new Set(['turnId', 'focusScopes']))) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const turnId = safeTurnId(input.turnId);
-    if (turnId === null) fail('COGNITIVE_LIFECYCLE_INVALID');
-    const state = store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess);
-    const continuity = buildCognitiveContextProjection(state, {
-      currentTurnId: turnId,
-      currentRuntimeId: runtime,
-    });
-    const focus = buildCognitiveFocusSelection(state, {
-      focusScopes: input.focusScopes,
-      currentSessionId: runtime,
-    });
-    if (focus?.selected.length > 0) {
-      const selected = [...focus.selected].sort((left, right) => (
-        cognitiveEntityKey(left).localeCompare(cognitiveEntityKey(right))
-      ));
-      const accessKey = digestId('focusaccess', selected.map(cognitiveEntityKey));
-      commitStage(`focus-access-${accessKey}`, selected.map(focusAccessObservation));
-    }
-    return [focus?.text, continuity].filter(Boolean).join('\n\n') || null;
-  }
-
-  function evaluateDecisionBasis(refs) {
-    const state = store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess);
-    return evaluateCognitiveDecisionBasis(state, refs);
-  }
-
-  function authorizeAttention(input) {
-    const candidate = input?.candidate;
-    const authorization = input?.authorization;
-    const memoryAccess = {
-      tenantId: tenant,
-      userId: agent,
-      actorId: agent,
-      agentId: agent,
-      portalId: 'cli',
-      channelId: String(input?.channel ?? ''),
-      conversationId: runtime,
-      requestedScope: String(candidate?.evidence_scope ?? ''),
-      permissionContext: {
-        authority: String(authorization?.authority ?? ''),
-        decision: authorization?.decision === 'passed' ? 'passed' : 'blocked',
-        receiptId: String(authorization?.receiptId ?? ''),
-      },
-    };
-    return authorizeAttentionCandidate({
-      store,
-      tenantId: tenant,
-      currentAgent: agent,
-      now,
-      input,
-      memoryAccess,
-    });
-  }
-
-  function memoryStatus() {
-    const verification = store.verify({ tenantId: tenant, agentId: agent }, internalMemoryAccess);
-    const valid = verification?.valid === true;
-    let crossPortalStatus = 'provider-configured-unverified';
-    if (memoryMode === 'profile-local-fallback') crossPortalStatus = 'blocked-profile-local';
-    else if (identityMode === 'profile-derived') crossPortalStatus = 'blocked-profile-derived-identity';
-    return {
-      version: 1,
-      authority: 'diagnostic-only',
-      adapter: {
-        mode: memoryMode,
-        kind: store.kind,
-        contractVersion: store.contractVersion,
-      },
-      identity: { mode: identityMode },
-      integrity: { valid },
-      crossPortal: {
-        status: crossPortalStatus,
-        evidence: 'not-run',
-      },
-    };
-  }
-
-  return {
-    startTurn,
-    recordRightsCheck,
-    recordToolPolicy,
-    recordToolResult,
-    recordToolBatch,
-    recordFocusSnapshot,
-    correctFocusObservation,
-    withdrawFocusObservation,
-    authorizeAttention,
-    memoryStatus,
-    evaluateDecisionBasis,
-    projectForTurn,
-    endTurn,
-    read: () => store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess),
-    verify: () => store.verify({ tenantId: tenant, agentId: agent }, internalMemoryAccess),
-    close: () => store.close(),
-  };
-}
-
-function createRuntimeCognitiveTurnLifecycle({
-  home,
-  agentName,
-  tenantId,
-  agentId,
-  runtimeId,
-  memoryAdapter,
-  memoryAdapterModule,
-  now,
-} = {}) {
-  const resolvedHome = String(home ?? '').trim();
-  const resolvedAgent = String(agentName ?? '').trim();
-  if (!resolvedHome || !resolvedAgent) fail('COGNITIVE_LIFECYCLE_INVALID');
-  const explicitTenant = tenantId === undefined ? '' : safeId(tenantId);
-  const explicitAgent = agentId === undefined ? '' : safeId(agentId);
-  if ((tenantId !== undefined && !explicitTenant) || (agentId !== undefined && !explicitAgent)) {
-    fail('COGNITIVE_LIFECYCLE_INVALID');
-  }
-  const manifestIdentity = identityFromManifest(resolvedHome);
-  const identity = {
-    tenantId: explicitTenant || manifestIdentity?.tenantId || '',
-    agentId: explicitAgent || manifestIdentity?.agentId || '',
-  };
-  const hasSharedIdentity = Boolean(identity.tenantId && identity.agentId);
-  const resolvedTenantId = hasSharedIdentity
-    ? identity.tenantId : digestId('home', [resolvedHome.toLowerCase()]);
-  const resolvedAgentId = hasSharedIdentity
-    ? identity.agentId : digestId('agent', [resolvedAgent.toLowerCase()]);
-  const resolvedMemoryAdapter = memoryAdapter === undefined
-    ? loadConfiguredCognitiveMemoryAdapter({
-      modulePath: memoryAdapterModule,
-      home: resolvedHome,
-      tenantId: resolvedTenantId,
-      agentId: resolvedAgentId,
-      agentName: resolvedAgent,
-    })
-    : memoryAdapter;
-  const memoryMode = memoryAdapter !== undefined
-    ? 'injected-adapter'
-    : resolvedMemoryAdapter === undefined ? 'profile-local-fallback' : 'configured-provider';
-  return createCognitiveTurnLifecycle({
-    home: resolvedHome,
-    tenantId: resolvedTenantId,
-    agentId: resolvedAgentId,
-    runtimeId,
-    memoryAdapter: resolvedMemoryAdapter,
-    memoryMode,
-    identityMode: hasSharedIdentity ? 'shared-identity' : 'profile-derived',
-    now,
-  });
-}
-
-module.exports = { createCognitiveTurnLifecycle, createRuntimeCognitiveTurnLifecycle };