@sriinnu/omit 0.4.0 → 0.5.0

package/.cursor/rules/omit.mdc

@@ -1,5 +1,5 @@
 ---
-description: omit: Omit needless code. Draft less, cite everything, cut last.
+description: "omit: Omit needless code. Draft less, cite everything, cut last."
 alwaysApply: true
 ---
 

package/.github/workflows/omit.yml

@@ -0,0 +1,21 @@
+name: omit
+
+on: pull_request
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  omit:
+    runs-on: ubuntu-latest
+    # A fork's PR gets a read-only token, so the comment could only fail there.
+    if: github.event.pull_request.head.repo.full_name == github.repository
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # `./`, not a tag: this runs the PR's own action.yml end to end, which
+      # nothing else does — test.yml only proves the file parses.
+      - uses: ./

package/.github/workflows/test.yml

@@ -38,3 +38,39 @@ jobs:
           assert doc["runs"].get("using") == "composite", "runs.using must be composite"
           print("action.yml parses and carries its required keys")
           PY
+
+      # Same failure mode as action.yml: Claude Code tolerates an unquoted ": "
+      # in a description, but strict YAML loaders (the skills CLI, skill
+      # indexers) reject the whole file, and the skill silently disappears.
+      - name: skill and rule frontmatter parses
+        run: |
+          python3 - <<'PY'
+          import sys
+          try:
+              import yaml
+          except ImportError:
+              print("PyYAML unavailable on this runner — frontmatter was NOT validated")
+              sys.exit(0)
+          for path in ("skills/omit/SKILL.md", "skills/omit-codemode/SKILL.md", ".cursor/rules/omit.mdc"):
+              meta = yaml.safe_load(open(path).read().split("---")[1])
+              assert meta.get("description"), f"{path}: frontmatter has no description"
+              print(f"{path}: frontmatter parses")
+          PY
+
+  # The sandbox is an optional peer, so `npm test` above never installs it and
+  # the end-to-end case there is announced as skipped. This job is where a real
+  # script runs in the real sandbox, at the version the lockfile pins.
+  codemode:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - run: npm ci
+
+      - run: node --test test/codemode.test.mjs
+        env:
+          OMIT_CODEMODE_REQUIRED: "1"

package/README.md

@@ -119,14 +119,16 @@ And server-side, the GitHub Action comments the verdict on every PR regardless o
 ```yaml
 # .github/workflows/omit.yml
 on: pull_request
-permissions: { pull-requests: write }
+permissions: { contents: read, pull-requests: write }
 jobs:
   omit:
     runs-on: ubuntu-latest
+    # A fork's PR gets a read-only token, so the comment could only fail there.
+    if: github.event.pull_request.head.repo.full_name == github.repository
     steps:
       - uses: actions/checkout@v4
         with: { fetch-depth: 0 }
-      - uses: sriinnu/omit@main
+      - uses: sriinnu/omit@v0.5.0
         # with: { exec: true }   # execute receipts' `run` snippets to verify them
                                  # fully. Off by default: a PR's receipts are
                                  # untrusted code, and this runs on pull requests.
@@ -148,6 +150,50 @@ jobs:
 // the receipts; a single number would just be another uncited claim.
 ```
 
+## Codemode (experimental)
+
+An agent exploring a repo pays for every intermediate result: each read and each grep is a round-trip whose raw output lands in the transcript and is sent again on every later turn. With `omit codemode` the model writes a script, the reads happen inside it, and only what the script returns comes back.
+
+```sh
+omit codemode run <<'EOF'
+const libs = (await tools.files({ under: 'lib' })).filter((f) => f.endsWith('.mjs'))
+const sources = await Promise.all(libs.map((path) => tools.read({ path })))
+return Object.fromEntries(libs.map((f, i) => [f, (sources[i].match(/^export /gm) ?? []).length]))
+EOF
+```
+
+- **Read-only.** Three tools: `files`, `read`, `grep`. They read the tree through git, so ignored files stay out, and every path is confined to the directory the server started in: no `..`, no absolute path, no symlink out.
+- **Sandboxed.** The script runs in a QuickJS VM compiled to wasm ([`@earendil-works/pi-codemode`](https://www.npmjs.com/package/@earendil-works/pi-codemode), the sandbox behind pi's codemode): no file system, no network, no `process`. `node:vm` is not isolation, and the receipt for this dependency runs the escape to show it.
+- **Secrets stay in.** A script may read a credentials file; it may not return it. Output that matches a secret rule is withheld whole.
+- **Bounded.** A script has 60 seconds, and output past 20,000 characters loses its middle.
+
+The sandbox is an optional peer that only this command loads, so `omit` itself still installs zero dependencies. It needs Node 22.19 or newer.
+
+```
+npm install -g @sriinnu/omit @earendil-works/pi-codemode
+```
+
+Any agent with a shell can use it as it stands: `omit codemode run` takes a script on stdin or from a file and prints the answer, and the `omit-codemode` skill (`skills/omit-codemode/SKILL.md`) teaches the agent when to reach for it and what a script can call. Nothing has to be registered.
+
+For a host without a shell, or one where you would rather approve a single read-only tool, the same thing is an MCP server on stdio:
+
+```
+claude mcp add omit -- omit codemode        # Claude Code
+```
+
+```toml
+# Codex: ~/.codex/config.toml
+[mcp_servers.omit]
+command = "omit"
+args = ["codemode"]
+```
+
+```
+// omitted: write and edit tools: a nested write is not seen by the host's
+// hooks, so it has to carry the hazard, dependency and lint gates itself. Add
+// them once bench/ shows the read side pays for the surface.
+```
+
 ## The referee (experimental)
 
 `bench/` is METHODOLOGY.md made runnable: paired agentic runs of the same tasks under baseline, omit, or **any competing skill**, metrics computed from the actual git diffs, all transcripts kept. The category argues about self-reported numbers; omit ships the measuring instrument. See `bench/README.md`.
@@ -174,6 +220,12 @@ New here? **[GETTING-STARTED.md](GETTING-STARTED.md)** has a copy-paste setup fo
 /plugin install omit@omit
 ```
 
+**Any SKILL.md-aware agent** (Claude Code, Codex, Cursor, and others, via [skills.sh](https://skills.sh)):
+
+```
+npx skills add sriinnu/omit
+```
+
 **Global command**: install once from GitHub, use everywhere:
 
 ```
@@ -213,9 +265,9 @@ skills/omit/SKILL.md  →  .claude/skills/omit/SKILL.md      (project)
 **Anything else**: paste the contents of `AGENTS.md` into the agent's custom-instructions/rules mechanism. It's plain markdown; there is nothing to build.
 
 ```
-// omitted: an MCP server: MCP exposes tools and data; omit is a behavioral
-// discipline, and rule files + skills already deliver it. Add one only if
-// omit ever grows verifiable tooling (e.g., a standalone diff auditor).
+// omitted: the discipline itself over MCP: MCP exposes tools and data; omit is
+// a behavioral discipline, and rule files + skills already deliver it. The one
+// MCP server omit ships is codemode, which is tooling.
 ```
 
 ## Commands (Claude Code)
@@ -223,6 +275,29 @@ skills/omit/SKILL.md  →  .claude/skills/omit/SKILL.md      (project)
 - `/omit [margin|redline|rewrite|off]`: switch or show the current mode
 - `/omit-edit`: run an editor's pass over the current diff: flag bloat, uncited claims, missing footnotes, and cut opportunities
 
+## Releasing
+
+One command, three destinations (npm, GitHub, Homebrew):
+
+    npm run release -- patch    # or minor / major
+
+`scripts/release.mjs` runs the tests (via `preversion`), bumps the version,
+and lands the bump on main **through a PR** (main takes no direct pushes).
+Once checks pass and it merges, the script tags the merge (signed, per repo
+policy) and pushes the tag — which triggers `publish.yml`, publishing to npm
+**with a provenance attestation**. It then cuts the GitHub release with
+generated notes, waits for the registry to serve the version, and updates the
+`omit` formula in [`sriinnu/homebrew-tap`](https://github.com/sriinnu/homebrew-tap),
+again through a PR. A failed step aborts the release, in order.
+
+Never `npm publish` by hand: a local publish cannot attach provenance, and
+npm will not let the same version be republished to add one later. If the CI
+publish fails, fix CI — don't work around it locally.
+
+If the `NPM_TOKEN` secret ever goes stale, put the new token in `~/.npmrc`
+and run `npm run token:sync` — it verifies the token against the registry
+before pushing, so a dead token never reaches CI.
+
 ## Prior art
 
 The minimalism-pressure idea was popularized by [ponytail](https://github.com/DietrichGebert/ponytail), which deserves its stars. `omit` differs where it matters: shortcuts require citations, the diff is edited *after* it works, safety lines are enumerated and never cut, and what's left out is footnoted instead of silent.

package/action.yml

@@ -34,10 +34,13 @@ runs:
         BASE="${{ inputs.base }}"
         if [ -z "$BASE" ]; then BASE="origin/${{ github.event.pull_request.base.ref }}"; fi
         git fetch --depth=1 origin "${{ github.event.pull_request.base.ref }}" || true
-        node "${{ github.action_path }}/bin/omit.mjs" audit --base "$BASE" --markdown > omit-verdict.md
-        cat omit-verdict.md
+        # Outside the workspace: the redirect creates the file before the audit
+        # runs, and the audit counts untracked files — a verdict written into
+        # the checkout reports itself as one more changed file.
+        node "${{ github.action_path }}/bin/omit.mjs" audit --base "$BASE" --markdown > "$RUNNER_TEMP/omit-verdict.md"
+        cat "$RUNNER_TEMP/omit-verdict.md"
     - name: Comment on PR
       shell: bash
       env:
         GH_TOKEN: ${{ github.token }}
-      run: gh pr comment ${{ github.event.pull_request.number }} --body-file omit-verdict.md --repo ${{ github.repository }}
+      run: gh pr comment ${{ github.event.pull_request.number }} --body-file "$RUNNER_TEMP/omit-verdict.md" --repo ${{ github.repository }}

package/bin/omit.mjs

@@ -10,7 +10,9 @@
 //   omit leak "<cmd>"                                     would this command print a real secret to stdout?
 //   omit hook install                                     add the gate to .git/hooks/pre-commit
 //   omit hook install codex                                write .codex/hooks.json (live sentinels inside Codex CLI)
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs'
+//   omit codemode run [file]                              run one sandboxed script over read-only repo tools (stdin without a file)
+//   omit codemode                                         the same, as an MCP server on stdio
+import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync, chmodSync } from 'node:fs'
 import { basename, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { isManifest, addedDeps, unparsedDependencyFile } from '../lib/deps.mjs'
@@ -20,6 +22,7 @@ import { findHazards } from '../lib/hazards.mjs'
 import { lintFiles } from '../lib/lint.mjs'
 import { assessCommand } from '../lib/danger.mjs'
 import { assessLeak } from '../lib/leaks.mjs'
+import { execute, serve } from '../lib/codemode.mjs'
 
 const cwd = process.cwd()
 const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
@@ -658,6 +661,32 @@ function verify() {
 // on purpose: a verdict rendered from a diff that could not be read is the
 // failure this whole contract exists to prevent, and a gate that cannot read the
 // change has to block it rather than pass it.
+// ---------- codemode ----------
+// The sandbox is an optional peer, loaded here and nowhere else: every other
+// command has to keep working on a machine that never installed it.
+async function codemode(args) {
+  if (args.length && args[0] !== 'run') die('usage: omit codemode [run [file]]')
+  let sandbox
+  try {
+    sandbox = await import('@earendil-works/pi-codemode')
+  } catch (e) {
+    if (e.code !== 'ERR_MODULE_NOT_FOUND') throw e
+    die('omit codemode needs its sandbox, which is not installed. Run: npm install @earendil-works/pi-codemode (it needs Node 22.19 or newer)')
+  }
+  const root = realpathSync(cwd)
+  // `run` is the whole feature for any agent that has a shell: one script in,
+  // one answer out, no server to register. Exit 1 marks a failed or withheld
+  // result, so a harness can tell it from an answer.
+  if (args[0] === 'run') {
+    const { text, isError } = await execute(readFileSync(args[1] ?? 0, 'utf8'), { CodemodeSandbox: sandbox.CodemodeSandbox, root })
+    console.log(text)
+    process.exitCode = isError ? 1 : 0
+    return
+  }
+  const { version } = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8'))
+  serve({ sandbox, root, version })
+}
+
 const [cmd, ...rest] = process.argv.slice(2)
 try {
   if (cmd === 'audit') audit(rest)
@@ -667,6 +696,7 @@ try {
   else if (cmd === 'guard') guard(rest)
   else if (cmd === 'leak') leak(rest)
   else if (cmd === 'verify') verify()
+  else if (cmd === 'codemode') await codemode(rest)
   else if (cmd === 'hook' && rest[0] === 'install' && rest[1] === 'codex') hookInstallCodex()
   else if (cmd === 'hook' && rest[0] === 'install' && rest[1] === undefined) hookInstall()
   else if (cmd === 'hook' && rest[0] === 'install') {
@@ -676,7 +706,7 @@ try {
   else if (cmd === 'init') init(rest[0])
   else if (targets[cmd]) init(cmd) // back-compat: `omit cursor`
   else {
-    console.error('usage: omit <init|audit|check|gate|lint|guard|leak|verify|hook install|hook install codex>')
+    console.error('usage: omit <init|audit|check|gate|lint|guard|leak|verify|codemode|hook install|hook install codex>')
     process.exit(cmd ? 1 : 0)
   }
 } catch (e) {

package/lib/codemode.mjs

@@ -0,0 +1,198 @@
+// omit codemode: one MCP tool that runs a model-written script in a sandbox
+// whose only capability is the read-only tools below.
+//
+// An agent exploring a repo pays for every intermediate result: each file read
+// and each grep is a round-trip whose raw output lands in the transcript and is
+// re-sent on every later turn. Here the reads happen inside the script and only
+// what it returns reaches the model.
+//
+// The sandbox itself is not written here. Isolation is load-bearing, and
+// node:vm is not isolation (the receipt in .omit/receipts.jsonl executes the
+// escape), so it comes from @earendil-works/pi-codemode: a QuickJS VM compiled
+// to wasm with no file system, network or process. It is an optional peer and
+// only this command loads it, so the rest of the CLI stays zero-dependency.
+//
+// omitted: write and edit tools: a nested write is not seen by the host's
+// hooks, so it has to carry the hazard, dependency and lint gates itself; add
+// them once bench/ shows the read side pays for the surface.
+// omitted: a tree walk for directories that are not git repositories: `files`
+// and `grep` read the tree through git, which is what knows what is ignored;
+// add one if a host turns out to run this outside repositories.
+import { execFile } from 'node:child_process'
+import { readFile, realpath, stat } from 'node:fs/promises'
+import { relative, resolve, sep } from 'node:path'
+import { createInterface } from 'node:readline'
+import { promisify } from 'node:util'
+import { findHazards } from './hazards.mjs'
+
+const run = promisify(execFile)
+
+const TIMEOUT_MS = 60_000
+// What may reach the transcript from one script. Past it the middle is cut: a
+// script that returns this much has not filtered anything.
+const MAX_OUTPUT_CHARS = 20_000
+// A read is one JSON round trip into the VM, so a multi-gigabyte log would be
+// held three times over before the script saw a byte.
+const MAX_READ_BYTES = 8 << 20
+const GIT_BUFFER = 64 << 20
+
+// load-bearing: path confinement. The lexical check refuses `..` and absolute
+// paths before the file system is touched; the realpath check refuses a
+// symlink inside the workspace that points out of it.
+async function confine(root, path) {
+  if (typeof path !== 'string' || !path) throw new Error('path must be a non-empty string')
+  const outside = (full) => full !== root && !full.startsWith(root + sep)
+  if (outside(resolve(root, path))) throw new Error(`${path} is outside the workspace`)
+  let full
+  try {
+    full = await realpath(resolve(root, path))
+  } catch (e) {
+    throw new Error(`${path}: ${e.code === 'ENOENT' ? 'no such file or directory' : e.message}`)
+  }
+  if (outside(full)) throw new Error(`${path} is outside the workspace`)
+  return full
+}
+
+// Async on purpose: the host owns the script's deadline, and a synchronous git
+// call would hold the event loop that enforces it. It also lets a script's
+// Promise.all actually run its calls side by side.
+async function git(root, args) {
+  try {
+    return (await run('git', args, { cwd: root, encoding: 'utf8', maxBuffer: GIT_BUFFER })).stdout
+  } catch (e) {
+    if (e.code === 1 && !e.stderr) return '' // `git grep` found nothing
+    if (e.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') throw new Error('too much output to hold: narrow the pattern or pass `under`')
+    throw new Error(String(e.stderr ?? '').trim() || e.message)
+  }
+}
+
+const pathspec = async (root, under) => (under === undefined ? [] : ['--', relative(root, await confine(root, under)) || '.'])
+
+export const toolsFor = (root) => [
+  {
+    name: 'files',
+    description: 'List files, tracked and untracked, minus what git ignores.',
+    inputSchema: { type: 'object', properties: { under: { type: 'string', description: 'only files below this directory' } } },
+    outputSchema: { type: 'array', items: { type: 'string' } },
+    execute: async ({ under } = {}) => {
+      const out = await git(root, ['ls-files', '-z', '--cached', '--others', '--exclude-standard', ...(await pathspec(root, under))])
+      return [...new Set(out.split('\0').filter(Boolean))]
+    },
+  },
+  {
+    name: 'read',
+    description: 'Read one file as text.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    outputSchema: { type: 'string' },
+    execute: async ({ path } = {}) => {
+      const full = await confine(root, path)
+      const { size } = await stat(full)
+      if (size > MAX_READ_BYTES) throw new Error(`${path} is ${size} bytes, past the ${MAX_READ_BYTES} a read holds: use grep`)
+      return readFile(full, 'utf8')
+    },
+  },
+  {
+    name: 'grep',
+    description: 'Search file contents with an extended regular expression.',
+    inputSchema: {
+      type: 'object',
+      properties: { pattern: { type: 'string' }, under: { type: 'string', description: 'only files below this directory' } },
+      required: ['pattern'],
+    },
+    outputSchema: {
+      type: 'array',
+      items: { type: 'object', properties: { path: { type: 'string' }, line: { type: 'number' }, text: { type: 'string' } }, required: ['path', 'line', 'text'] },
+    },
+    execute: async ({ pattern, under } = {}) => {
+      if (typeof pattern !== 'string' || !pattern) throw new Error('pattern must be a non-empty string')
+      // -z: a path is then followed by NUL, never by the `:` a file name may contain.
+      const out = await git(root, ['grep', '-nIz', '-E', '--untracked', '-e', pattern, ...(await pathspec(root, under))])
+      return out.split('\n').filter(Boolean).map((row) => {
+        const [path, line, ...text] = row.split('\0')
+        return { path, line: Number(line), text: text.join('\0') }
+      })
+    },
+  },
+]
+
+// What a finished script hands back to the model.
+export function shape(text, isError) {
+  // load-bearing: secrets stay out of the transcript. A script that read a
+  // credentials file must not be able to return it, and the same rules that
+  // stop a key landing in a file decide what counts as one.
+  const secrets = findHazards(text.split('\n')).filter((h) => h.type === 'secret')
+  if (secrets.length) {
+    const where = secrets.map((h) => `${h.rule} (output line ${h.line})`).join(', ')
+    return { isError: true, text: `omit: output withheld, it carries ${where}. A transcript is not a safe place for a key: filter it out in the script and return only what you need.` }
+  }
+  if (!text) return { isError, text: '(no output: return a value or call text())' }
+  if (text.length <= MAX_OUTPUT_CHARS) return { isError, text }
+  const half = MAX_OUTPUT_CHARS / 2
+  return {
+    isError,
+    text: `${text.slice(0, half)}\n[omit: ${text.length - MAX_OUTPUT_CHARS} characters cut here. Return less: count, aggregate or filter in the script.]\n${text.slice(-half)}`,
+  }
+}
+
+export async function execute(code, { CodemodeSandbox, root }) {
+  const sandbox = new CodemodeSandbox({ tools: toolsFor(root), timeoutMs: TIMEOUT_MS })
+  try {
+    const r = await sandbox.execute(code)
+    const parts = r.output.map((item) => (item.type === 'text' ? item.text : `[${item.type} output is not supported]`))
+    if (r.ok && r.value !== undefined) parts.push(typeof r.value === 'string' ? r.value : JSON.stringify(r.value, null, 1))
+    if (!r.ok) parts.push(`Script error (${r.error.kind}): ${r.error.stack ?? r.error.message}`)
+    return shape(parts.join('\n'), !r.ok)
+  } finally {
+    await sandbox.close()
+  }
+}
+
+const PROTOCOLS = ['2025-06-18', '2025-03-26', '2024-11-05']
+
+// MCP over stdio is one JSON-RPC message per line, and three methods are all a
+// tools-only server answers, so the protocol is spoken here rather than
+// imported. stdout carries nothing but those messages.
+export function serve({ sandbox, root, version, stdin = process.stdin, stdout = process.stdout }) {
+  const tool = {
+    name: 'codemode',
+    description:
+      'Run JavaScript that explores this repository through read-only tools, and get back only what the script returns. ' +
+      'Use it instead of many separate reads and searches: call tools in parallel with Promise.all, filter and count in the script, return the conclusion. ' +
+      `\`code\` is the body of an async function: \`await\` and \`return\` work at the top level, text(value) adds to the output, and there is no fs, network or process. Paths are relative to ${root}.\n\n` +
+      sandbox.renderDeclarations({ tools: toolsFor(root) }),
+    inputSchema: { type: 'object', properties: { code: { type: 'string', description: 'JavaScript source, the body of an async function' } }, required: ['code'] },
+    annotations: { readOnlyHint: true },
+  }
+  const invalid = (message) => Object.assign(new Error(message), { code: -32602 })
+  // A Map, not an object literal: `method` is untrusted, and "constructor"
+  // would otherwise resolve to something callable.
+  const methods = new Map([
+    ['initialize', (p) => ({ protocolVersion: PROTOCOLS.includes(p?.protocolVersion) ? p.protocolVersion : PROTOCOLS[0], capabilities: { tools: {} }, serverInfo: { name: 'omit', version } })],
+    ['ping', () => ({})],
+    ['tools/list', () => ({ tools: [tool] })],
+    ['tools/call', async (p) => {
+      if (p?.name !== tool.name) throw invalid(`unknown tool: ${p?.name}`)
+      if (typeof p.arguments?.code !== 'string') throw invalid('`code` must be a string')
+      const { text, isError } = await execute(p.arguments.code, { CodemodeSandbox: sandbox.CodemodeSandbox, root })
+      return { content: [{ type: 'text', text }], isError }
+    }],
+  ])
+  const send = (message) => stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`)
+  createInterface({ input: stdin }).on('line', async (line) => {
+    if (!line.trim()) return
+    let message
+    try {
+      message = JSON.parse(line)
+    } catch {
+      return send({ id: null, error: { code: -32700, message: 'parse error' } })
+    }
+    if (message?.id === undefined) return // a notification: nothing to answer
+    const method = methods.get(message.method)
+    if (!method) return send({ id: message.id, error: { code: -32601, message: `method not found: ${message.method}` } })
+    try {
+      send({ id: message.id, result: await method(message.params) })
+    } catch (e) {
+      send({ id: message.id, error: { code: Number.isInteger(e.code) ? e.code : -32603, message: e.message } })
+    }
+  })
+}

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@sriinnu/omit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Omit needless code. Editorial discipline for AI coding agents: draft less, cite everything, cut last: enforced by hooks, a pre-commit gate, and a PR bot, whatever agent writes the code.",
   "type": "module",
   "bin": {
     "omit": "bin/omit.mjs"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "preversion": "npm test",
+    "release": "node scripts/release.mjs",
+    "token:sync": "node scripts/sync-token.mjs"
   },
   "files": [
     "bin",
@@ -33,12 +36,35 @@
     "code-quality",
     "agent-skill",
     "secrets-detection",
-    "pre-commit"
+    "pre-commit",
+    "agent-skills",
+    "claude-skills",
+    "skill-md",
+    "agents-md",
+    "codex",
+    "windsurf",
+    "cline",
+    "github-copilot",
+    "llm",
+    "ai-coding",
+    "code-review",
+    "github-action"
   ],
   "repository": {
     "type": "git",
     "url": "https://github.com/sriinnu/omit.git"
   },
+  "devDependencies": {
+    "@earendil-works/pi-codemode": "^1.0.3"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-codemode": "^1.0.3"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-codemode": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   },

package/skills/omit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: omit
-description: Editorial discipline for AI-written code: omit needless code, cite every claim, cut after it works. Use when writing or changing code, when the user says "omit", "tighten this", "simplest solution", "do less", or complains about over-engineering, bloat, or hallucinated APIs.
+description: "Editorial discipline for AI-written code: omit needless code, cite every claim, cut after it works. Use when writing or changing code, when the user says \"omit\", \"tighten this\", \"simplest solution\", \"do less\", or complains about over-engineering, bloat, or hallucinated APIs."
 ---
 
 # omit

package/skills/omit-codemode/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: omit-codemode
+description: "Explore a repository with one sandboxed script instead of many separate reads and searches, so only the answer reaches the conversation. Use when a task needs three or more reads or greps, a loop over files, or a count or summary across the codebase. Read-only."
+---
+
+# omit codemode
+
+*Omit needless context.*
+
+Every separate read or grep puts its raw output into the conversation, where it is paid for again on every later turn. Write one script instead: the reads happen inside it, and only what it returns comes back.
+
+## Run it
+
+```sh
+omit codemode run <<'EOF'
+const libs = (await tools.files({ under: 'lib' })).filter((f) => f.endsWith('.mjs'))
+const sources = await Promise.all(libs.map((path) => tools.read({ path })))
+return Object.fromEntries(libs.map((f, i) => [f, (sources[i].match(/^export /gm) ?? []).length]))
+EOF
+```
+
+Quote the delimiter (`'EOF'`) so the shell leaves the script alone. Exit status 1 means the script failed or its result was withheld.
+
+## The script
+
+The body of an async function: `await` and `return` work at the top level.
+
+| Call | Resolves to |
+|---|---|
+| `tools.files({ under? })` | `string[]`: tracked and untracked files, minus what git ignores |
+| `tools.read({ path })` | `string`: one file as text |
+| `tools.grep({ pattern, under? })` | `{ path, line, text }[]`: extended regular expression; no match is `[]` |
+
+`text(value)` adds to the output and `return` adds the returned value. A call that fails rejects with an `Error`; use `Promise.allSettled` to keep the calls that worked. Run independent calls together with `Promise.all`.
+
+There is nothing else in there: no file system, network, `process` or timers. Paths are relative to the current directory and cannot leave it.
+
+## Return the conclusion
+
+- Return counts, names and the few lines that matter, not file contents. Past 20,000 characters the middle of the result is cut.
+- A result that contains a secret is withheld whole. Filter it out in the script.
+- A script has 60 seconds.
+
+## When not to
+
+- One file or one search: use the ordinary tool.
+- Anything that writes. Codemode is read-only: make edits with the ordinary tools, where the sentinels see them.
+- If the command says its sandbox is not installed, give the user the install line it prints and carry on with ordinary tools. Do not work around it.