@awebai/oats 0.29.4 → 0.30.1

package/capabilities/oats-linear/skills/linear-tasks/SKILL.md

@@ -1,223 +0,0 @@
----
-name: linear-tasks
-description: >-
-  Linear task tracking for OATS agent instances. Use when reading an agent's
-  Linear work queue, opening or inspecting an issue, creating issues or
-  sub-issues, claiming work with an agent label, posting progress/blocker/
-  handoff comments, or moving work through Linear workflow states. Also use
-  when asked about "my issue", "the project", "the board", a Linear issue key
-  such as ENG-123, or shared task status. Uses JSON-first `oats linear` commands.
----
-
-# Agent task tracking in Linear
-
-Linear is your deployment's **tasks layer**: task status and outcomes live
-here. Conversation lives in the messaging layer; a message may nudge someone,
-but it never replaces the Linear update.
-
-## Deployment target and authentication
-
-Get the target from the `Tasks: Linear` line in your `TASK.md` briefing:
-
-- **team** is required and uses Linear's issue-prefix key (for example `ENG`).
-- **project** is an optional deployment default. Do not invent one when unset.
-- **alias** is your exact OATS instance name; your label is `agent-<alias>`.
-
-team and project come from the tasks payload OATS merged for this instance —
-the soul's `soul.yaml` `tasks: { team, project }`, the deployment's
-`oats-local.yaml` `settings.oats.linear.*`, or a spawn's `--provider` — and
-`./instance.json` in your instance home records it as `providers["oats.linear"]`.
-If team is unset, stop and ask your human to set it there.
-
-Before the first operation, run:
-
-```bash
-oats linear auth
-oats linear teams
-```
-
-If `LINEAR_API_KEY` is missing or rejected, **stop and ask the human** to create
-or export a personal API key (Linear Settings → Security & access → API keys).
-Never ask for the key's value, print it, put it in a command argument, or store
-it in OATS config/files. Never attempt an interactive login.
-
-Commands emit JSON. An error is JSON on stderr with a non-zero exit code; act
-on that error rather than retrying variants blindly.
-
-## Hierarchy
-
-- **Project** — an optional, human-owned outcome or initiative container. Do
-  not create, rename, change status, or close projects.
-- **Issue** — the normal bounded work item assigned to an agent.
-- **Sub-issue** — an issue with a parent, used only when the parent genuinely
-  decomposes into multiple independently verifiable pieces.
-
-Do not create placeholder parent issues for one child. Every issue belongs to
-a team; project membership is optional unless your briefing names a project.
-
-## Project context and documentation
-
-Use project-level and issue-level records deliberately:
-
-- **Project overview**: intent, scope/non-goals, ownership, constraints, human
-  gates, architecture, and success criteria.
-- **Project documents**: detailed designs, decisions, runbooks, and research.
-- **Issues/sub-issues**: bounded execution and acceptance criteria.
-- **Issue comments**: milestones, blockers, handoffs, verification, and links.
-
-The overview/documents explain the work; issues execute it. Link a governing
-project document from each affected issue rather than copying inconsistent
-versions. Keep task status in issues, not project prose or messaging.
-
-The current wrapper can discover project metadata but **cannot read or mutate
-project overview Markdown or Linear documents**:
-
-```bash
-oats linear projects --team <TEAM>
-```
-
-That output includes project IDs, names, slugs, status, and teams. Project
-creation, lifecycle/status, overview content, documents, and project updates
-remain human-owned in the Linear UI. If your task depends on unavailable
-project documentation, ask the human for its URL/content; never infer policy
-from an issue title.
-
-## Identity and ownership
-
-- Keep the **human assignee unchanged**. A personal API key acts as its human;
-  OATS agents are not Linear users.
-- Claim work with label `agent-<exact-instance-name>`. `--agent <alias>` creates
-  this team-scoped label on first use and applies it.
-- New issue descriptions also receive `Agent: <alias>`. On existing issues,
-  use the label and comments; do not rewrite a human's description merely to
-  add the line.
-- Never delete issues, labels, or comments. Do not change cycle, priority,
-  project, parent, or assignee unless explicitly directed.
-
-## Read before writing
-
-```bash
-# Your open queue (terminal states excluded by default)
-oats linear issue list --team <TEAM> --agent <alias>
-
-# Narrow to the deployment project when one is configured
-oats linear issue list --team <TEAM> --agent <alias> --project "<PROJECT>"
-
-# Read full task context before acting
-oats linear issue get <TEAM>-123
-
-# Discover this team's real workflow names; never guess them
-oats linear states --team <TEAM>
-```
-
-`issue get` includes team, status/type, project, parent, assignee, labels,
-description, and URL. Read the parent too when working a sub-issue. Record the
-issue key in instance memory (`STATE.md`) if your knowledge layer provides it.
-
-## Work an issue
-
-1. Read the issue and parent/project context.
-2. If not already claimed, apply your identity label:
-
-   ```bash
-   oats linear issue update <TEAM>-123 --agent <alias>
-   ```
-
-3. Move to the deployment's `started` workflow state (often `In Progress`),
-   using the exact name returned by `oats linear states`:
-
-   ```bash
-   oats linear issue update <TEAM>-123 --state "In Progress"
-   ```
-
-4. Post only useful durable events, prefixed with your alias:
-
-   ```bash
-   oats linear issue comment <TEAM>-123 \
-     --body "[<alias>] milestone: implemented parser; tests pass with node --test"
-   oats linear issue comment <TEAM>-123 \
-     --body "[<alias>] blocked: need API scope decision from @owner"
-   oats linear issue comment <TEAM>-123 \
-     --body "[<alias>] handoff → <next-alias>: branch agents/x, verify with npm test"
-   ```
-
-5. When implementation is review-ready, comment the outcome (branch/PR and
-   verification), then move to the team's review state. Do **not** mark it
-   completed:
-
-   ```bash
-   oats linear issue comment <TEAM>-123 \
-     --body "[<alias>] review-ready: PR <url>; verified npm test"
-   oats linear issue update <TEAM>-123 --state "In Review"
-   ```
-
-Workflow names vary. Agents may use backlog/unstarted/started states. The
-wrapper refuses `completed`, `canceled`, and `duplicate` state types unless
-`--allow-terminal` is supplied; use that override only after explicit human
-authorization and mention that authorization in a comment.
-
-## Create bounded work
-
-Use ≤12 words in the title. Describe requirements and acceptance checks, not a
-speculative implementation. For multiline Markdown, prefer a file so shell
-quoting cannot corrupt it.
-
-```bash
-cat > /tmp/linear-description.md <<'EOF'
-Why this is needed.
-
-Acceptance:
-- [ ] Observable outcome one
-- [ ] Verification command or evidence
-EOF
-
-oats linear issue create --team <TEAM> --project "<PROJECT>" \
-  --title "Bounded outcome" --description-file /tmp/linear-description.md \
-  --agent <alias>
-```
-
-Omit `--project` when the briefing has none. Create a sub-issue only for a real
-independent slice:
-
-```bash
-oats linear issue create --team <TEAM> --parent <TEAM>-123 \
-  --title "Independent child outcome" \
-  --description-file /tmp/linear-description.md --agent <alias>
-```
-
-`--project` sets project membership; `--parent` sets issue hierarchy. They are
-independent, so supply both when a sub-issue must explicitly carry the project:
-
-```bash
-oats linear issue create --team <TEAM> --project "<PROJECT>" \
-  --parent <TEAM>-123 --title "Independent child outcome" \
-  --description-file /tmp/linear-description.md --agent <alias>
-```
-
-Use an existing non-agent label only after discovery:
-
-```bash
-oats linear labels --team <TEAM>
-oats linear issue create --team <TEAM> --title "Fix token refresh" \
-  --label bug --agent <alias>
-```
-
-## Current command boundary
-
-Supported: discover teams/states/projects/labels; list/get/create/update/comment
-on issues; create sub-issues; claim work with agent labels.
-
-Not supported: create/update/close projects; read/edit project overviews;
-list/read/create/edit project documents; publish project updates; move an
-existing issue into/out of a project; reparent an existing issue; or create
-issue relations such as blocks/related. Those operations stay in the Linear
-UI with the human. **Do not invent GraphQL calls or command flags to bypass
-this boundary.**
-
-## Validate every mutation
-
-Mutation output is the resulting issue/comment. Check its identifier, status,
-project/parent, and labels immediately. Then run `issue get` for
-correctness-critical changes. If a GraphQL permission or validation error
-persists, post no partial workaround: preserve the task state and escalate to
-the human with the exact error (never the key).

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

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-import { runBindingWire } from '../lib/binding-wire.mjs';
-
-const args=process.argv.slice(2);
-if(args.includes('--help') || args.includes('-h')) {
-  process.stdout.write('oats okf provider binding phase (manifest-owned JSON stdin/stdout)\n');
-} else {
-  const phase=args[0];
-  if(args.length!==1) {
-    await runBindingWire(phase,[],process.stdout);
-  } else {
-    await runBindingWire(phase);
-  }
-}

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

@@ -1,209 +0,0 @@
-#!/usr/bin/env node
-import { fs, join, resolve, readJSON, safePath, oats, fail, unlock, redactUrls } from '../lib/io.mjs';
-import { loadBindings } from '../lib/config.mjs';
-import { register, registerCaptured, loadInvocationSourceReceipt, homeSource, loadSource, loadStatus, saveStatus, updateStatus, capture, scheduleSource, settleRetiredSchedule, service, markerPath, harvestOffRecord, sourceSwitch, retireHarvestOff } from '../lib/sources.mjs';
-import { harvestStatus, setupHarvest } from '../lib/harvest-status.mjs';
-import { settings } from '../lib/config.mjs';
-import { CONSULT } from '../lib/consult.mjs';
-import { runSource, complete, retry, readRun, requireQualifiedHelper } from '../lib/worker.mjs';
-import { initBase, migrate, deliverMigration, cutoverMigration, migrateSource, forgetMigration } from '../lib/migration.mjs';
-import { inspect } from '../lib/inspection.mjs';
-import { loadInvocationKnowledgeBinding } from '../lib/binding-wire.mjs';
-import { loadCapturedOkfInvocation, loadOkfSourceReceiptInput, assertOkfInvocationAction, requireOkfAdmittedAction, assertOkfSourceContext, assertOkfRegisteredSourceReplay } from '../lib/invocation-context.mjs';
-const HELP=`oats okf inspect [--home PATH | --source FILE] [--json]
-oats okf harvest [--home PATH] [--no-launch] [--json]
-oats okf run-source --source FILE [--manual] [--no-launch] [--json]
-oats okf complete --source FILE --run ID --judgment FILE [--json]
-oats okf retry --source FILE [--run ID --rejudge | --rejudge | --launch | --adopt-home PATH] [--json]
-oats okf bases [--fresh] [--json]
-oats okf index [--base ALIAS] [NODE | ALIAS/NODE] [--fresh] [--json]
-oats okf cat --base ALIAS PATH [--from PATH] [--fresh] [--json]
-oats okf ls --base ALIAS [DIR] [--fresh] [--json]
-oats okf links --base ALIAS PATH [--fresh] [--json]
-oats okf search [--base ALIAS | --all] [--node NODE] [--regex] [--case-sensitive] TEXT [--fresh] [--json]
-Consult commands read the accepted state remotely (host cache, no local copy);
-also accept --home PATH | --source FILE. PATH is /node/x.md from the base root,
-relative to --from's directory, or bare node/x.md from the root.
-oats okf setup --source FILE [--enable | --disable] [--install-host] [--json]
-oats okf setup --harvest on|off [--json]      (writes oats-local.yaml settings.oats.okf.harvest)
-oats okf harvest-status [--soul NAME] [--json]  (the effective harvest switch, why, and the registered sources)
-oats okf init --base ALIAS --nodes FILE [--output PATH | --confirm] [--json]
-oats okf migrate --legacy PATH --base ALIAS --node NODE --output PATH [--json]
-oats okf migrate --deliver FILE | --cutover FILE --soul-dir PATH [--json]
-oats okf migrate --source-home PATH [--json]
-oats okf migrate --forget ID [--json]
-oats okf unlock --lock PATH --token TOKEN [--json]
-Captured workers use oats operation run knowledge:harvest with SOURCE --deployment/--resolution/--home,
---arg native-request=ABS_BACKEND_ONLY_JSON and optional --arg worker-mode=prepare|launch.
-Raw captured harvest/run-source/scheduler/rejudge remain held; completed runs use SOURCE complete/retry.
-Unknown scaffold/native outcomes are retained, never automatically re-scaffolded or redispatched.
-Explicit retry --run ID requires --rejudge; add --launch only for operator-approved launch.
-Closed-PR recovery uses retained evidence and a fresh run; complete its returned ID.
-Settled destinations and old proposals/receipts are preserved; another active run blocks recovery.
-All settings use one absolute bindings-file. Setup host installation is explicit.
-`;
-const args=process.argv.slice(2);
-if(args.includes('--help') || args.includes('-h')) {process.stdout.write(HELP);}
-else {
-  const event=process.env.OATS_EVENT || args[0];
-  const hook=['spawn','retire','soul-scaffold'].includes(event);
-  const consult=Object.hasOwn(CONSULT,event);
-  let exit=0,answer,text,textMode=consult && !args.includes('--json');
-  try {
-    const flags={},positionals=[]; const boolean=new Set(['json','no-launch','manual','rejudge','launch','enable','disable','install-host','confirm','fresh','all','regex','case-sensitive']);
-    for(let i=1;i<args.length;i++) {
-      if(consult && args[i]==='--') {positionals.push(...args.slice(i+1));break;}
-      if(!args[i].startsWith('--')) {if(!consult) fail('E_USAGE',`unexpected argument ${args[i]}`);positionals.push(args[i]);continue;}
-      const k=args[i].slice(2);if(k in flags) fail('E_USAGE',`duplicate --${k}`);
-      if(boolean.has(k)) flags[k]=true;
-      else {if(!args[i+1] || args[i+1].startsWith('--')) fail('E_USAGE',`--${k} needs a value`);flags[k]=args[++i];}
-    }
-    const accepted={
-      spawn:[],retire:['home'], 'soul-scaffold':[],
-      harvest:['home','no-launch','native-request','worker-mode'],inspect:['home','source'],
-      'run-source':['source','manual','no-launch'],complete:['source','run','judgment'],
-      retry:['source','run','rejudge','launch','adopt-home'],read:['home','source','base','path','fresh'],refresh:['home','source'],'harvest-status':['home'],
-      bases:['home','source','fresh'],index:['home','source','base','fresh'],cat:['home','source','base','from','fresh'],ls:['home','source','base','fresh'],
-      links:['home','source','base','fresh'],search:['home','source','base','all','node','regex','case-sensitive','fresh'],
-      setup:['source','enable','disable','install-host','harvest'],init:['base','nodes','output','confirm'],
-      migrate:['source-home','legacy','base','node','output','deliver','cutover','soul-dir'],unlock:['lock','token']
-    };
-    for(const k of Object.keys(flags)) if(!['json','soul',...(accepted[event] || [])].includes(k)) fail('E_USAGE',`unknown flag --${k} for ${event}`);
-    if(flags.source && flags.home) fail('E_USAGE','choose source descriptor OR home');
-    const execution=Object.hasOwn(process.env,'OATS_INVOCATION_CONTEXT_FILE')?loadCapturedOkfInvocation():null;
-    const invocation=execution?{kind:'captured',binding:execution.binding}:loadInvocationKnowledgeBinding(),captured=invocation.kind==='captured';
-    if(execution) assertOkfInvocationAction(execution.context,event,readJSON(new URL('../oats.json',import.meta.url)));
-    // Only an actual admitted, instance-scoped kernel operation can create a
-    // captured worker. Raw commands/null intents and legacy ingress stay closed.
-    const capturedHarvest=captured && execution?.context.action.kind==='operation' && execution.context.action.slot==='knowledge' && execution.context.action.name==='harvest';
-    if(captured && event==='harvest') {
-      if(!capturedHarvest)requireQualifiedHelper({providerBinding:invocation.binding});
-      requireOkfAdmittedAction(execution.context);
-      if(!flags['native-request']||!['prepare','launch'].includes(flags['worker-mode']||'launch'))fail('E_CAPTURED_HELPER','captured harvest needs explicit native-request and supported worker-mode');
-    }
-    const unsupportedCaptured=new Set(['setup','init','migrate','unlock']);
-    if(captured && unsupportedCaptured.has(event)) fail('E_MIGRATION',`captured ${event} is not supported; use an explicit operator administration path`);
-    const target=execution?.context.instance;
-    if(target && flags.home && resolve(flags.home)!==target.home) fail('E_INVOCATION','captured invocation target differs from requested home');
-    const home=target?.home || resolve(flags.home || (execution?process.cwd():process.env.OATS_INSTANCE_HOME || process.env.OATS_HOME || process.cwd()));
-    if(execution && ['spawn','retire'].includes(event)) requireOkfAdmittedAction(execution.context);
-    const sourceReceipt=execution?loadOkfSourceReceiptInput(execution):loadInvocationSourceReceipt(home);
-    if(sourceReceipt.mode==='captured' && !['spawn','retire'].includes(event)) fail('E_SOURCE','captured source receipt is valid only for lifecycle hooks');
-    const src=()=>{
-      try {
-        const source=flags.source?loadSource(resolve(flags.source)):homeSource(home);
-        if(execution) assertOkfSourceContext(source,execution.context,execution.binding);
-        else if(captured) assertOkfRegisteredSourceReplay(source,invocation.binding);
-        else if(source.providerBinding && event!=='inspect') fail('E_INVOCATION','captured source execution requires its selected binding');
-        return source;
-      } catch(error) {if(captured && ['ENOENT','ENOTDIR'].includes(error.code)) fail('E_SOURCE','captured command requires its durable registered source descriptor');throw error;}
-    };
-    // Deliberate old registered-source replay is a separate qualified contract,
-    // never a way to create a source or synthesize generic admission. A present
-    // invalid/unadmitted generic invocation cannot enter this compatibility path.
-    if(captured && !execution && Object.hasOwn(accepted,event) && event!=='soul-scaffold') {
-      if(!fs.existsSync(flags.source?resolve(flags.source):markerPath(home))) fail('E_ADMISSION','new captured registration requires generic admitted invocation inputs');
-      src();
-    }
-    if(['spawn','retire'].includes(event)) {
-      // A generic intent authorizes its action, not missing source/role input.
-      // Absence may replay an already qualified source, never create one or
-      // infer a helper skip from an ambient kind/name/knowledge-slot heuristic.
-      if(captured && sourceReceipt.mode!=='captured' && !fs.existsSync(markerPath(home))) fail('E_SOURCE','new captured registration requires SourceReceipt1 input authority');
-      if(execution && fs.existsSync(markerPath(home))) src();
-      if(!captured && fs.existsSync(join(home,'instance.json')) && Object.hasOwn(readJSON(safePath(join(home,'instance.json'))),'executionBinding')) fail('E_INVOCATION','captured home cannot use legacy lifecycle ingress');
-    }
-    // Scope commands have no kernel instance intent. They may finish only
-    // already retained runs under their exact source binding/descriptor, never
-    // allocate a new worker or infer an incarnation for a deleted source.
-    const retainedRun=s=>{
-      const id=event==='complete'?flags.run:loadStatus(s).activeRun;
-      if(!id) {if(event==='complete') fail('E_RUN','complete requires an existing --run');requireQualifiedHelper(s);}
-      readRun(s,id);return s;
-    };
-    let result;
-    if(event==='read') fail('E_REMOVED','okf 4.0.0 removed read: use `oats okf cat --base ALIAS PATH` (same path, text and receipt)');
-    if(consult) {const answer=CONSULT[event](src(),flags,positionals);result=answer.result;text=answer.text;}
-    else if(event==='refresh') fail('E_REMOVED','okf 3.0.0 has no per-instance views; index/cat always read the accepted state: run `oats okf index`, then `oats okf cat --base ALIAS PATH`');
-    else if(event==='harvest-status') result=harvestStatus({home,flags});
-    else if(event==='soul-scaffold') {
-      // Souls are portable declarations, never an implicit knowledge store.
-      result={meta:{scaffolded:false},brief:'OKF requires explicit external bindings and soul/okf.json before a working instance can spawn. Use init or migrate; no knowledge was created in this soul.'};
-    } else if(event==='spawn') {
-      const s=sourceReceipt.mode==='captured'?registerCaptured(home,sourceReceipt.receipt):register(home);
-      const nodes=(list)=>list.join(', ') || 'none';
-      const brief=decl=>`Your soul knowledge is read remotely at its accepted state; there is no local copy. Start every task with your instance knowledge (STATE.md, log.md, notes/), then \`oats okf index\` (owns: ${nodes(decl.owns)}; reads: ${nodes(decl.reads.filter(r=>!decl.owns.includes(r)))}) and \`oats okf cat --base ALIAS PATH\` for the concepts the task needs; \`oats okf search\` before re-deriving a decision. Load okf-consultation and okf-instance-knowledge. Never edit accepted knowledge.`;
-      if(s.skipped) result={meta:{memory:'none'},brief:'Service agent: follow your own task; no working-memory upkeep.'};
-      else if(s.harvestOff) result={meta:{memory:'okf-v2',harvest:'off',reason:s.switch.reason},brief:`${brief(s.decl)} Harvest is off for this instance: nothing of this session is captured.`,...(s.switch.warnings.length?{warning:`oats-okf: ${s.switch.warnings.join('; ')}`}:{})};
-      else {
-        const schedule=loadStatus(s).schedule.result;
-        result={meta:{memory:'okf-v2',harvest:'on',source:s.file,schedule},brief:`${brief(s.decl)} Harvest is on: your notes and session are captured for the knowledge harvester.`};
-      }
-    } else if(event==='retire') {
-      if(captured) {
-        let s;
-        if(sourceReceipt.mode==='captured') {s=registerCaptured(home,sourceReceipt.receipt);if(s.skipped) {result={meta:{retired:true,reason:'service'}};s=null;}}
-        else {if(!fs.existsSync(markerPath(home))) fail('E_MIGRATION','captured retire requires a durable registered source or explicit helper receipt');s=src();}
-        if(s) {scheduleSource(s);const r=capture(s,{final:true});const schedule=settleRetiredSchedule(s);result={meta:{retired:r.complete===true,source:s.file,capture:r,schedule},brief:'Final input is in durable custody. Delivery remains asynchronous.'};}
-      } else if(service(home)) result={meta:{retired:true}};
-      else if(!fs.existsSync(markerPath(home)) && harvestOffRecord(home)) result={meta:{retired:true,reason:'harvest-off'}};
-      else if(!fs.existsSync(markerPath(home))) {
-        if(['STATE.md','log.md','notes','.okf-harvest-record.json','.okf-harvest-record.next.json'].some(p=>fs.existsSync(join(home,p)))) fail('E_MIGRATION','unregistered/legacy source has memory; explicitly migrate/register before retirement');
-        result={meta:{retired:true,reason:'nothing-to-delete'}};
-      } else {
-        const s=src(),sw=sourceSwitch(s);
-        // okf 4.0.1 #6: harvest switched off since spawn (deployment or soul) → no final capture.
-        if(sw.effective!=='on') result={meta:retireHarvestOff(s,sw),brief:`Harvest is now off (${sw.reason}): no final capture was taken; earlier inputs stay in custody.`};
-        else {scheduleSource(s);const r=capture(s,{final:true});const schedule=settleRetiredSchedule(s);result={meta:{retired:r.complete===true,source:s.file,capture:r,schedule},brief:'Final input is in durable custody. Delivery remains asynchronous.'};}
-      }
-    } else if(event==='harvest') {
-      if(capturedHarvest) {
-        const s=src(); // existing registered descriptor ONLY; never new registration.
-        result=runSource(s,{manual:true,noLaunch:!!flags['no-launch']||flags['worker-mode']==='prepare',capturedInvocation:execution.context,nativeRequest:flags['native-request']});
-      } else {
-        if(flags['native-request']||flags['worker-mode'])fail('E_USAGE','native-request/worker-mode require an admitted captured operation');
-        // Snapshot absence does not turn a persisted captured source into legacy.
-        if(fs.existsSync(markerPath(home))) requireQualifiedHelper(src());
-        const s=register(home);
-        if(s.harvestOff) fail('E_HARVEST_OFF',`harvest is off for this instance: ${s.switch.reason}. Nothing was captured.`);
-        result=s.skipped?{status:'skipped',reason:'service'}:runSource(s,{manual:true,noLaunch:!!flags['no-launch']});
-      }
-    } else if(event==='run-source') {
-      // The deployment can switch harvest off after a source registered: the
-      // job then captures and processes nothing (the soul's opt-out was already
-      // applied at registration). Nothing drains when it is switched back on.
-      const source=src(),sw=sourceSwitch(source);
-      result=sw.effective!=='on'?{status:'harvest-off',source:source.file,reason:`${sw.reason}; nothing was captured`}
-        :runSource(source,{manual:!!flags.manual,noLaunch:!!flags['no-launch']});
-    }
-    else if(event==='complete') {const s=src();if(captured) retainedRun(s);result=complete(s,flags.run,flags.judgment && resolve(flags.judgment));}
-    else if(event==='retry') {const s=src();if(captured && !flags.run && !flags.rejudge && !flags.launch && !flags['adopt-home']) retainedRun(s);result=retry(s,{run:flags.run,rejudge:!!flags.rejudge,launch:!!flags.launch,adoptHome:flags['adopt-home']});}
-    else if(event==='inspect') result=inspect(src());
-    else if(event==='setup' && flags.harvest!==undefined) {
-      if(flags.source || flags.enable || flags.disable || flags['install-host']) fail('E_USAGE','setup --harvest takes no other setup flag');
-      result=setupHarvest(flags.harvest);
-    }
-    else if(event==='setup') {
-      const s=src();if(flags.enable && flags.disable) fail('E_USAGE','choose enable or disable');
-      scheduleSource(s);
-      if(flags.enable || flags.disable) {oats(['schedule',flags.enable?'enable':'disable',`okf-${s.id}`,'--dir',s.context,'--json'],s.context);updateStatus(s,current=>{current.auto=!!flags.enable;});}
-      if(flags['install-host']) oats(['schedule','host','install','--dir',s.context,'--json'],s.context);
-      result={source:s.file,scheduler:oats(['schedule','list','--dir',s.context,'--json'],s.context).scheduler};
-    } else if(event==='init') result=initBase(loadBindings(),flags.base,flags.nodes,flags.output,{confirm:!!flags.confirm});
-    else if(event==='migrate') {
-      if(flags['source-home']) result=migrateSource(loadBindings(),flags['source-home']);
-      else if(flags.forget) result=forgetMigration(loadBindings(),flags.forget);
-      else if(flags.deliver) result=deliverMigration(resolve(flags.deliver));
-      else if(flags.cutover) result=cutoverMigration(resolve(flags.cutover),flags['soul-dir']);
-      else result=migrate(loadBindings(),{legacy:flags.legacy,alias:flags.base,node:flags.node,output:flags.output});
-    } else if(event==='unlock') result=unlock(resolve(flags.lock),flags.token);
-    else fail('E_USAGE',`unknown command ${event}; see --help`);
-    answer=hook?result:{schemaVersion:1,ok:true,result};
-  } catch(e) {const code=e.code || 'E_OKF',message=redactUrls(e.message);exit=1;answer=hook?{meta:{...(event==='retire'?{retired:false,reason:message}:{})},warning:`oats-okf ${code}: ${message}`}:{schemaVersion:1,ok:false,error:{code,message}};}
-  // Consult commands print text unless --json; every other answer is JSON.
-  // Let Node drain the pipe; no process.exit after a possibly large answer.
-  if(textMode && exit) process.stderr.write(`oats okf ${event}: ${answer.error.code}: ${answer.error.message}\n`);
-  else if(textMode) process.stdout.write(text+'\n');
-  else process.stdout.write(JSON.stringify(answer)+'\n');
-  process.exitCode=exit;
-}

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

@@ -1,42 +0,0 @@
-## Knowledge: OKF
-
-You have two kinds of knowledge. Work WITH both: consult them at the start of
-every task, after compaction, and every so often while you work, to decide,
-to situate the task and to stay coherent with what your soul already knows.
-
-- **Soul knowledge**: your soul's accepted OKF bases, external to the soul and
-  read remotely at their accepted state (there is no local copy).
-  **Consultation** reads them with the `oats okf` CLI from your instance home.
-  Load the **okf-consultation** skill at the start of every task.
-- **Instance knowledge**: this instance's own STATE.md, log.md and notes/ in
-  instance home. Load the **okf-instance-knowledge** skill: it teaches what is
-  worth capturing, not only where to put it.
-
-The work mode:
-- **At task start and after compaction:** read STATE.md, recent log.md
-  entries and the relevant notes/, then `oats okf index` and
-  `oats okf cat --base ALIAS PATH` for the concepts the task needs. Follow
-  links; do not bulk-load.
-- **Before compaction and before a task boundary:** update STATE.md, log.md
-  and notes/ first, so your future self can continue.
-- **Every so often while working, and always before a design decision or
-  before re-deriving something:** `oats okf search` / `cat` the relevant
-  concepts and re-read your own notes. Consult prior decisions before
-  re-deriving them.
-- Cite what you relied on as `alias/node/concept.md@<short-oid>`. A Git PR is
-  not accepted knowledge until it is merged. Report missing configuration or
-  blocked reads; do not create a substitute.
-
-**Capture with judgment**, as it happens: decisions and why, rejected
-alternatives, costly discoveries, limitations and the workaround that worked,
-conclusions, blockers, human direction and corrections, and surprises that
-contradict soul knowledge (flag those as candidate supersessions). Not code
-descriptions, command logs, retries, secrets, verbatim third-party messages,
-or what the tracker and docs already hold. One concept per note in notes/;
-STATE.md is the current picture (rewritten); log.md is dated events
-(append-only). The knowledge harvester, not you, decides what is promoted.
-
-**Never write accepted knowledge or soul knowledge.** This is an instruction
-boundary, not a filesystem sandbox. Skills remain curated soul artifacts.
-Instance knowledge lives in instance home, not ./work; code and repository
-documentation remain the truth about code.