hyp policy: class-neutral machine-local marking verb (LLP 0110/0111) (#327)

* Design: hyp policy verb (covers LLP 0110)

Generated-by: neutral

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Plan: hyp policy verb (LLP 0112, implements LLP 0111)

Generated-by: neutral

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Hoist ignore/unignore marking internals into verb-agnostic shared impls

Extract runMarkMachineLocal, runUnmarkMachineLocal, and runIgnoreCheck in
src/core/commands/clients.js so they take an explicit resolved targetDir
instead of computing it from parsed argv, and add repoRootDefaultTarget as
the one shared repo-root-default placement rule. This is a pure refactor
with zero behavior change: the flag branches in runIgnore/runUnignore now
resolve the target and delegate, but stdout/stderr/exit codes are unchanged,
so all existing ignore/unignore tests pass unmodified. This sets up both
the flag forms and the future hyp policy runners (LLP 0112 T2) to call one
implementation instead of drifting. Carries the existing @ref LLP 0103#cli
annotations along with the moved code; gloss updates come in T6.

Task-Id: T1

* Register hyp policy set/show/unset/list, delegating to shared T1 internals

Adds the hyp policy command group (LLP 0110/0111) as the class-neutral
successor to the ignore --sync/--local-only/--private aliases: thin
runners in src/core/commands/policy.js parse CLI args and delegate to
the shared runMarkMachineLocal/runUnmarkMachineLocal/runIgnoreCheck
internals in clients.js, now exported and parameterized by a
`component` attribute so telemetry still names the dispatching verb.

runUnmarkMachineLocal gains a class-neutral mode (targetClass
undefined) backing `policy unset <path>` with no trailing token,
removing every machine-local entry governing a path regardless of
class, alongside the existing class-scoped removal used by both
`unignore` and `policy unset <path> <class>`.

`policy list` enumerates the machine-local store directly with a
--json {entries, path} shape; `policy show` reuses runIgnoreCheck so
its --json output stays byte-compatible with `ignore --check --json`.

New test/core/policy-command.test.js mirrors the existing
ignore-private-sync-command coverage for the new spellings, plus list
enumeration and class-neutral unset across multiple governing
entries.

Task-Id: T2

* Turn ignore/unignore marking flags into deprecated policy aliases

The --sync/--local-only/--private/--check branches in runIgnore/runUnignore
already delegate to the T1 hoisted internals (runMarkMachineLocal,
runUnmarkMachineLocal, runIgnoreCheck) that the T2 policy runners call, so
the delegation seam is single-implementation by construction and alias
behavior cannot drift from the verb's. This task makes the compatibility
posture explicit:

- Annotate the delegation seam in both runners with
  // @ref LLP 0111#aliases [implements], noting the flag forms' repo-root
  defaulting is preserved at the alias edge (and unignore's cwd-relative
  no-default target likewise).
- Mark the --local-only/--private/--sync/--check flags "deprecated: use
  hyp policy ..." in the hyp ignore / hyp unignore registry help, while
  stating the bare dotfile verbs are not deprecated. No runtime stderr
  warning (LLP 0111 #aliases).

Zero behavior change: every existing alias test passes unchanged (stdout,
stderr, exit codes, JSON fields, usage_policy.mark log event), the
compatibility proof LLP 0110's exit criteria require. npm test (2284),
typecheck, and build:types all green.

@ref LLP 0111#aliases [implements]

Task-Id: T3
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Migrate classification hook copy to hyp policy set (LLP 0106, 0110, 0111)

Swap the consent-sensitive classification hook copy off the deprecated
`hyp ignore --sync`/`--local-only`/`--private` misnomer and onto the
class-neutral `hyp policy set <path> <token>` verb (registered since T2).

- CLASSIFICATION_CHOICES: replace the `flag` field with the CLI-edge class
  `token` (`sync`/`local-only`/`ignore`).
- verbArgvForClass now returns ['policy', 'set', targetPath, token], dispatched
  against the registry's two-word `policy set` path.
- buildClassificationPrompt prints `hyp policy set <cwd> <token>`.
- Pinned consent-copy tests updated in the same commit, plus an exit-criterion
  assertion that no ignore-spelled command is taught for a non-ignore class.
- @ref glosses cite LLP 0111#teaching for the verb surface; the store and class
  rationale keeps citing LLP 0103#cli.

Task-Id: T4

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* T5: migrate skill and status/help teaching copy to the hyp policy verb

Both hypaware-privacy SKILL.md bodies (claude + codex) now teach the
machine-local marking surface as `hyp policy set/show/unset` instead of
the `hyp ignore --sync/--local-only/--private/--check` and
`hyp unignore --<class>` misnomer. The bare `.hypignore` dotfile verbs
are left untouched. Both bodies stay byte-consistent with each other.

Swept the remaining runtime help strings that pointed users at the
marking flags: the login durable-command hint (DURABLE_HINT) and the
purge durability tip now name `hyp policy set ...`, with their pinned
teaching-copy test assertions moved in the same commit. The alias
behavior tests (hyp ignore --*/hyp unignore --*) are untouched and still
pass as the compatibility proof.

No product surface teaches an ignore-spelled command for a non-ignore
class. Classification hook copy (classification.js) is out of scope here
(T4); the JSDoc on the alias runners keeps naming the old flags because
those functions are the aliases.

@ref LLP 0111#teaching [implements]
@ref LLP 0110 [implements]

Task-Id: T5

* Ref hygiene sweep for hyp policy verb (LLP 0110/0111)

Ran ref-check across the touched hyp-policy-verb surface (clients.js,
policy.js, classification.js, core_commands.js, both hypaware-privacy
SKILL.md bodies, and LLP 0103/0110/0111/0112) and found the verb-surface
@ref citations already correct from T2-T5. The remaining stale spots
were three doc comments left over from T1's carry-forward
(repoRootDefaultTarget, runMarkMachineLocal, runIgnoreCheck) that still
described the policy set/show runners as "a future task" and described
repoRootDefaultTarget as shared with the future policy verb, when in
fact policy set/show now exist and policy set deliberately never calls
repoRootDefaultTarget (it marks the resolved path exactly as pointed at,
per LLP 0111 #set). Corrected those glosses to state the current,
already-landed relationship instead of a stale forward-looking one.

Verified LLP 0103's Extended-by: LLP 0110 forward-ref still reads
correctly against the final shipped verb surface. ref-check's only
remaining findings in touched files are two pre-existing false
positives against LLP 0086's HTML-anchor sections (the tool only scans
markdown headings), unrelated to this change set and present before
T1-T5 touched this file.

No behavior change. npm test (2284 tests) and npm run typecheck both
pass.

Task-Id: T6

* Complete hyp policy doc sweep: hyp ignore --check -> hyp policy show in sibling skills

Folds in the deferred minor review finding from PR #327 review round 1
(the sensitive-scan and reference skills still taught the deprecated
hyp ignore --check alias). Doc-only; no behavior change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: neutral-loop <neutral-loop@localhost>

Author: 3 people

hypaware-core/plugins-workspace/claude/skills/hypaware-privacy/SKILL.md

@@ -91,9 +91,9 @@ WHERE cwd = '<dir>' ORDER BY date DESC LIMIT 40" --format json --output /tmp/sam
 
 Before you propose or apply **anything**, explain the classes in plain language, including what the org can and cannot see in each case:
 
-- **ignore** (`hyp ignore --private <dir>`): never recorded going forward; the machine-local rule stops capture at the source. Existing cached rows are **purgeable** (Step 6) but are not removed by marking alone. The org sees **nothing** from this directory.
-- **local-only** (`hyp ignore --local-only <dir>`): recorded and queryable **here** on this machine, but **never forwarded**. Withheld at the export seam. The org sees **nothing**, while you keep local history.
-- **sync** (`hyp ignore --sync <dir>`): the explicit "this ships" choice - forwarded to the org server like the default. Marking `--sync` records an explicit decision so this directory is not asked about again. The org sees this directory's captured exchanges.
+- **ignore** (`hyp policy set <dir> ignore`): never recorded going forward; the machine-local rule stops capture at the source. Existing cached rows are **purgeable** (Step 6) but are not removed by marking alone. The org sees **nothing** from this directory.
+- **local-only** (`hyp policy set <dir> local-only`): recorded and queryable **here** on this machine, but **never forwarded**. Withheld at the export seam. The org sees **nothing**, while you keep local history.
+- **sync** (`hyp policy set <dir> sync`): the explicit "this ships" choice - forwarded to the org server like the default. Marking it `sync` records an explicit decision so this directory is not asked about again. The org sees this directory's captured exchanges.
 
 Name the trade honestly: `local-only` keeps your history usable locally; `ignore` is stronger (nothing is even recorded once marked) but you lose local queryability too.
 
@@ -112,14 +112,14 @@ Then **apply nothing without per-item user confirmation.** Propose, wait for a y
 Apply each confirmed decision **only** through the `hyp` verbs below. **Never** author policy files or write anything into the user's repositories - the machine-local store is the only target.
 
 ```bash
-hyp ignore --private <dir>       # class: ignore  (stop recording this dir)
-hyp ignore --local-only <dir>    # class: local-only (record here, never forward)
-hyp ignore --sync <dir>          # class: sync (explicit "this ships")
-hyp ignore --check <dir>         # report the governing source + class, and residual cached rows; never writes
-hyp unignore --private|--local-only|--sync <dir>   # symmetric removal per class
+hyp policy set <dir> ignore      # class: ignore  (stop recording this dir)
+hyp policy set <dir> local-only  # class: local-only (record here, never forward)
+hyp policy set <dir> sync        # class: sync (explicit "this ships")
+hyp policy show <dir>            # report the governing source + class, and residual cached rows; never writes
+hyp policy unset <dir> [class]   # remove markings (class-neutral by default; a trailing class scopes it)
 ```
 
-`hyp ignore --check <dir>` names **which source governs** (a committed `.hypignore` dotfile vs a machine-local entry) and the entry's class, and reports how many already-cached rows still sit under it - the residue that purge (below) clears. Marking is always **non-destructive**: it changes future capture/forwarding, not existing cached rows.
+`hyp policy show <dir>` names **which source governs** (a committed `.hypignore` dotfile vs a machine-local entry) and the entry's class, and reports how many already-cached rows still sit under it - the residue that purge (below) clears. Marking is always **non-destructive**: it changes future capture/forwarding, not existing cached rows.
 
 **For every directory you mark `ignore`, and every session you flag as sensitive, offer `hyp purge` as a separately confirmed step** so that "completely ignored" also means "not sitting in the cache". Purge is destructive and cache-only (it never contacts the server); confirm each purge on its own.
 
@@ -129,10 +129,10 @@ hyp purge --session <id>     # delete all cached rows for one session (cheapest:
 hyp purge --ignored          # sweep every cached row whose cwd currently resolves to `ignore`
 ```
 
-Purge prompts for confirmation on a TTY; it errors on a bare `hyp purge` with no target. Sequencing matters: **mark `--private` first, then purge** - purging a directory that still resolves to `sync`/default warns that the next backfill will re-import it. Once a directory is `ignore`d, the capture seam blocks re-import, so the purge is durable. A common close-out for a directory the user wants fully gone:
+Purge prompts for confirmation on a TTY; it errors on a bare `hyp purge` with no target. Sequencing matters: **mark the directory `ignore` first, then purge** - purging a directory that still resolves to `sync`/default warns that the next backfill will re-import it. Once a directory is `ignore`d, the capture seam blocks re-import, so the purge is durable. A common close-out for a directory the user wants fully gone:
 
 ```bash
-hyp ignore --private <dir> && hyp purge <dir>
+hyp policy set <dir> ignore && hyp purge <dir>
 ```
 
 ## After the review

hypaware-core/plugins-workspace/claude/skills/hypaware-sensitive-scan/SKILL.md

@@ -92,7 +92,7 @@ All examples redacted. Two groups, then the caveat:
   current session forward, reverse with `/hypaware-unignore`).
 - **Caveat (always).** The sensitive rows above are **already recorded**; ignoring is
   prospective and does not delete them. Show the residual with
-  `hyp ignore --check <path>` (reports the governor and how many cached rows from the
+  `hyp policy show <path>` (reports the governor and how many cached rows from the
   scope remain). Retroactive purge is out of scope.
 
 ## Notes

hypaware-core/plugins-workspace/codex/skills/hypaware-privacy/SKILL.md

@@ -119,9 +119,9 @@ WHERE cwd = '<dir>' ORDER BY date DESC LIMIT 40" --format json --output /tmp/sam
 
 Before you propose or apply **anything**, explain the classes in plain language, including what the org can and cannot see in each case:
 
-- **ignore** (`hyp ignore --private <dir>`): never recorded going forward; the machine-local rule stops capture at the source. Existing cached rows are **purgeable** (Step 6) but are not removed by marking alone. The org sees **nothing** from this directory.
-- **local-only** (`hyp ignore --local-only <dir>`): recorded and queryable **here** on this machine, but **never forwarded**. Withheld at the export seam. The org sees **nothing**, while you keep local history.
-- **sync** (`hyp ignore --sync <dir>`): the explicit "this ships" choice - forwarded to the org server like the default. Marking `--sync` records an explicit decision so this directory is not asked about again. The org sees this directory's captured exchanges.
+- **ignore** (`hyp policy set <dir> ignore`): never recorded going forward; the machine-local rule stops capture at the source. Existing cached rows are **purgeable** (Step 6) but are not removed by marking alone. The org sees **nothing** from this directory.
+- **local-only** (`hyp policy set <dir> local-only`): recorded and queryable **here** on this machine, but **never forwarded**. Withheld at the export seam. The org sees **nothing**, while you keep local history.
+- **sync** (`hyp policy set <dir> sync`): the explicit "this ships" choice - forwarded to the org server like the default. Marking it `sync` records an explicit decision so this directory is not asked about again. The org sees this directory's captured exchanges.
 
 Name the trade honestly: `local-only` keeps your history usable locally; `ignore` is stronger (nothing is even recorded once marked) but you lose local queryability too.
 
@@ -140,14 +140,14 @@ Then **apply nothing without per-item user confirmation.** Propose, wait for a y
 Apply each confirmed decision **only** through the `hyp` verbs below. **Never** author policy files or write anything into the user's repositories - the machine-local store is the only target.
 
 ```bash
-hyp ignore --private <dir>       # class: ignore  (stop recording this dir)
-hyp ignore --local-only <dir>    # class: local-only (record here, never forward)
-hyp ignore --sync <dir>          # class: sync (explicit "this ships")
-hyp ignore --check <dir>         # report the governing source + class, and residual cached rows; never writes
-hyp unignore --private|--local-only|--sync <dir>   # symmetric removal per class
+hyp policy set <dir> ignore      # class: ignore  (stop recording this dir)
+hyp policy set <dir> local-only  # class: local-only (record here, never forward)
+hyp policy set <dir> sync        # class: sync (explicit "this ships")
+hyp policy show <dir>            # report the governing source + class, and residual cached rows; never writes
+hyp policy unset <dir> [class]   # remove markings (class-neutral by default; a trailing class scopes it)
 ```
 
-`hyp ignore --check <dir>` names **which source governs** (a committed `.hypignore` dotfile vs a machine-local entry) and the entry's class, and reports how many already-cached rows still sit under it - the residue that purge (below) clears. Marking is always **non-destructive**: it changes future capture/forwarding, not existing cached rows.
+`hyp policy show <dir>` names **which source governs** (a committed `.hypignore` dotfile vs a machine-local entry) and the entry's class, and reports how many already-cached rows still sit under it - the residue that purge (below) clears. Marking is always **non-destructive**: it changes future capture/forwarding, not existing cached rows.
 
 **For every directory you mark `ignore`, and every session you flag as sensitive, offer `hyp purge` as a separately confirmed step** so that "completely ignored" also means "not sitting in the cache". Purge is destructive and cache-only (it never contacts the server); confirm each purge on its own.
 
@@ -157,10 +157,10 @@ hyp purge --session <id>     # delete all cached rows for one session (cheapest:
 hyp purge --ignored          # sweep every cached row whose cwd currently resolves to `ignore`
 ```
 
-Purge prompts for confirmation on a TTY; it errors on a bare `hyp purge` with no target. Sequencing matters: **mark `--private` first, then purge** - purging a directory that still resolves to `sync`/default warns that the next backfill will re-import it. Once a directory is `ignore`d, the capture seam blocks re-import, so the purge is durable. A common close-out for a directory the user wants fully gone:
+Purge prompts for confirmation on a TTY; it errors on a bare `hyp purge` with no target. Sequencing matters: **mark the directory `ignore` first, then purge** - purging a directory that still resolves to `sync`/default warns that the next backfill will re-import it. Once a directory is `ignore`d, the capture seam blocks re-import, so the purge is durable. A common close-out for a directory the user wants fully gone:
 
 ```bash
-hyp ignore --private <dir> && hyp purge <dir>
+hyp policy set <dir> ignore && hyp purge <dir>
 ```
 
 ## After the review

hypaware-core/plugins-workspace/codex/skills/hypaware-reference/SKILL.md

@@ -146,7 +146,7 @@ registry.
   **hypaware-ai-spend-report**, **-adoption-report**, **-security-report**, or
   **-improvement-report** skills.
 - Opt a folder out of recording - `hyp ignore` / `hyp unignore` write or remove
-  a `.hypignore` for the folder subtree (`hyp ignore --check` reports what
+  a `.hypignore` for the folder subtree (`hyp policy show` reports what
   governs a path).
 - "Is it working?" or diagnose a problem - `hyp status` (with `--json` for the
   stable shape); its `diagnostics:` section carries `repair:` lines to run.

hypaware-core/plugins-workspace/codex/skills/hypaware-sensitive-scan/SKILL.md

@@ -94,7 +94,7 @@ All examples redacted. Two groups, then the caveat:
   `hyp unignore` once the sensitive work is done).
 - **Caveat (always).** The sensitive rows above are **already recorded**; ignoring is
   prospective and does not delete them. Show the residual with
-  `hyp ignore --check <path>` (reports the governor and how many cached rows from the
+  `hyp policy show <path>` (reports the governor and how many cached rows from the
   scope remain). Retroactive purge is out of scope.
 
 ## Notes