@6reduk/workspace-pipeline 0.1.0 → 0.3.0

package/README.md

@@ -10,6 +10,11 @@ observed in disposable sessions. Kimi native verification is deferred; its
 configuration renderer remains experimental. Real-project migration requires an
 explicit preview and approval; installation is not blanket runtime certification.
 
+Version 0.3.0 adds [rebind](docs/rebind.md) (explicit
+manifest/source binding changes) and [reset](docs/reset.md) (backed-up restoration
+or clearing of selected local adapter configuration). Both require a separate
+preview and explicit apply for changes; these commands are not in registry 0.2.0.
+
 Grok's Claude-import suppression requires the [scoped launch command](docs/launch.md).
 File installation does not establish native session discovery or runtime isolation;
 Kimi/Grok checks and known generic-skill discovery limits are documented in

package/docs/lifecycle-cli.md

@@ -27,8 +27,8 @@ Preview returns the complete prepared JSON on stdout. It may acquire a Git
 source into temporary storage outside the wrapper, but does not write provider
 configuration. Network acquisition requires explicit `--network`. When manifest
 is omitted, setup uses the standard workspace manifest; update uses the recorded
-manifest origin. Relocation does not silently rebind it. The separate source
-rebind workflow is not exposed by these commands yet.
+manifest origin. Relocation does not silently rebind it. Use the explicit
+[manifest rebind workflow](rebind.md) to change that origin.
 
 Save prepared JSON privately, inspect its operations and then explicitly invoke
 `--apply --preview`. It may contain configuration secrets and absolute local
@@ -42,6 +42,30 @@ existing locked approval, registry, ownership, history, snapshot and drift check
 from preview generation. Existing local opt-in retention is handled by the
 internal lifecycle coordinator, not a second cleanup pass in the dispatcher.
 
+### Renamed or removed skills during update
+
+For a provider that remains selected, update retires an old managed
+`skills/<name>/SKILL.md` when the new source no longer supplies that path.
+The exact deletion appears in the preview; if installation took over an existing
+file, update restores its verified original backup instead. This supports names
+such as `unity-review` changing to `sdx-review` without leaving duplicate skills.
+
+Only recorded, unchanged native skill entry files qualify. A user edit before
+preview or after approval blocks the operation. User-added files (including notes
+beside a retired skill), other skills, agent definitions, configuration files and
+root instructions are not cleaned up by this rule. Directories are not recursively
+deleted. Provider/bundle removal remains a separate selection operation, except
+for the existing bundle-member update behavior.
+
+This is not a reset or a force-update option. Missing owned files should be
+repaired from the installed snapshot first; conflicting local customizations
+must not be silently discarded. Rebind only approves a new manifest origin;
+it does not relax these ownership checks.
+
+To deliberately discard local adapter customizations, use the separate
+[reset preview/backup/apply workflow](reset.md). Its default is installed-snapshot
+restoration; empty reset must be explicitly selected.
+
 ## Output and failures
 
 - stdout: one prepared JSON or operation result.

package/docs/rebind.md

@@ -0,0 +1,48 @@
+# Move a workspace manifest or change its source binding
+
+The installer remembers the location of your workspace manifest and the repository
+it resolves to. Editing its selected Git ref in place is an ordinary update.
+Moving the file or changing its repository needs explicit rebind approval.
+This is installation metadata, not a version requirement for project documents.
+
+## Three steps
+
+Prepare the new manifest yourself, preferably as `workspace.json` in the wrapper.
+Keep the old file until the update succeeds. Relative local Git paths are resolved
+from the **new manifest's directory**, not from the shell or the wrapper.
+
+The following PowerShell example uses illustrative absolute paths; replace them.
+Use a private directory for preview files: they can contain configuration values.
+
+```powershell
+workspace-pipeline rebind --workspace 'C:\Work\Game' --manifest 'C:\Work\Game\workspace.json' > 'C:\Private\rebind.json'
+workspace-pipeline update --workspace 'C:\Work\Game' --accept-rebind 'C:\Private\rebind.json' > 'C:\Private\update.json'
+workspace-pipeline update --workspace 'C:\Work\Game' --apply --preview 'C:\Private\update.json'
+workspace-pipeline doctor --workspace 'C:\Work\Game'
+```
+
+Check the exit status after each command. Never apply an empty or failed preview.
+Between the first and second commands inspect `previousOrigin`, `proposed.origin`
+and `proposed.manifest`. The first command only reads local state/history and the
+new manifest. It does not fetch Git, move files, or activate the new origin.
+
+`--accept-rebind` explicitly approves the saved proposal for source acquisition.
+For a remote source, add `--network` to this second command. Inspect the resulting
+update operations before the third command, which separately approves file writes.
+The new origin becomes active as part of that normal, locked update, not as a
+standalone write to `.pipeline/state.json`.
+
+## Boundaries and failures
+
+- Rebind requires an installed workspace without pending operations or broken history.
+- Moving the workspace itself is not supported by this command.
+- A changed state or manifest invalidates the proposal: regenerate and review it.
+- `--accept-rebind` is update-preview-only; do not combine it with `--manifest`,
+  `--apply`, or another lifecycle command. Apply uses the saved update preview only.
+- Rebind does not approve conflicts with user-edited files, credentials, MCP execution,
+  trust grants, cleanup or deletion of the old manifest.
+- `repair` still uses the installed snapshot, not a newer Git revision.
+- A failed/interrupted apply may have partial effects. Inspect its reported recovery
+  record and doctor; do not edit state manually or blindly repeat the update.
+
+Availability: introduced in 0.3.0; these commands are not present in 0.2.0.

package/docs/reset.md

@@ -0,0 +1,96 @@
+# Reset a local adapter environment
+
+Use reset when you deliberately want to discard local pipeline customizations.
+Ordinary `update`, `repair` and `remove` continue to protect conflicting edits.
+Reset is an offline operation on the **installed snapshot**, not an upgrade.
+It does not reset Git repositories or delete the workspace.
+
+Availability: introduced in 0.3.0; not present in 0.2.0.
+
+## Preview first
+
+Close running harnesses/configuration editors. Keep preview files private: they
+contain before/after bytes, potentially including MCP credentials.
+
+```powershell
+workspace-pipeline reset --workspace 'C:\Work\Game' --all > 'C:\Private\reset.json'
+# Check $LASTEXITCODE and review reset.scope, reset.backup and preview.plan.targets.
+workspace-pipeline reset --workspace 'C:\Work\Game' --apply --preview 'C:\Private\reset.json'
+workspace-pipeline doctor --workspace 'C:\Work\Game'
+```
+
+The default is `--to installed`: clean the selected scope and restore its supplied
+configuration from the installed snapshot. Use `--to empty` explicitly to remove
+the selected adapter configuration instead. After full empty reset, `doctor`
+reports `not-installed` (exit 1), not an installed/ready pipeline. Then use setup
+with a chosen manifest. For an upgrade after customization, reset to installed,
+then perform a normal update from the source you selected.
+
+Selection is mandatory: `--all`, or `--providers codex`, or
+`--bundles claude-grok` (use the actual installed bundle ID). Provider and bundle
+lists can be combined, but not with `--all`. Claude/Grok bundle members cannot be
+selected individually. Apply accepts only the saved preview, no mode/selection
+overrides. Preview generation alone changes no provider files.
+
+## Exactly what is reset
+
+| Selected provider | File trees, including user additions | Configuration sections |
+| --- | --- | --- |
+| Codex | `.agents/skills`, `.codex/agents` | Named agents and MCP servers in `.codex/config.toml` |
+| Claude | `.claude/skills`, `.claude/agents` | `mcpServers` in `.mcp.json` |
+| Grok | `.grok/skills`, `.grok/agents` | `mcp_servers` in `.grok/config.toml` |
+| Kimi | `.kimi-code/skills`, `.kimi-code/agents` | `mcpServers` in `.kimi-code/mcp.json` |
+
+Only recorded `AGENTS.md` / `CLAUDE.md` entry files associated with the selection
+are included. Shared entries remain when unselected providers need them. Conflicts
+in unselected owned files block reset rather than being repaired implicitly.
+Kimi configuration tests do not imply native Kimi runtime support is verified.
+
+This is **not** recursive deletion of `.codex`, `.claude`, `.grok`, `.kimi-code`,
+or the wrapper. Repositories, documents, assets, `.git`, manifests, snapshots,
+history, globals, account/auth files, model/permission/trust settings and unrelated
+configuration sections remain. Codex agent runtime/model controls also remain,
+as do unknown non-table values under `[agents]` (scalars, dates and arrays).
+Non-control table entries under `[agents]` are treated as named agent definitions.
+Unknown files outside the listed trees are not guessed to be pipeline files.
+Files under listed trees are included regardless of ignore rules. Empty directories
+and empty containing configuration files may remain; they are not an active skill
+or MCP declaration. Grok still uses its scoped launcher for import suppression.
+
+Malformed configurations, unsupported TOML representations, unsafe paths/links,
+hardlinks, repository overlap, unavailable snapshots, incompatible renderer replay,
+broken history and pending operations cause a refusal. Reset is not a force option
+for corrupted installer metadata. No Git download, harness or MCP is started.
+
+The portable path policy currently rejects non-ASCII names inside scoped trees,
+including Cyrillic user filenames. Reset refuses the whole operation rather than
+skipping those files. Move such additions to a safe location outside the reset
+trees or rename them yourself, then generate a new preview; do not reuse an old
+approval after changing the file inventory.
+
+## Backups and interruptions
+
+Before target changes, the CLI saves and verifies complete original bytes at
+`.pipeline/backups/reset/<digest>/`. It prints that location and the transaction's
+journal/recovery paths. `manifest.json` maps each binary backup to its original
+workspace-relative path and SHA-256. Backups can contain secrets: keep them local,
+do not commit or publish them. Logs cleanup does not delete these backups.
+
+If backup verification fails, no provider target is changed. A later failure can
+leave partial effects; do not treat a failure as rollback. Inspect the reported
+recovery and use the normal `continue` preview/apply workflow. It rechecks the
+exact approved scope and preserves the original records and backups. Added or
+changed files invalidate the applicable preview; they are never silently included
+in a previous destructive approval. Stop other writers while applying.
+
+To recover an individual discarded customization after successful reset, read
+the backup manifest, verify the selected `.bin` hash, and copy only those bytes
+to its listed destination after checking the current file and saving any newer
+edits. This is a deliberate customization: doctor/update may then report drift.
+Do not copy an old `.pipeline/state.json`, overwrite an entire provider directory,
+or restore a whole config file without reviewing newer settings/credentials.
+Reset does not provide automatic rollback of account settings or Git work.
+
+Reset creates a new clean ownership baseline for its selected supplied entries;
+ordinary removal will not resurrect discarded pre-reset custom configuration.
+Historical backups remain available for explicit recovery.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@6reduk/workspace-pipeline",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Workspace-local Git pipeline configuration dispatcher",
   "type": "module",
   "bin": {

package/schemas/operation.schema.json

@@ -23,6 +23,7 @@
             "update",
             "repair",
             "remove",
+            "reset",
             "switch"
           ]
         },

package/src/commands/dispatch.js

@@ -24,6 +24,8 @@ import {listRepositoryHistory} from '../operations/repository-history.js';
 import {runRepositoryCommand} from './init.js';
 import {parseMigrationCommand,runMigrationCommand} from './migration.js';
 import {parseLaunch,runLaunch} from './launch.js';
+import {parseRebind,runRebind,acceptedRebind} from './rebind.js';
+import {parseReset,runReset} from './reset.js';
 
 export const help=`Workspace Pipeline CLI — development preview
 Usage: workspace-pipeline doctor --workspace <absolute-directory> [--recovery <relative-record>] [--json]
@@ -32,6 +34,11 @@ Usage: workspace-pipeline doctor --workspace <absolute-directory> [--recovery <r
        workspace-pipeline <init|adopt|wrap> --workspace <absolute-directory> --apply --preview <absolute-json-file>
        workspace-pipeline <setup|update> --workspace <absolute-directory> [--manifest <absolute-file>] [--network]
        workspace-pipeline <setup|update> --workspace <absolute-directory> --apply --preview <absolute-json-file>
+       workspace-pipeline rebind --workspace <absolute-directory> --manifest <absolute-file>
+       workspace-pipeline update --workspace <absolute-directory> --accept-rebind <absolute-json-file> [--network]
+       workspace-pipeline reset --workspace <absolute-directory> --all [--to installed|empty]
+       workspace-pipeline reset --workspace <absolute-directory> [--providers <ids>] [--bundles <ids>] [--to installed|empty]
+       workspace-pipeline reset --workspace <absolute-directory> --apply --preview <absolute-json-file>
        workspace-pipeline <repair|remove> --workspace <absolute-directory> [--providers <comma-separated-ids>] [--bundles <comma-separated-ids>]
        workspace-pipeline <repair|remove> --workspace <absolute-directory> --apply --preview <absolute-json-file>
        workspace-pipeline switch --workspace <absolute-directory> --manifest <absolute-file> [--network]
@@ -79,6 +86,11 @@ select a new source/manifest or download a replacement for missing staged data.
 No native plugins are installed. Source packages cannot supply executable adapters.
 Repair/remove are offline installed-snapshot operations. --providers and --bundles are remove-only,
 preview-only; omission previews full removal. No automatic history cleanup on these commands.
+Reset is separate and destructive within its explicit local configuration scope,
+including user additions: default --to installed, --to empty explicit. Selection
+is mandatory. Preview first; apply backs up affected bytes before target writes.
+No repository/global/auth/model/permissions cleanup. Malformed configuration fails
+closed. Recovery uses the existing continue command; backups remain local/private.
 Switch requires an explicit incoming manifest in preview, preserves two separate
 phases and activates only after both pass. Failure is not rolled back or retried.
 Continue creates a new approved operation from pending evidence; it does not replay old journals.
@@ -131,6 +143,8 @@ export function parseCommand(args) {
   if(!Array.isArray(args) || args.some(a=>typeof a!=='string')) fail('cli.arguments');
   if(args.length===0 || (args.length===1 && ['--help','-h'].includes(args[0])))return {command:'help'};
   if(args[0]==='launch')return parseLaunch(args);
+  if(args[0]==='rebind')return parseRebind(args);
+  if(args[0]==='reset')return parseReset(args);
   if(['setup','update','repair','remove','switch','continue'].includes(args[0]))return parseLifecycle(args);
   if(args[0]==='migration')return parseMigrationCommand(args);
   if(['init','adopt','wrap'].includes(args[0]))return parseRepositories(args);
@@ -214,7 +228,7 @@ function parseLifecycle(args) {
   const result={command:args[0]},seen=new Set(),maintenance=['repair','remove'].includes(args[0]);
   for(let i=1;i<args.length;i++) {
     const flag=args[i];
-    const allowed=['--workspace','--apply','--preview','--json',...(result.command==='continue'?['--recovery']:maintenance?result.command==='remove'?['--providers','--bundles']:[]:['--manifest','--network'])];
+    const allowed=['--workspace','--apply','--preview','--json',...(result.command==='update'?['--accept-rebind']:[]),...(result.command==='continue'?['--recovery']:maintenance?result.command==='remove'?['--providers','--bundles']:[]:['--manifest','--network'])];
     if(!allowed.includes(flag) || seen.has(flag))fail('cli.arguments');
     seen.add(flag);
     if(flag==='--json')continue;
@@ -235,9 +249,10 @@ function parseLifecycle(args) {
       if(providers.some(p=>!['codex','claude','kimi','grok'].includes(p)) || new Set(providers).size!==providers.length)fail('cli.arguments');
       result.providers=providers.sort();continue;
     }
-    result[{'--workspace':'workspace','--manifest':'manifestPath','--preview':'previewFile'}[flag]]=absoluteRoot(value);
+    result[{'--workspace':'workspace','--manifest':'manifestPath','--preview':'previewFile','--accept-rebind':'rebindFile'}[flag]]=absoluteRoot(value);
   }
   if(!result.workspace)fail('cli.workspace-required');
+  if(result.rebindFile && (result.apply || result.manifestPath))fail('cli.arguments');
     if(result.apply?(!result.previewFile || result.manifestPath || result.network || result.providers || result.bundles):result.previewFile)fail('cli.arguments');
   if(result.command==='switch' && !result.apply && !result.manifestPath)fail('switch.manifest-required');
   if(result.command==='continue' && (result.apply?result.recoveryPath:!result.recoveryPath))fail('continuation.recovery-required');
@@ -259,6 +274,7 @@ async function runLifecycle(command,registry,stdout,stderr) {
     if(command.providers)input.providers=command.providers;
     if(command.bundles)input.bundles=command.bundles;
     if(command.recoveryPath)input.recoveryPath=command.recoveryPath;
+    if(command.rebindFile)Object.assign(input,await acceptedRebind(command.workspace,command.rebindFile));
     await stdout(JSON.stringify(await prepare(input,registry))+'\n');return 0;
   }
   const prepared=(await readRecord(command.previewFile)).value;
@@ -374,6 +390,8 @@ export async function runCli(args,{stdout,stderr,registry=null}) {
     const command=parseCommand(args);
     if(command.command==='help') {await stdout(help+'\n');return 0;}
     if(command.command==='launch')return await runLaunch(command,stdout,stderr);
+    if(command.command==='rebind')return await runRebind(command,stdout);
+    if(command.command==='reset')return await runReset(command,registry,stdout,stderr);
     if(command.command==='migration')return await runMigrationCommand(command,stdout,stderr);
     if(command.command==='logs')return await runLogs(command,stdout,stderr);
     if(command.command==='policy')return await runPolicy(command,stdout);

package/src/commands/rebind.js

@@ -0,0 +1,48 @@
+import {absoluteRoot,resolveChild} from '../workspace/paths.js';
+import {fail} from '../contracts/parse.js';
+import {contractDigest} from '../contracts/semantic.js';
+import {readRecord,readState,previewRebind,resolveApprovedRebind} from '../operations/state.js';
+import {assertNoRepositoryPending} from '../operations/repository-pending.js';
+import {inspectHistory} from '../operations/history.js';
+
+export function parseRebind(args) {
+  const result={command:'rebind'},seen=new Set();
+  for(let i=1;i<args.length;i++) {
+    const flag=args[i];
+    if(!['--workspace','--manifest'].includes(flag) || seen.has(flag))fail('cli.arguments');
+    seen.add(flag);
+    const value=args[++i];if(!value || value.startsWith('--'))fail('cli.arguments');
+    result[flag==='--workspace'?'workspace':'manifestPath']=absoluteRoot(value);
+  }
+  if(!result.workspace || !result.manifestPath)fail('cli.arguments');
+  return result;
+}
+
+async function current(wrapper) {
+  await assertNoRepositoryPending(wrapper);
+  const history=await inspectHistory(wrapper);
+  if(!history.complete || history.diagnostics.length)fail('lifecycle.history');
+  return (await readState(resolveChild(wrapper,'.pipeline/state.json'))).value;
+}
+
+// Read manifests and installed history only. Never acquire Git, update state,
+// move the supplied manifest, or manufacture source/apply approval here.
+export async function runRebind(command,stdout) {
+  const previous=await current(command.workspace);
+  const proposal=await previewRebind({wrapper:command.workspace,previous,manifestPath:command.manifestPath});
+  if(proposal.previousWorkspace!==proposal.workspace)fail('rebind.workspace-move');
+  await stdout(JSON.stringify(proposal)+'\n');
+  return 0;
+}
+
+// Called only for the explicit update --accept-rebind flag. The resulting
+// prepared update still needs a separate --apply --preview approval.
+export async function acceptedRebind(wrapper,filename) {
+  const proposal=(await readRecord(filename)).value;
+  if(proposal?.kind!=='rebind-preview' || typeof proposal?.proposed?.origin?.path!=='string')fail('rebind.proposal');
+  const manifestPath=absoluteRoot(proposal.proposed.origin.path);
+  const previous=await current(wrapper);
+  const approval={decision:'approve',proposalDigest:contractDigest(proposal)};
+  await resolveApprovedRebind({wrapper,previous,manifestPath,proposal,approval});
+  return {manifestPath,rebind:{proposal,approval}};
+}

package/src/commands/reset.js

@@ -0,0 +1,63 @@
+import {absoluteRoot,resolveChild} from '../workspace/paths.js';
+import {ContractError,fail} from '../contracts/parse.js';
+import {readRecord} from '../operations/state.js';
+import {resetOptions,prepareReset,validateResetRecord} from '../operations/reset.js';
+import {applyReset} from '../operations/apply.js';
+import {acquireWorkspaceLock} from '../operations/lock.js';
+import {inspectHistory} from '../operations/history.js';
+import {assertNoRepositoryPending} from '../operations/repository-pending.js';
+
+export function parseReset(args){
+  const result={command:'reset'},seen=new Set();
+  for(let i=1;i<args.length;i++){
+    const flag=args[i];
+    if(!['--workspace','--to','--all','--providers','--bundles','--apply','--preview'].includes(flag) || seen.has(flag))fail('cli.arguments');
+    seen.add(flag);
+    if(flag==='--apply'){result.apply=true;continue;}
+    if(flag==='--all'){(result.options??={}).all=true;continue;}
+    const value=args[++i];if(!value || value.startsWith('--'))fail('cli.arguments');
+    if(flag==='--workspace')result.workspace=absoluteRoot(value);
+    else if(flag==='--preview')result.previewFile=absoluteRoot(value);
+    else if(flag==='--to')(result.options??={}).to=value;
+    else{
+      const ids=value.split(',');
+      if(ids.some(id=>!/^[a-z][a-z0-9-]{0,62}$/.test(id)) || new Set(ids).size!==ids.length)fail('cli.arguments');
+      (result.options??={})[flag==='--providers'?'providers':'bundles']=ids.sort();
+    }
+  }
+  if(!result.workspace)fail('cli.workspace-required');
+  if(result.apply){if(!result.previewFile || result.options)fail('cli.arguments');}
+  else {if(result.previewFile)fail('cli.arguments');result.options=resetOptions(result.options??{});}
+  return result;
+}
+async function history(workspace){
+  await assertNoRepositoryPending(workspace);
+  const h=await inspectHistory(workspace);if(!h.complete || h.diagnostics.length)fail('reset.history');
+}
+export async function runReset(command,registry,stdout,stderr){
+  if(!command.apply){
+    await history(command.workspace);
+    await stdout(JSON.stringify(await prepareReset(command.workspace,registry,command.options))+'\n');return 0;
+  }
+  const raw=(await readRecord(command.previewFile)).value;
+  const approval={decision:'approve',preparedDigest:raw.digest};
+  const prepared=validateResetRecord(raw,approval);
+  if(prepared.preview.plan.workspace!==command.workspace)fail('reset.workspace');
+  const result={command:'reset',mode:prepared.reset.selection.to,workspace:command.workspace,status:'failed',
+    backupDirectory:resolveChild(command.workspace,prepared.reset.backup.directory),
+    journal:null,recovery:null,runtime:'not-run',lockRelease:'not-acquired'};
+  let lock;
+  try{
+    lock=await acquireWorkspaceLock(command.workspace);result.lockRelease='pending';await history(command.workspace);
+    await stderr(JSON.stringify({kind:'reset-backup-location',path:result.backupDirectory,status:'not-yet-verified'})+'\n');
+    const applied=await applyReset(lock,prepared,approval,registry,{onJournal:async location=>{
+      result.journal=location.directory;
+      result.recovery=resolveChild(command.workspace,location.relative.replace('/journals/','/transactions/')+'/recovery.json');
+      await stderr(JSON.stringify({kind:'journal-location',path:result.journal,recovery:result.recovery,backupDirectory:result.backupDirectory})+'\n');
+    }});
+    result.status=applied.status;
+  }catch(error){result.error=error instanceof ContractError?error.code:'reset.io';}
+  finally{if(lock)try{await lock.release();result.lockRelease='released';}catch{result.lockRelease='failed';}}
+  await stdout(JSON.stringify(result)+'\n');
+  return ['ready','not-installed'].includes(result.status) && result.lockRelease==='released'?0:1;
+}

package/src/contracts/semantic.js

@@ -5,6 +5,7 @@ import { fail } from './parse.js';
 import { validateStructure } from './validate.js';
 import { requiredCapabilities, assertAdapter } from '../providers/interface.js';
 import { resolveProviders, validateInstalledBundles } from '../providers/bundles.js';
+import {retiredSkillOwnership} from '../operations/skill-retirement.js';
 
 const has = (o, k) => Object.hasOwn(o, k);
 export function portablePath(value) {
@@ -173,7 +174,8 @@ export function validateOperation(op, previous) {
         o.path===t.path && o.owner===t.owner && o.kind==='file') &&
         Object.entries(previous.active.bundles??{}).some(([id,b])=>op.desired?.bundles?.[id] &&
           b.providers.includes(t.owner) && !op.desired.providers.includes(t.owner));
-      if (t.action === 'verify-absent' && ((op.command !== 'remove' && !retiredBundleFile) || t.beforeHash !== null || t.desiredHash !== null)) fail('operation.hash');
+      const retiredSkillFile=op.command==='update' && retiredSkillOwnership(previous,op.desired).some(o=>o.path===t.path && o.owner===t.owner);
+      if (t.action === 'verify-absent' && ((!['remove','reset'].includes(op.command) && !retiredBundleFile && !retiredSkillFile) || t.beforeHash !== null || t.desiredHash !== null)) fail('operation.hash');
       if (['replace', 'edit-fields'].includes(t.action) && (t.beforeHash === null || t.desiredHash === null)) fail('operation.hash');
       if ((t.action === 'edit-fields') !== (t.fields.length > 0)) fail('operation.fields');
       const fieldPointers = [];

package/src/operations/apply.js

@@ -9,6 +9,7 @@ import { checkPreview, composePlan } from './plan.js';
 import { assertLockHeld } from './lock.js';
 import { requestShape } from './ownership.js';
 import {planObservationPaths,retiredBundleOwnership} from './bundle-update.js';
+import {retiredSkillOwnership} from './skill-retirement.js';
 import {readConfigField} from './config-fields.js';
 import { planLayout } from '../workspace/resolve.js';
 import { cap, LIMITS, sha256 } from '../source/inventory.js';
@@ -18,6 +19,8 @@ import {verifyRepairApproval,validateRepairRecord} from './repair.js';
 import {verifyContinuationApproval,validateContinuationRecord,continuationTargetAction,continuationCommand} from './reconciliation.js';
 import {createLineageGuard} from './lineage-guard.js';
 import {verifyRemovalApproval,validateRemovalRecord} from './remove.js';
+import {verifyResetApproval,validateResetRecord} from './reset.js';
+import {assertResetTreeScope,resetBackupBytes} from './reset-scope.js';
 
 const fileHash=bytes=>bytes===null?null:sha256(bytes);
 const recordBytes=value=>{
@@ -59,26 +62,32 @@ export async function inspectRecovery(workspace,recoveryPath,options={}) {
   const repair=recovery.prepared?.kind==='prepared-repair';
   const continuation=recovery.prepared?.kind==='prepared-continuation';
   const removal=recovery.prepared?.kind==='prepared-removal';
-  const prepared=removal?validateRemovalRecord(recovery.prepared,recovery.approval):continuation?validateContinuationRecord(recovery.prepared,recovery.approval):repair?validateRepairRecord(recovery.prepared,recovery.approval):validatePreparedRecord(recovery.prepared,recovery.approval),previous=structuredClone(recovery.previous);
+  const reset=recovery.prepared?.kind==='prepared-reset';
+  const prepared=reset?validateResetRecord(recovery.prepared,recovery.approval):removal?validateRemovalRecord(recovery.prepared,recovery.approval):continuation?validateContinuationRecord(recovery.prepared,recovery.approval):repair?validateRepairRecord(recovery.prepared,recovery.approval):validatePreparedRecord(recovery.prepared,recovery.approval),previous=structuredClone(recovery.previous);
   const declared=prepared.preview.observations;
   if(!Array.isArray(declared))fail('recovery.record');
   const before=declared.map(o=>({path:o.path,bytes:o.bytes===null?null:Buffer.from(o.bytes,'base64')}));
   checkPreview(prepared.preview,previous,before);
   const plan=prepared.preview.plan;
-  const removalFlow=removal || (continuation && plan.command==='remove');
+  const removalFlow=removal || plan.command==='reset' || (continuation && plan.command==='remove');
   const deployment=removalFlow?previous?.active:plan.desired;
-  if(plan.workspace!==workspace || !(removalFlow?['remove']:continuation?['repair','update']:repair?['repair']:['setup','update']).includes(plan.command) || !deployment || !plan.source ||
+  if(plan.workspace!==workspace || !(plan.command==='reset' && (reset || continuation)?['reset']:removalFlow?['remove']:continuation?['repair','update']:repair?['repair']:['setup','update']).includes(plan.command) || !deployment || !plan.source ||
       contractDigest(plan.source)!==contractDigest(deployment.snapshot) ||
       plan.source.path!=='.pipeline/snapshots/'+plan.source.digest.slice(7))fail('recovery.binding');
   if(repair && (!previous?.active || contractDigest(plan.desired)!==contractDigest(previous.active) ||
       plan.targets.some(t=>!['create','edit-fields'].includes(t.action) || t.fields.some(f=>f.beforeHash!==null))))fail('recovery.binding');
   const lineage=continuation?await verifyContinuationLineage(workspace,prepared,previous):[];
   const expectedBackups=new Set(deployment.owned.filter(o=>o.backup!==null).map(o=>o.backup)),seen=new Set();
+  if(plan.command==='reset')for(const b of [...prepared.reset.backup.files,prepared.reset.backup.manifest])expectedBackups.add(b.path);
   for(const backup of recovery.backups) {
     requestShape(backup,['path','hash','existing'],[],'recovery.backup');
     if(!expectedBackups.has(backup.path) || seen.has(backup.path) || typeof backup.existing!=='boolean' ||
         !/^sha256:[a-f0-9]{64}$/.test(backup.hash))fail('recovery.backup');
     seen.add(backup.path);
+    if(plan.command==='reset'){
+      const expected=[...prepared.reset.backup.files,prepared.reset.backup.manifest].find(b=>b.path===backup.path);
+      if(expected && expected.hash!==backup.hash)fail('recovery.backup');
+    }
   }
   if(seen.size!==expectedBackups.size)fail('recovery.backup');
   const journalPath='.pipeline/journals/'+match[1];
@@ -258,6 +267,24 @@ export async function applyRepair(lock,prepared,approval,registry,options={}) {
     ()=>verifyRepairApproval(lock,copy,approval,registry),options);
 }
 
+export async function applyReset(lock,prepared,approval,registry,options={}) {
+  const copy=await verifyResetApproval(lock,prepared,approval,registry);
+  const previous=(await readState(resolveChild(lock.workspace,'.pipeline/state.json'))).value;
+  await preflightPreview(lock,copy.preview,previous,copy.stateFileHash);
+  const active=previous.active,source=active.snapshot;
+  const snapshot={snapshotPath:resolveChild(lock.workspace,source.path),manifest:{id:active.pipelineId,version:active.version},
+    digest:source.digest,inventoryDigest:source.inventoryDigest};
+  const backups=await planBackups(lock,{plan:{desired:active}},previous);
+  for(const item of copy.reset.backup.files){
+    const observed=copy.preview.observations.find(o=>o.path===item.source);
+    if(!observed || observed.hash!==item.hash || observed.bytes===null)fail('reset.backup-binding');
+    backups.push({path:item.path,hash:item.hash,existing:false,bytes:Buffer.from(observed.bytes,'base64')});
+  }
+  backups.push({...copy.reset.backup.manifest,existing:false,bytes:resetBackupBytes(copy.reset.backup)});
+  return executeChecked(lock,{prepared:copy,previous,snapshot,backups},approval,
+    ()=>verifyResetApproval(lock,copy,approval,registry),options);
+}
+
 // A new transaction records readback outcomes without changing the old journal.
 // Source/adapter replay was authorized by the original immutable operation;
 // current bytes and exact old evidence require a separate fresh approval here.
@@ -274,7 +301,7 @@ export async function applyContinuation(lock,prepared,approval,options={}) {
     const [{bytes}]=await observeTargets(lock.workspace,[backup.path]);
     backups.push({...backup,bytes,existing:true});
   }
-  const deployment=copy.preview.plan.command==='remove'?previous.active:copy.desired;
+  const deployment=['remove','reset'].includes(copy.preview.plan.command)?previous.active:copy.desired;
   const source=copy.preview.plan.source,snapshot={snapshotPath:resolveChild(lock.workspace,source.path),
     manifest:{id:deployment.pipelineId,version:deployment.version},digest:source.digest,inventoryDigest:source.inventoryDigest};
   return executeChecked(lock,{prepared:copy,previous,snapshot,backups},approval,
@@ -290,20 +317,23 @@ async function verifyContinuationLineage(workspace,prepared,previous) {
   guard.visit(evidence.recoveryPath);
   const old=await readRecord(resolveChild(workspace,evidence.recoveryPath));
   if(old.digest!==evidence.recoveryHash)fail('reconciliation.lineage');
-  const original=old.value.prepared?.kind==='prepared-removal'?validateRemovalRecord(old.value.prepared,old.value.approval):old.value.prepared?.kind==='prepared-continuation'?validateContinuationRecord(old.value.prepared,old.value.approval):old.value.prepared?.kind==='prepared-repair'?validateRepairRecord(old.value.prepared,old.value.approval):validatePreparedRecord(old.value.prepared,old.value.approval);
+  const original=old.value.prepared?.kind==='prepared-reset'?validateResetRecord(old.value.prepared,old.value.approval):old.value.prepared?.kind==='prepared-removal'?validateRemovalRecord(old.value.prepared,old.value.approval):old.value.prepared?.kind==='prepared-continuation'?validateContinuationRecord(old.value.prepared,old.value.approval):old.value.prepared?.kind==='prepared-repair'?validateRepairRecord(old.value.prepared,old.value.approval):validatePreparedRecord(old.value.prepared,old.value.approval);
+  if(contractDigest(prepared.reset??null)!==contractDigest(original.reset??null))fail('reconciliation.lineage');
   const plan=original.preview.plan;
   if(prepared.preview.plan.command!==continuationCommand(plan) ||
       contractDigest(prepared.preview.plan.source)!==contractDigest(plan.source))fail('reconciliation.lineage');
   checkPreview(original.preview,old.value.previous,original.preview.observations.map(o=>({path:o.path,bytes:o.bytes===null?null:Buffer.from(o.bytes,'base64')})));
   const beforeSetup=evidence.statePhase==='before';
-  if(beforeSetup ? (previous!==null || old.value.previous!==null || evidence.stateHash!==null ||
-      original.kind!=='prepared-plan' || original.stateFileHash!==null || plan.command!=='setup') :
+  const beforeReset=beforeSetup && original.kind==='prepared-reset' && plan.command==='reset' && previous?.active &&
+    previous.pending===null && contractDigest(previous)===contractDigest(old.value.previous) && original.stateFileHash===evidence.stateHash;
+  if(beforeSetup ? (!beforeReset && (previous!==null || old.value.previous!==null || evidence.stateHash!==null ||
+      original.kind!=='prepared-plan' || original.stateFileHash!==null || plan.command!=='setup')) :
       (previous?.pending!==contractDigest(plan) || contractDigest(previous?.active)!==contractDigest(old.value.previous?.active??null)))fail('reconciliation.lineage');
   if(contractDigest(prepared.desired)!==contractDigest(plan.desired))fail('reconciliation.lineage');
   const expectedJournal=evidence.recoveryPath.replace('/transactions/','/journals/').replace('/recovery.json','');
   if(evidence.journal!==expectedJournal)fail('reconciliation.lineage');
   const head=await readJournal(workspace,expectedJournal,plan,old.value.previous);
-  if(beforeSetup && (head.nextIndex!==0 || head.pending!==null || head.receipt!==null ||
+  if(beforeSetup && (head.nextIndex!==0 || head.pending!==null || ((!beforeReset || plan.targets.length>0) && head.receipt!==null) ||
       prepared.actions.some(a=>a.action!=='write-desired' || a.recorded!=='skipped')))fail('reconciliation.lineage');
   if(head.sequence!==evidence.journalHead.sequence || head.lastHash!==evidence.journalHead.hash)fail('reconciliation.lineage');
   if(prepared.stateFileHash!==evidence.stateHash || evidence.workspace!==workspace ||
@@ -336,8 +366,9 @@ async function executeChecked(lock,checked,approval,recheck,{boundary=async()=>{
   let prepared,previous;
   prepared=checked.prepared;previous=checked.previous;approval=structuredClone(approval);
   const plan=prepared.preview.plan,digest=contractDigest(plan);
-  const retired=new Set(plan.command==='update'?retiredBundleOwnership(previous,plan.desired).map(o=>o.path):[]);
-  if(plan.targets.some(t=>!['create','replace','edit-fields',...((plan.command==='remove' || retired.has(t.path))?['delete','verify-absent']:[])].includes(t.action)))fail('apply.unsupported-action');
+  const retired=new Set(plan.command==='update'?[...retiredBundleOwnership(previous,plan.desired),
+    ...retiredSkillOwnership(previous,plan.desired)].map(o=>o.path):[]);
+  if(plan.targets.some(t=>!['create','replace','edit-fields',...((['remove','reset'].includes(plan.command) || retired.has(t.path))?['delete','verify-absent']:[])].includes(t.action)))fail('apply.unsupported-action');
   if(plan.targets.some(t=>t.action==='verify-absent' && !readbackOnly.has(t.path)))fail('apply.unsupported-action');
   const pending={schemaVersion:1,workspace:lock.workspace,status:'needs-reconciliation',runtime:'not-run',
     active:previous?.active??null,pending:digest,...(previous?.activation?{activation:structuredClone(previous.activation)}:{})};
@@ -358,6 +389,7 @@ async function executeChecked(lock,checked,approval,recheck,{boundary=async()=>{
   // No contents, secrets or open file handles are passed to it.
   const io=purpose=>(phase,detail)=>ioBoundary({phase,purpose,...detail});
   await boundary('preflight');
+  if(plan.command==='reset')await assertResetTreeScope(lock.workspace,prepared.reset,plan);
   await copySnapshot(lock,checked.snapshot);
   for(const backup of checked.backups)await saveBackup(lock,backup.path,backup.bytes,backup.hash);
   await boundary('backups');
@@ -398,6 +430,7 @@ async function executeChecked(lock,checked,approval,recheck,{boundary=async()=>{
     }
   }
   await boundary('before-active');
+  if(plan.command==='reset')await assertResetTreeScope(lock.workspace,prepared.reset,plan,true);
   const final=await readJournal(lock.workspace,journal.relative,plan,previous);
   if(final.receipt?.status!=='completed')fail('apply.journal-incomplete');
   const expected=new Map(prepared.preview.observations.map(o=>[o.path,o.hash]));

package/src/operations/bundle-update.js

@@ -2,6 +2,7 @@ import { fail } from '../contracts/parse.js';
 import { contractDigest } from '../contracts/semantic.js';
 import { sha256 } from '../source/inventory.js';
 import { readConfigField, reconcileConfigFields } from './config-fields.js';
+import {retiredSkillOwnership} from './skill-retirement.js';
 
 // Only a member removed from a still-selected bundle may retire during update.
 // Standalone removal and removal of an entire bundle remain explicit operations.
@@ -14,7 +15,7 @@ export function retiredBundleOwnership(previous, selection) {
   return (previous?.active?.owned??[]).filter(o=>owners.has(o.owner));
 }
 export function planObservationPaths(requests, previous, selection) {
-  const retired=retiredBundleOwnership(previous,selection);
+  const retired=[...retiredBundleOwnership(previous,selection),...retiredSkillOwnership(previous,selection,requests)];
   return [...new Set([...requests.map(r=>r.path),...retired.flatMap(o=>[o.path,...(o.backup?[o.backup]:[])])])].sort();
 }
 export function restoreRetired(entries, observations) {

package/src/operations/plan.js

@@ -12,6 +12,7 @@ import { acquire } from '../source/git.js';
 import { readState, resolveOrigin, resolveApprovedRebind, verifyPreparedSnapshot, observeTargets } from './state.js';
 import { commonEntryPath, commonEntryText, needsCommonEntry } from '../providers/common-entry.js';
 import {planObservationPaths,retiredBundleOwnership,restoreRetired} from './bundle-update.js';
+import {retiredSkillOwnership} from './skill-retirement.js';
 
 // Trusted CLI destination policy, not a claim about tested harness discovery.
 const roots = {shared:['AGENTS.md','CLAUDE.md'],codex:['.codex/','.agents/skills/'],
@@ -193,7 +194,8 @@ export function composePlan({pipeline, workspace, wrapper, previous = null, snap
     }
   }
   // Removal/provider switch is S7. Never silently abandon existing ownership.
-  for(const restored of restoreRetired(retiredBundleOwnership(previous,layout),observed)) {
+  for(const restored of restoreRetired([...retiredBundleOwnership(previous,layout),
+    ...retiredSkillOwnership(previous,layout,ordered)],observed)) {
     if([...used].some(name=>overlaps(name,restored.path)))fail('plan.overlap');
     // Retirement cannot reach a newly selected repository destination.
     planLayout(pipeline,workspace,wrapper,{adapters,managedPaths:[...used,restored.path]});

package/src/operations/reconciliation.js

@@ -8,8 +8,10 @@ import {assertLockHeld} from './lock.js';
 import {bindPreview} from './plan.js';
 import {assertContinuationCapacity} from './lineage-guard.js';
 import {retiredBundleOwnership} from './bundle-update.js';
+import {retiredSkillOwnership} from './skill-retirement.js';
+import {assertResetTreeScope} from './reset-scope.js';
 
-export const continuationCommand=plan=>plan.command==='remove'?'remove':
+export const continuationCommand=plan=>['remove','reset'].includes(plan.command)?plan.command:
   plan.command==='update' && plan.targets.some(t=>t.desiredHash===null)?'update':'repair';
 
 // Current evidence and decisions still required, never a runnable retry/rollback.
@@ -42,13 +44,17 @@ export async function prepareContinuation(workspace,recoveryPath) {
   if(record.digest!==evidence.recoveryHash)fail('recovery.observation-drift');
   const previousPlan=record.value.prepared.preview,actions=[];
   const beforeSetup=evidence.statePhase==='before';
-  if(beforeSetup && (evidence.stateHash!==null || record.value.previous!==null ||
+  const beforeReset=beforeSetup && record.value.prepared.kind==='prepared-reset' && previousPlan.plan.command==='reset' &&
+    record.value.previous?.active && record.value.previous.pending===null && record.value.prepared.stateFileHash===evidence.stateHash;
+  if(beforeSetup && !beforeReset && (evidence.stateHash!==null || record.value.previous!==null ||
       record.value.prepared.kind!=='prepared-plan' || record.value.prepared.stateFileHash!==null ||
       previousPlan.plan.command!=='setup'))fail('reconciliation.not-pending');
-  if(beforeSetup && ((await inspectRecovery(workspace,recoveryPath)).receipt!==null ||
+  if(beforeSetup && ((!beforeReset || previousPlan.plan.targets.length>0) && (await inspectRecovery(workspace,recoveryPath)).receipt!==null ||
       evidence.targets.some(t=>t.position!=='before' || t.recorded!=='skipped')))fail('reconciliation.conflict');
-  const removal=previousPlan.plan.command==='remove';
-  const retired=new Set(retiredBundleOwnership(record.value.previous,previousPlan.plan.desired??{}).map(o=>o.path));
+  const removal=['remove','reset'].includes(previousPlan.plan.command);
+  if(previousPlan.plan.command==='reset')await assertResetTreeScope(workspace,record.value.prepared.reset,previousPlan.plan);
+  const retired=new Set([...retiredBundleOwnership(record.value.previous,previousPlan.plan.desired??{}),
+    ...(previousPlan.plan.command==='update'?retiredSkillOwnership(record.value.previous,previousPlan.plan.desired):[])].map(o=>o.path));
   assertContinuationCapacity(evidence.lineage.length);
   for(const target of previousPlan.plan.targets) {
     const observed=evidence.targets.find(t=>t.id===target.id);
@@ -78,6 +84,7 @@ export async function prepareContinuation(workspace,recoveryPath) {
       action:continuationTargetAction(a),beforeHash:a.beforeHash,desiredHash:a.desiredHash,fields:[]}))};
   const preview=bindPreview(plan,state?.value??null,{observations,outputs});
   const body={kind:'prepared-continuation',evidence,actions,preview,stateFileHash:evidence.stateHash,
+    ...(previousPlan.plan.command==='reset'?{reset:structuredClone(record.value.prepared.reset)}:{}),
     dependencies:previousPlan.observations.filter(o=>!actions.some(a=>a.path===o.path)),
     desired:structuredClone(previousPlan.plan.desired),
     applySupported:true,requiresFreshApproval:true,automaticActions:false,runtime:'not-run'};
@@ -91,13 +98,14 @@ export function continuationTargetAction(action) {
 }
 
 export function validateContinuationRecord(prepared,approval) {
-  requestShape(prepared,['kind','evidence','actions','preview','stateFileHash','dependencies','desired','applySupported','requiresFreshApproval','automaticActions','runtime','digest'],[],'reconciliation.prepared');
+  requestShape(prepared,['kind','evidence','actions','preview','stateFileHash','dependencies','desired','applySupported','requiresFreshApproval','automaticActions','runtime','digest'],['reset'],'reconciliation.prepared');
   requestShape(approval,['decision','preparedDigest'],[],'reconciliation.approval');
   const copy=structuredClone(parse(JSON.stringify(prepared),'json')),decision=structuredClone(approval);
   const {digest,...body}=copy;
   if(copy.kind!=='prepared-continuation' || copy.applySupported!==true || copy.requiresFreshApproval!==true ||
       copy.automaticActions!==false || copy.runtime!=='not-run' || contractDigest(body)!==digest)fail('reconciliation.prepared');
   if(decision.decision!=='approve' || decision.preparedDigest!==digest)fail('reconciliation.approval');
+  if((copy.preview?.plan?.command==='reset')!==Object.hasOwn(copy,'reset'))fail('reconciliation.prepared');
   return copy;
 }
 

package/src/operations/repair.js

@@ -25,7 +25,7 @@ function at(root,pointer) {
 // Read-only inspection, NOT a prepared repair/apply envelope. All requests are
 // replayed from installed bytes by trusted adapters; owned value hashes must
 // match state. User changes become conflicts, never rewritten ownership records.
-async function observeRepair(workspace,registry) {
+export async function observeRepair(workspace,registry) {
   requestShape(registry,['adapters','sharedAdapter'],[],'provider.interface');
   if(!registry.adapters || typeof registry.adapters!=='object' || Array.isArray(registry.adapters) ||
       typeof registry.sharedAdapter?.plan!=='function')fail('provider.interface');
@@ -96,7 +96,7 @@ async function observeRepair(workspace,registry) {
     if(hash(observation.bytes)!==hash(current.get(observation.path)))fail('repair.observation-drift');
   const body={kind:'repair-inspection',workspace,stateHash:record.digest,snapshot:active.snapshot.digest,entries,
     runtime:'not-run',automaticActions:false,applySupported:false,requiresFreshApproval:true};
-  return {inspection:{...body,digest:contractDigest(body)},current,desired};
+  return {inspection:{...body,digest:contractDigest(body)},current,desired,requests};
 }
 
 export async function inspectRepair(workspace,registry) {

package/src/operations/reset-scope.js

@@ -0,0 +1,82 @@
+import {opendir,lstat} from 'node:fs/promises';
+import {resolveChild,inspectDirectory} from '../workspace/paths.js';
+import {portablePath,contractDigest} from '../contracts/semantic.js';
+import {fail} from '../contracts/parse.js';
+import {cap,LIMITS,sha256} from '../source/inventory.js';
+import {removedWithProviders} from '../providers/common-entry.js';
+
+// Installer policy, never paths supplied by a pipeline package. Entire provider
+// dot-directories, authentication, permissions and models are NOT reset surfaces.
+const surfaces={
+  codex:{trees:['.agents/skills','.codex/agents'],fields:{'.codex/config.toml':['/agents','/mcp_servers']}},
+  claude:{trees:['.claude/skills','.claude/agents'],fields:{'.mcp.json':['/mcpServers']}},
+  grok:{trees:['.grok/skills','.grok/agents'],fields:{'.grok/config.toml':['/mcp_servers']}},
+  kimi:{trees:['.kimi-code/skills','.kimi-code/agents'],fields:{'.kimi-code/mcp.json':['/mcpServers']}}
+};
+export function resetScope(active,selection) {
+  const trees=[],fields={};
+  for(const id of selection.providers){
+    if(!Object.hasOwn(surfaces,id))fail('reset.provider');
+    trees.push(...surfaces[id].trees);Object.assign(fields,surfaces[id].fields);
+  }
+  if(active.owned.some(o=>o.kind==='file' && o.owner==='shared' && removedWithProviders(o,selection) && !['AGENTS.md','CLAUDE.md'].includes(o.path)))fail('reset.shared-scope');
+  const files=active.owned.filter(o=>o.kind==='file' && ['AGENTS.md','CLAUDE.md'].includes(o.path) && removedWithProviders(o,selection)).map(o=>o.path);
+  return {trees:trees.sort(),fields,files:[...new Set(files)].sort()};
+}
+export function scopeOwns(scope,name){
+  return scope.files.includes(name) || Object.hasOwn(scope.fields,name) || scope.trees.some(t=>name.startsWith(t+'/'));
+}
+export function scopeOwnsRecord(scope,owned){
+  if(!scopeOwns(scope,owned.path))return false;
+  return owned.kind==='file'?!Object.hasOwn(scope.fields,owned.path):
+    (scope.fields[owned.path]??[]).some(p=>owned.pointer===p || owned.pointer.startsWith(p+'/'));
+}
+export async function scanResetTrees(workspace,scope){
+  const files=[],directories=[],seen=new Set();let count=0;
+  async function walk(relative){
+    cap(++count,LIMITS.files,'reset.count');
+    const full=resolveChild(workspace,relative);
+    if(!(await inspectDirectory(full)).exists)return;
+    directories.push(relative);
+    for await(const entry of await opendir(full)){
+      cap(++count,LIMITS.files,'reset.count');
+      const name=relative+'/'+entry.name;portablePath(name);
+      if(['.git','.pipeline'].includes(entry.name.toLowerCase()))fail('reset.protected-tree');
+      const folded=name.toLowerCase();if(seen.has(folded))fail('reset.case-alias');seen.add(folded);
+      const stat=await lstat(resolveChild(workspace,name));
+      if(stat.isSymbolicLink())fail('reset.link');
+      if(stat.isDirectory())await walk(name);
+      else if(stat.isFile() && stat.nlink===1)files.push(name);
+      else fail('reset.file-type');
+    }
+  }
+  for(const tree of scope.trees)await walk(tree);
+  return {files:files.sort(),directories:directories.sort()};
+}
+// During recovery allow only the approved before/result pathname union. Unknown
+// files require a new decision; reset never expands deletion authority silently.
+export async function assertResetTreeScope(workspace,reset,plan,final=false){
+  const actual=await scanResetTrees(workspace,reset.scope);
+  const allowed=new Set(reset.tree.files);
+  for(const t of plan.targets)if(reset.scope.trees.some(p=>t.path.startsWith(p+'/'))){
+    if(t.desiredHash!==null)allowed.add(t.path);else if(final)allowed.delete(t.path);
+  }
+  if(actual.files.some(p=>!allowed.has(p)) || (final && (actual.files.length!==allowed.size || [...allowed].some(p=>!actual.files.includes(p)))))fail('reset.tree-drift');
+  const allowedDirs=new Set(reset.tree.directories);
+  for(const name of allowed){
+    for(const tree of reset.scope.trees)if(name.startsWith(tree+'/')){
+      let parent=name.slice(0,name.lastIndexOf('/'));
+      while(parent.length>=tree.length){allowedDirs.add(parent);parent=parent.slice(0,parent.lastIndexOf('/'));}
+    }
+  }
+  if(actual.directories.some(p=>!allowedDirs.has(p)))fail('reset.tree-drift');
+}
+export function resetBackupManifest(preview,selection,mode){
+  const seed=contractDigest({plan:preview.plan,selection,mode});
+  const directory='.pipeline/backups/reset/'+seed.slice(7);
+  const backup={directory,files:preview.plan.targets.filter(t=>t.beforeHash!==null).map((t,i)=>({
+    source:t.path,path:directory+'/'+i+'.bin',hash:t.beforeHash
+  }))};
+  return {...backup,manifest:{path:directory+'/manifest.json',hash:sha256(resetBackupBytes(backup))}};
+}
+export const resetBackupBytes=backup=>Buffer.from(JSON.stringify({schemaVersion:1,files:backup.files},null,2)+'\n');

package/src/operations/reset.js

@@ -0,0 +1,127 @@
+import {observeRepair} from './repair.js';
+import {readState,observeTargets,verifyInstalledSnapshot} from './state.js';
+import {selectBundleRemoval} from './remove.js';
+import {removedWithProviders} from '../providers/common-entry.js';
+import {absoluteRoot,resolveChild} from '../workspace/paths.js';
+import {readConfigField,reconcileConfigFields} from './config-fields.js';
+import {clearResetTOMLSections} from './toml-fields.js';
+import {requestShape} from './ownership.js';
+import {bindPreview} from './plan.js';
+import {contractDigest} from '../contracts/semantic.js';
+import {fail,parse} from '../contracts/parse.js';
+import {sha256} from '../source/inventory.js';
+import {assertLockHeld} from './lock.js';
+import {resetScope,scopeOwns,scopeOwnsRecord,scanResetTrees,resetBackupManifest} from './reset-scope.js';
+
+const hash=b=>b===null?null:sha256(b);
+const same=(a,b)=>contractDigest(a)===contractDigest(b);
+export function resetOptions(options){
+  requestShape(options,[],['to','all','providers','bundles'],'reset.options');
+  const to=options.to??'installed';if(!['installed','empty'].includes(to))fail('reset.mode');
+  if(options.all!==undefined && options.all!==true)fail('reset.selection');
+  if(options.all?(options.providers!==undefined || options.bundles!==undefined):
+    !(options.providers?.length || options.bundles?.length))fail('reset.selection');
+  return {to,...options.all?{all:true}:{...(options.providers?{providers:[...options.providers]}:{}),...(options.bundles?{bundles:[...options.bundles]}:{})}};
+}
+
+export async function prepareReset(workspace,registry,options){
+  const selectionRequest=resetOptions(options);workspace=absoluteRoot(workspace);
+  const {inspection,requests}=await observeRepair(workspace,registry);
+  const record=await readState(resolveChild(workspace,'.pipeline/state.json'));
+  if(record.digest!==inspection.stateHash)fail('reset.observation-drift');
+  const previous=record.value,active=previous.active;
+  const selection=selectBundleRemoval(active,selectionRequest.all?{}:selectionRequest);
+  const scope=resetScope(active,selection);
+  // Protect repository destinations, including absent repositories and docs roots.
+  const protectedPaths=[...Object.values(active.layout.repositories).map(r=>r.path)];
+  const docs=active.layout.documentation;
+  protectedPaths.push(active.layout.repositories[docs.repository].path+'/'+docs.path);
+  const overlap=(a,b)=>a.toLowerCase()===b.toLowerCase() || a.toLowerCase().startsWith(b.toLowerCase()+'/') || b.toLowerCase().startsWith(a.toLowerCase()+'/');
+  if([...scope.trees,...scope.files,...Object.keys(scope.fields)].some(p=>protectedPaths.some(r=>overlap(p,r))))fail('reset.repository-overlap');
+  const tree=await scanResetTrees(workspace,scope);
+  const selected=o=>removedWithProviders(o,selection);
+  if(active.owned.some(o=>selected(o) && !scopeOwnsRecord(scope,o)))fail('reset.unsupported-owned-scope');
+  if(active.owned.some(o=>!selected(o) && scopeOwnsRecord(scope,o)))fail('reset.shared-conflict');
+  if(inspection.entries.some(e=>!selected(e) && e.disposition!=='intact'))fail('reset.unselected-drift');
+  const names=[...new Set([...tree.files,...scope.files,...Object.keys(scope.fields),...active.owned.map(o=>o.path),
+    ...requests.filter(selected).map(r=>r.path)])].sort();
+  const observations=await observeTargets(workspace,names),current=new Map(observations.map(o=>[o.path,o.bytes]));
+  const desiredBytes=new Map(),owned=active.owned.filter(o=>!selected(o)).map(o=>structuredClone(o));
+  for(const name of [...tree.files,...scope.files])desiredBytes.set(name,null);
+  // Remove only known provider sections; model/auth/permissions and foreign
+  // sections survive. Malformed documents fail rather than getting wiped whole.
+  for(const [name,pointers] of Object.entries(scope.fields)){
+    const before=current.get(name);let bytes=before;
+    if(name.endsWith('.toml')){
+      desiredBytes.set(name,clearResetTOMLSections(before,pointers.map(p=>p.slice(1))));continue;
+    }
+    for(const pointer of pointers){
+      const found=readConfigField(name,bytes,pointer);
+      if(found.present)bytes=reconcileConfigFields(name,bytes,[{pointer,present:false,managedHash:contractDigest(found.value)}]).bytes;
+    }
+    desiredBytes.set(name,bytes);
+  }
+  if(selectionRequest.to==='installed')for(const request of requests.filter(selected)){
+    if(!scopeOwns(scope,request.path))fail('reset.unsupported-owned-scope');
+    if(request.kind==='file'){
+      desiredBytes.set(request.path,request.bytes);
+      owned.push({path:request.path,owner:request.owner,kind:'file',pointer:null,beforeHash:null,managedHash:sha256(request.bytes),backup:null});
+    }else{
+      const fields=request.fields.map(f=>f.present?{pointer:f.pointer,present:true,value:f.value}:{pointer:f.pointer,present:false});
+      if(fields.some(f=>!(scope.fields[request.path]??[]).some(p=>f.pointer===p || f.pointer.startsWith(p+'/'))))fail('reset.unsupported-owned-scope');
+      const result=reconcileConfigFields(request.path,desiredBytes.get(request.path)??null,fields);
+      desiredBytes.set(request.path,result.bytes);
+      for(const f of result.decisions)if(f.desiredHash!==null)owned.push({path:request.path,owner:request.owner,kind:'field',pointer:f.pointer,beforeHash:null,managedHash:f.desiredHash,backup:null});
+    }
+  }
+  const targets=[],outputs=[];
+  for(const [name,bytes] of [...desiredBytes].sort(([a],[b])=>a.localeCompare(b))){
+    const before=current.get(name)??null;if(hash(before)===hash(bytes))continue;
+    const owner=active.owned.find(o=>o.path===name && selected(o))?.owner??selection.providers.find(id=>scopeOwns(resetScope(active,{providers:[id],remaining:active.providers.filter(p=>p!==id),owners:[id]}),name));
+    if(!owner)fail('reset.owner');
+    targets.push({id:'target-'+(targets.length+1),path:name,owner,action:bytes===null?'delete':before===null?'create':'replace',
+      beforeHash:hash(before),desiredHash:hash(bytes),fields:[]});
+    if(bytes!==null)outputs.push({path:name,bytes});
+  }
+  let desired=structuredClone(active);
+  if(selectionRequest.to==='empty'){
+    desired.providers=selection.remaining;
+    desired.adapterVersions=Object.fromEntries(selection.remaining.map(p=>[p,active.adapterVersions[p]]));
+    if(desired.bundles){desired.bundles=Object.fromEntries(Object.entries(desired.bundles).filter(([id])=>!selection.bundles.includes(id)));if(!Object.keys(desired.bundles).length)delete desired.bundles;}
+    if(!selection.remaining.length)desired=null;
+  }
+  if(desired){desired.owned=owned;desired.id='deployment-'+contractDigest({resetFrom:record.digest,deployment:{...desired,id:null}}).slice(7);}
+  const preview=bindPreview({schemaVersion:1,kind:'plan',command:'reset',workspace,beforeStateHash:contractDigest(previous),
+    source:structuredClone(active.snapshot),desired,targets},previous,{observations,outputs});
+  const backup=resetBackupManifest(preview,selectionRequest,selectionRequest.to);
+  const body={kind:'prepared-reset',preview,stateFileHash:record.digest,reset:{selection:selectionRequest,scope,tree,backup},
+    applySupported:true,requiresFreshApproval:true,automaticActions:false,runtime:'not-run'};
+  if(!same(tree,await scanResetTrees(workspace,scope)))fail('reset.tree-drift');
+  for(const fresh of await observeTargets(workspace,names))if(hash(fresh.bytes)!==hash(current.get(fresh.path)))fail('reset.observation-drift');
+  await verifyInstalledSnapshot(previous);
+  if((await readState(resolveChild(workspace,'.pipeline/state.json'))).digest!==record.digest)fail('reset.observation-drift');
+  parse(JSON.stringify(body),'json');return {...body,digest:contractDigest(body)};
+}
+
+export function validateResetRecord(prepared,approval){
+  requestShape(prepared,['kind','preview','stateFileHash','reset','applySupported','requiresFreshApproval','automaticActions','runtime','digest'],[],'reset.prepared');
+  requestShape(approval,['decision','preparedDigest'],[],'reset.approval');
+  const copy=parse(JSON.stringify(prepared),'json'),{digest,...body}=copy;
+  if(copy.kind!=='prepared-reset' || copy.preview?.plan?.command!=='reset' || copy.runtime!=='not-run' ||
+    copy.applySupported!==true || copy.requiresFreshApproval!==true || copy.automaticActions!==false || contractDigest(body)!==digest)fail('reset.prepared');
+  if(approval.decision!=='approve' || approval.preparedDigest!==digest)fail('reset.approval');
+  validateResetContext(copy.reset,copy.preview);
+  return structuredClone(copy);
+}
+export function validateResetContext(reset,preview){
+  requestShape(reset,['selection','scope','tree','backup'],[],'reset.context');
+  resetOptions(reset.selection);
+  if(!same(reset.backup,resetBackupManifest(preview,reset.selection,reset.selection.to)))fail('reset.backup-binding');
+}
+export async function verifyResetApproval(lock,prepared,approval,registry){
+  const copy=validateResetRecord(prepared,approval);await assertLockHeld(lock);
+  if(copy.preview.plan.workspace!==lock.workspace)fail('reset.workspace');
+  const fresh=await prepareReset(lock.workspace,registry,copy.reset.selection);
+  if(!same(fresh,copy))fail('reset.plan-drift');
+  await assertLockHeld(lock);return fresh;
+}

package/src/operations/skill-retirement.js

@@ -0,0 +1,14 @@
+// Only native skill routing files of still-selected providers are eligible.
+// No config, root instruction, agent, unknown file or removed provider cleanup.
+// Eligibility alone is not deletion authority: replay, before hashes and preview
+// approval remain mandatory in the plan/apply lifecycle.
+const roots={codex:'.agents',claude:'.claude',grok:'.grok',kimi:'.kimi-code'};
+export function retiredSkillOwnership(previous,selection,requests=selection.owned??[]) {
+  const paths=new Set(requests.map(r=>r.path));
+  return (previous?.active?.owned??[]).filter(o=>{
+    const root=roots[o.owner],prefix=root+'/skills/';
+    if(!root || o.kind!=='file' || !selection.providers.includes(o.owner) ||
+      paths.has(o.path) || !o.path.startsWith(prefix))return false;
+    return /^[a-z][a-z0-9-]{0,62}\/SKILL\.md$/.test(o.path.slice(prefix.length));
+  });
+}

package/src/operations/toml-fields.js

@@ -4,14 +4,16 @@ import {fail, MAX_INPUT_BYTES} from '../contracts/parse.js';
 import {utf8} from '../source/inventory.js';
 import {reconcileFields,requestShape} from './ownership.js';
 
+export const AGENT_CONTROL_KEYS=Object.freeze(['enabled','max_threads','max_depth','max_concurrent_threads_per_session',
+  'default_subagent_model','default_subagent_reasoning_effort','job_max_runtime_seconds','interrupt_message']);
+
 // Only complete named Codex agent/MCP entries. No model, permission, auth or
 // trust setting may be addressed through this editor. No I/O or authorization.
 function parts(pointer) {
   if(typeof pointer!=='string' || !/^\/(agents|mcp_servers)\/[a-z][a-z0-9_-]{0,99}$/.test(pointer))fail('toml.scope');
   const result=pointer.slice(1).split('/');
   if(['__proto__','prototype','constructor'].includes(result[1]))fail('toml.scope');
-  if(result[0]==='agents' && ['enabled','max_threads','max_depth','max_concurrent_threads_per_session',
-    'default_subagent_model','default_subagent_reasoning_effort','job_max_runtime_seconds','interrupt_message'].includes(result[1]))fail('toml.scope');
+  if(result[0]==='agents' && AGENT_CONTROL_KEYS.includes(result[1]))fail('toml.scope');
   return result;
 }
 const prefix=(a,b)=>a.length<=b.length && a.every((x,i)=>x===b[i]);
@@ -94,6 +96,37 @@ function normalizeEmptyRoots(value) {
   return value;
 }
 
+// Reset-only editor: never widen the ordinary ownership editor's pointer scope.
+// Keep agent runtime/model controls; clear named definitions and MCP declarations.
+export function clearResetTOMLSections(bytes,roots) {
+  if(!Array.isArray(roots) || roots.some(r=>!['agents','mcp_servers'].includes(r)))fail('toml.scope');
+  if(bytes===null)return null;
+  const before=document(bytes),expected=structuredClone(before.value),ranges=[];
+  for(const root of roots){
+    if(!Object.hasOwn(before.value,root))continue;
+    if(root==='agents'){
+      const entries=before.value[root];
+      if(!entries || typeof entries!=='object' || Array.isArray(entries) || entries instanceof Date)fail('toml.ancestor');
+      for(const name of Object.keys(entries).filter(n=>!AGENT_CONTROL_KEYS.includes(n))){
+        // Unknown non-table settings are not named agent definitions. Preserve
+        // their original bytes rather than guessing future harness controls.
+        const entry=entries[name];
+        if(!entry || typeof entry!=='object' || Array.isArray(entry) || entry instanceof Date)continue;
+        ranges.push(...deletionRanges(before.ast,[root,name]));delete expected[root][name];
+      }
+    }else{ranges.push(...deletionRanges(before.ast,[root]));delete expected[root];}
+  }
+  let result=before.text;
+  const ordered=ranges.map(([s,e])=>[s,e+(before.text.startsWith('\r\n',e)?2:before.text[e]==='\n'?1:0)]).sort((a,b)=>b[0]-a[0]);
+  for(let i=0;i<ordered.length;i++){
+    const [s,e]=ordered[i];if(i && e>ordered[i-1][0])fail('toml.overlap');
+    result=result.slice(0,s)+result.slice(e);
+  }
+  const output=Buffer.from(result);
+  if(!isDeepStrictEqual(normalizeEmptyRoots(document(output).value),normalizeEmptyRoots(expected)))fail('toml.postcondition');
+  return output;
+}
+
 export function reconcileTOMLFields(bytes,requests) {
   const before=document(bytes),projected=Object.create(null);
   if(!Array.isArray(requests) || !requests.length || requests.length>1000)fail('toml.requests');