sneakoscope 0.7.25 → 0.7.26

package/README.md

@@ -45,6 +45,7 @@ sks selftest --mock
 | --- | --- |
 | CLI runtime | `sks tmux open` and `sks --mad` explicitly launch Codex CLI with tmux; bare `sks` only prints help/readiness surfaces. |
 | Codex App commands | Installs generated skills so `$Team`, `$From-Chat-IMG`, `$DFix`, `$QA-LOOP`, `$PPT`, `$Goal`, `$DB`, `$Wiki`, `$Help`, and related routes are visible in prompt workflows. |
+| OpenClaw agents | Generates an OpenClaw skill package so OpenClaw agents can attach `sneakoscope-codex`, enable the `shell` tool, and discover/use SKS commands from the target repo root. |
 | Pipeline plans | Writes `pipeline-plan.json` for stateful routes so the runtime lane, kept stages, skipped stages, verification commands, and no-unrequested-fallback invariant are visible with `sks pipeline plan`. |
 | Team orchestration | Runs substantial work through score-based ambiguity handling, scouts, TriWiki refresh, debate, runtime task graphs, worker inboxes, implementation, review, cleanup, reflection, and Honest Mode; narrow work should use Proof Field evidence to skip unrelated pipeline work instead of expanding Team. |
 | Skill dreaming | Records cheap generated-skill usage counters in JSON and only periodically scans `.agents/skills` for keep, merge, prune, and improvement candidates. Reports are recommendation-only and never delete skills automatically. |
@@ -301,6 +302,57 @@ Use `sks dollar-commands` to confirm that terminal discovery and Codex App promp
 
 TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim into future prompts. `sks harness fixture` validates the broader Harness Growth Factory contract: deliberate forgetting fixtures, skill card metadata, experiment schema, tool-error taxonomy, permission profiles, MultiAgentV2 defaults, and tmux cockpit view coverage. `sks code-structure scan` flags handwritten files above 1000/2000/3000-line thresholds so new logic can be extracted before command files become harder to maintain.
 
+## OpenClaw Agent Usage
+
+Sneakoscope can generate an OpenClaw skill package for agents that need to operate SKS-enabled repositories.
+
+```sh
+sks openclaw install
+sks openclaw path
+```
+
+By default this writes:
+
+```text
+~/.openclaw/skills/sneakoscope-codex/
+```
+
+The generated skill contains `manifest.yaml`, `SKILL.md`, a skill README, and `openclaw-agent-config.example.yaml`. If you use a custom OpenClaw home, set `OPENCLAW_HOME` or pass `--dir`:
+
+```sh
+OPENCLAW_HOME=/opt/openclaw sks openclaw install
+sks openclaw install --dir /opt/openclaw/skills/sneakoscope-codex
+```
+
+Attach the skill to an OpenClaw agent with the built-in `shell` tool enabled:
+
+```yaml
+agents:
+  coding-agent:
+    tools:
+      - shell
+    skills:
+      - sneakoscope-codex
+```
+
+Then prompt the OpenClaw agent from the target repo root:
+
+```text
+Run sks root, inspect AGENTS.md, then use the SKS Team route to implement this fix and verify it.
+```
+
+Useful commands for OpenClaw agents:
+
+```sh
+sks root
+sks commands
+sks dollar-commands
+sks deps check
+sks proof-field scan --intent "small CLI change" --changed src/cli/main.mjs
+```
+
+If OpenClaw runs the skill inside a sandbox, grant shell execution only for the trusted local workspace. Database, Supabase, migration, and destructive filesystem work should still follow the repo's SKS safety route and require explicit write scope.
+
 ## Prompt `$` Commands
 
 Use these inside Codex App or another agent prompt. They are prompt commands, not terminal commands.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.25",
+  "version": "0.7.26",
   "description": "Sneakoscope Codex: database-safe Codex CLI/App harness with Team, Goal, AutoResearch, TriWiki, and Honest Mode.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -48,6 +48,8 @@
     "sks",
     "openai",
     "openai-codex",
+    "openclaw",
+    "openclaw-skill",
     "cli",
     "developer-tools",
     "ai-coding",

package/src/cli/main.mjs

@@ -56,11 +56,13 @@ import { buildPromptContext } from '../core/prompt-context-builder.mjs';
 import { renderTeamDashboardState, writeTeamDashboardState } from '../core/team-dashboard-renderer.mjs';
 import { GOAL_WORKFLOW_ARTIFACT } from '../core/goal-workflow.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
+import { OPENCLAW_SKILL_NAME, installOpenClawSkill } from '../core/openclaw.mjs';
 import { buildTmuxLaunchPlan, buildTmuxOpenArgs, createTmuxSession, isTmuxShellSession, runTmuxLaunchPlanSyntaxCheck, tmuxReadiness, tmuxStatusKind, defaultTmuxSessionName, formatTmuxBanner, launchTmuxTeamView, launchTmuxUi, platformTmuxInstallHint, runTmuxStatus, sanitizeTmuxSessionName, teamLaneStyle } from '../core/tmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
 import { context7Command } from './context7-command.mjs';
 import { askPostinstallQuestion, checkContext7, checkRequiredSkills, ensureCodexCliTool, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureRelatedCliTools, ensureSksCommandDuringInstall, globalCodexSkillsRoot, postinstall, postinstallBootstrapDecision } from './install-helpers.mjs';
 import { buildTeamPlan, codeStructureCommand, dbCommand, defaultBeta, defaultVGraph, evalCommand, gcCommand, goalCommand, gxCommand, harnessCommand, hproofCommand, memoryCommand, migrateWikiContextPack, parseTeamCreateArgs, perfCommand, profileCommand, projectWikiClaims, proofFieldCommand, qaLoopCommand, quickstartCommand, researchCommand, skillDreamCommand, statsCommand, team, teamWorkflowMarkdown, validateArtifactsCommand, wikiCommand, wikiVoxelRowCount, writeWikiContextPack } from './maintenance-commands.mjs';
+import { openClawCommand } from './openclaw-command.mjs';
 
 const flag = (args, name) => args.includes(name);
 const promptOf = (args) => args.filter((x) => !String(x).startsWith('--')).join(' ').trim();
@@ -88,7 +90,7 @@ export async function main(args) {
   if (cmd === 'dollar-commands' || cmd === 'dollars' || cmd === '$') return dollarCommands(tail);
   if (String(cmd).toLowerCase() === 'dfix') return dfixHelp();
   const handlers = {
-    postinstall: () => postinstall({ bootstrap }), wizard: () => wizard(tail), ui: () => wizard(tail), 'update-check': () => updateCheck(tail), help: () => help(tail), commands: () => commands(tail), usage: () => usage(tail), root: () => rootCommand(tail), quickstart: () => quickstartCommand(), 'codex-app': () => codexAppHelp(tail), bootstrap: () => bootstrap(tail), deps: () => deps(sub, rest),
+    postinstall: () => postinstall({ bootstrap }), wizard: () => wizard(tail), ui: () => wizard(tail), 'update-check': () => updateCheck(tail), help: () => help(tail), commands: () => commands(tail), usage: () => usage(tail), root: () => rootCommand(tail), quickstart: () => quickstartCommand(), 'codex-app': () => codexAppHelp(tail), openclaw: () => openClawCommand(tail), bootstrap: () => bootstrap(tail), deps: () => deps(sub, rest),
     'qa-loop': () => qaLoopCommand(sub, rest), ppt: () => pptCommand(sub, rest), context7: () => context7Command(sub, rest), pipeline: () => pipeline(sub, rest), guard: () => guard(sub, rest), conflicts: () => conflicts(sub, rest), versioning: () => versioning(sub, rest), reasoning: () => reasoningCommand(tail), aliases: () => aliases(), setup: () => setup(tail), 'fix-path': () => fixPath(tail), doctor: () => doctor(tail), init: () => init(tail), selftest: () => selftest(tail),
     goal: () => goalCommand(sub, rest), research: () => researchCommand(sub, rest), hook: () => emitHook(sub), profile: () => profileCommand(sub, rest), hproof: () => hproofCommand(sub, rest), 'validate-artifacts': () => validateArtifactsCommand(tail), perf: () => perfCommand(sub, rest), 'proof-field': () => proofFieldCommand(sub, rest), 'skill-dream': () => skillDreamCommand(sub, rest), 'code-structure': () => codeStructureCommand(sub, rest), memory: () => memoryCommand(sub, rest), gx: () => gxCommand(sub, rest),
     team: () => team(tail), db: () => dbCommand(sub, rest), eval: () => evalCommand(sub, rest), harness: () => harnessCommand(sub, rest), wiki: () => wikiCommand(sub, rest), gc: () => gcCommand(tail), stats: () => statsCommand(tail)
@@ -116,6 +118,7 @@ Usage:
   sks bootstrap [--install-scope global|project] [--local-only] [--json]
   sks deps check|install [tmux|codex|context7|all] [--yes] [--json]
   sks codex-app
+  sks openclaw install|path|print [--dir path] [--force] [--json]
   sks --mad [--high]
   sks auto-review status|enable|start [--high]
   sks --Auto-review [--high]
@@ -1192,6 +1195,7 @@ function usage(args = []) {
     root: ['Root', '', '  sks root [--json]', '', 'Inside a project, SKS uses that project root. Outside any project marker, runtime commands use the per-user global SKS root instead of writing .sneakoscope into the current random folder.'],
     deps: ['Dependencies', '', '  sks deps check [--json]', '  sks deps install [tmux|codex|context7|all] [--yes]', '', 'tmux on macOS uses Homebrew only after approval.'],
     tmux: ['tmux', '', '  sks tmux open', '  sks tmux check', '  sks tmux status --once', '  sks deps install tmux', '', 'tmux launch is explicit. Running bare `sks` prints help and never opens tmux by itself.'],
+    openclaw: ['OpenClaw', '', '  sks openclaw install', '  sks openclaw path', '  sks openclaw print SKILL.md', '', 'Installs an OpenClaw skill package under ~/.openclaw/skills/sneakoscope-codex so OpenClaw agents can attach skills: [sneakoscope-codex] with the shell tool and call local SKS commands from a project root.'],
     team: ['Team', '', '  sks team "task" executor:5 reviewer:2 user:1', '  sks team watch latest', '  sks team lane latest --agent analysis_scout_1 --follow', '  sks team message latest --from analysis_scout_1 --to executor_1 --message "handoff note"', '  sks team cleanup-tmux latest', '', '$Team runs questions -> contract -> scouts -> TriWiki attention -> debate -> runtime graph/inbox -> fresh executors -> review -> cleanup -> reflection -> Honest.'],
     'qa-loop': ['QA-LOOP', '', '  sks qa-loop prepare "QA this app"', '  sks qa-loop answer <MISSION_ID> answers.json', '  sks qa-loop run <MISSION_ID> --max-cycles 8', '', 'Report: YYYY-MM-DD-v<version>-qa-report.md'],
     ppt: ['PPT', '', '  $PPT 투자자용 피치덱을 HTML 기반 PDF로 만들어줘', '  $PPT 우리 SaaS 소개자료 만들어줘', '  sks ppt build latest --json', '  sks ppt status latest --json', '', '$PPT asks delivery context, audience profile, STP strategy, decision context, and 3+ pain-point/solution/aha mappings before source research, design-system work, HTML/PDF export, and render QA. Independent strategy/render/file-write phases run in parallel where inputs allow and are recorded in ppt-parallel-report.json. The visual system must stay simple, restrained, and information-first; editable source HTML is kept under source-html/, PPT-only temporary build files are cleaned, and installed skills/MCPs outside the $PPT allowlist are ignored. Design uses getdesign-reference plus the built-in PPT design pipeline; imagegen and Context7 are conditional only when the sealed PPT contract needs raster assets or current external docs.'],
@@ -1653,7 +1657,7 @@ function readMaxCycles(args, fallback) {
 
 function positionalArgs(args = []) {
   const out = [];
-  const valueFlags = new Set(['--format', '--iterations', '--out', '--baseline', '--candidate', '--install-scope', '--max-cycles', '--depth', '--scope', '--transport', '--query', '--topic', '--tokens', '--timeout-ms', '--sql', '--command', '--project-ref', '--agent', '--phase', '--message', '--role', '--max-anchors', '--lines']);
+  const valueFlags = new Set(['--format', '--iterations', '--out', '--baseline', '--candidate', '--install-scope', '--max-cycles', '--depth', '--scope', '--transport', '--query', '--topic', '--tokens', '--timeout-ms', '--sql', '--command', '--project-ref', '--agent', '--phase', '--message', '--role', '--max-anchors', '--lines', '--dir']);
   for (let i = 0; i < args.length; i++) {
     const arg = String(args[i]);
     if (valueFlags.has(arg)) {
@@ -2062,7 +2066,16 @@ async function selftest() {
   if (!DOLLAR_DEFAULT_PIPELINE_TEXT.includes('$Team')) throw new Error('selftest failed: dollar-commands missing Team default routing guidance');
   if (!DOLLAR_DEFAULT_PIPELINE_TEXT.includes('$From-Chat-IMG')) throw new Error('selftest failed: dollar-commands missing From-Chat-IMG guidance');
   if (!DOLLAR_DEFAULT_PIPELINE_TEXT.includes('$MAD-SKS')) throw new Error('selftest failed: dollar-commands missing MAD-SKS scoped override guidance');
-  if (!COMMAND_CATALOG.some((c) => c.name === 'context7') || !COMMAND_CATALOG.some((c) => c.name === 'pipeline') || !COMMAND_CATALOG.some((c) => c.name === 'qa-loop') || !COMMAND_CATALOG.some((c) => c.name === 'root')) throw new Error('selftest failed: context7/pipeline/qa-loop/root commands missing from catalog');
+  if (!COMMAND_CATALOG.some((c) => c.name === 'context7') || !COMMAND_CATALOG.some((c) => c.name === 'pipeline') || !COMMAND_CATALOG.some((c) => c.name === 'qa-loop') || !COMMAND_CATALOG.some((c) => c.name === 'root') || !COMMAND_CATALOG.some((c) => c.name === 'openclaw')) throw new Error('selftest failed: context7/pipeline/qa-loop/root/openclaw commands missing from catalog');
+  const openClawTmp = tmpdir();
+  const openClawResult = await installOpenClawSkill({ targetDir: path.join(openClawTmp, 'skills', OPENCLAW_SKILL_NAME) });
+  if (!openClawResult.ok) throw new Error(`selftest failed: OpenClaw skill install blocked: ${openClawResult.reason}`);
+  const openClawSkillText = await safeReadText(path.join(openClawResult.target_dir, 'SKILL.md'));
+  const openClawManifestText = await safeReadText(path.join(openClawResult.target_dir, 'manifest.yaml'));
+  const openClawConfigText = await safeReadText(path.join(openClawResult.target_dir, 'openclaw-agent-config.example.yaml'));
+  if (!openClawSkillText.includes('sks root') || !openClawSkillText.includes('$Team') || !openClawSkillText.includes('OpenClaw agent must have the built-in `shell` tool enabled')) throw new Error('selftest failed: OpenClaw skill missing SKS agent guidance');
+  if (!openClawManifestText.includes('generated_by: sneakoscope') || !openClawManifestText.includes(`version: ${PACKAGE_VERSION}`)) throw new Error('selftest failed: OpenClaw manifest missing generated marker or version');
+  if (!openClawConfigText.includes(`- ${OPENCLAW_SKILL_NAME}`) || !openClawConfigText.includes('- shell')) throw new Error('selftest failed: OpenClaw agent config example missing skill or shell tool');
   const registryDollarCommands = DOLLAR_COMMANDS.map((c) => c.command);
   const manifest = await readJson(path.join(tmp, '.sneakoscope', 'manifest.json'));
   const policy = await readJson(path.join(tmp, '.sneakoscope', 'policy.json'));

package/src/cli/openclaw-command.mjs

@@ -0,0 +1,83 @@
+import path from 'node:path';
+import { OPENCLAW_SKILL_NAME, buildOpenClawSkillFiles, defaultOpenClawSkillDir, installOpenClawSkill } from '../core/openclaw.mjs';
+
+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 file = positionalArgs(args.slice(1))[0] || 'SKILL.md';
+    const files = buildOpenClawSkillFiles();
+    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}
+`);
+}

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.7.25';
+export const PACKAGE_VERSION = '0.7.26';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/openclaw.mjs

@@ -0,0 +1,161 @@
+import path from 'node:path';
+import os from 'node:os';
+import { exists, readText, writeTextAtomic, PACKAGE_VERSION } from './fsx.mjs';
+
+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
+
+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.
+
+## 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 Codex, Context7, tmux, 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 \`${sksCommand} root\` and inspect the repository's \`AGENTS.md\` if present.
+2. For implementation, prefer the repository's requested SKS route. General code work normally routes to \`$Team\`; tiny design or copy edits can use \`$DFix\`; UI/browser dogfood uses \`$QA-LOOP\`; 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.
+
+## 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
+    skills:
+      - ${skillName}
+`;
+}

package/src/core/routes.mjs

@@ -7,7 +7,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|tmux|auto-review|team|qa-loop|ppt|goal|research|db|codex-app|dfix|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|code-structure|proof-field|skill-dream';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|tmux|auto-review|team|qa-loop|ppt|goal|research|db|codex-app|openclaw|dfix|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|code-structure|proof-field|skill-dream';
 export const CODEX_COMPUTER_USE_EVIDENCE_SOURCE = 'codex_computer_use';
 export const CODEX_APP_IMAGE_GENERATION_DOC_URL = 'https://developers.openai.com/codex/app/features#image-generation';
 export const CODEX_COMPUTER_USE_ONLY_POLICY = 'Pipeline UI/browser verification and visual inspection must use Codex Computer Use only. Do not use Playwright, Chrome MCP, Browser Use, Selenium, Puppeteer, or any other browser automation substitute; if Codex Computer Use is unavailable, mark the UI/browser evidence unverified instead of substituting another tool.';
@@ -456,6 +456,7 @@ export const COMMAND_CATALOG = [
   { name: 'root', usage: 'sks root [--json]', description: 'Show whether SKS is using a project root or the per-user global SKS runtime root.' },
   { name: 'deps', usage: 'sks deps check|install [tmux|codex|context7|all] [--yes]', description: 'Check or guided-install Node/npm PATH, Codex CLI/App, Context7, Browser Use, Computer Use, tmux, and Homebrew on macOS.' },
   { name: 'codex-app', usage: 'sks codex-app [check|open]', description: 'Check Codex App install and first-party MCP/plugin readiness, then show app setup files and examples.' },
+  { name: 'openclaw', usage: 'sks openclaw install|path|print [--dir path] [--force] [--json]', description: 'Generate an OpenClaw skill package so OpenClaw agents can discover and use local SKS workflows.' },
   { name: 'tmux', usage: 'sks tmux open|check|status [--workspace name]', description: 'Explicitly open the SKS tmux runtime, or check/status without launching tmux.' },
   { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot tmux Codex CLI workspace with the SKS MAD full-access auto-review profile.' },
   { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS tmux with the auto-review profile.' },