| import fs from "node:fs/promises"; |
| import os from "node:os"; |
| import path from "node:path"; |
| import { pathToFileURL } from "node:url"; |
| import { deriveSkynetCausalLabelCounts } from "../causal-valence/episode-ledger.js"; |
| import { collectSkynetSessionTranscriptFiles } from "../causal-valence/observability-audit.js"; |
| import { harvestSkynetObservedCausalEpisodes } from "../causal-valence/observed-harvester.js"; |
| import { replaySkynetCognitiveKernelState } from "../cognitive-kernel/min-kernel.js"; |
| import { runSkynetCognitiveKernelBenchmark } from "../cognitive-kernel/online-benchmark.js"; |
| import { writeSkynetCognitiveKernelState } from "../cognitive-kernel/state-store.js"; |
| import { buildSkynetRuntimeTrajectorySamples } from "../runtime-observer/trajectory-builder.js"; |
|
|
| export type SkynetCognitiveKernel01Result = ReturnType<typeof runSkynetCognitiveKernelBenchmark> & { |
| sessionKey: string; |
| updatedAt: number; |
| projectName: string; |
| harvestedEpisodes: number; |
| trajectorySamples: number; |
| lookback: number; |
| scannedSessionFiles: string[]; |
| sourceLabelCoverage: ReturnType<typeof deriveSkynetCausalLabelCounts>; |
| }; |
|
|
| function sanitizeSessionKey(sessionKey: string): string { |
| return (sessionKey.trim() || "main").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 64) || "main"; |
| } |
|
|
| function defaultSessionsDir(): string { |
| return path.join(os.homedir(), ".openskynet", "agents", "main", "sessions"); |
| } |
|
|
| export function resolveSkynetCognitiveKernel01JsonPath(params: { |
| workspaceRoot: string; |
| sessionKey: string; |
| }): string { |
| return path.join( |
| params.workspaceRoot, |
| ".openskynet", |
| "skynet-experiments", |
| `${sanitizeSessionKey(params.sessionKey)}-cognitive-kernel-01.json`, |
| ); |
| } |
|
|
| export function resolveSkynetCognitiveKernel01MarkdownPath(workspaceRoot: string): string { |
| return path.join(workspaceRoot, "memory", "SKYNET_EXPERIMENT_COGNITIVE_KERNEL_01.md"); |
| } |
|
|
| function buildMarkdown(result: SkynetCognitiveKernel01Result): string { |
| return [ |
| "# SKYNET Experiment - Cognitive Kernel 01", |
| "", |
| `Updated: ${new Date(result.updatedAt).toISOString()}`, |
| `Session: ${result.sessionKey}`, |
| `Status: ${result.status}`, |
| `Harvested episodes: ${result.harvestedEpisodes}`, |
| `Trajectory samples: ${result.trajectorySamples}`, |
| `Lookback: ${result.lookback}`, |
| `Warmup samples: ${result.warmupSamples}`, |
| `Accuracy: ${result.accuracy.toFixed(2)}`, |
| `Sequential majority baseline: ${result.majorityBaseline.toFixed(2)}`, |
| `Improvement: ${result.improvementOverBaseline.toFixed(2)}`, |
| "", |
| "## Source Label Coverage", |
| "", |
| ...Object.entries(result.sourceLabelCoverage).map(([label, count]) => `- ${label}: ${count}`), |
| "", |
| "## Trajectory Label Coverage", |
| "", |
| ...Object.entries(result.labelCoverage).map(([label, count]) => `- ${label}: ${count}`), |
| "", |
| "## Failure Reasons", |
| "", |
| ...(result.failureReasons.length > 0 |
| ? result.failureReasons.map((reason) => `- ${reason}`) |
| : ["- none"]), |
| "", |
| ].join("\n"); |
| } |
|
|
| export async function runSkynetCognitiveKernel01(params: { |
| workspaceRoot: string; |
| sessionKey: string; |
| lookback?: number; |
| sessionsDir?: string; |
| }): Promise<SkynetCognitiveKernel01Result> { |
| const lookback = Math.max(1, Math.min(6, params.lookback ?? 3)); |
| const sessionFiles = await collectSkynetSessionTranscriptFiles( |
| params.sessionsDir ?? defaultSessionsDir(), |
| ); |
| const harvested = await harvestSkynetObservedCausalEpisodes({ sessionFiles }); |
| const trajectorySamples = buildSkynetRuntimeTrajectorySamples({ |
| episodes: harvested.episodes, |
| lookback, |
| }); |
| const benchmark = runSkynetCognitiveKernelBenchmark({ samples: trajectorySamples }); |
| const result: SkynetCognitiveKernel01Result = { |
| sessionKey: params.sessionKey, |
| updatedAt: Date.now(), |
| projectName: "Skynet", |
| harvestedEpisodes: harvested.episodes.length, |
| trajectorySamples: trajectorySamples.length, |
| lookback, |
| scannedSessionFiles: sessionFiles, |
| sourceLabelCoverage: deriveSkynetCausalLabelCounts(harvested.episodes), |
| ...benchmark, |
| }; |
|
|
| const jsonPath = resolveSkynetCognitiveKernel01JsonPath(params); |
| const markdownPath = resolveSkynetCognitiveKernel01MarkdownPath(params.workspaceRoot); |
| await fs.mkdir(path.dirname(jsonPath), { recursive: true }); |
| await fs.mkdir(path.dirname(markdownPath), { recursive: true }); |
| await fs.writeFile(jsonPath, JSON.stringify(result, null, 2) + "\n", "utf-8"); |
| await fs.writeFile(markdownPath, buildMarkdown(result), "utf-8"); |
| const state = replaySkynetCognitiveKernelState({ samples: trajectorySamples }); |
| if (state) { |
| await writeSkynetCognitiveKernelState({ |
| workspaceRoot: params.workspaceRoot, |
| sessionKey: params.sessionKey, |
| state, |
| }); |
| } |
| return result; |
| } |
|
|
| async function main() { |
| const result = await runSkynetCognitiveKernel01({ |
| workspaceRoot: process.cwd(), |
| sessionKey: "agent:openskynet:main", |
| }); |
| console.log(`--- ${result.projectName} Experiment: Cognitive Kernel 01 ---`); |
| console.log(`Status: ${result.status}`); |
| console.log(`Samples: ${result.trajectorySamples}`); |
| console.log(`Accuracy: ${result.accuracy.toFixed(2)}`); |
| console.log(`Baseline: ${result.majorityBaseline.toFixed(2)}`); |
| } |
|
|
| if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) { |
| main().catch((error) => { |
| console.error(error); |
| process.exitCode = 1; |
| }); |
| } |
|
|
