@techgoblin/gobstack 0.4.4-beta.6 → 0.4.4-beta.8

package/bin/goblin-lib.sh

@@ -216,6 +216,37 @@ g_installed_scalar() {
   sed -n "s/^[[:space:]]*\"$2\"[[:space:]]*:[[:space:]]*\"\{0,1\}\([^\",]*\)\"\{0,1\},\{0,1\}$/\1/p" "$1" | head -n 1
 }
 
+# g_installed_scalar_options <file> <key> — the value of one key inside the "options" object
+# of an install record (e.g. skills). The installer writes options on ONE line
+# (`"options": {"skills": "yes", ...}`), so the awk reads that line's shape directly; a
+# multi-line variant is read the same way the other installed_* readers read their block.
+g_installed_scalar_options() {
+  awk -v k="$2" '
+    /^[[:space:]]*"options"[[:space:]]*:[[:space:]]*\{/ && index($0, "\"" k "\"") {
+      # single-line form: pull the value out between the key and the next , or }
+      line = $0
+      sub(/^[^{]*\{/, "", line)          # everything up to and including the opening brace
+      n = split(line, pair, ",")
+      for (i = 1; i <= n; i++) {
+        p = pair[i]
+        sub(/^[[:space:]]*/, "", p); sub(/[[:space:]]*$/, "", p)
+        key = p; sub(/[[:space:]]*:.*/, "", key); gsub(/"/, "", key)
+        if (key == k) {
+          v = p; sub(/^[^:]*:[[:space:]]*/, "", v); gsub(/"/, "", v); sub(/\}[[:space:]]*$/, "", v)
+          print v; exit
+        }
+      }
+      exit
+    }
+    /^[[:space:]]*"options"[[:space:]]*:[[:space:]]*\{/ { inf = 1; next }
+    inf && /^[[:space:]]*\}/ { inf = 0 }
+    inf && index($0, "\"" k "\"") {
+      v = $0; sub(/^[^:]*:[[:space:]]*/, "", v); sub(/,?[[:space:]]*$/, "", v); gsub(/"/, "", v)
+      print v; exit
+    }
+  ' "$1"
+}
+
 # ------------------------------------------------------------- self-test -----
 # Proves the parser actually parses. Every assertion is a real comparison against a
 # value written to a temp file in this function — blank the awk in g_yaml_scalar and

package/bin/goblin-verify

@@ -536,6 +536,13 @@ check_in_02() {
           [ -e "$ROOT/$p" ] || continue ;;
       esac
     fi
+    # W6 neutral-first: an EXPLICIT --skills no re-install removes the recorded skill files
+    # by design (the record follows the switch). Their absence on a record whose options now
+    # say skills=no is the documented opt-out, not drift - the same clause W4a wrote for the
+    # global tier, scoped to the record's own declared choice.
+    case "$p" in
+      .hermes/skills/*) [ -e "$ROOT/$p" ] || [ "$(g_installed_scalar_options "$INSTALLED" skills)" = "yes" ] || continue ;;
+    esac
     n=$((n + 1))
     cur=$(g_sha256_file "$ROOT/$p")
     if [ "$cur" != "$h" ]; then
@@ -2661,6 +2668,21 @@ while IFS=$'\t' read -r id scope rule enforced_by artifact check why; do
   only_selected "$id" || continue
 
   part=$(row_part "$id")
+  # W6 neutral-first: in global engine mode AU-01's subject is the PRODUCER glob, which
+  # global mode reads from the engine dir — the row must run there even when the repo's
+  # skills opt-out (playbooks) is set, or the W1 control below it is skip-masked. This
+  # clause precedes the opt-out branch on purpose. SK-01/SK-02/SK-04 and AU-02..AU-04 keep
+  # their opt-out semantics.
+  if [ "$id" = "AU-01" ] && [ "$ENGINE_MODE" = "global" ]; then
+    out=$(check_au_01 2>&1); rc=$?
+    case "$rc" in
+      0) PASS=$((PASS + 1)); emit "$id" PASS "$out" ;;
+      1) FAIL=$((FAIL + 1)); emit "$id" FAIL "$out" ;;
+      2) ADV=$((ADV + 1));  emit "$id" ADV "$out" ;;
+      3) SKIP=$((SKIP + 1)); emit "$id" SKIP "$out" ;;
+    esac
+    continue
+  fi
   if [ -n "$part" ] && g_part_disabled "$CONFIG" "$part"; then
     SKIP=$((SKIP + 1)); emit "$id" SKIP "$rule (opt-out: $part)"; continue
   fi

package/docs/ADOPTION.md

@@ -102,13 +102,16 @@ Each step is independently useful and the later ones build on the earlier:
 Then, in order:
 
     git add -A && git commit          # the install is a change like any other
-    .goblin/bin/goblin-verify         # 42 passed, 1 failed - HP-05, until HANDOFF names a commit
-    hermes skills trust <target>      # one-time, so the project-tier skills load
+    .goblin/bin/goblin-verify         # 37 passed, 1 failed - HP-05, until HANDOFF names a commit
+    gob emit --platform <p>           # optional, per platform: the agent skills are an opt-in
 
-A class-A install is **green** — `43 passed, 0 failed, 11 advisory, 28 skipped`, exit 0 — once
+A default class-A install (no agent skills) is **green** — `38 passed, 0 failed, 11 advisory,
+33 skipped`, exit 0 — once
 `HANDOFF.md` names a commit that exists; before that edit the scaffold's `0000000` placeholder is
-the one expected red (`42 passed, 1 failed`). Both numbers are measured, not assumed
-(`docs/CONTRACTS.md`; step 2 of `docs/GUIDE.md`). Twenty-eight rows skip with a reason: `HS-02` (no
+the one expected red (`37 passed, 1 failed`). Both numbers are measured, not assumed
+(`docs/CONTRACTS.md`; step 2 of `docs/GUIDE.md`). Thirty-three rows skip with a reason: the
+five skill rows (`SK-01`..`SK-04`, `AU-04`) skip on the `playbooks` opt-out a skills-free
+install records, plus the not-yet rows: `HS-02` (no
 pinned pre-change commit yet), `AU-02`/`AU-03` (no report has been filed, so there is nothing to
 dedup and no reporter run to audit), `SC-06`/`SC-07`/`SC-08` (no dependency manifest, no lockfile,
 no audit record), `PF-01` (no measured perf baseline), `BN-01`/`BN-02`/`BN-05` (no `src/` for a ban
@@ -160,7 +163,7 @@ The remedy is a reconciliation. The project's file stays the file of record; not
        git add -A && git commit
        .goblin/bin/goblin-verify        # HP-02, HP-03, HP-05 go green
 
-   Success is the class's full green path (`43 passed, 0 failed, 11 advisory, 28 skipped`, exit 0 for
+   Success is the class's full green path (`38 passed, 0 failed, 11 advisory, 33 skipped`, exit 0 for
    class A) with `git status --short` empty.
 
 The edit is additive and small — measured on the model repo (§1's exemplar, 2450 lines): three

package/docs/CONTRACTS.md

@@ -14,7 +14,10 @@ same way the fleet's own tool reads it. Everything else is line-oriented shell.
     --practice <path>     the referenced standard (default: $GOBLIN_PRACTICE -> ~/projects/PROJECT-PRACTICE.md)
     --parts <list>        comma list to install; default = every part the class requires
     --archive             mark the project archive: verify requires no HANDOFF and no gates
-    --skills yes|no       install .hermes/skills (default yes; needs the one-time trust step)
+    --skills yes|no       install agent skills under .hermes/skills (default no — the harness is
+                          neutral; opt in per platform with: gob emit --platform <p>). On a repo whose
+                          record already has skills installed, an OMITTED flag keeps them; an explicit
+                          --skills no removes them.
     --dry-run             print the plan; write nothing
     --upgrade             re-install at the current version; report created/updated/unchanged/skipped
     --opt-out <part>      record the part in disabled: so its required checks are skipped
@@ -37,7 +40,7 @@ files whose hash changed and prints `created C · updated U · unchanged N · sk
 
 | kind | recorded as | overwritten? | hash-checked? | removed by `--uninstall`? |
 |---|---|---|---|---|
-| installed artifact (bin, manifest, roles, skills, harness scaffold) | `files` | yes, on upgrade | yes — IN-02, SK-02 | yes |
+| installed artifact (bin, manifest, roles, opt-in skills, harness scaffold) | `files` | yes, on upgrade | yes — IN-02, SK-02 | yes |
 | created once, then yours (`.goblin/goblin.yaml`, `HANDOFF.md`, `AGENTS.md`, `*-SPEC.md`, `reviews/.gitkeep`) | `owned` | never | no — you are meant to edit them | no, except the config |
 | pre-existing, left alone | `refused` | never | no — IN-04 only proves it was not taken over | no |
 
@@ -112,9 +115,9 @@ Output is one line per executed row, in manifest order, plus a summary line at t
     ADV   MD-02  code lane and review lane both resolve to the same family
     SKIP  HS-02  no pinned pre-change commit yet - REPLAY not provable
 
-Those four lines are one row of each marking. The summary line of a green class-A run is:
+Those four lines are one row of each marking. The summary line of a green default class-A run is:
 
-          43 passed, 0 failed, 11 advisory, 28 skipped
+          38 passed, 0 failed, 11 advisory, 33 skipped
 
 **Exit codes:** `0` every executed check passed (advisories and skips do not fail the run) ·
 `1` at least one check FAILED · `2` verify could not run (not installed, a missing dependency,
@@ -135,8 +138,10 @@ settings that make a workflow a **gate** are written down.
 
 ### A fresh install verifies green
 
-Measured on a fresh class-A install, committed with no hand edit: **`43 passed, 0 failed,
-11 advisory, 28 skipped`, exit 0.** Twenty-eight rows skip with a reason: `HS-02` — no pre-change commit
+Measured on a fresh DEFAULT class-A install (skills opt-in, W6 neutral-first), committed with no
+hand edit: **`38 passed, 0 failed, 11 advisory, 33 skipped`, exit 0.** Thirty-three rows skip with
+a reason — the same not-yet rows as before, plus the five skill rows (`SK-01`..`SK-04`,
+`AU-04`) that skip on the `playbooks` opt-out a skills-free install records: `HS-02` — no pre-change commit
 is pinned yet, so the REPLAY is not provable (`docs/LIMITS.md` #11) — `AU-02` and `AU-03`, which
 have no report to audit in a repo where no reporter has run — `SC-06`, `SC-07` and `SC-08`, which
 have no dependency manifest, no lockfile and no audit record to read yet — `PF-01`, which has
@@ -173,13 +178,20 @@ verifier is reporting FAILs.
 - **Per part:** `--opt-out <part>` records the part in `disabled:`. `goblin-verify` then reports
   the part's rows as `SKIP (opt-out)` in the summary, so the opt-out is **visible rather than
   absent**. The same mechanism is what makes a class's `-` (off) real.
-- **The opt-out numbers are pinned (V3-3).** A fresh class-A install with `--skills no` verifies
-  `39 passed, 0 failed, 11 advisory, 28 skipped`, exit 0, and `tests/t-install-off-switch.sh`
-  asserts that line: a silent drift in the opt-out path is caught rather than left as a number
-  nobody wrote down (the `--skills no` count moved from `37/0/9/11` at v0.2 to here when the ban
-  rows landed, and no file recorded the shift; **the skipped count moved 15 → 18 on 2026-09-25
-  (G1)** — the three new feature-map rows skip on the same path for the same reason, measured;
-  **and 18 → 24 on 2026-09-25 (W3)** — the six judge/loop rows skip there too, measured).
+- **The opt-out numbers are pinned (V3-3).** A class-A install with an explicit `--skills no`
+  verifies `38 passed, 0 failed, 11 advisory, 33 skipped`, exit 0, and
+  `tests/t-install-off-switch.sh` asserts that line: a silent drift in the opt-out path is caught
+  rather than left as a number nobody wrote down (the `--skills no` count moved from `37/0/9/11`
+  at v0.2 when the ban rows landed, **15 → 18 on 2026-09-25 (G1)** — the feature-map rows,
+  **18 → 24 on 2026-09-25 (W3)** — the judge/loop rows, and **to `38/0/11/33` at W6
+  (neutral-first)**, when this opt-out shape BECAME the default and the two lines converged:
+  the old default install measured `43/0/11/28`).
+- **Skills, W6 neutral-first.** A default install ships no agent skills. A repo whose record has
+  `skills: yes` keeps them through every flag-less re-install and `--upgrade` (the installer
+  reads the record's choice and says so out loud); an explicit `--skills no` removes exactly the
+  recorded skill files; `--uninstall` removes everything recorded, as always.
+  `tests/t-install-off-switch.sh` walks that migration: install `--skills yes`, upgrade flag-less,
+  the skills survive byte-identical; uninstall, and they are all gone.
 - **Whole harness:** `--uninstall` deletes the `files` list plus `.goblin/goblin.yaml`, removes
   every directory that leaves empty (deepest first, after `installed.json` itself is gone — the
   order that used to leave `.goblin/` and the sixteen `.hermes/skills/*` directories behind),

package/docs/GUIDE.md

@@ -106,18 +106,20 @@ or the plain installer this wizard drives, if you prefer the one-shot shape:
 
 Expected output (this is a real transcript, trimmed):
 
-    created 50 · updated 0 · unchanged 0 · skipped 0
+    created 25 · updated 0 · unchanged 0 · skipped 0
 
     next:
       1. cd /tmp/gs-try && git add -A && git commit   # the install is a change like any other
       2. .goblin/bin/goblin-verify   # or add .goblin/bin to PATH
       3. edit .goblin/goblin.yaml: replace the default gate with your real commands (P8 step 3)
-      4. hermes skills trust /tmp/gs-try   # one-time, so the project-tier skills load
+      4. agent skills are opt-in: gob emit --platform <p>   # hermes, claude, copilot, cursor, opencode, codex, gemini
 
-**`created 50`** is the installer's count of the files it **tracks** — the 41 in its `files` map,
-the 8 it `owns`, and `.gitignore`. It writes **51**: the 51st is `.goblin/installed.json`, the
-record it keeps for itself, which it writes but does not count. It has written nothing outside this
-directory.
+**`created 25`** is the installer's count of the files it **tracks** — the 16 in its `files`
+map, the 8 it `owns`, and `.gitignore`. It writes **26**: the 26th is `.goblin/installed.json`,
+the record it keeps for itself, which it writes but does not count. It has written nothing
+outside this directory. The default install ships **no agent skills** — the harness is neutral,
+and `gob emit --platform <p>` is the per-platform opt-in (the old `--skills yes` default is
+still there for repos that want the Hermes project tier vendored).
 
 ### Why `git init -b main` matters
 
@@ -141,14 +143,14 @@ branch** (unless you want to).
 You will see one line per rule. The shape:
 
     PASS  IN-01  (test -s .goblin/installed.json && grep -q '"version"' .goblin/installed.json)
-    PASS  IN-02  40 installed files hashed | practice pin ok
+    PASS  IN-02  16 installed files hashed | practice pin ok
     FAIL  HP-05  HANDOFF.md names no commit that exists in this repo
     SKIP  HS-02  no pinned pre-change commit yet - the REPLAY is not provable
     ADV   HP-04  A stale sentence is corrected in place... (advisory)
 
 and a summary line at the bottom:
 
-    42 passed, 1 failed, 11 advisory, 28 skipped     # the one FAIL is HP-05, below
+    37 passed, 1 failed, 11 advisory, 33 skipped     # the one FAIL is HP-05, below
 
 ### How to read that output
 
@@ -185,7 +187,7 @@ against a declared expectation. That is exactly what you want it to do.
 `HEAD when this file was written: `0000000``, and `HP-05` **rejects that placeholder on purpose**.
 A file that names a commit which does not exist is worse than one that names none — it looks like a
 record. Commit first, then write the real short SHA in. Measured: with the placeholder left in,
-verify reports `42 passed, 1 failed`; with the real SHA, `43 passed, 0 failed`.
+verify reports `37 passed, 1 failed`; with the real SHA, `38 passed, 0 failed`.
 
 ---
 
@@ -305,9 +307,9 @@ honest entry, and the harness treats it as one.
 > **Prove it was broken first.**
 
 Before you trust a check, break the thing it checks and watch it go red — then put it back and watch
-it go green. Break it on a row this walkthrough can actually break: `IN-02` hashes the **41 files it
+it go green. Break it on a row this walkthrough can actually break: `IN-02` hashes the **16 files it
 tracks** — not the 8 it `owns` (including `.goblin/goblin.yaml`, which §5 has you editing) and not
-`.goblin/installed.json`; edit one of the 41 — the exercise below uses `.goblin/bans/README.md`.
+`.goblin/installed.json`; edit one of the 16 — the exercise below uses `.goblin/bans/README.md`.
 
     # REPLAY-BEGIN (this exact block is run by tests/t-doc-guide.sh - keep the two copies identical)
     .goblin/bin/goblin-verify --only IN-02                 # expect PASS
@@ -393,13 +395,13 @@ the next session.
 A class-A install lands on a specific shape. The scaffold ships one deliberate red — `HP-05`, the
 `0000000` placeholder in `HANDOFF.md` (§4) — so a literal first run prints:
 
-    42 passed, 1 failed, 11 advisory, 28 skipped     (the one FAIL is HP-05)
+    37 passed, 1 failed, 11 advisory, 33 skipped     (the one FAIL is HP-05)
 
 Name a real commit in `HANDOFF.md` and commit, and it is green:
 
-    43 passed, 0 failed, 11 advisory, 28 skipped     (on a real project; your numbers will differ)
+    38 passed, 0 failed, 11 advisory, 33 skipped     (on a real project; your numbers will differ)
 
-**Twenty-eight rows skipping is correct**, and each skip prints its reason. In plain terms: the
+**Thirty-three rows skipping is correct**, and each skip prints its reason. In plain terms: the
 harness is telling you which of its rules have nothing to read yet. It is a checklist, not a
 scolding.
 
@@ -579,7 +581,7 @@ with *"prove it was broken first"* — it is the one practice that survives cont
     # 1. try it somewhere disposable
     mkdir -p /tmp/gs-try && cd /tmp/gs-try
     git init -b main
-    gob install --target . --class A                     # expect: created 50
+    gob install --target . --class A                     # expect: created 25 (no skills — those are gob emit)
 
     # 2. commit and check
     git add -A && git commit -m "chore: install gobstack"

package/docs/LIMITS.md

@@ -111,7 +111,7 @@ deliberate trade or an unfilled gap.
     drift check — `IN-02`, `SK-02`, and `HS-01`'s hash of the harness dir — reads its expected
     hash out of that one file, and that file is the one file no check protects. Measured: append a
     byte to `.goblin/bin/goblin-verify`, rewrite its recorded hash in `installed.json`, commit, and
-    the run is **fully GREEN** (`43 passed, 0 failed`, exit 0). One edit defeats three rows at
+    the run is **fully GREEN** (`38 passed, 0 failed`, exit 0). One edit defeats three rows at
     once, and it is the cheapest way to fake a green run. Doing better needs an anchor the target
     cannot edit — a signature, or a hash held outside the repo — and goblin-stack has no such
     trust root: the source checkout is not guaranteed to exist at verify time, and any value

package/docs/w6-tty-redraw-pty-transcript.txt

@@ -0,0 +1,334 @@
+Script started on 2026-10-02 00:53:48+07:00 [COMMAND="bash /home/harvey/projects/goblin-stack/bin/goblin-init --target /tmp/ptyfinal/repo --yes" <not executed on terminal>]
+
+
+
+
+
+
+
+
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+  ◆ 1. platforms    
+  ○ 2. class        
+  ○ 3. branch/email 
+  ○ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+  ✔ 1. platforms    
+  ◆ 2. class        
+  ○ 3. branch/email 
+  ○ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        
+  ◆ 3. branch/email 
+  ○ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+      
+  ✔ 2. class            A — shipped-software
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+
+  ✔ 2. class            A — shipped-software
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        A (shipped-software)
+  ✔ 3. branch/email 
+  ◆ 4. first gate   
+  ○ 5. emit         
+  ○ 6. done         
+
+      the forge contract — the identity this repo commits with (CM-01)
+      default branch ─ main
+      owner email ─ t@t.co
+  ✔ 3. branch/email   main · t@t.co
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+
+  ✔ 2. class            A — shipped-software
+
+      the forge contract — the identity this repo commits with (CM-01)
+
+
+  ✔ 3. branch/email   main · t@t.co
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        A (shipped-software)
+  ✔ 3. branch/email main · t@t.co
+  ✔ 4. first gate   
+  ◆ 5. emit         
+  ○ 6. done         
+
+      one real command that must stay green — suggested for a bash suite:
+      bash tests/run-tests.sh
+      gate command ─ bash tests/run-tests.sh
+  ✔ 4. first gate      bash tests/run-tests.sh
+▄███▄ ▄██▄ ██▄  █    ▄█▄ █  █   ▄██▀ █████ ▄███▄ ▄███ █  █
+█   █ █  █ █▄▀█ █     █  █▄ █   ▀██▄   █   █   █ █    █ █
+█ ▄██ █  █ █▄▀█ █     █  █ ▄█   ▄█▀    █   █████ █    ██
+▀██▀▀ ▀██▀ ██▀  ▀▀▀▀ ▀█▀ █  █   ██▀▀   ▀   █   █ ▀██▀ █ █
+     discipline around whatever executes
+
+  gob init — first-run setup (gobstack v0.4.4)
+  6 steps · every step has a flag · nothing is written until the plan is confirmed
+
+
+  ✔ 1. platforms      0 detected
+      no platform detected here — the wizard will still install the harness; emit later with gob emit
+
+      what kind of work does this repo do?
+        1 ▸ app        shipped features, PRs, review gates        (class A)
+        2   service    backend jobs, config, unattended runs      (class B)
+        3   game       playable builds, perf budgets              (class C)
+        4   research   specs, replays, reference corpora          (class D)
+        5   agent      fleets, loops, unattended automation       (class E)
+        6   desktop    the shell you live in, perf budget         (class F)
+      ↑ number + Enter · Enter = app · the class letter works too (A-F)
+
+  ✔ 2. class            A — shipped-software
+
+      the forge contract — the identity this repo commits with (CM-01)
+
+
+  ✔ 3. branch/email   main · t@t.co
+
+      one real command that must stay green — suggested for a bash suite:
+      bash tests/run-tests.sh
+
+  ✔ 4. first gate      bash tests/run-tests.sh
+  ✔ 1. platforms    0 detected
+  ✔ 2. class        A (shipped-software)
+  ✔ 3. branch/email main · t@t.co
+  ✔ 4. first gate   bash tests/run-tests.sh
+  ✔ 5. emit         
+  ◆ 6. done         
+  ✔ 5. emit             0 platform(s) · scope project
+
+  running: goblin-install --target /tmp/ptyfinal/repo --class A
+created 50 · updated 0 · unchanged 0 · skipped 0
+
+next:
+  1. cd /tmp/ptyfinal/repo && git add -A && git commit   # the install is a change like any other
+  2. .goblin/bin/goblin-verify   # or add .goblin/bin to PATH
+  3. edit .goblin/goblin.yaml: replace the default gate with your real commands (P8 step 3)
+  4. hermes skills trust /tmp/ptyfinal/repo   # one-time, so the project-tier skills load
+
+automations (optional; neither writes outside this repo, and A-02 has no agent in it):
+  bash /tmp/ptyfinal/repo/.goblin/automations/drift-audit.sh --dry-run        # read the record first
+  cp /tmp/ptyfinal/repo/.goblin/automations/drift-audit.sh ~/.hermes/scripts/
+  hermes cron create "0 9 * * 1" --name "Drift audit - weekly" --no-agent \
+      --script drift-audit.sh --deliver <channel>
+  P13/P14 in docs/FLOWS.md; the whole model in automations/README.md
+      PASS  IN-01  the install record exists and names its version
+      PASS  IN-02  41 installed files hashed
+      PASS  IN-03  the manifest is complete: every rule carries a check or is advisory, inside the enum
+      PASS  IN-04  0 pre-existing file(s) left untouched
+      PASS  HP-01  (test -f HANDOFF.md)
+      PASS  HP-02  (for h in 'START HERE' 'STATE|STATUS' 'GATES?' 'NEXT STEPS|NEXT' 'NOT VERIFIED|UNVERIFIED|NOT PROVEN|UNPROVEN|PENDING[^.]*DEVICE TEST'; do grep -qiE "^#{2,3}[[:space:]]+[^[:alpha:]]*($h)\b" HANDOFF.md || { echo "missing section: $h"; exit 1; }; done)
+      PASS  HP-03  1 gate line(s) inside the Gates section, each with a measured date (anchored on the declared gate name(s): commit todo_ceiling)
+      ADV   HP-04  A stale sentence is corrected in place with a dated parenthetical, never deleted. (advisory)
+      PASS  HP-05  names 3c96403 (ancestor of HEAD 3c96403)
+      PASS  SP-01  (ls ./*-SPEC.md >/dev/null 2>&1)
+      FAIL  SP-02  (test -z "$(git ls-files --others --exclude-standard -- '*-SPEC.md')" -> exit 1)
+      PASS  SP-03  (awk '/^[[:space:]]*[-*][[:space:]]/ && /AC[0-9]*:/ && !/`|==|===|exit|<|>/ {print; bad=1} END{exit bad}' ./*-SPEC.md)
+      PASS  GT-01  2 declared gate(s), each with a cmd
+      PASS  GT-02  commit=0 todo_ceiling=0 · client_js_bytes 0 (ceiling 0) · measured 2026-10-02
+      PASS  GT-03  (test -f .goblin/last-gate-line && [ .goblin/last-gate-line -nt "$(git rev-parse --git-dir)/logs/HEAD" ])
+      PASS  GT-04  ratchet client_js_bytes ceiling 0
+      PASS  GT-05  client_js_bytes 0 (ceiling 0)
+      PASS  HS-01  not an asserting harness (report utility): gate.sh
+1 asserting harness(es), 1 report utility(ies)
+      SKIP  HS-02  no pinned pre-change commit yet (replay.commit empty or unknown) - REPLAY not provable
+      ADV   HS-03  Source probes read text with comments blanked first. (advisory)
+      PASS  CM-01  (test "$(git log -1 --format='%ae')" = "$(grep '^owner_email:' .goblin/goblin.yaml | cut -d' ' -f2)")
+      ADV   CM-02  The commit message was written to a file, not passed with -m. (advisory)
+      FAIL  CM-03  9 dirty entr(y|ies), max_dirty 0
+      PASS  MD-01  (for d in skills manifest bin templates presets .goblin .hermes; do [ -d "$d" ] || continue; grep -rniE '(d[e]epseek|cl[a]ude|g[p]t-[0-9]|gr[o]k|g[e]mini|g[l]m-[0-9]|k[i]mi)[a-z0-9.:_-]*' "$d" && exit 1; done; exit 0)
+      ADV   MD-02  no model mapping configured (/tmp/ptyfinal/home/projects/fleet-model.yaml absent) - advisory
+      ADV   MD-03  Role-pinned fan-out goes through kanban, not a model-less subagent spawn. (advisory)
+      PASS  PG-01  0 review note(s)
+      PASS  PG-02  0 review note(s) classified
+      PASS  PG-03  0 review note(s) patch-id checked
+      ADV   PG-04  Never bypass what the forge enforces. (advisory)
+      PASS  PG-05  1 workflow file(s) checked for a self-skipping required check
+      PASS  PG-06  goblin-gate.yml: runs the verifier, which executes every declared gate
+1 workflow file(s) compared with the 2 declared gate(s)
+      PASS  DS-01  unchanged: .goblin/state.json=missing
+      PASS  DS-02  snapshot .goblin/state.json=missing
+      ADV   DOC-01 A significant change updates the docs that teach it. (advisory)
+      ADV   DOC-02 System-level changes are recorded wherever the project's standard says they live. (advisory)
+      PASS  SK-01  
+      PASS  SK-02  20 installed skill file(s) hashed
+      PASS  SK-03  advisory 10 of ceiling 10 (0 free slots: the next advisory row FAILs)
+      PASS  SK-04  
+      PASS  PT-01  (for d in skills manifest bin templates presets .goblin .hermes; do [ -d "$d" ] || continue; grep -rniE --exclude=goblin.yaml --exclude=installed.json '(h[a]rvey|tech-g[o]blin|/h[o]me/[a-z]+|g[o]blin-ui|op[e]n-door|sup[r]eme|bb[t]ech|c[l]v)' "$d" && exit 1; done; exit 0)
+      PASS  PT-02  declared main, actual main
+      PASS  CL-01  part pr-gate: optional, present
+part review-panel: optional, present
+part tokens: optional, absent
+      PASS  CL-02  archive: false - the full class requirement applies
+      PASS  SC-01  0 tracked secret file(s)
+      PASS  SC-02  the whole secret family is ignored (.env, .env.local, .env.production proved by git)
+      PASS  SC-03  0 client-visible secret-shaped name(s); no build output to scan for clause 2
+      PASS  SC-04  0 cookie write(s) checked; a JS-written cookie is readable by any script - reported, not failed
+      PASS  SC-05  0 write handler(s), 0 waived; 11 dir(s) declared
+      SKIP  SC-06  no package.json - there is no dependency manifest to lock
+      SKIP  SC-07  no audit record yet. Run .goblin/bin/goblin-audit once, deliberately, then commit
+.goblin/audit.tsv: SC-07 reads the record and never the network
+      SKIP  SC-08  no package-lock.json - there is no install-hook surface to enumerate
+      ADV   SC-09  Auth is applied consistently across sibling routes. (advisory)
+      SKIP  PF-01  no perf baseline recorded yet: run `find .next/static dist/assets dist -type f -name '*.js' -exec cat {} + 2>/dev/null | wc -c` on a pinned commit, then write
+perf.baseline_commit, perf.baseline_value, perf.measured and the matching ratchet ceiling
+      PASS  AU-01  2 automation producer(s) scanned, none opens with a network or forge verb
+      SKIP  AU-02  no reports/*/report.yaml - nothing to dedup
+      SKIP  AU-03  no reports/ - no reporter run in this repo to audit
+      PASS  AU-04  
+      PASS  BN-00  8 ban(s), each with an enforcement row and a named replacement
+      SKIP  BN-01  No `any` in application TypeScript. (no matching files: src) 
+      SKIP  BN-02  No `@ts-ignore` / `@ts-expect-error` suppressions. (no matching files: src) 
+      SKIP  BN-03  No direct network call from a component. (not enabled in bans: - add BN-03 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-05  No import across a declared layer boundary. (no matching files: src) 
+      SKIP  BN-06  No renderer with Node access (`nodeIntegration: true`). (not enabled in bans: - add BN-06 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-07  No renderer with context isolation or the process sandbox turned off. (not enabled in bans: - add BN-07 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-08  No dangerous webPreferences. (not enabled in bans: - add BN-08 to .goblin/goblin.yaml to turn it on) 
+      SKIP  BN-09  No synchronous IPC and no `@electron/remote`. (not enabled in bans: - add BN-09 to .goblin/goblin.yaml to turn it on) 
+      SKIP  FM-01  feature_map: is empty - no map is declared, so there is nothing to index
+      SKIP  FM-02  feature_map: is empty - no map is declared, so there are no entry paths to resolve
+      SKIP  VA-01  verify_doctor: is empty - no doctor is declared, so "the generated skill was executed once" is not provable here
+      SKIP  JG-01  no loop record in this repo - no judge verdict to check
+      ADV   JG-02  no model mapping configured (/tmp/ptyfinal/home/projects/fleet-model.yaml absent) - advisory
+remedy: add a `judge:` entry beside the code lane in the file declared as models_file: in /tmp/ptyfinal/repo/.goblin/goblin.yaml
+      ADV   JG-03  A judge lane that has never returned a non-`done` verdict is escalated. (advisory)
+      SKIP  LP-01  no loop has run in this repo
+      SKIP  LP-02  no loop has run in this repo
+      SKIP  LP-03  no loop has run in this repo
+      SKIP  LP-04  no loop has run in this repo
+      SKIP  LP-05  no loop has run in this repo
+      SKIP  RC-01  reference_manifest: is empty - no reference corpus is declared, so there is nothing for a build to match against
+      SKIP  RC-02  reference_manifest: is empty - there is no manifest to shape-check (RC-01 skips for the same reason)
+      SKIP  RC-03  no manifests/ directory - this is not a lab repo with a reference corpus, so there are no tracked bytes to check
+      SKIP  RC-04  no manifests/*.sha256 - no acquisition record is declared, so there is none to read
+      41 passed, 2 failed, 11 advisory, 28 skipped
+      of those 11 advisory: the matrix labels 10 row(s) advisory; the difference is the non-advisory row(s) reporting ADV by design (an unresolved lane) and any labelled row skipped by an opt-out
+      cannot see: whether a check in the harness dir tests the right path rather than
+      merely passing; whether the forge is bound by the workflow CL-01 found; whether a human
+      read the diff;
+      whether the model mapping names a family that actually differs (MD-02 reports it
+      and cannot change it); and whether .goblin/installed.json — the record every drift
+      check trusts — was itself rewritten. It is not signed, so one edit to it (with the
+      matching edit to the file it protects) defeats IN-02, SK-02 and HS-01 at once
+      (docs/LIMITS.md #18). The ban lane carries the same blind spot and two of its own:
+      the ban table is a manifest file under the same unsigned record, so a defanged ban
+      passes BN-00 (docs/LIMITS.md #28); a ban probe is a TEXT probe with no AST, so a
+      `Record<string, any>` is missed and a `: any` inside a string is reported
+      (docs/LIMITS.md #27); and no check here can reach a ban IN CONTEXT — the row proves
+      the forbidden path fails mechanically, never that the ban reached the agent that
+      wrote the line. The judge/loop lane adds its own: every JG-/LP- row reads a RECORD, so
+      it proves a handle, a pin, a budget and a pointer exist — never that the loop made
+      progress (a changed pointer is a proxy, docs/LIMITS.md #33), never which lane returned
+      a verdict, and never that the predicate was the right one or was really run. The CI lane
+      adds its own: PG-05 and PG-06 read a workflow's TEXT, so PG-05 sees a job whose gate step is
+      conditional and cannot see branch protection, the required-check list, or a forge that never
+      ran the job at all, and PG-06 proves a declared gate is INVOKED in a file under
+      .github/workflows/ — never that the forge marks that job required, never that it is the job
+      the forge waits on, and never that the workflow can fail (that is PG-05). A required check
+      that reports Success after skipping its gate is a green light for a commit whose gate never
+      ran (docs/CI.md). The reference-corpus lane adds its own: RC-01 matches EXACT sha256 only,
+      so a resized, recoloured or re-encoded reference asset, or copied text inside a shipped
+      string, passes it unseen; RC-02 proves the manifest is well-shaped, never that its entries
+      are the right hashes (as strong as tamper hashing, and installed.json is unsigned); RC-03
+      reads the tracked tree and cannot see a payload renamed and re-encoded; and RC-04 proves an
+      acquisition record EXISTS, never that the number beside it came from the store (HP-03's
+      defect, one artifact over). No row here reaches a reference asset in CONTEXT either.
+      engine: mode=vendored cli_sha256=2d37cf1c9f38a582ad60f3f75d2fcd53d10b743905dc3274eab6511c5c5ea008 enforcement_tsv_sha256=fd474c268b0852587c632910c503144fbcfe5e211ed2182902949a79fc5282b1
+
+  gob verify: 41 passed, 2 failed, 28 skipped · exit 1
+
+  next:
+    1. the 28 skipped checks ARE your checklist — gob verify names each one
+    2. replace the placeholder gate in .goblin/goblin.yaml with your real commands (P8 step 3)
+    3. not emitted here: gob emit --platform <p> --scope global
+    4. hermes skills trust /tmp/ptyfinal/repo   # one-time, so the project-tier skills load
+
+  ▙ the goblin sees you. the gate is RED — start there.
+
+Script done on 2026-10-02 00:53:50+07:00 [COMMAND_EXIT_CODE="0"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techgoblin/gobstack",
-  "version": "0.4.4-beta.6",
+  "version": "0.4.4-beta.8",
   "description": "Agent-discipline toolkit: one verify command, an enforcement matrix, and LIMITS. bash engine, npm shim.",
   "bin": {
     "goblin": "bin/goblin.js",