scene-capability-engine 3.6.64 → 3.6.67

package/lib/semantic/native-runtime.js

@@ -0,0 +1,359 @@
+const { SessionStore } = require('../runtime/session-store');
+const { observeSemanticInteraction } = require('./interaction-observer');
+const {
+  activatePromotedSemanticBehaviors,
+  listPromotedSemanticBehaviors,
+  recordSemanticCapabilityActivation
+} = require('./kernel-loader');
+const { getWriteAuthorizationLease } = require('../security/write-authorization');
+const {
+  assessSupremeIntent,
+  buildNativeGovernedReply,
+  writeSupremeIntentEvidence,
+  recordSupremeIntentAssessment
+} = require('../governance/supreme-principles');
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function unique(values = []) {
+  return Array.from(new Set(values.filter(Boolean)));
+}
+
+async function resolveLeaseSnapshot(leaseId, dependencies = {}) {
+  const normalizedLeaseId = normalizeString(leaseId);
+  if (!normalizedLeaseId) {
+    return null;
+  }
+  return getWriteAuthorizationLease(normalizedLeaseId, {
+    projectPath: dependencies.projectPath || process.cwd(),
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env
+  });
+}
+
+async function resolveNativeSession(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const store = dependencies.sessionStore || new SessionStore(projectPath, null, {
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule
+  });
+
+  const requestedSessionId = normalizeString(options.session_id || options.sessionId);
+  if (requestedSessionId) {
+    const session = await store.getSession(requestedSessionId);
+    return { store, session, created: false };
+  }
+
+  const sessions = await store.listSessions();
+  const latestNative = sessions.find((item) => normalizeString(item.tool) === 'sce-native');
+  if (latestNative) {
+    return { store, session: latestNative, created: false };
+  }
+
+  const session = await store.startSession({
+    tool: 'sce-native',
+    agentVersion: options.agent_version || options.agentVersion || null,
+    objective: normalizeString(options.objective) || 'SCE native semantic session',
+    sessionId: options.id || null
+  });
+  return { store, session, created: true };
+}
+
+async function bindNativeSession(store, session, options = {}) {
+  const projectId = normalizeString(options.project_id || options.projectId);
+  const channelId = normalizeString(options.channel_id || options.channelId || options.channel);
+  if (!projectId || !channelId) {
+    return null;
+  }
+
+  const bound = await store.bindSessionToProjectChannel(session.session_id, {
+    projectId,
+    channelId,
+    activeScene: options.scene_id || options.sceneId || options.scene,
+    activeSpecId: options.spec_id || options.specId || options.spec,
+    activeDoc: options.doc_id || options.docId || options.doc,
+    focus: true,
+    syncCurrentContext: true
+  });
+  return {
+    project_id: projectId,
+    channel_id: channelId,
+    focused_channel_id: bound.context.focusedChannelId,
+    active_session_path: bound.channel.activeSessionPath,
+    active_scene: bound.channel.activeScene,
+    active_spec_id: bound.channel.activeSpecId,
+    active_doc: bound.channel.activeDoc
+  };
+}
+
+function buildNativeReply(prompt, activations = [], context = {}) {
+  const top = activations.slice(0, 3);
+  if (top.length === 0) {
+    return {
+      text: 'No promoted semantic behavior matched this request. Continue with project/channel/spec context and gather more governed observations before promotion.',
+      explanation: {
+        activated_lessons: [],
+        matched_terms: []
+      }
+    };
+  }
+
+  const steps = unique(top.map((item) => normalizeString(item.heuristic)).filter(Boolean)).slice(0, 3);
+  const activatedLessons = top.map((item) => ({
+    lesson_id: item.lesson_id,
+    title: item.title,
+    matched_terms: item.activation.matched_terms
+  }));
+  const matchedTerms = unique(top.flatMap((item) => item.activation.matched_terms || []));
+  const prefix = context.project_id
+    ? `Native SCE guidance for ${context.project_id}:`
+    : 'Native SCE guidance:';
+  const body = steps.length > 0
+    ? steps.map((item, index) => `${index + 1}. ${item}`).join('\n')
+    : top.map((item, index) => `${index + 1}. ${item.summary || item.title || item.lesson_id}`).join('\n');
+
+  return {
+    text: `${prefix}\n${body}`,
+    explanation: {
+      activated_lessons: activatedLessons,
+      matched_terms: matchedTerms
+    }
+  };
+}
+
+async function startNativeConsoleSession(options = {}, dependencies = {}) {
+  const { store, session, created } = await resolveNativeSession(options, dependencies);
+  const projectChannel = await bindNativeSession(store, session, options);
+  const promoted = await listPromotedSemanticBehaviors({
+    project_id: options.project_id || options.projectId,
+    channel_id: options.channel_id || options.channelId || options.channel,
+    scene_id: options.scene_id || options.sceneId || options.scene,
+    spec_id: options.spec_id || options.specId || options.spec,
+    limit: options.limit || 20
+  }, {
+    projectPath: dependencies.projectPath || process.cwd(),
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    stateStore: dependencies.stateStore
+  });
+  const lease = await resolveLeaseSnapshot(options.auth_lease || options.authLease, dependencies);
+
+  return {
+    session,
+    created,
+    project_channel: projectChannel,
+    lease,
+    promoted_behaviors: promoted
+  };
+}
+
+async function runNativeSemanticTurn(options = {}, dependencies = {}) {
+  const prompt = normalizeString(options.prompt || options.message);
+  if (!prompt) {
+    throw new Error('prompt is required');
+  }
+
+  const supremeAssessment = await assessSupremeIntent({
+    text: prompt,
+    source_kind: 'native-ask',
+    scene_id: options.scene_id || options.sceneId || options.scene,
+    spec_id: options.spec_id || options.specId || options.spec
+  }, {
+    projectPath: dependencies.projectPath || process.cwd(),
+    fileSystem: dependencies.fileSystem
+  });
+  const effectivePrompt = normalizeString(supremeAssessment.effective_text) || prompt;
+
+  const resolved = await startNativeConsoleSession(options, dependencies);
+  const { store, session } = await resolveNativeSession({
+    session_id: resolved.session.session_id
+  }, dependencies);
+  const governedReply = buildNativeGovernedReply(supremeAssessment);
+  let activations = [];
+  let reply = governedReply;
+
+  if (supremeAssessment.execution_allowed) {
+    activations = await activatePromotedSemanticBehaviors(effectivePrompt, {
+      project_id: options.project_id || options.projectId,
+      channel_id: options.channel_id || options.channelId || options.channel,
+      scene_id: options.scene_id || options.sceneId || options.scene,
+      spec_id: options.spec_id || options.specId || options.spec,
+      limit: options.limit || 10
+    }, {
+      projectPath: dependencies.projectPath || process.cwd(),
+      fileSystem: dependencies.fileSystem,
+      env: dependencies.env,
+      sqliteModule: dependencies.sqliteModule,
+      stateStore: dependencies.stateStore
+    });
+
+    const semanticReply = buildNativeReply(effectivePrompt, activations, {
+      project_id: options.project_id || options.projectId
+    });
+    reply = (supremeAssessment.action === 'rewrite' || supremeAssessment.action === 'narrow') && governedReply
+      ? {
+        ...semanticReply,
+        text: `${governedReply.text}\n\n${semanticReply.text}`
+      }
+      : semanticReply;
+  }
+  const activatedLessonIds = activations.map((item) => item.lesson_id);
+  const activatedCapabilityIds = activations.map((item) => item.capability_id);
+  const replyQualitySignal = supremeAssessment.execution_allowed
+    ? (activations.length > 0 ? 'positive' : 'mixed')
+    : (supremeAssessment.action === 'refuse' ? 'negative' : 'mixed');
+
+  const supremeEvidence = normalizeString(options.spec_id || options.specId || options.spec)
+    ? await writeSupremeIntentEvidence(dependencies.projectPath || process.cwd(), options.spec_id || options.specId || options.spec, {
+      ...supremeAssessment,
+      source_kind: 'native-ask',
+      spec_id: options.spec_id || options.specId || options.spec
+    }, {
+      fileSystem: dependencies.fileSystem
+    })
+    : null;
+
+  const supremeLedgerEntry = await recordSupremeIntentAssessment({
+    ...supremeAssessment,
+    project_id: options.project_id || options.projectId,
+    channel_id: options.channel_id || options.channelId || options.channel,
+    session_id: session.session_id,
+    scene_id: options.scene_id || options.sceneId || options.scene,
+    spec_id: options.spec_id || options.specId || options.spec,
+    source_kind: 'native-ask',
+    evidence_path: supremeEvidence ? supremeEvidence.relative_path : null,
+    metadata: {
+      project_channel: resolved.project_channel || null,
+      activated_lesson_ids: activatedLessonIds,
+      activated_capability_ids: activatedCapabilityIds,
+      reply_quality_signal: replyQualitySignal
+    }
+  }, {
+    projectPath: dependencies.projectPath || process.cwd(),
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    stateStore: dependencies.stateStore,
+    noCache: dependencies.noCache === true
+  });
+
+  await observeSemanticInteraction({
+    project_id: options.project_id || options.projectId,
+    channel_id: options.channel_id || options.channelId || options.channel,
+    session_id: session.session_id,
+    scene_id: options.scene_id || options.sceneId || options.scene,
+    spec_id: options.spec_id || options.specId || options.spec,
+    source_runtime: 'sce-native',
+    source_kind: 'native-shell',
+    event_kind: 'prompt',
+    role: 'user',
+    text: prompt,
+    summary: prompt.slice(0, 240),
+    outcome: 'observed',
+    quality_signal: 'unknown',
+    metadata: {
+      native_runtime: true,
+      activated_lesson_ids: [],
+      activated_capability_ids: [],
+      supreme_action: supremeAssessment.action,
+      supreme_effective_text: effectivePrompt,
+      supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null
+    }
+  }, {
+    projectPath: dependencies.projectPath || process.cwd(),
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    stateStore: dependencies.stateStore
+  });
+
+  await observeSemanticInteraction({
+    project_id: options.project_id || options.projectId,
+    channel_id: options.channel_id || options.channelId || options.channel,
+    session_id: session.session_id,
+    scene_id: options.scene_id || options.sceneId || options.scene,
+    spec_id: options.spec_id || options.specId || options.spec,
+    source_runtime: 'sce-native',
+    source_kind: 'native-shell',
+    event_kind: 'reply',
+    role: 'assistant',
+    text: reply.text,
+    summary: reply.text.slice(0, 240),
+    outcome: 'observed',
+    quality_signal: replyQualitySignal,
+    metadata: {
+      native_runtime: true,
+      activated_lesson_ids: activatedLessonIds,
+      activated_capability_ids: activatedCapabilityIds,
+      supreme_action: supremeAssessment.action,
+      supreme_effective_text: effectivePrompt,
+      supreme_intent_evidence: supremeEvidence ? supremeEvidence.relative_path : null
+    }
+  }, {
+    projectPath: dependencies.projectPath || process.cwd(),
+    fileSystem: dependencies.fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    stateStore: dependencies.stateStore
+  });
+
+  for (const activation of activations) {
+    await recordSemanticCapabilityActivation({
+      capability_id: activation.capability_id,
+      lesson_id: activation.lesson_id,
+      project_id: options.project_id || options.projectId,
+      channel_id: options.channel_id || options.channelId || options.channel,
+      session_id: session.session_id,
+      source_runtime: 'sce-native',
+      quality_signal: replyQualitySignal,
+      activated_at: new Date().toISOString()
+    }, {
+      projectPath: dependencies.projectPath || process.cwd(),
+      fileSystem: dependencies.fileSystem,
+      env: dependencies.env,
+      sqliteModule: dependencies.sqliteModule,
+      stateStore: dependencies.stateStore
+    });
+  }
+
+  await store.snapshotSession(session.session_id, {
+    summary: `native turn | ${prompt.slice(0, 80)}`,
+    status: 'active',
+    payload: {
+      prompt,
+      effective_prompt: effectivePrompt,
+      reply_preview: reply.text.slice(0, 240),
+      activated_lesson_ids: activatedLessonIds,
+      activated_capability_ids: activatedCapabilityIds,
+      supreme_principles: {
+        action: supremeAssessment.action,
+        execution_allowed: supremeAssessment.execution_allowed,
+        evidence: supremeEvidence ? supremeEvidence.relative_path : null
+      }
+    }
+  });
+
+  return {
+    session: await store.getSession(session.session_id),
+    project_channel: resolved.project_channel,
+    lease: resolved.lease,
+    reply,
+    activations,
+    supreme_principles: supremeAssessment,
+    supreme_intent_record: supremeLedgerEntry
+  };
+}
+
+module.exports = {
+  resolveNativeSession,
+  buildNativeReply,
+  startNativeConsoleSession,
+  runNativeSemanticTurn
+};