sneakoscope 3.1.4 → 3.1.6

package/dist/cli/hermes-command.js

@@ -1,99 +0,0 @@
-import path from 'node:path';
-import { HERMES_SKILL_NAME, buildHermesSkillFiles, defaultHermesSkillDir, installHermesSkill } from '../core/hermes.js';
-import { exists } from '../core/fsx.js';
-const flag = (args, name) => args.includes(name);
-function readFlagValue(args, name, fallback) {
-    const i = args.indexOf(name);
-    return i >= 0 && args[i + 1] ? args[i + 1] : fallback;
-}
-function positionalArgs(args = []) {
-    const out = [];
-    const valueFlags = new Set(['--dir']);
-    for (let i = 0; i < args.length; i++) {
-        const arg = String(args[i]);
-        if (valueFlags.has(arg)) {
-            i++;
-            continue;
-        }
-        if (!arg.startsWith('--'))
-            out.push(arg);
-    }
-    return out;
-}
-export async function hermesCommand(args = []) {
-    const action = args[0] || 'help';
-    const targetDir = readFlagValue(args, '--dir', defaultHermesSkillDir());
-    const resultOptions = {
-        targetDir,
-        force: flag(args, '--force'),
-        dryRun: flag(args, '--dry-run')
-    };
-    if (action === 'path') {
-        const result = { skill: HERMES_SKILL_NAME, target_dir: path.resolve(targetDir) };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.log(result.target_dir);
-        return;
-    }
-    if (action === 'status') {
-        const files = buildHermesSkillFiles();
-        const target = path.resolve(targetDir);
-        const installed = await exists(path.join(target, 'SKILL.md'));
-        const result = {
-            schema: 'sks.hermes-skill-status.v1',
-            ok: true,
-            skill: HERMES_SKILL_NAME,
-            target_dir: target,
-            installed,
-            expected_files: Object.keys(files),
-            env_mode: 'SKS_HERMES=1',
-            slash_command: `/${HERMES_SKILL_NAME}`
-        };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.log(`Hermes skill: ${installed ? 'installed' : 'not installed'} ${target}`);
-        return;
-    }
-    if (action === 'print') {
-        const files = buildHermesSkillFiles();
-        const file = (positionalArgs(args.slice(1))[0] || 'SKILL.md');
-        if (!files[file]) {
-            console.error(`Unknown Hermes skill file: ${file}`);
-            console.error(`Files: ${Object.keys(files).join(', ')}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(files[file]);
-        return;
-    }
-    if (action === 'install') {
-        const result = await installHermesSkill(resultOptions);
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        if (!result.ok) {
-            console.error(`Hermes skill install blocked: ${result.reason}`);
-            console.error(`Target: ${result.target_dir}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(`Hermes skill ${result.status}: ${result.target_dir}`);
-        console.log(`Use it in Hermes as /${HERMES_SKILL_NAME} and run SKS shell commands with SKS_HERMES=1.`);
-        return;
-    }
-    console.log(`Hermes
-
-Usage:
-  sks hermes install [--dir path] [--force] [--dry-run] [--json]
-  sks hermes status [--dir path] [--json]
-  sks hermes path [--dir path] [--json]
-  sks hermes print [SKILL.md|README.md|hermes-config.example.yaml|skill-bundle.example.yaml]
-
-Default skill: ${HERMES_SKILL_NAME}
-Default path:  ${defaultHermesSkillDir()}
-
-After install, open Hermes and invoke:
-
-/${HERMES_SKILL_NAME} Use SKS in this repository.
-`);
-}
-//# sourceMappingURL=hermes-command.js.map

package/dist/cli/openclaw-command.js

@@ -1,83 +0,0 @@
-import path from 'node:path';
-import { OPENCLAW_SKILL_NAME, buildOpenClawSkillFiles, defaultOpenClawSkillDir, installOpenClawSkill } from '../core/openclaw.js';
-const flag = (args, name) => args.includes(name);
-function readFlagValue(args, name, fallback) {
-    const i = args.indexOf(name);
-    return i >= 0 && args[i + 1] ? args[i + 1] : fallback;
-}
-function positionalArgs(args = []) {
-    const out = [];
-    const valueFlags = new Set(['--dir']);
-    for (let i = 0; i < args.length; i++) {
-        const arg = String(args[i]);
-        if (valueFlags.has(arg)) {
-            i++;
-            continue;
-        }
-        if (!arg.startsWith('--'))
-            out.push(arg);
-    }
-    return out;
-}
-export async function openClawCommand(args = []) {
-    const action = args[0] || 'help';
-    const targetDir = readFlagValue(args, '--dir', defaultOpenClawSkillDir());
-    const resultOptions = {
-        targetDir,
-        force: flag(args, '--force'),
-        dryRun: flag(args, '--dry-run')
-    };
-    if (action === 'path') {
-        const result = { skill: OPENCLAW_SKILL_NAME, target_dir: path.resolve(targetDir) };
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        console.log(result.target_dir);
-        return;
-    }
-    if (action === 'print') {
-        const files = buildOpenClawSkillFiles();
-        const file = (positionalArgs(args.slice(1))[0] || 'SKILL.md');
-        if (!files[file]) {
-            console.error(`Unknown OpenClaw skill file: ${file}`);
-            console.error(`Files: ${Object.keys(files).join(', ')}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(files[file]);
-        return;
-    }
-    if (action === 'install') {
-        const result = await installOpenClawSkill(resultOptions);
-        if (flag(args, '--json'))
-            return console.log(JSON.stringify(result, null, 2));
-        if (!result.ok) {
-            console.error(`OpenClaw skill install blocked: ${result.reason}`);
-            console.error(`Target: ${result.target_dir}`);
-            process.exitCode = 1;
-            return;
-        }
-        console.log(`OpenClaw skill ${result.status}: ${result.target_dir}`);
-        console.log(`Attach it to an agent with skills: [${OPENCLAW_SKILL_NAME}] and tools: [shell].`);
-        return;
-    }
-    console.log(`OpenClaw
-
-Usage:
-  sks openclaw install [--dir path] [--force] [--dry-run] [--json]
-  sks openclaw path [--dir path] [--json]
-  sks openclaw print [SKILL.md|manifest.yaml|README.md|openclaw-agent-config.example.yaml]
-
-Default skill: ${OPENCLAW_SKILL_NAME}
-Default path:  ${defaultOpenClawSkillDir()}
-
-After install, add this to an OpenClaw agent config:
-
-agents:
-  coding-agent:
-    tools:
-      - shell
-    skills:
-      - ${OPENCLAW_SKILL_NAME}
-`);
-}
-//# sourceMappingURL=openclaw-command.js.map

package/dist/commands/hermes.js

@@ -1,5 +0,0 @@
-import { hermesCommand } from '../cli/hermes-command.js';
-export async function run(_command, args = []) {
-    return hermesCommand(args);
-}
-//# sourceMappingURL=hermes.js.map

package/dist/commands/openclaw.js

@@ -1,3 +0,0 @@
-import { openClawCommand } from '../cli/openclaw-command.js';
-export async function run(_command, args = []) { return openClawCommand(args); }
-//# sourceMappingURL=openclaw.js.map

package/dist/core/codex-app/lazycodex-analysis.js

@@ -1,51 +0,0 @@
-// @ts-nocheck
-import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../fsx.js';
-export function buildLazyCodexPatternAnalysis() {
-    return {
-        schema: 'sks.lazycodex-pattern-analysis.v1',
-        source_repo: 'code-yeongyu/lazycodex',
-        analyzed_at: nowIso(),
-        patterns: [
-            pattern('npx-no-global-install', 'npx no-global install alias', ['Directive: npx lazycodex-ai install aliases npx --yes --package oh-my-openagent omo install --platform=codex.'], 'adapt', 'Keep optional tooling no-global by default and record repair transactions.', ['src/cli/install-helpers.ts', 'src/core/zellij/zellij-self-heal.ts']),
-            pattern('codex-marketplace-plugin', 'Codex marketplace plugin add/upgrade', ['Directive: codex plugin marketplace add and codex plugin add omo@sisyphuslabs.'], 'adapt', 'Track marketplace/plugin inventory without assuming hooks are approved.', ['src/core/codex-app/codex-app-harness-matrix.ts']),
-            pattern('startup-review-hooks', 'Startup review hook approval', ['Directive: hooks require Codex startup review approval and re-approval after modifications.'], 'adopt', 'Separate installed hook files from approval state; unknown remains unknown.', ['src/core/codex-app/codex-hook-lifecycle.ts']),
-            pattern('background-bootstrap', 'Background bootstrap and restart notice', ['Directive: first approved session performs background bootstrap and upgrade may require restart.'], 'adapt', 'Report bootstrap proof as warning/blocker instead of silently assuming completion.', ['src/core/codex-app/codex-app-harness-matrix.ts']),
-            pattern('doctor-health-report', 'Doctor health report for plugin cache/hooks/MCP/agents/config', ['Directive: LazyCodex doctor reports plugin cache, hooks, MCP servers, agents, config state.'], 'adopt', 'Add Codex App Harness section to SKS doctor.', ['src/commands/doctor.ts']),
-            pattern('dollar-skill-picker', '$ skill picker and $command invocation', ['Directive: Codex composer $ browses installed skills.'], 'adapt', 'Keep SKS route skills synced without clobbering user or LazyCodex skills.', ['src/core/codex-app/codex-skill-sync.ts']),
-            pattern('init-deep-agents', '$init-deep hierarchical AGENTS.md', ['Directive: init-deep creates hierarchical AGENTS.md context.'], 'adapt', 'Generate SKS memory under .sneakoscope/context by default and preserve user AGENTS.md.', ['src/core/codex-app/codex-init-deep.ts']),
-            pattern('plan-start-loop', '$ulw-plan, $start-work, $ulw-loop command pillars', ['Directive: separate planning, durable work, and evidence loop.'], 'adapt', 'Map onto sks loop plan/run/proof without replacing existing Loop Mesh.', ['src/core/commands/loop-command.ts']),
-            pattern('specialist-skills', 'Specialist skills', ['Directive: specialist skills include review-work, LSP, AST-grep, programming, frontend UI/UX.'], 'watch', 'Keep checker profile selection explicit and evidence-backed.', ['src/core/loops/loop-gate-selector.ts']),
-            pattern('native-agent-type', 'Native spawn_agent agent_type with message fallback', ['Directive: LazyCodex probes agent_type and falls back to role in message.'], 'adopt', 'Expose native agent_type capability in execution profile.', ['src/core/codex-app/codex-agent-role-sync.ts', 'src/core/codex-app/codex-app-execution-profile.ts']),
-            pattern('multi-model-routing', 'Multi-model routing', ['Directive: LazyCodex/OmO route multiple models.'], 'watch', 'SKS keeps provider/profile policy separate from harness matrix.', ['src/core/provider/provider-context.ts']),
-            pattern('hook-continuation', 'Hook lifecycle and continuation enforcer', ['Directive: UserPromptSubmit, PreToolUse, PostToolUse, Stop, Notification map to pipeline actions.'], 'adopt', 'Map lifecycle and add Loop continuation proof adapter.', ['src/core/codex-app/codex-hook-lifecycle.ts', 'src/core/loops/loop-continuation-enforcer.ts']),
-            pattern('skill-mcp-slashcommand', 'Skill MCP and slashcommand tool', ['Directive: OmO exposes skill MCP and slashcommand tools.'], 'adapt', 'Report MCP candidates and SKS route skill availability without assuming external plugin behavior.', ['src/core/codex-app/codex-app-harness-matrix.ts']),
-            pattern('lsp-ast-grep', 'LSP/AST-grep optional tooling', ['Directive: LSP/AST-grep are optional-but-first-class loop gates/tools.'], 'watch', 'Use as future specialist gates; do not add unrequested fallback tooling now.', ['src/core/loops/loop-gate-selector.ts'])
-        ],
-        blockers: []
-    };
-}
-export async function writeLazyCodexPatternAnalysis(root) {
-    const report = buildLazyCodexPatternAnalysis();
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-analysis.json'), report);
-    return report;
-}
-export function renderLazyCodexAnalysisMarkdown(report) {
-    const rows = report.patterns.map((p) => `| ${p.id} | ${p.sks_adoption} | ${p.rationale.replace(/\|/g, '\\|')} |`).join('\n');
-    return [
-        '# LazyCodex / OmO Pattern Analysis',
-        '',
-        `Source repo: \`${report.source_repo}\``,
-        `Analyzed at: \`${report.analyzed_at}\``,
-        '',
-        '| Pattern | Adoption | Rationale |',
-        '|---|---|---|',
-        rows,
-        '',
-        'This artifact is deterministic and based on the SKS 3.1.4 directive plus current SKS repository surfaces. Live LazyCodex runtime behavior remains a separate verification concern.'
-    ].join('\n');
-}
-function pattern(id, title, evidence, sks_adoption, rationale, target_modules) {
-    return { id, title, evidence, sks_adoption, rationale, target_modules };
-}
-//# sourceMappingURL=lazycodex-analysis.js.map

package/dist/core/codex-app/lazycodex-interop-policy.js

@@ -1,49 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { nowIso, writeJsonAtomic } from '../fsx.js';
-import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
-export async function buildLazyCodexInteropPolicy(input) {
-    const root = path.resolve(input.root);
-    const inventory = input.inventory || await buildCodexPluginInventory().catch((err) => ({ plugins: [], blockers: [err?.message || String(err)] }));
-    const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-    const skillNames = await discoverSkillNames([path.join(root, '.agents', 'skills'), path.join(codexHome, 'skills')]);
-    const pluginIds = (inventory.plugins || []).map((plugin) => `${plugin.id || ''} ${plugin.name || ''}`.toLowerCase());
-    const lazycodexInstalled = pluginIds.some((id) => id.includes('omo') || id.includes('lazycodex'))
-        || ['ulw-loop', 'ulw-plan', 'start-work'].some((name) => skillNames.includes(name));
-    const collisions = ['ulw-loop', 'ulw-plan', 'start-work'].filter((name) => skillNames.includes(name));
-    const report = {
-        schema: 'sks.lazycodex-interop-policy.v1',
-        generated_at: nowIso(),
-        ok: true,
-        mode: input.mode || 'coexist',
-        lazycodex_detected: lazycodexInstalled,
-        detection: {
-            plugin_inventory_ids: pluginIds,
-            skill_names: skillNames,
-            collisions
-        },
-        policy: {
-            clobber_lazycodex_skills: false,
-            clobber_user_skills: false,
-            default_mode: 'coexist',
-            explicit_handoff_required: true
-        },
-        actions: collisions.map((name) => `preserve_existing_skill:${name}`),
-        blockers: []
-    };
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'lazycodex-interop-policy.json'), report).catch(() => undefined);
-    return report;
-}
-async function discoverSkillNames(roots) {
-    const names = new Set();
-    for (const root of roots) {
-        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
-        for (const entry of entries)
-            if (entry.isDirectory())
-                names.add(entry.name);
-    }
-    return [...names].sort();
-}
-//# sourceMappingURL=lazycodex-interop-policy.js.map

package/dist/core/hermes.js

@@ -1,192 +0,0 @@
-import path from 'node:path';
-import os from 'node:os';
-import { exists, readText, writeTextAtomic, PACKAGE_VERSION } from './fsx.js';
-export const HERMES_SKILL_NAME = 'sneakoscope-codex';
-export function defaultHermesHome(env = process.env) {
-    return path.resolve(env.HERMES_HOME || path.join(env.HOME || os.homedir(), '.hermes'));
-}
-export function defaultHermesSkillDir(env = process.env) {
-    return path.join(defaultHermesHome(env), 'skills', HERMES_SKILL_NAME);
-}
-export function buildHermesSkillFiles(options = {}) {
-    const sksCommand = options.sksCommand || 'sks';
-    const version = options.version || PACKAGE_VERSION;
-    const skillName = options.skillName || HERMES_SKILL_NAME;
-    return {
-        'SKILL.md': hermesSkillMarkdown({ sksCommand, skillName, version }),
-        'README.md': hermesSkillReadme({ sksCommand, skillName, version }),
-        'hermes-config.example.yaml': hermesConfigExample({ skillName }),
-        'skill-bundle.example.yaml': hermesSkillBundleExample({ skillName })
-    };
-}
-export async function installHermesSkill(options = {}) {
-    const targetDir = path.resolve(options.targetDir || defaultHermesSkillDir(options.env || process.env));
-    const files = buildHermesSkillFiles(options);
-    const existingSkill = path.join(targetDir, 'SKILL.md');
-    const existing = await exists(existingSkill);
-    if (existing && !options.force) {
-        const text = await readText(existingSkill, '');
-        if (!text.includes('generated_by: sneakoscope') && !text.includes('Generated by Sneakoscope')) {
-            return {
-                ok: false,
-                status: 'blocked_existing_skill',
-                target_dir: targetDir,
-                reason: 'Existing Hermes skill is not marked as generated by Sneakoscope. Re-run with --force to overwrite.'
-            };
-        }
-    }
-    if (options.dryRun) {
-        return { ok: true, status: existing ? 'would_update' : 'would_create', target_dir: targetDir, files: Object.keys(files) };
-    }
-    for (const [name, content] of Object.entries(files)) {
-        await writeTextAtomic(path.join(targetDir, name), content);
-    }
-    return { ok: true, status: existing ? 'updated' : 'created', target_dir: targetDir, files: Object.keys(files) };
-}
-function hermesSkillMarkdown({ sksCommand, skillName, version }) {
-    return `---
-name: ${skillName}
-description: Use Sneakoscope Codex (sks) routes, TriWiki, proof/trust, and safety gates from Hermes Agent.
-version: ${version}
-generated_by: sneakoscope
-metadata:
-  hermes:
-    category: autonomous-ai-agents
-    tags: [sks, codex, coding-agent, orchestration, qa, safety]
-    requires_toolsets: [terminal]
-    config:
-      - key: sks.command
-        description: Local Sneakoscope Codex command to run from the active workspace.
-        default: ${sksCommand}
-        prompt: Path or command name for Sneakoscope Codex.
----
-
-# Sneakoscope Codex For Hermes
-
-## LLM Init Prompt For Hermes Agent Builders
-
-\`\`\`text
-Set up this Hermes agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-Codex](https://github.com/mandarange/Sneakoscope-Codex)] as the repo reference and [npm i -g sneakoscope] as the recommended global install command, then run \`SKS_HERMES=1 ${sksCommand} root --json\`, setup/doctor, Codex App, and proof checks for this repo.
-\`\`\`
-
-## When to Use
-
-Use this skill when a Hermes Agent is operating in a repository that mentions Sneakoscope Codex, SKS, \`sks\`, Team, QA-LOOP, TriWiki, Context7, DB safety, Completion Proof, Trust Kernel, Honest Mode, or \`$...\` SKS prompt routes.
-
-Hermes exposes installed skills as slash commands, so users can run \`/${skillName} <task>\` from the CLI or any messaging gateway.
-
-## Required Tool Access
-
-The Hermes agent needs the \`terminal\` toolset or an equivalent shell/command tool. Prefer running commands in the target repository root.
-
-Set \`SKS_HERMES=1\` for SKS shell commands. Hermes mode lets SKS treat dependency/update prompts as non-interactive agent prompts, matching the OpenClaw agent mode without changing database or destructive-operation safety rules.
-
-## Procedure
-
-1. Run \`SKS_HERMES=1 ${sksCommand} root --json\` from the target workspace.
-2. Read \`AGENTS.md\` if present, then run \`SKS_HERMES=1 ${sksCommand} status --json\`.
-3. Discover available surfaces with \`SKS_HERMES=1 ${sksCommand} commands --json\` and \`SKS_HERMES=1 ${sksCommand} dollar-commands --json\`.
-4. For broad implementation, use the repo's selected SKS route. General code work normally belongs on Team; tiny direct edits may use DFix; UI/API dogfood belongs on QA-LOOP; DB/Supabase work belongs on DB safety routes.
-5. Before coding, preserve existing user changes. Do not reset the worktree or overwrite unrelated files.
-6. After edits, run the smallest relevant tests, then run \`${sksCommand} proof validate --json\` or \`${sksCommand} trust validate latest --json\` when a mission exists.
-
-## Safety Rules
-
-- Do not invent fallback implementation code when SKS reports that a requested path is blocked. Report the blocker and the source artifact instead.
-- Database, migration, Supabase, and credential work stays read-only unless the user explicitly authorizes a scoped write path.
-- \`$MAD-SKS\` or \`sks --mad\` is a temporary high-risk permission modifier only when the user explicitly invokes it. It does not remove catastrophic safeguards.
-- Mock, fixture, or static evidence must be reported as partial verification, never as live runtime proof.
-
-## Useful Commands
-
-- \`${sksCommand} root --json\`
-- \`${sksCommand} status --json\`
-- \`${sksCommand} commands --json\`
-- \`${sksCommand} dollar-commands --json\`
-- \`${sksCommand} deps check --json\`
-- \`${sksCommand} codex compatibility --json\`
-- \`${sksCommand} proof-field scan --intent "<task>" --changed file1,file2 --json\`
-- \`${sksCommand} proof validate --json\`
-- \`${sksCommand} trust validate latest --json\`
-
-## Pitfalls
-
-- SKS prompt routes such as \`$Team\` are prompt commands in Codex App, not shell commands. In Hermes terminal workflows, prefer the corresponding \`sks team\`, \`sks qa-loop\`, \`sks dfix\`, \`sks db\`, or \`sks pipeline\` command.
-- If Hermes runs in a sandbox, grant shell access only for trusted workspaces and keep SKS DB safety gates enabled.
-- If \`latest\` moved to a fixture mission, pin the explicit mission id from \`${sksCommand} status --json\` before final proof/trust closeout.
-
-## Verification
-
-The minimum healthy check is:
-
-\`\`\`sh
-SKS_HERMES=1 ${sksCommand} root --json
-SKS_HERMES=1 ${sksCommand} commands --json
-SKS_HERMES=1 ${sksCommand} status --json
-\`\`\`
-
-For code changes, add the route-specific tests and proof/trust validation before claiming completion.
-`;
-}
-function hermesSkillReadme({ sksCommand, skillName, version }) {
-    return `# ${skillName}
-
-Version: ${version}
-
-Generated by Sneakoscope Codex for Hermes Agent.
-
-This Hermes skill lets Hermes discover and use Sneakoscope Codex through the local \`${sksCommand}\` command. It installs as \`/${skillName}\` and assumes the Hermes \`terminal\` toolset is available.
-
-## LLM Init Prompt
-
-\`\`\`text
-Set up this Hermes agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-Codex](https://github.com/mandarange/Sneakoscope-Codex)] as the repo reference and [npm i -g sneakoscope] as the recommended global install command, then run \`SKS_HERMES=1 ${sksCommand} root --json\`, setup/doctor, Codex App, and proof checks for this repo.
-\`\`\`
-
-## Install
-
-\`\`\`sh
-${sksCommand} hermes install
-\`\`\`
-
-The default target is \`~/.hermes/skills/${skillName}/\`.
-
-## Verify From Hermes
-
-\`\`\`sh
-hermes skills list | grep ${skillName}
-SKS_HERMES=1 ${sksCommand} root --json
-SKS_HERMES=1 ${sksCommand} commands --json
-\`\`\`
-
-Then start a fresh Hermes session and invoke \`/${skillName} Use SKS in this repository.\`
-
-## Optional External Skill Directory
-
-If you keep SKS/Codex skills in a shared folder, add it under \`skills.external_dirs\` in \`~/.hermes/config.yaml\`. Hermes can update writable external skill directories, so use filesystem permissions when shared skills must remain read-only. See \`hermes-config.example.yaml\`.
-`;
-}
-function hermesConfigExample({ skillName }) {
-    return `# Optional Hermes config snippet for Sneakoscope Codex.
-# The installed skill under ~/.hermes/skills/${skillName}/ works without this.
-
-skills:
-  external_dirs:
-    - ~/.agents/skills
-
-# Hermes may update writable external skill directories. Use filesystem
-# permissions if shared skills must remain read-only.
-#
-# For terminal sessions, run SKS commands with:
-#   SKS_HERMES=1 sks status --json
-`;
-}
-function hermesSkillBundleExample({ skillName }) {
-    return `# Optional ~/.hermes/skill-bundles/sks.yaml
-name: sks
-description: Load Sneakoscope Codex operating rules for SKS-enabled repositories.
-skills:
-  - ${skillName}
-`;
-}
-//# sourceMappingURL=hermes.js.map

package/dist/core/openclaw.js

@@ -1,171 +0,0 @@
-import path from 'node:path';
-import os from 'node:os';
-import { exists, readText, writeTextAtomic, PACKAGE_VERSION } from './fsx.js';
-export const OPENCLAW_SKILL_NAME = 'sneakoscope-codex';
-export function defaultOpenClawHome(env = process.env) {
-    return path.resolve(env.OPENCLAW_HOME || path.join(env.HOME || os.homedir(), '.openclaw'));
-}
-export function defaultOpenClawSkillDir(env = process.env) {
-    return path.join(defaultOpenClawHome(env), 'skills', OPENCLAW_SKILL_NAME);
-}
-export function buildOpenClawSkillFiles(options = {}) {
-    const sksCommand = options.sksCommand || 'sks';
-    const version = options.version || PACKAGE_VERSION;
-    const skillName = options.skillName || OPENCLAW_SKILL_NAME;
-    return {
-        'manifest.yaml': openClawManifest({ skillName, version }),
-        'SKILL.md': openClawSkillMarkdown({ sksCommand, skillName, version }),
-        'README.md': openClawSkillReadme({ sksCommand, skillName, version }),
-        'openclaw-agent-config.example.yaml': openClawAgentConfigExample({ skillName })
-    };
-}
-export async function installOpenClawSkill(options = {}) {
-    const targetDir = path.resolve(options.targetDir || defaultOpenClawSkillDir(options.env || process.env));
-    const files = buildOpenClawSkillFiles(options);
-    const existingManifest = path.join(targetDir, 'manifest.yaml');
-    const existing = await exists(existingManifest);
-    if (existing && !options.force) {
-        const text = await readText(existingManifest, '');
-        if (!text.includes('generated_by: sneakoscope')) {
-            return {
-                ok: false,
-                status: 'blocked_existing_skill',
-                target_dir: targetDir,
-                reason: 'Existing OpenClaw skill is not marked as generated by Sneakoscope. Re-run with --force to overwrite.'
-            };
-        }
-    }
-    if (options.dryRun) {
-        return { ok: true, status: existing ? 'would_update' : 'would_create', target_dir: targetDir, files: Object.keys(files) };
-    }
-    for (const [name, content] of Object.entries(files)) {
-        await writeTextAtomic(path.join(targetDir, name), content);
-    }
-    return { ok: true, status: existing ? 'updated' : 'created', target_dir: targetDir, files: Object.keys(files) };
-}
-function openClawManifest({ skillName, version }) {
-    return `name: ${skillName}
-version: ${version}
-description: Expose Sneakoscope Codex (sks) workflows to OpenClaw agents.
-author: mandarange
-license: MIT
-generated_by: sneakoscope
-homepage: https://github.com/mandarange/Sneakoscope-Codex
-entrypoint: SKILL.md
-permissions:
-  shell: execute
-  filesystem: read_write_project
-tags:
-  - codex
-  - coding-agent
-  - orchestration
-  - qa
-  - safety
-`;
-}
-function openClawSkillMarkdown({ sksCommand, skillName, version }) {
-    return `---
-name: ${skillName}
-version: ${version}
-description: Use Sneakoscope Codex routes, checks, and release gates from an OpenClaw agent.
----
-
-# Sneakoscope Codex For OpenClaw
-
-## LLM Init Prompt For OpenClaw Agent Builders
-
-\`\`\`text
-Set up this OpenClaw agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-Codex](https://github.com/mandarange/Sneakoscope-Codex)] as the repo reference and [npm i -g sneakoscope] as the recommended global install command, then run \`SKS_OPENCLAW=1 ${sksCommand} root\`, setup/doctor, Codex App, and proof checks for this repo.
-\`\`\`
-
-Use this skill when the user asks an OpenClaw agent to work in a codebase that uses Sneakoscope Codex, SKS, Team, QA-LOOP, TriWiki, Context7, DB safety, Honest Mode, release gates, or \`$...\` prompt routes.
-
-## Required Tool Access
-
-The OpenClaw agent must have the built-in \`shell\` tool enabled. Prefer running commands in the target repository root.
-
-Set \`SKS_OPENCLAW=1\` for SKS shell commands. In OpenClaw mode, SKS treats update/install prompts as automatically approved so \`sks\` can update \`sneakoscope\` or \`@openai/codex\` before launching Zellij without pausing for a human \`Y/n\` answer.
-
-## Core Commands
-
-- \`${sksCommand} root\` checks whether SKS is using a project root or the global runtime root.
-- \`${sksCommand} bootstrap\` installs or repairs SKS project files, Codex App skills, hooks, and runtime state.
-- \`${sksCommand} commands\` lists terminal commands the agent can call.
-- \`${sksCommand} dollar-commands\` lists prompt routes such as \`$Team\`, \`$DFix\`, \`$QA-LOOP\`, \`$PPT\`, \`$Goal\`, \`$DB\`, \`$Wiki\`, and \`$Help\`.
-- \`${sksCommand} deps check\` checks Node/npm path readiness; \`${sksCommand} doctor\` checks Codex, Context7, Zellij, and related local readiness.
-- \`${sksCommand} proof-field scan --intent "<task>" --changed file1,file2\` checks whether a narrow change can stay on a lightweight proof path.
-- \`${sksCommand} release:check\` is not a terminal command; use \`npm run release:check\` inside the Sneakoscope package repository.
-
-## Agent Operating Rules
-
-1. Before substantive work, run \`SKS_OPENCLAW=1 ${sksCommand} root\` and inspect the repository's \`AGENTS.md\` if present.
-2. For implementation, prefer the repository's requested SKS route. General code work and broad implementation normally route to \`$Team\`; Direct Fix work, meaning tiny copy/config/docs/labels/spacing/translation/simple mechanical edits, can use \`$DFix\`; UI design specifics follow the repo's UI/design route rules; web UI/browser dogfood uses \`$QA-LOOP\` with the Codex Chrome Extension gate first; native Mac/non-web visual work uses \`$Computer-Use\`; database or Supabase work uses \`$DB\`.
-3. Do not invent fallback implementation code when the requested SKS path is blocked. Report the blocker with command output and source paths.
-4. For database, migration, and Supabase tasks, default to read-only inspection unless the user explicitly authorizes a write/migration scope.
-5. Before claiming completion, run the most relevant verification command and summarize what passed, what was not verified, and any remaining blocker.
-
-## Example Prompts For An OpenClaw Agent
-
-- "In this repo, run \`${sksCommand} root\`, inspect \`AGENTS.md\`, then use the SKS Team route to implement the bug fix and verify it."
-- "Use SKS QA-LOOP against localhost:3000. Do not run destructive tests."
-- "Prepare this project for Codex App use: run \`${sksCommand} bootstrap\`, \`${sksCommand} codex-app check\`, and \`${sksCommand} dollar-commands\`."
-`;
-}
-function openClawSkillReadme({ sksCommand, skillName, version }) {
-    return `# ${skillName}
-
-Version: ${version}
-
-This OpenClaw skill lets an OpenClaw agent discover and use Sneakoscope Codex through the local \`${sksCommand}\` command.
-
-OpenClaw agents should set \`SKS_OPENCLAW=1\` when running SKS commands. That mode auto-approves SKS dependency/update prompts, including the Codex CLI update preflight before Zellij launch.
-
-## LLM Init Prompt
-
-\`\`\`text
-Set up this OpenClaw agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-Codex](https://github.com/mandarange/Sneakoscope-Codex)] as the repo reference and [npm i -g sneakoscope] as the recommended global install command, then run \`SKS_OPENCLAW=1 ${sksCommand} root\`, setup/doctor, Codex App, and proof checks for this repo.
-\`\`\`
-
-## Install
-
-\`\`\`sh
-${sksCommand} openclaw install
-\`\`\`
-
-Then attach the skill to an OpenClaw agent:
-
-\`\`\`yaml
-agents:
-  coding-agent:
-    tools:
-      - shell
-    skills:
-      - ${skillName}
-\`\`\`
-
-## Verify
-
-\`\`\`sh
-openclaw skill run ${skillName} --help
-${sksCommand} root
-${sksCommand} commands
-\`\`\`
-
-If OpenClaw runs skills in a sandbox, allow shell execution for this skill and run it from the target repository root so SKS can find \`.git\`, \`.sneakoscope\`, or \`.dcodex\`.
-`;
-}
-function openClawAgentConfigExample({ skillName }) {
-    return `agents:
-  coding-agent:
-    model: openai/gpt-4o
-    channels:
-      - terminal
-    tools:
-      - shell
-    env:
-      SKS_OPENCLAW: "1"
-    skills:
-      - ${skillName}
-`;
-}
-//# sourceMappingURL=openclaw.js.map