sneakoscope 0.7.24 → 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. |
@@ -95,7 +96,7 @@ sks bootstrap
 
 `sks` commands work even when no project root is present. Project-aware commands use the nearest `.sneakoscope`, `.dcodex`, or `.git` root; if none exists, SKS uses a per-user global runtime root. `sks bootstrap` still initializes the current project when you want project-local hooks, skills, and TriWiki state.
 
-Project setup writes shared `.gitignore` entries for generated SKS files: `.sneakoscope/`, `.codex/`, `.agents/`, and managed `AGENTS.md`. Use `sks setup --local-only` when you want those excludes kept only in `.git/info/exclude`.
+Project setup writes shared `.gitignore` entries for generated SKS files: `.sneakoscope/`, `.codex/`, `.agents/`, and managed `AGENTS.md`. Setup, doctor repair, and npm postinstall refreshes also compare the previous SKS generated-file manifest with the current package templates and prune stale SKS-generated legacy skills or agent files while preserving user-owned custom skills. Use `sks setup --local-only` when you want those excludes kept only in `.git/info/exclude`.
 
 During npm postinstall, SKS also installs generated Codex App skills and tries the official getdesign Codex skill command, `skills add MohtashamMurshid/getdesign`, when the `skills` CLI is available. If that CLI is missing, setup still installs the generated `getdesign-reference` skill. Design work still flows through one authority: `design.md`. When `design.md` is missing, `docs/Design-Sys-Prompt.md` is the builder prompt and getdesign plus curated DESIGN.md examples such as [VoltAgent/awesome-design-md](https://github.com/VoltAgent/awesome-design-md) are inputs to fuse into that SSOT or into route-local `$PPT` style tokens.
 
@@ -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.24",
+  "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/install-helpers.mjs

@@ -186,7 +186,14 @@ export async function ensureGlobalCodexSkillsDuringInstall(opts = {}) {
   try {
     const install = await installSkills(home);
     const skills = await checkRequiredSkills(home, root);
-    return { status: skills.ok ? 'installed' : 'partial', root, installed_count: install.installed_skills.length, removed_aliases: install.removed_agent_skill_aliases, missing_skills: skills.missing };
+    return {
+      status: skills.ok ? 'installed' : 'partial',
+      root,
+      installed_count: install.installed_skills.length,
+      removed_aliases: install.removed_agent_skill_aliases,
+      removed_stale_generated_skills: install.removed_stale_generated_skills,
+      missing_skills: skills.missing
+    };
   } catch (err) {
     return { status: 'failed', root, error: err.message };
   }

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.'],
@@ -1396,11 +1400,12 @@ async function doctor(args) {
   let conflictScan = await scanHarnessConflicts(root);
   let repairApplied = false;
   let globalSkillsRepair = null;
+  let projectRepair = null;
   const globalCommand = await globalSksCommand();
   if (flag(args, '--fix') && !conflictScan.hard_block) {
     const existingManifest = await readJson(path.join(root, '.sneakoscope', 'manifest.json'), null);
     const fixScope = requestedScope || normalizeInstallScope(existingManifest?.installation?.scope || 'global');
-    await initProject(root, { installScope: fixScope, globalCommand, localOnly: flag(args, '--local-only') || Boolean(existingManifest?.git?.local_only), force: true, repair: true });
+    projectRepair = await initProject(root, { installScope: fixScope, globalCommand, localOnly: flag(args, '--local-only') || Boolean(existingManifest?.git?.local_only), force: true, repair: true });
     if (!flag(args, '--local-only')) globalSkillsRepair = await ensureGlobalCodexSkillsDuringInstall({ force: true });
     repairApplied = true;
     conflictScan = await scanHarnessConflicts(root);
@@ -1427,7 +1432,7 @@ async function doctor(args) {
   const result = {
     node: { ok: nodeOk, version: process.version }, root, codex, rust,
     install,
-    repair: { applied: repairApplied, global_skills: globalSkillsRepair, blocked_by_other_harness: flag(args, '--fix') && conflictScan.hard_block },
+    repair: { applied: repairApplied, project: projectRepair, global_skills: globalSkillsRepair, blocked_by_other_harness: flag(args, '--fix') && conflictScan.hard_block },
     harness_conflicts: {
       ok: conflictScan.ok,
       hard_block: conflictScan.hard_block,
@@ -1652,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)) {
@@ -1743,6 +1748,26 @@ async function selftest() {
   await initProject(repairTmp, { installScope: 'project', localOnly: true });
   await writeTextAtomic(path.join(repairTmp, '.agents', 'skills', 'team', 'SKILL.md'), 'tampered\n');
   await writeTextAtomic(path.join(repairTmp, '.agents', 'skills', 'agent-team', 'SKILL.md'), '---\nname: agent-team\ndescription: Fallback Codex App picker alias for $Team.\n---\n');
+  await ensureDir(path.join(repairTmp, '.agents', 'skills', 'stale-sks-generated'));
+  await writeTextAtomic(path.join(repairTmp, '.agents', 'skills', 'stale-sks-generated', 'SKILL.md'), '---\nname: stale-sks-generated\ndescription: Old SKS generated skill that should disappear on update.\n---\n');
+  await writeJsonAtomic(path.join(repairTmp, '.agents', 'skills', '.sks-generated.json'), {
+    schema_version: 1,
+    generated_by: 'sneakoscope',
+    version: '0.0.1',
+    skills: ['team', 'stale-sks-generated'],
+    files: ['.agents/skills/team/SKILL.md', '.agents/skills/stale-sks-generated/SKILL.md']
+  });
+  const staleCodexAgentRel = '.codex/agents/stale-generated.toml';
+  await writeTextAtomic(path.join(repairTmp, staleCodexAgentRel), 'name = "stale_generated"\n');
+  const staleManifest = await readJson(path.join(repairTmp, '.sneakoscope', 'manifest.json'));
+  staleManifest.version = '0.0.1';
+  staleManifest.generated_files = {
+    schema_version: 1,
+    generated_by: 'sneakoscope',
+    prune_policy: 'remove_previous_sks_generated_paths_absent_from_current_manifest',
+    files: [...(staleManifest.generated_files?.files || []), '.agents/skills/stale-sks-generated/SKILL.md', staleCodexAgentRel]
+  };
+  await writeJsonAtomic(path.join(repairTmp, '.sneakoscope', 'manifest.json'), staleManifest);
   await ensureDir(path.join(repairTmp, '.agents', 'skills', 'custom-keep'));
   await writeTextAtomic(path.join(repairTmp, '.agents', 'skills', 'custom-keep', 'SKILL.md'), '---\nname: custom-keep\ndescription: User custom skill, not generated by SKS.\n---\n');
   await writeTextAtomic(path.join(repairTmp, '.codex', 'skills', 'team', 'SKILL.md'), 'legacy mirror\n');
@@ -1765,6 +1790,11 @@ async function selftest() {
   const repairedTeamSkill = await safeReadText(path.join(repairTmp, '.agents', 'skills', 'team', 'SKILL.md'));
   if (!repairedTeamSkill.includes('SKS Team orchestration') || repairedTeamSkill.includes('tampered')) throw new Error('selftest failed: doctor repair did not regenerate team skill');
   if (await exists(path.join(repairTmp, '.agents', 'skills', 'agent-team', 'SKILL.md'))) throw new Error('selftest failed: doctor repair did not remove deprecated agent-team alias skill');
+  if (await exists(path.join(repairTmp, '.agents', 'skills', 'stale-sks-generated', 'SKILL.md'))) throw new Error('selftest failed: doctor repair did not prune stale generated skill from previous SKS manifest');
+  if (await exists(path.join(repairTmp, staleCodexAgentRel))) throw new Error('selftest failed: doctor repair did not prune stale generated agent file from previous SKS manifest');
+  if (!doctorRepairJson.repair?.project?.skill_install?.removed_stale_generated_skills?.includes('.agents/skills/stale-sks-generated')) throw new Error('selftest failed: doctor repair did not report stale generated skill pruning');
+  const generatedCleanupReport = doctorRepairJson.repair?.project?.generated_cleanup || {};
+  if (![...(generatedCleanupReport.pruned || []), ...(generatedCleanupReport.already_absent || [])].includes(staleCodexAgentRel)) throw new Error('selftest failed: doctor repair did not report stale generated file pruning');
   if (!(await exists(path.join(repairTmp, '.agents', 'skills', 'custom-keep', 'SKILL.md')))) throw new Error('selftest failed: doctor repair removed a user-owned custom skill');
   if (await exists(path.join(repairTmp, '.codex', 'skills', 'team', 'SKILL.md'))) throw new Error('selftest failed: doctor repair did not remove legacy .codex/skills');
   const repairedQuickReference = await safeReadText(path.join(repairTmp, '.codex', 'SNEAKOSCOPE.md'));
@@ -2036,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.24';
+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/init.mjs

@@ -11,6 +11,8 @@ import { SKILL_DREAM_POLICY, skillDreamPolicyText } from './skill-forge.mjs';
 
 const REFLECTION_MEMORY_PATH = '.sneakoscope/memory/q2_facts/post-route-reflection.md';
 const SKS_GENERATED_GIT_PATTERNS = ['.sneakoscope/', '.codex/', '.agents/', 'AGENTS.md'];
+const SKS_SKILL_MANIFEST_FILE = '.sks-generated.json';
+const GENERATED_PRUNE_POLICY = 'remove_previous_sks_generated_paths_absent_from_current_manifest';
 
 function reflectionInstructionText(commandPrefix = 'sks') {
   return `Post-route reflection: full routes load \`reflection\` after work/tests and before final; DFix/Answer/Help/Wiki/SKS discovery are exempt. Write reflection.md; record only real misses/gaps, or no_issue_acknowledged. For lessons, append TriWiki claim rows to ${REFLECTION_MEMORY_PATH}. Run "${commandPrefix} wiki refresh" or pack, validate, then pass reflection-gate.json.`;
@@ -101,6 +103,8 @@ export async function initProject(root, opts = {}) {
   const requestedHookCommandPrefix = opts.hookCommandPrefix || sksCommandPrefix(installScope, { globalCommand: opts.globalCommand });
   const hookCommandPrefix = sourceProject ? 'node ./bin/sks.mjs' : requestedHookCommandPrefix;
   const sine = path.join(root, '.sneakoscope');
+  const manifestPath = path.join(sine, 'manifest.json');
+  const previousManifest = await readJson(manifestPath, null);
   if (opts.repair) {
     const repair = await repairSksGeneratedArtifacts(root, { resetState: Boolean(opts.resetState) });
     if (repair.removed.length) created.push(`repaired generated SKS files (${repair.removed.length})`);
@@ -114,7 +118,7 @@ export async function initProject(root, opts = {}) {
   if (localExclude?.path) created.push(`${path.relative(root, localExclude.path)} local-only excludes`);
   if (sharedIgnore?.changed) created.push(`${path.relative(root, sharedIgnore.path)} SKS generated files ignore`);
 
-  await writeJsonAtomic(path.join(sine, 'manifest.json'), {
+  const manifest = {
     package: 'sneakoscope',
     version: PACKAGE_VERSION,
     initialized_at: nowIso(),
@@ -197,7 +201,8 @@ export async function initProject(root, opts = {}) {
     },
     database_safety: 'destructive_db_operations_denied_always',
     gx_renderer: 'deterministic_svg_html'
-  });
+  };
+  await writeJsonAtomic(manifestPath, manifest);
   created.push('.sneakoscope/manifest.json');
 
   const dbSafetyPath = path.join(sine, 'db-safety.json');
@@ -467,16 +472,36 @@ policy = "Deny destructive database operations, credential exfiltration, persist
 
   const skillInstall = await installSkills(root);
   created.push('.agents/skills/*');
+  if (skillInstall.removed_stale_generated_skills.length) created.push(`stale generated skills removed (${skillInstall.removed_stale_generated_skills.length})`);
+  if (skillInstall.removed_agent_skill_aliases.length) created.push(`deprecated generated skill aliases removed (${skillInstall.removed_agent_skill_aliases.length})`);
   if (skillInstall.removed_codex_skill_mirrors.length) created.push(`.codex/skills generated mirrors removed (${skillInstall.removed_codex_skill_mirrors.length})`);
-  await installCodexAgents(root);
+  const agentInstall = await installCodexAgents(root);
   created.push('.codex/agents/*');
+  const generatedFiles = currentGeneratedFileInventory(skillInstall, agentInstall);
+  const generatedCleanup = await pruneStaleGeneratedFiles(root, previousManifest, generatedFiles);
+  if (generatedCleanup.pruned.length) created.push(`stale generated files pruned (${generatedCleanup.pruned.length})`);
+  manifest.generated_files = {
+    schema_version: 1,
+    generated_by: 'sneakoscope',
+    prune_policy: GENERATED_PRUNE_POLICY,
+    files: generatedFiles
+  };
+  manifest.generated_cleanup = {
+    schema_version: 1,
+    last_run_at: nowIso(),
+    previous_version: previousManifest?.version || null,
+    current_version: PACKAGE_VERSION,
+    pruned: generatedCleanup.pruned,
+    already_absent: generatedCleanup.already_absent || []
+  };
+  await writeJsonAtomic(manifestPath, manifest);
   await writeHarnessGuardPolicy(root);
   created.push('.sneakoscope/harness-guard.json');
   const versionHookCommand = sourceProject ? 'node ./bin/sks.mjs' : hookCommandPrefix;
   const versionHook = await installVersionGitHook(root, versionHookCommand);
   if (versionHook.installed) created.push('.git/hooks/pre-commit SKS version guard');
   else created.push(`version guard skipped (${versionHook.reason})`);
-  return { created };
+  return { created, generated_cleanup: generatedCleanup, skill_install: skillInstall };
 }
 
 async function ensureSharedGitIgnore(root) {
@@ -601,13 +626,57 @@ export async function installSkills(root) {
     await writeSkillMetadata(dir, name);
   }
   const skillNames = Object.keys(skills);
+  const removedStaleGeneratedSkills = await removeStaleGeneratedSkillsFromManifest(root, skillNames);
+  await writeGeneratedSkillManifest(root, skillNames);
   return {
     installed_skills: skillNames,
+    generated_files: generatedSkillFiles(skillNames),
+    removed_stale_generated_skills: removedStaleGeneratedSkills,
     removed_agent_skill_aliases: await removeGeneratedAgentSkillAliases(root, skillNames),
     removed_codex_skill_mirrors: await removeGeneratedCodexSkillMirrors(root, skillNames)
   };
 }
 
+function generatedSkillFiles(skillNames) {
+  return skillNames.flatMap((name) => [
+    `.agents/skills/${name}/SKILL.md`,
+    `.agents/skills/${name}/agents/openai.yaml`
+  ]).sort();
+}
+
+function generatedSkillManifestPath(root) {
+  return path.join(root, '.agents', 'skills', SKS_SKILL_MANIFEST_FILE);
+}
+
+async function writeGeneratedSkillManifest(root, skillNames) {
+  const manifestPath = generatedSkillManifestPath(root);
+  await writeJsonAtomic(manifestPath, {
+    schema_version: 1,
+    generated_by: 'sneakoscope',
+    version: PACKAGE_VERSION,
+    prune_policy: GENERATED_PRUNE_POLICY,
+    skills: [...skillNames].sort(),
+    files: generatedSkillFiles(skillNames)
+  });
+}
+
+async function removeStaleGeneratedSkillsFromManifest(root, skillNames) {
+  const previous = await readJson(generatedSkillManifestPath(root), null);
+  const previousSkills = Array.isArray(previous?.skills) ? previous.skills : [];
+  if (!previousSkills.length) return [];
+  const current = new Set(skillNames);
+  const removed = [];
+  for (const name of previousSkills) {
+    const skillName = String(name || '').trim();
+    if (!skillName || current.has(skillName) || !/^[a-z0-9-]+$/.test(skillName)) continue;
+    const dir = path.join(root, '.agents', 'skills', skillName);
+    if (!(await exists(dir))) continue;
+    await fsp.rm(dir, { recursive: true, force: true });
+    removed.push(path.relative(root, dir));
+  }
+  return removed.sort();
+}
+
 function enrichSkillContent(name, content) {
   if (!['sks', 'answer', 'wiki', 'team', 'qa-loop', 'ppt', 'computer-use', 'computer-use-fast', 'cu', 'goal', 'research', 'autoresearch', 'db', 'gx', 'reflection', 'prompt-pipeline', 'pipeline-runner', 'context7-docs', 'turbo-context-pack', 'hproof-evidence-bind'].includes(name)) return content;
   const text = String(content || '').trimEnd();
@@ -704,4 +773,89 @@ async function installCodexAgents(root) {
   for (const [file, content] of Object.entries(agents)) {
     await writeTextAtomic(path.join(dir, file), content);
   }
+  return {
+    installed_agents: Object.keys(agents),
+    generated_files: Object.keys(agents).map((file) => `.codex/agents/${file}`).sort()
+  };
+}
+
+function currentGeneratedFileInventory(skillInstall = {}, agentInstall = {}) {
+  return Array.from(new Set([
+    '.codex/config.toml',
+    '.codex/SNEAKOSCOPE.md',
+    '.codex/hooks.json',
+    '.sneakoscope/harness-guard.json',
+    '.sneakoscope/db-safety.json',
+    '.sneakoscope/policy.json',
+    '.agents/skills/.sks-generated.json',
+    ...(Array.isArray(skillInstall.generated_files) ? skillInstall.generated_files : []),
+    ...(Array.isArray(agentInstall.generated_files) ? agentInstall.generated_files : [])
+  ])).sort();
+}
+
+async function pruneStaleGeneratedFiles(root, previousManifest, currentFiles) {
+  const previousFiles = Array.isArray(previousManifest?.generated_files?.files) ? previousManifest.generated_files.files : [];
+  if (!previousFiles.length) return { pruned: [] };
+  const current = new Set(currentFiles);
+  const pruned = [];
+  const already_absent = [];
+  for (const rel of previousFiles) {
+    const relPath = normalizeGeneratedRelPath(rel);
+    if (!relPath || current.has(relPath) || !isPrunableGeneratedPath(relPath)) continue;
+    const removed = await removeGeneratedRelPath(root, relPath);
+    if (removed) pruned.push(removed);
+    else already_absent.push(relPath);
+  }
+  return { pruned: pruned.sort(), already_absent: already_absent.sort() };
+}
+
+function normalizeGeneratedRelPath(value) {
+  const rel = String(value || '').trim().replaceAll('\\', '/');
+  if (!rel || rel.startsWith('/') || rel.includes('\0')) return null;
+  if (rel.split('/').some((part) => part === '..')) return null;
+  return rel;
+}
+
+function isPrunableGeneratedPath(rel) {
+  if (rel.startsWith('.agents/skills/')) return true;
+  if (rel.startsWith('.codex/agents/')) return true;
+  if (rel.startsWith('.codex/skills/')) return true;
+  return new Set([
+    '.codex/config.toml',
+    '.codex/SNEAKOSCOPE.md',
+    '.codex/hooks.json',
+    '.sneakoscope/harness-guard.json',
+    '.sneakoscope/db-safety.json',
+    '.sneakoscope/policy.json'
+  ]).has(rel);
+}
+
+async function removeGeneratedRelPath(root, rel) {
+  const absRoot = path.resolve(root);
+  const abs = path.resolve(absRoot, rel);
+  if (abs !== absRoot && !abs.startsWith(`${absRoot}${path.sep}`)) return null;
+  if (!(await exists(abs))) return null;
+  await fsp.rm(abs, { recursive: true, force: true });
+  await removeEmptyGeneratedParents(root, rel);
+  return rel;
+}
+
+async function removeEmptyGeneratedParents(root, rel) {
+  const parts = rel.split('/');
+  if (parts.length <= 1) return;
+  const stopDirs = new Set([
+    path.resolve(root, '.agents', 'skills'),
+    path.resolve(root, '.codex', 'agents'),
+    path.resolve(root, '.codex', 'skills'),
+    path.resolve(root, '.codex'),
+    path.resolve(root, '.sneakoscope')
+  ]);
+  let dir = path.resolve(root, ...parts.slice(0, -1));
+  while (!stopDirs.has(dir) && dir.startsWith(path.resolve(root))) {
+    await removeDirIfEmpty(dir);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (rel.startsWith('.codex/skills/')) await removeDirIfEmpty(path.join(root, '.codex', 'skills'));
 }

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.' },