@awebai/oats 0.29.4 → 0.30.1

package/capabilities/oats-okf/skills/okf-consultation/SKILL.md

@@ -1,144 +0,0 @@
----
-name: okf-consultation
-description: >-
-  Consulting your soul's knowledge with the `oats okf` CLI: reading its
-  external OKF bases remotely at the accepted commit (index, cat, ls, links,
-  search, bases) with no local copy, then citing what you relied on. Use when
-  starting a task or resuming after compaction, when looking up a prior
-  decision, lesson or concept, when asked "what do we know about X" or to
-  "check the knowledge base", before re-deriving a design decision, when a
-  question touches your domain, or when an `oats okf` receipt says STALE or a
-  command errors. What to write in your own notes is the okf-instance-knowledge
-  skill.
----
-
-# Consulting your knowledge with `oats okf`
-
-Your soul's accumulated judgment — decisions and their rationale, lessons,
-rejected alternatives, limits — lives outside the soul, in external OKF
-**bases**. You read it remotely; nothing is copied into your home. Consulting
-it before you act is how you avoid re-deciding what was already decided.
-
-## The model
-
-- **Base / alias.** Each bound base has an alias (`oats okf bases` lists
-  them). A base is one OKF bundle and one link namespace.
-- **Node.** A subdirectory of a base with its own `index.md`. Your soul
-  **owns** some nodes (you are responsible for them) and **reads** others
-  (starting context). Neither is an access list: every bound base is readable.
-- **Accepted commit.** `oats okf` serves only a base's accepted state: the
-  accepted branch of a Git base, the in-place files of a directory base. An
-  open PR is not accepted knowledge until it is merged.
-- **Host cache, no local copy.** A Git base is read from one host-wide cache
-  that fetches file contents on first read. Your home has no `./knowledge/`
-  and no view directory. A `./knowledge/` left by okf 2.x is stale; ignore it.
-- **Receipts.** Every answer ends with `— alias@<short-oid> (fetched <age>)`.
-  With `--json`, the result carries `receipt: {base, kind, commit|digest,
-  fetchedAt, stale}`.
-
-Run every command from your instance home.
-
-## At the start of every task, and after compaction
-
-1. `oats okf index` prints your owned then read nodes' indexes, each headed
-   `## alias/node (owns|reads)`.
-2. Choose the entries relevant to *this* task by their one-line descriptions.
-3. `oats okf cat --base ALIAS /node/path.md` for each of those, and follow
-   their links only as far as the task needs (see Navigating).
-4. Write down in STATE.md which concepts shaped your plan, with their
-   citations.
-
-Do not skip this because the task looks small: prior decisions are cheapest
-to find before you have written the code that contradicts them.
-
-## Consult again while working
-
-The start-of-task read is not enough. Consult again:
-
-- **Before a design decision.** Search for the decision's subject, and read
-  any prior decision on it before choosing.
-- **Before re-deriving something.** If you are about to work out why
-  something is the way it is, search first; the rationale may be recorded.
-- **When a question touches your domain**, including a teammate's question.
-- **Before saying "we decided…" or "we tried…"**: cite it, or don't claim it.
-- **When something surprises you.** A lesson may already explain it.
-
-## Commands
-
-| Command | What it answers |
-| --- | --- |
-| `oats okf bases [--fresh]` | aliases, accepted commit, freshness, validity, your owns/reads |
-| `oats okf index [--base A] [NODE \| A/NODE]` | one node's `index.md`; no args: all your nodes; `--base A` alone: the base root index |
-| `oats okf cat --base A PATH [--from P]` | one Markdown file, in full |
-| `oats okf ls --base A [DIR]` | directory entries, each concept's `type` / `title` / `description` |
-| `oats okf links --base A PATH` | the file's outgoing links, resolved, `ok` / `MISSING` / `REFUSED` / `external` |
-| `oats okf search [--base A \| --all] [--node N] [--regex] [--case-sensitive] TEXT` | matching lines `{base, path, line, snippet}` |
-
-All take `--json`. `read` (the okf 2.x spelling of `cat`) is removed in 4.0.0
-(`E_REMOVED`): use `cat`.
-
-## Navigating
-
-Paths resolve like OKF links, **from the base root, not the filesystem**:
-
-- `/node/decisions/x.md` is base-root absolute (the usual form in indexes'
-  absolute links and in citations);
-- a relative link (`../lessons/y.md`, `decisions/x.md`) is relative to the file
-  it appeared in: pass that file as `--from`;
-- a bare `node/x.md` without `--from` resolves from the root.
-
-Worked example (a lesson linked from a decision):
-
-```sh
-oats okf index expert
-oats okf cat --base project /expert/decisions/retry-policy.md
-oats okf links --base project /expert/decisions/retry-policy.md
-oats okf cat --base project ../lessons/storm.md --from /expert/decisions/retry-policy.md
-```
-
-`links` shows every target already resolved, so you can `cat` the resolved
-path directly. `ls` is for choosing what to read from its descriptions, not
-for reading everything.
-
-## Searching
-
-`oats okf search TEXT` searches your nodes' bases (fixed string,
-case-insensitive, Markdown only), capped at 50 hits with "and N more". Narrow
-with `--node`, a longer phrase or `--base`; widen with `--all`. Search finds
-words, not meaning: when it finds nothing, try a synonym, then navigate from
-the index. A hit is a pointer: `cat` the concept before relying on it.
-
-## Citing
-
-Cite what you relied on as `alias/node/concept.md@<short-oid>`, using the oid
-from the receipt line (a directory base cites `alias@dir:<digest>`). Cite in
-STATE.md, notes/, PR descriptions and answers, so a reader knows which
-accepted state you saw.
-
-## Freshness
-
-Reads use the cached accepted commit while it is younger than the
-`consult-max-age` setting (default 300 s); after that the accepted branch is
-refetched first. `--fresh` refetches now (for example right after a PR
-merged). If a fetch fails, the last fetched accepted commit is still served,
-marked `stale: true` / `STALE:` with the reason: say so when it matters. With
-nothing cached and no network, the command fails with `E_BASE_UNAVAILABLE`:
-report it, and do not answer from memory or from an old `./knowledge/`.
-
-## Gotchas
-
-- Links resolve from the base root. `/node/x.md` is never a filesystem path,
-  and filesystem paths, `..` escapes, URLs, hidden paths and symlinks are
-  refused (`E_PATH`).
-- Never bulk-`cat` a whole node or loop `cat` over `ls` output. Index first,
-  then follow the few relevant links.
-- Don't edit knowledge. The write path is notes/ → the knowledge harvester →
-  a reviewed PR (or a directory publication). Write insights to notes/ (the
-  okf-instance-knowledge skill), not into a base.
-- `oats okf refresh` and `read` are gone (`E_REMOVED`): every read already sees the
-  accepted state.
-- `cat` reads `.md` files only (`E_NOT_MARKDOWN` otherwise); `E_NOT_FOUND`
-  lists the nearest directory's entries to try instead.
-
-Read [references/consult.md](references/consult.md) for more search examples,
-the error table and freshness edge cases.

package/capabilities/oats-okf/skills/okf-consultation/references/consult.md

@@ -1,86 +0,0 @@
-# okf-consultation — reference detail
-
-The okf-consultation skill's detail. Read this when navigating links, when a search is noisy or empty, when a
-receipt says `STALE`, or when a command errors. Run every command from your
-instance home (`oats okf …` resolves your registered source there).
-
-## Navigation, worked example
-
-Task: "change how retries back off". Your soul owns `project/expert`.
-
-```sh
-oats okf index                      # ## project/expert (owns) … ## project/peer (reads)
-#   * [Retry policy](decisions/retry-policy.md) - Why retries back off exponentially.
-oats okf cat --base project /expert/decisions/retry-policy.md
-#   … "superseded the fixed delay; see [the incident](../lessons/fixed-delay-storm.md)"
-oats okf links --base project /expert/decisions/retry-policy.md
-#   ok        /expert/lessons/fixed-delay-storm.md  (../lessons/fixed-delay-storm.md)
-#   MISSING   /expert/decisions/jitter.md
-oats okf cat --base project ../lessons/fixed-delay-storm.md \
-  --from /expert/decisions/retry-policy.md
-```
-
-- `index` with a node name (`oats okf index expert` or `project/expert`) prints
-  one index; `--base A` alone prints the base's root `index.md`.
-- A link in a concept is relative to **that concept's directory**: pass the
-  concept as `--from`, or use `links` to see every target already resolved.
-- `/node/x.md` is always from the base root; a bare `node/x.md` without
-  `--from` is also from the root.
-- `ls --base A /node/decisions` shows each concept's `type`, `title` and
-  `description` — use it to pick what to `cat`, not to read everything.
-- `MISSING` in `links` is a dangling link (allowed by OKF; not an error).
-  `REFUSED` is a link that would leave the base or is malformed.
-
-## Search
-
-```sh
-oats okf search "backoff"                     # your nodes' bases, case-insensitive
-oats okf search --node expert "jitter"        # one of your nodes
-oats okf search --base project --node peer "rate limit"
-oats okf search --all "idempotency"           # every bound base
-oats okf search --regex "retr(y|ies)"         # opt-in regex
-```
-
-- Fixed string, case-insensitive by default (`--case-sensitive` to change);
-  `--regex` is extended regex in Git bases, JavaScript RegExp in directory ones.
-- Only `.md` files inside the base root; results are `{base, path, line,
-  snippet}`, capped at 50 with "and N more" — narrow with `--node` or a longer
-  phrase rather than paging.
-- Search finds words, not meaning: when it's empty, try a synonym, then
-  navigate from the index. A hit is a pointer; `cat` the concept before
-  relying on it.
-- Git bases search with `git grep` at the accepted commit (the first search of
-  a node fetches its blobs in one batch); directory bases walk the files in
-  place, bounded to 20000 files.
-
-## Citing
-
-Cite what you relied on as `alias/node/concept.md@<short-oid>`, the oid from
-the receipt line (`— project@1a2b3c4d5e6f (fetched 2m ago)`). A directory base
-cites its digest (`project@dir:9f8e…`). Cite in notes/, PR descriptions and
-answers so a reader can see which accepted state you saw.
-
-## Freshness
-
-- Reads use the host cache's accepted commit if it was fetched within
-  `consult-max-age` seconds (setting, default 300); older, the accepted branch
-  is fetched first. `--fresh` fetches now. Neither ever selects another
-  branch or commit: only the accepted one is served.
-- Fetch failed (offline, auth, timeout): the last fetched accepted commit is
-  served with `stale: true` and the reason in the receipt (`STALE:` in text).
-  Say so if it matters to your answer; retry later with `--fresh`.
-- No cached commit and no network → `E_BASE_UNAVAILABLE`: report it, don't
-  guess from memory or from an old `./knowledge/`.
-- Merged a PR a minute ago? `--fresh` sees it once it is on the accepted branch.
-
-## Errors
-
-| Code | Meaning / what to do |
-| --- | --- |
-| `E_BASE_UNKNOWN` | alias not bound; the message lists the bound aliases (`oats okf bases`) |
-| `E_NOT_FOUND` | no such file at the accepted commit; the message lists the nearest directory |
-| `E_NOT_MARKDOWN` | `cat` reads `.md` concepts only; use `ls` for a directory |
-| `E_PATH` | escapes the base root, filesystem path, URL, hidden path, symlink or submodule |
-| `E_RECOVERY` | a directory-base publication is pending; retry after it completes |
-| `E_BASE_UNAVAILABLE` | the base can't be read and nothing is cached; report it |
-| `E_REMOVED` | `refresh` and `read` no longer exist; use `index` / `cat` |

package/capabilities/oats-okf/skills/okf-instance-knowledge/SKILL.md

@@ -1,104 +0,0 @@
----
-name: okf-instance-knowledge
-description: >-
-  Keeping this instance's own knowledge (STATE.md, log.md, notes/) with
-  judgment: the capture test, what is worth writing down and what is not,
-  one concept per note with type, claim, why, evidence and generality, when to
-  write (at the decision, before compaction, before a task boundary), and how
-  a note cites the soul knowledge it confirms or contradicts. Use at the start
-  of every task, when a decision is taken or rejected, when something costs
-  effort to find out, when a human corrects you, before compaction, and
-  before finishing a task.
----
-
-# Instance knowledge
-
-Your instance knowledge is your working memory: what you are doing, what
-happened, and what you learned. It lives in instance home (not ./work):
-- **STATE.md**: the current task picture, **rewritten** as it changes. What
-  the task is, where it stands, what is decided, what is blocked. `# Next`
-  names ONE next step.
-- **log.md**: dated significant events, **append-only**. Never rewrite
-  history.
-- **notes/**: **one concept per insight**, one Markdown file each.
-
-Your future self reads it after compaction. When harvest is on, the knowledge
-harvester reads it with your session transcript and decides what becomes soul
-knowledge. Write for both.
-
-## The capture test
-
-> Would my future self after compaction, or the harvester judging this
-> session, decide or act better for having it — and is it absent from the
-> code, the tracker and the repository docs?
-
-Both halves must hold. The capture bar is lower than the promotion bar: you
-capture what might matter; the harvester promotes what does. Do not
-self-censor a real decision because it might not be promoted.
-
-## Capture
-
-- **Decisions taken, and why.** The why is the part that dies with you.
-- **Alternatives rejected, and why.** Code shows the outcome, never the road
-  not taken; without this, a later instance "helpfully" takes it.
-- **Discoveries that cost effort**: facts about the world that were written
-  nowhere.
-- **Limitations, and the workaround that worked.**
-- **Conclusions of an investigation**, not its transcript.
-- **Blockers**, with what they block and what unblocks them.
-- **Human direction and corrections**, as you understood them, with when.
-- **Surprises**: the world behaved differently from what your soul knowledge
-  says. That is a *candidate supersession*: flag it as one and cite the
-  concept it contradicts.
-- **Process and environment lessons** the repository cannot express.
-
-## Don't capture
-
-- Descriptions of the code, or maps of the repository: code is the truth
-  about code, and a stored description drifts and lies.
-- Command logs and tool output; retries that taught nothing.
-- Secrets and credentials, however they appear.
-- Third-party messages verbatim (a lesson *about* one is fine).
-- What the tracker or the docs already hold: link to it instead.
-
-## The form of a note
-
-```markdown
----
-type: Decision            # Decision | Rejected | Discovery | Limitation | Conclusion | Lesson | Blocker
-title: Retry budget is per request, not per connection
-description: One-line claim, the sentence an index would show.
-generality: soul          # instance (true only for this task) | soul (likely true for the soul) — a hint, not a verdict
-observed: 2026-09-26, load test on the staging cluster (turns around the 14:10 run)
----
-
-The claim, then **why**: the reasoning, the alternatives, the evidence.
-Relates to: oats/expert/decisions/retries.md@5b6a9cab (refines it).
-```
-
-- A one-line claim in `description`; the *why* in the body.
-- Evidence and provenance: what was observed, when, from what.
-- **Generality** tells the harvester whether you think it outlives the task.
-- A note that confirms, refines or contradicts soul knowledge **cites it**
-  (`alias/node/concept.md@<short-oid>`, from `oats okf`'s receipt). That is
-  what lets the harvester situate it.
-
-## When
-
-- **At the decision, as it happens.** A decision reconstructed at the end has
-  lost its why.
-- **Before compaction** and **before a task boundary**: update STATE.md and
-  log.md, and write the notes you have been meaning to write.
-- **Consult first**: before writing a note, check notes/ and `oats okf search`
-  so you refine or cite rather than duplicate.
-
-## The theory, briefly
-
-- **Decision versus description.** A decision is superseded explicitly, and
-  the new one names the old; a description goes stale silently. Capture
-  decisions, not descriptions.
-- **Code is truth about code.** Anything a fresh instance could learn from
-  the repository in ten minutes is not worth your note.
-- **Indexical residue dies with the instance.** "Was working on X", "the PR
-  from this morning" mean nothing to anyone else. Write the durable claim
-  underneath it, or nothing.

package/capabilities/oats-okf-harvest/bin/okf-harvest.mjs

@@ -1,140 +0,0 @@
-#!/usr/bin/env node
-// oats.okf-harvest: the harvester's two commands. Both are thin: the delivery
-// code lives in oats.okf (a capability module is fetched per directory, so it
-// cannot import oats.okf's lib), and `complete` runs the source's frozen
-// `oats okf complete` from the source deployment, never from this home.
-import { spawnSync } from 'node:child_process';
-import { readFileSync, lstatSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HELP = `oats okf-harvest complete --source FILE --run ID --judgment ABS_FILE [--json]
-oats okf-harvest harvest-status --source FILE --run ID [--json]
-complete runs the source's frozen \`oats okf complete\` in its deployment (the
-only delivery path). harvest-status reports each PR's state and what to do:
-stay, retire or max-age (setting harvester-max-age, default 7d).
-`;
-const fail = (code, message, extra = {}) => { throw Object.assign(new Error(message), { code, ...extra }); };
-const IDENTITY = /^(OATS_(?!HOME_DIR$|PACKAGE_CATALOG$)|PI_AGENT|GIT_)/;
-
-export function parseFlags(args, allowed) {
-  const flags = {};
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (!a.startsWith('--')) fail('E_USAGE', `unexpected argument ${a}`);
-    const k = a.slice(2);
-    if (k in flags) fail('E_USAGE', `duplicate --${k}`);
-    if (!allowed.includes(k)) fail('E_USAGE', `unknown flag --${k}`);
-    if (k === 'json') { flags.json = true; continue; }
-    if (!args[i + 1] || args[i + 1].startsWith('--')) fail('E_USAGE', `--${k} needs a value`);
-    flags[k] = args[++i];
-  }
-  return flags;
-}
-const readJson = (file, what) => {
-  try { return JSON.parse(readFileSync(file, 'utf8')); } catch (e) { fail('E_SOURCE', `${what} is unreadable: ${file} (${e.code || e.message})`); }
-};
-/** The frozen source descriptor: <stateDir>/sources/<uuid>/source.json. */
-export function readSource(file) {
-  if (typeof file !== 'string' || !isAbsolute(file) || resolve(file) !== file) fail('E_USAGE', '--source must be an absolute descriptor path');
-  if (basename(file) !== 'source.json' || !/^[0-9a-f-]{36}$/.test(basename(dirname(file))) || basename(dirname(dirname(file))) !== 'sources') fail('E_SOURCE', 'not an OKF source descriptor path (<stateDir>/sources/<id>/source.json)');
-  if (lstatSync(file, { throwIfNoEntry: false })?.isFile() !== true) fail('E_SOURCE', `source descriptor missing: ${file}`);
-  const s = readJson(file, 'source descriptor');
-  if (s?.version !== 1 || s.id !== basename(dirname(file)) || typeof s.context !== 'string' || !isAbsolute(s.context) || typeof s.agent !== 'string') fail('E_SOURCE', 'invalid source descriptor');
-  return s;
-}
-export function readRun(source, file, id) {
-  if (typeof id !== 'string' || !/^[0-9a-f-]{36}$/.test(id)) fail('E_USAGE', '--run must be a run id');
-  const run = readJson(join(dirname(file), 'runs', id, 'run.json'), 'run');
-  if (run?.id !== id || run.source !== source.id) fail('E_RUN', 'run identity mismatch');
-  return run;
-}
-/** The completion argv, exactly as oats.okf's completionArgv freezes it. */
-export function completionArgv(source, file, run, judgment) {
-  const tail = ['okf', 'complete', '--source', file, '--run', run, '--judgment', judgment];
-  const e = source.executionBinding;
-  if (e !== undefined) {
-    if (e?.schemaVersion !== 1 || typeof e.deployment !== 'string' || !isAbsolute(e.deployment) || !/^sha256-[a-f0-9]{64}$/.test(e.resolution?.id || '')) fail('E_SOURCE', 'invalid captured completion execution binding');
-    return ['--deployment', e.deployment, '--resolution', e.resolution.id, ...tail, '--json'];
-  }
-  return [...tail, '--soul', source.agent, '--json'];
-}
-// A refusal meaning oats.okf cannot run for the source soul in its deployment.
-const INACTIVE = new Set(['E_CAPABILITY_INACTIVE', 'E_CAPABILITY_BLOCKED', 'E_CAPABILITY_MISSING', 'E_PACKAGE_MISSING', 'E_PACKAGE_INTEGRITY', 'E_SOUL_UNKNOWN', 'E_SOUL_DISABLED', 'E_UNKNOWN_COMMAND']);
-export function complete(flags, env = process.env) {
-  for (const k of ['source', 'run', 'judgment']) if (!flags[k]) fail('E_USAGE', `--${k} is required`);
-  if (!isAbsolute(flags.judgment)) fail('E_USAGE', '--judgment must be an absolute path');
-  const source = readSource(flags.source);
-  readRun(source, flags.source, flags.run);
-  const cli = env.OATS_CLI_BIN;
-  if (!cli || !isAbsolute(cli)) fail('E_RUNTIME', 'absolute OATS_CLI_BIN required; never resolve oats on PATH');
-  const clean = Object.fromEntries(Object.entries(env).filter(([k]) => !IDENTITY.test(k)));
-  const argv = completionArgv(source, flags.source, flags.run, flags.judgment);
-  const r = spawnSync(cli, argv, { cwd: source.context, env: clean, encoding: 'utf8', timeout: 30 * 60 * 1000, maxBuffer: 16 * 1024 * 1024 });
-  let answer; try { answer = JSON.parse(r.stdout); } catch { /* below */ }
-  if (answer?.schemaVersion === 1 && answer.ok === true) return { deployment: source.context, ...answer.result };
-  const code = answer?.error?.code || 'E_COMPLETE', message = answer?.error?.message || (r.error?.message || r.stderr || `exit ${r.status}`).trim();
-  if (INACTIVE.has(code)) fail('E_SOURCE_INACTIVE', `oats.okf cannot run for source soul ${source.agent} in ${source.context} (${code}: ${message}). Nothing was published: report this to the okf team and your operator, and stay.`, { cause: code });
-  fail(code, `${message} (completion ran in ${source.context}; keep your home and report)`);
-}
-/** "7d" | "48h" | "90m" | seconds → milliseconds. */
-export function maxAgeMs(value) {
-  if (value === undefined || value === null) return 7 * 86400000;
-  if (Number.isInteger(value) && value > 0) return value * 1000;
-  const m = /^(\d+)(m|h|d)$/.exec(String(value));
-  if (!m || Number(m[1]) < 1) fail('E_CONFIG', 'harvester-max-age must be a duration like 7d, 48h or 90m, or a positive number of seconds');
-  return Number(m[1]) * { m: 60000, h: 3600000, d: 86400000 }[m[2]];
-}
-function settings(env) {
-  let s; try { s = JSON.parse(env.OATS_SETTINGS || '{}'); } catch { fail('E_CONFIG', 'OATS_SETTINGS is not JSON'); }
-  return s && typeof s === 'object' ? s : {};
-}
-function prState(pr, env) {
-  const r = spawnSync('gh', ['pr', 'view', pr.url, '--json', 'state,mergedAt,closedAt,url,number'], { encoding: 'utf8', timeout: 60000, env: Object.fromEntries(Object.entries(env).filter(([k]) => !IDENTITY.test(k))) });
-  if (r.status !== 0) return { url: pr.url, number: pr.number, state: 'UNKNOWN', error: (r.stderr || r.error?.message || `exit ${r.status}`).trim() };
-  const v = JSON.parse(r.stdout);
-  return { url: v.url, number: v.number, state: v.state, mergedAt: v.mergedAt || null, closedAt: v.closedAt || null };
-}
-export function harvestStatus(flags, env = process.env, { now = Date.now(), view = prState } = {}) {
-  for (const k of ['source', 'run']) if (!flags[k]) fail('E_USAGE', `--${k} is required`);
-  const source = readSource(flags.source), run = readRun(source, flags.source, flags.run);
-  const limit = maxAgeMs(settings(env)['harvester-max-age']);
-  const age = now - Date.parse(run.created);
-  const receipts = run.receipts && typeof run.receipts === 'object' ? run.receipts : {};
-  const destinations = Object.entries(receipts).map(([alias, r]) => {
-    if (r?.pr?.url) return { alias, receipt: r.status, pr: view(r.pr, env) };
-    return { alias, receipt: r?.status ?? null, pr: null };
-  });
-  const judged = !!run.judgment;
-  let action, reason;
-  const open = destinations.filter((d) => d.pr && !['MERGED', 'CLOSED'].includes(d.pr.state));
-  const pending = destinations.filter((d) => !d.pr && !['no-change', 'accepted'].includes(d.receipt));
-  if (!judged || pending.length) { action = age >= limit ? 'max-age' : 'stay'; reason = !judged ? 'the run is not completed yet' : `destinations not delivered: ${pending.map((d) => d.alias).join(', ')}`; }
-  else if (open.length) { action = age >= limit ? 'max-age' : 'stay'; reason = `open PR: ${open.map((d) => d.pr.url).join(', ')}`; }
-  else { action = 'retire'; reason = destinations.some((d) => d.pr) ? 'every PR is merged or closed' : 'no PR was needed (no-change or directory publication)'; }
-  if (action === 'max-age') reason += `; older than harvester-max-age (${Math.round(limit / 3600000)}h): tell the okf team and retire, never close the PR`;
-  return { run: run.id, status: run.status, ageSeconds: Math.round(age / 1000), maxAgeSeconds: limit / 1000, destinations, action, reason };
-}
-function text(event, r) {
-  if (event === 'harvest-status') return [`run ${r.run} (${r.status}): ${r.action} — ${r.reason}`, ...r.destinations.map((d) => `  ${d.alias}: ${d.pr ? `${d.pr.state} ${d.pr.url}` : d.receipt}`)].join('\n');
-  return `completed run ${r.run}: ${r.status}${Object.entries(r.receipts || {}).map(([a, x]) => `\n  ${a}: ${x.status}${x.pr?.url ? ` ${x.pr.url}` : ''}`).join('')}`;
-}
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  const args = process.argv.slice(2), event = args[0];
-  if (!event || args.includes('--help') || args.includes('-h')) process.stdout.write(HELP);
-  else {
-    const json = args.includes('--json');
-    try {
-      let result;
-      if (event === 'complete') result = complete(parseFlags(args.slice(1), ['source', 'run', 'judgment', 'json']));
-      else if (event === 'harvest-status') result = harvestStatus(parseFlags(args.slice(1), ['source', 'run', 'json']));
-      else fail('E_USAGE', `unknown command ${event}; see --help`);
-      process.stdout.write((json ? JSON.stringify({ schemaVersion: 1, ok: true, result }) : text(event, result)) + '\n');
-    } catch (e) {
-      const code = e.code || 'E_OKF_HARVEST';
-      if (json) process.stdout.write(JSON.stringify({ schemaVersion: 1, ok: false, error: { code, message: e.message } }) + '\n');
-      else process.stderr.write(`oats okf-harvest ${event}: ${code}: ${e.message}\n`);
-      process.exitCode = 1;
-    }
-  }
-}

package/capabilities/oats-okf-harvest/injects/harvester.md

@@ -1,12 +0,0 @@
-## Knowledge harvester (oats.okf-harvest)
-
-You are a **judge, not a worker**. Load the **knowledge-harvest** skill before
-anything else, and judge by **knowledge-theory**.
-
-- Read the whole input: the notes AND every transcript window. Cite the turn
-  ids you relied on in the judgment receipt.
-- Your staged roots in ./work are your only write surface, and only the owned
-  nodes in them. `oats okf-harvest complete` is the only delivery path.
-- Stay alive until your PR is merged or closed. On every wake, run
-  `oats okf-harvest harvest-status` first, answer the maintainer in the okf
-  team, and retire only when it says `retire` or `max-age`. Never close the PR.

package/capabilities/oats-okf-harvest/oats.json

@@ -1,26 +0,0 @@
-{
-  "capability": "oats.okf-harvest",
-  "command": "okf-harvest",
-  "version": "4.0.1",
-  "compatibility": {
-    "oats": ">=0.29.0"
-  },
-  "description": "The OKF knowledge harvester: judges one source instance's captured notes and session transcript by the OKF promotion doctrine, opens the labelled harvest PR with its provenance block, and stays in the okf team until the PR is merged or closed.",
-  "requires": [
-    { "command": "gh", "why": "read the harvest PR's state (harvest-status)" }
-  ],
-  "settings": {
-    "harvester-max-age": {
-      "default": "7d",
-      "description": "How long a harvester stays alive waiting for its PR (a duration like 7d, 48h or 90m, or seconds). At max-age it tells the okf team and retires; it never closes the PR."
-    }
-  },
-  "skills": [
-    "skills"
-  ],
-  "inject": "injects/harvester.md",
-  "commands": {
-    "complete": "bin/okf-harvest.mjs complete",
-    "harvest-status": "bin/okf-harvest.mjs harvest-status"
-  }
-}