Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
skills: keep company-brainify at its shipped version
garrytan186cd0294aaf
diff --git a/skills/company-brainify/SKILL.md b/skills/company-brainify/SKILL.mdindex 5a994485c2..43526a69f5 100644--- a/skills/company-brainify/SKILL.md+++ b/skills/company-brainify/SKILL.md@@ -55,75 +55,122 @@ brain_first: true> edits stay in the page's existing directory; the deletion log files> date-keyed under `daily/`.-A personal brain holds candid notes (ratings, comp, assessments, retention,-politics) that must not reach a shared team brain. Three surfaces carry them:-page files, takes/facts, and git history. Clean files alone are not enough.+## The Problem-## When to Use+Personal brains accumulate everything — company knowledge, meeting notes,+internal assessments, compensation details, management strategy, candid+opinions about the people you work with. When you stand up a shared team+brain from that personal brain (see `docs/architecture/brains-and-sources.md`+for the team-mount topology), all of that has to go. The knowledge is+valuable; the sensitive metadata is a liability.-Standing up a team brain from a founder's or exec's personal brain; auditing an-existing shared brain (report-only or with edits); verifying a repo before-onboarding; periodic hygiene.+Clean working-tree files alone are NOT enough: git history still carries every+pre-sanitization version, and gbrain takes/facts carry evaluative claims+outside the page prose. This skill handles all three surfaces — pages,+takes/facts, and history.-Not for connecting or indexing an existing company repo: that is no-sanitization. On the trusted brain host run-`gbrain sources inspect <path> --profile company-brain` and follow-`docs/guides/company-brain-ingestion.md`; never strip metadata or purge history-just to make a repo searchable.+## When to Use-## What Gets Removed+Connecting or indexing an existing company repository without editing it is not+sanitization. For “connect our company brain” or “import an existing company+brain,” use the migrate (host-side) company workflow. On the trusted brain host,+start with `gbrain sources inspect <path> --profile company-brain`; follow+`docs/guides/company-brain-ingestion.md` for destination preview and approval.+Do not strip metadata or purge history merely to make an existing repository+searchable.-**Always strip:** rating/score fields (`score:`, `rating:`, `skill:`, any-`*_score:`, any numeric rating of a person); compensation (salary, equity,-carry, grants, comp changes, retention packages); performance assessments-(weaknesses, "at risk", underperformance, "picking up slack"); departure and-retention talk; management strategy about a person; political dynamics; personal-PII (phone, personal email, home address, family, medical, personal legal or-life details); and every take or fact row about any of these.+- Standing up a shared company brain from a founder/exec's personal brain+- Auditing an existing shared brain for sensitive content that shouldn't be there+- Onboarding new team members to a brain repo that must be verified clean first+- Periodic hygiene pass on a shared brain that re-accumulates sensitive data-**Always keep:** name, role, title, work email, LinkedIn; what they build;-career arc and education; professional beliefs; factual timeline of work-(attendance, milestones, launches); skills and expertise.+## What Gets Removed-**Scan scope:** `people/`, `meetings/`, `daily/`, `companies/`, `projects/`,-`analysis/`, takes (`gbrain takes search`), facts (`gbrain recall --grep`), and-back-links (`gbrain check-backlinks check`). A people-only pass certifies a brain-that still leaks.+### Always strip (non-negotiable)++| Category | Examples |+|----------|----------|+| **Internal scores/ratings** | `score:`, `rating:`, `skill:`, or any vertical-specific `*_score:` frontmatter field; any numeric rating of a person |+| **Compensation** | Salary, equity, carry, option grants, comp changes, retention packages |+| **Performance assessments** | Strengths/weaknesses sections about employees, "at risk" flags, underperformance mentions, "picking up slack" references |+| **Departure/retention** | Who's considering leaving, who was convinced to stay, departure rumors, retention conversations |+| **Management strategy** | How-to-manage-someone sections, "the hard conversation" notes, scope/title management plans |+| **Internal political dynamics** | Who doesn't like whom, who's nervous about whom, adversarial relationships, power dynamics |+| **Personal PII** | Phone numbers, personal email addresses, home addresses, family or medical details, personal legal matters, personal-life details |+| **Takes/facts** | Any take or fact referencing the above categories — performance, comp, retention, weakness, management risk. Fact rows are DELETED from the page's Facts fence, never merely expired with `gbrain forget` |++### Always keep++| Category | Examples |+|----------|----------|+| **Professional identity** | Name, role, title, work email, LinkedIn |+| **What they're building** | Current projects, product work, technical contributions |+| **Career arc** | Prior companies, education, professional background (public info) |+| **Professional beliefs** | Their views on technology, strategy, product philosophy |+| **Timeline of work** | Meeting attendance, project milestones, launches (factual, not evaluative) |+| **Skills/expertise** | Technical capabilities, domain knowledge |++## Scan Scope — Wider Than people/++Sensitive content leaks far beyond people pages. The scan scope is:++- `people/` — the primary surface (frontmatter fields, assessment sections)+- `meetings/` — transcripts and minutes with candid assessments+- `daily/` — daily notes referencing comp/performance/retention conversations+- `companies/`, `projects/`, `analysis/` — cross-references to removed content+- **Takes** — evaluative claims in page takes fences (`gbrain takes search`)+- **Facts** — hot-memory facts (`gbrain recall --grep`)+- **Back-links** — after edits, `gbrain check-backlinks check` confirms no page+ still points at removed sections++A pass that only covers `people/` will certify a brain that still leaks.## Procedure+All paths below are relative to the brain repo root:+```bashBRAIN="$(gbrain config get sync.repo_path)"cd "$BRAIN"```-On a repo-less brain (no `sync.repo_path`) run Phase 1's retrieval and Phase 4's-retrieval checks only, and edit pages through `gbrain get` / `gbrain put`.+### Phase 1: Identify scope (retrieval-first)-### Phase 1: Scope (retrieval first)+1. Retrieval discovery — hybrid search catches judgment-shaped content that no+ keyword pattern will:-```bash-gbrain query "compensation, equity, or salary discussions about team members" --limit 50-gbrain query "performance concerns, underperformance, or who is struggling" --limit 50-gbrain query "considering leaving, retention conversations, departure rumors" --limit 50-gbrain takes search "performance" --limit 50-gbrain recall --grep "salary"-```+ ```bash+ gbrain query "compensation, equity, or salary discussions about team members" --limit 50+ gbrain query "performance concerns, underperformance, or who is struggling" --limit 50+ gbrain query "considering leaving, retention conversations, departure rumors" --limit 50+ gbrain takes search "performance" --limit 50+ gbrain recall --grep "salary"+ ```-Write every hit's repo-relative path to `/tmp/brainify-scope.txt`, then APPEND-the structural pass (never truncate the file):+ Resolve every returned slug to its repo-relative file path and write the+ paths into `/tmp/brainify-scope.txt` (one per line). This file is the+ scope list; the structural pass below APPENDS to it — nothing later in+ the procedure may truncate it, or the retrieval-discovered pages+ silently drop out of scope.-```bash-grep -rli 'company: *"acme-example"' people/ --include="*.md" | sort >> /tmp/brainify-scope.txt-grep -rli -E 'salary|equity|carry|retention|underperform|performance review|hard conversation' \- meetings/ daily/ companies/ projects/ analysis/ --include="*.md" 2>/dev/null >> /tmp/brainify-scope.txt-sort -u -o /tmp/brainify-scope.txt /tmp/brainify-scope.txt-```+2. Structural discovery — people files that belong to the company, plus+ keyword hits across the wider scan scope:++ ```bash+ grep -rli 'company: *"acme-example"' people/ --include="*.md" | sort >> /tmp/brainify-scope.txt+ grep -rli -E 'salary|equity|carry|retention|underperform|performance review|hard conversation' \+ meetings/ daily/ companies/ projects/ analysis/ --include="*.md" 2>/dev/null >> /tmp/brainify-scope.txt+ sort -u -o /tmp/brainify-scope.txt /tmp/brainify-scope.txt+ ```++3. Cross-reference against the company's public people page (website,+ LinkedIn) to catch files using different frontmatter conventions.++4. Count: `wc -l /tmp/brainify-scope.txt`-Cross-check the company's public team page for people filed under other-conventions.+### Phase 2: Triage sensitivity-### Phase 2: Triage+Prioritize by hit density (portable `grep -E`; no `\b` — BSD and GNU disagree):```bashwhile read -r f; do@@ -132,28 +179,44 @@ while read -r f; dodone < /tmp/brainify-scope.txt | sort -rn > /tmp/brainify-triage.txt```-High-hit files first. Every scoped file is still read in full: grep triages,-the model judges.--### Phase 3: Sanitize (destructive — gated)--**Target.** New team brain (default): copy ONLY the scanned directories into a-durable staging dir and edit there, leaving the personal brain's working tree-untouched. Re-auditing an existing shared brain: edit the shared repo in place,-never the personal `sync.repo_path`.--```bash-STAGING="$HOME/.gbrain/backups/brainify-staging-$(date +%Y%m%d-%H%M%S)"-mkdir -p "$STAGING" && chmod 700 "$STAGING"-for d in people meetings daily companies projects analysis; do- [ -d "$d" ] && rsync -a "$d/" "$STAGING/$d/"-done-cd "$STAGING"-```--**Before the bulk edits, present the [data-loss-gate](../data-loss-gate/SKILL.md)-card and stop until the user types "yes" or "do it"** ("ok", "sure" are not-consent):+High-hit files need full judgment passes. Zero-hit files may only need+frontmatter field removal — but they still get read (regex triages, the model+judges).++### Phase 3: Sanitize (STAGING COPY preferred; test first, then parallel)++Phase 3 is destructive: it strips content across many files, removes takes,+and deletes fact rows. Two rules govern it.++**Choose the target FIRST — copy, don't mutate the personal brain.**++- **Standing up a NEW team brain (default, preferred):** sanitize a STAGING+ COPY of the scanned directories, never the personal brain in place. The+ founder's personal brain is SUPPOSED to keep comp, performance, and candid+ notes — stripping them from the personal working tree destroys valuable+ private data. Copy the Phase-1 scope into a durable staging dir and edit+ THAT; Phase 5 Step 0 exports from the staging copy. Blast radius: none on the+ personal brain.++ ```bash+ # Durable staging dir (NOT /tmp — same reasoning as the mirror backup).+ STAGING="$HOME/.gbrain/backups/brainify-staging-$(date +%Y%m%d-%H%M%S)"+ mkdir -p "$STAGING" && chmod 700 "$STAGING"+ for d in people meetings daily companies projects analysis; do+ [ -d "$d" ] && rsync -a "$d/" "$STAGING/$d/"+ done+ cd "$STAGING" # all edits below happen here, not in sync.repo_path+ ```++- **Re-auditing an EXISTING shared brain:** the shared brain IS the target, so+ edits are in place on the SHARED repo (cd into the shared repo, never the+ personal `sync.repo_path`). Fact-row removal + re-sync applies to the shared+ source's DB.++**Fire the [data-loss-gate](../data-loss-gate/SKILL.md) confirmation card+BEFORE the bulk destructive edits begin.** Both targets are destructive (the+copy path removes content from the tree destined for the team; the in-place+path removes content from a live brain). Pre-filled for Phase 3:```⚠️ DATA DELETION — Confirmation Required@@ -162,6 +225,7 @@ What: strip sensitive content, remove takes, and delete fact rows across[N files] in [STAGING COPY at <path> | the SHARED brain in place]Count: [N files edited; T takes removed; F fact rows removed]Location: [staging path OR shared repo path] — NOT the personal sync.repo_path+ on the staging pathWhy: preparing a sanitized tree for team access@@ -173,37 +237,83 @@ Recoverable?Proceed? (yes/no)```-Then 3–5 files first, read the results, ramp (50+ files: batches of 10–12 in-parallel subagents). Per file: read it completely; delete rating and comp-frontmatter lines; remove whole sensitive sections; remove whole take and fact-rows that touch a strip category (the claim is the leak — never keep the row-minus its attribution); edit inline mentions surgically (`Edit` for a few spots,-`Write` only when content is interwoven throughout).--**`gbrain forget` is not removal.** It expires a fact (struck through, still-served with `--include-expired`). Delete the row from the page's Facts fence.-In place on a shared brain, then run `gbrain sync`, reconcile the facts index-(`gbrain sweep`; sync alone does not re-extract facts), and confirm with-`gbrain recall --grep` that the row is gone. On the staging copy, editing the-markdown is enough. Either way finish with `gbrain check-backlinks check`.--### Phase 4: Verify the tree that ships--Run against the staging tree (staging path) or the shared repo (in place) —-never the personal tree. Re-run the triage (hits should drop to near zero),-then:+Require a typed "yes"/"do it" per data-loss-gate; "ok"/"sure" are not consent.++Per test-before-bulk: do 3-5 files first, read the results, then ramp. For+large sets (50+ files), batch into groups of 10-12 and spawn parallel+subagents. Per file:++1. Read the file completely+2. Remove all content matching the "Always strip" categories+3. Frontmatter: delete rating/comp field lines entirely+4. Sections: remove entire sections (assessment weaknesses, team dynamics,+ management strategy)+5. Takes and Facts fences: remove entire rows that reference sensitive+ categories — a take like "alice-example believes charlie-example is+ underperforming" reveals both the opinion and who holds it; remove the+ whole row, never just the attribution+6. Inline mentions: surgically edit sentences/paragraphs+7. Write the cleaned file back++**Decision rule:** use `Edit` for surgical removal when only a few sections+need it. Use `Write` to rewrite the entire file only when sensitive content is+deeply interwoven throughout.++**Facts: `forget` is NOT removal.** `gbrain forget <fact-id>` expires a fact+— the row stays on the page's Facts fence struck through, and the DB still+serves it via `--include-expired`. An expired fact is retained, not gone.+For sanitization, sensitive fact rows must be ACTUALLY REMOVED: find them+(`gbrain recall --grep`), then delete the row from the page's Facts fence+(step 5), exactly like a sensitive take. On an in-place shared brain, the+page edit must then be re-synced (`gbrain sync` re-imports the edited page)+AND the facts index reconciled — sync's convergence contract covers page+import only; downstream fact extraction is explicitly decoupled+(`src/commands/sync.ts`, "CONVERGENCE CONTRACT"), so the DB keeps serving+the deleted row until the extract-facts reconcile runs. Trigger it+(`gbrain sweep`, or wait for the serve-resident sweep), then confirm with+`gbrain recall --grep` that the row is actually gone. An edited page over+an un-reconciled facts index still leaks through retrieval. `forget` alone+can never certify a brain clean.++After edits: on the **staging-copy** path the fact rows are removed by editing+the copied markdown directly (there is no live DB to re-sync yet — the team DB+is built fresh when Phase 5 Step 0 turns the export into a source). On the+**in-place shared-brain** path, run `gbrain sync` so the page content matches+the markdown, then reconcile and verify the facts index as above. Either way,+run `gbrain check-backlinks check` to catch pages still pointing at removed+content.++### Phase 4: Verify++Re-run the Phase 2 triage — the count of flagged files should drop to+(near-)zero. Then targeted greps:```bash+# Rating fields remaining in frontmattergrep -rn -E '^[a-z_]*(score|rating|skill)[a-z_]*: *[0-9]' people/ --include="*.md"++# Phone numbersgrep -rn -E '\+1[0-9]{10}|\([0-9]{3}\) [0-9]{3}-[0-9]{4}' people/ --include="*.md"++# Comp keywords (full scan scope, not just people/)grep -rin -E 'carry|comp change|equity|salary' people/ meetings/ daily/ companies/ projects/ analysis/ --include="*.md" 2>/dev/null++# Management/performancegrep -rin -E 'considering leaving|departure rumor|underperform|picking up slack|hard conversation' people/ meetings/ daily/ companies/ projects/ analysis/ --include="*.md" 2>/dev/null```-Confirm each remaining hit by reading it; never tighten a pattern to silence-false positives. Then the retrieval the team will use (add-`--source <team-source-id>` when mounted beside personal content); each must-return nothing or only keep-category content:+False positives (e.g. "carry the torch") are fine — manually confirm each+remaining hit rather than tightening the pattern (regex-discipline).++**Verify the tree that ships.** On the staging-copy path, these greps run+against the sanitized `$STAGING` tree (which Phase 5 Step 0 turns into the+export) — the personal working tree is not what ships, so certifying it proves+nothing. For an in-place shared-brain re-audit, the shared repo's tree is the+shipped tree and this pass stands as-is.++Then the strongest check — the retrieval the team will actually use. Against+the sanitized brain/source (scope with `--source <team-source-id>` when the+shared source is mounted alongside personal content):```bashgbrain query "what is alice-example's compensation" --limit 10@@ -211,69 +321,356 @@ gbrain query "who is underperforming or at risk of leaving" --limit 10gbrain takes search "weakness" --limit 20```-### Phase 5: Ship+Every one of these must come back empty or with only keep-category content.++### Phase 5: Commit and purge history — GATED++Clean files aren't enough if the repo has history: old commits still contain+the sensitive versions.++**Step 0 — preferred alternative (non-destructive).** When standing up a NEW+team repo, skip history rewriting entirely: the sanitized STAGING tree from+Phase 3 becomes a fresh repo with fresh history. The personal repo keeps its+full history AND its full working tree, untouched.-**Fresh team repo (preferred, non-destructive).** The verified staging tree-becomes a new repo with fresh history. Ship only scanned directories: if-anything else is there (`conversations/`, `originals/`, `sources/`, `inbox/`),-remove it or scan it through Phases 1–4 first.+**Export rule: nothing unscanned ships.** Because Phase 3 copied ONLY the+scanned directories into `$STAGING`, the staging tree contains nothing the+sanitization pass didn't read — the include-only rule holds by construction.+Never copy extra directories in: everything outside the scan scope+(`conversations/`, `originals/`, `sources/`, `inbox/`) stays out. A whole-repo+copy is the classic leak — it ships raw transcripts, originals, and inbox+captures no pass ever read. To ship a new directory, add it to the scan scope+first (Phases 1-4) so it lands in `$STAGING` sanitized.```bash+# The sanitized staging tree IS the export.cd "$STAGING"++# Re-run the Phase 4 verification greps + retrieval checks INSIDE $STAGING —+# the staging tree is what ships, and it is the tree that must certify clean.+# ... Phase 4 greps against $STAGING ...+git init -b maingit add -A && git commit -m "Initial import — sanitized team brain" # gbrain-allow-shared-tree-git: first commit of a fresh single-writer export repogit remote add origin <TEAM_REPO_URL>gbrain git commit-push --push-only```-On a non-zero exit stop and relay the error (`git_push_unavailable`: fix URL or-credentials and rerun; a non-empty team repo: ask the user). Never force-push.+The first commit is plain git because `$STAGING` is a brand-new repo only+this run writes. The push goes through `gbrain git commit-push --push-only`:+it pushes to `origin/main` and fails loudly if the push does not land. On a+non-zero exit, stop and tell the user what the error says: usually+`git_push_unavailable` (check the team repo URL and credentials, then rerun+it), or a team repo that already has commits (this export needs an empty+one; ask the user before going further). Never force-push it.++Only when a shared repo ALREADY exists with sensitive history in it do you+need the purge below.++**Step 1 — target the SHARED repo, commit the clean tree, then mirror-clone.**+The purge operates on the SHARED repo, NEVER on `sync.repo_path` (the personal+brain) — Step 0's guarantee that the personal repo keeps full history depends+on it. Clone the shared repo to a durable work dir, stay there for every step+below, and assert the target is not the personal repo before touching anything.++```bash+PERSONAL="$(gbrain config get sync.repo_path)"+mkdir -p "$HOME/.gbrain/backups" && chmod 700 "$HOME/.gbrain/backups"+WORK="$HOME/.gbrain/backups/brainify-purge-$(date +%Y%m%d-%H%M%S)"+git clone <SHARED_REPO_URL> "$WORK/shared"+cd "$WORK/shared"+[ "$(git rev-parse --show-toplevel)" != "$PERSONAL" ] \+ || { echo "target IS sync.repo_path (personal brain) — ABORT"; exit 1; }++# Apply the sanitized tree, then COMMIT it BEFORE the mirror clone. A mirror+# captures COMMITTED state only; if the clean tree lives only in volatile+# staging during the rewrite window, a crash loses the sanitization work.+# Committing makes the clean state durable and recoverable; pushing it means+# the remote stops serving the sensitive current versions even if the purge+# below is declined. Only the sanitized directories are committed. On a+# non-zero exit stop: retry once on commit_lock_busy; on integrate_conflict+# someone changed the shared repo meanwhile, so ask the user before going on.+for d in people meetings daily companies projects analysis; do+ [ -d "$STAGING/$d" ] && rsync -a "$STAGING/$d/" "./$d/" # or sanitize in place here+done+SANITIZED=""+for d in people meetings daily companies projects analysis; do [ -d "$d" ] && SANITIZED="$SANITIZED $d"; done+gbrain git commit-push -m "Sanitize: strip sensitive content before history purge" -- $SANITIZED++# Mirror-clone backup = the recoverability line on the card. Capture the path+# in a variable NOW and reuse it verbatim at purge time — a run crossing+# midnight must NOT recompute $(date) and false-abort on a mismatched name.+BACKUP_PATH="$HOME/.gbrain/backups/shared-brain-history-backup-$(date +%Y%m%d-%H%M%S).git"+git clone --mirror "$WORK/shared" "$BACKUP_PATH"+git -C "$BACKUP_PATH" log -1 >/dev/null || { echo "backup unreadable — ABORT"; exit 1; }+```++Verify the mirror exists and reads before presenting the card — it is the+card's recoverability line.++**Step 2 — STOP. Present the [data-loss-gate](../data-loss-gate/SKILL.md)+confirmation card and wait.** History rewrite + force-push is the most+destructive operation in this skill: it permanently discards every prior+version of the purged paths from the remote. Never run it without the card+answered. Pre-filled for this operation:++```+⚠️ DATA DELETION — Confirmation Required++What: rewrite git history to remove all prior versions of [purged paths]+ from the SHARED repo, then force-push to [remote/branch]+Count: [N commits rewritten; M files with history purged]+Size: [repo size before → expected after]+Location: [SHARED repo work dir; remote URL; branch]+Target check: this is the SHARED repo, verified ≠ personal sync.repo_path+ ($PERSONAL) — the personal brain's history is never rewritten++Why: prior commits contain pre-sanitization versions of pages that were+ just cleaned — team access to the repo means team access to history++Recoverable?+- [x] Mirror-clone backup at $BACKUP_PATH+ (verified: exists, `git -C "$BACKUP_PATH" log` works)+- [ ] NOT recoverable from the rewritten remote — old SHAs become unreachable++What we'd lose:+- all pre-sanitization history for the purged paths (edit trail, blame,+ old versions)+- every existing clone breaks — all collaborators must re-clone++Alternative to deletion:+- fresh-history export to a NEW team repo (Step 0) — personal repo untouched++Proceed? (yes/no)+```++Per data-loss-gate: require a typed **"yes"** or **"do it"** — "ok", "sure",+"go ahead" are not consent. If the user asks a question, answer and re-present+the card. This gate is a routing convention, not a runtime enforcement —+nothing in gbrain mechanically blocks `git filter-repo` — which is exactly why+the agent following this skill must not skip it.-**Existing shared repo with sensitive history:** follow-[references/history-purge.md](references/history-purge.md). Its rules hold-even before you read it: purge only the SHARED repo cloned to a work dir, never-`sync.repo_path`; verify a mirror-clone backup, then show its data-loss-gate-card and wait for a typed yes before `git filter-repo` or any force-push.+**Step 3 — purge (only after the explicit typed yes).** Requires+`git filter-repo` (not bundled with git; install separately). **Run this ONLY+in the shared-repo work dir from Step 1 (`cd "$WORK/shared"`). NEVER run+`git filter-repo` or `git push --force` in `sync.repo_path` — the personal <!-- gbrain-allow-shared-tree-git: warns against a force push in the personal brain -->+brain's history must stay intact.** The commands below reuse `$WORK` and+`$BACKUP_PATH` from Step 1; they never recompute a date-stamped path.-**Handoff:** run `gbrain config set brain.audience shared` against the TEAM-brain (never the personal one). Team members who init the shared brain before-that stamp exists prefix that one command with `GBRAIN_NO_ONBOARD_NUDGE=1`.+```bash+cd "$WORK/shared"+[ "$(git rev-parse --show-toplevel)" != "$PERSONAL" ] \+ || { echo "target IS sync.repo_path — ABORT, do not filter-repo"; exit 1; }++# The purge list derives from the COMPLETE set of sanitized paths — the same+# directories Phases 1-4 scanned. A filter list narrower than the scan+# (people/ + meetings/ only) leaves pre-sanitization history alive for every+# other scanned directory. The restore carrier below MUST match this same+# list — backed-up set, filtered set, and re-added set are identical.+PURGE_DIRS="people meetings daily companies projects analysis"++# Back up the clean working tree of every purged path to a DURABLE carrier+# (under $WORK in ~/.gbrain/backups — never /tmp, which can vanish mid-rewrite).+CLEAN="$WORK/clean"+mkdir -p "$CLEAN"+for d in $PURGE_DIRS; do+ [ -d "$d" ] || continue+ mkdir -p "$CLEAN/$d" && cp -r "$d/." "$CLEAN/$d/"+done-### Phase 6: Re-audit+# Rewrite history: one --path per purged directory, derived from $PURGE_DIRS+rm -rf .git/filter-repo+git filter-repo --invert-paths $(for d in $PURGE_DIRS; do printf -- '--path %s/ ' "$d"; done) --force-Schedule a monthly re-audit (weekly for high-ingest brains) that runs Phases-1, 2 and 4 report-only and surfaces hits for a human, wired per-[conventions/cron-via-minions.md](../conventions/cron-via-minions.md)-(`gbrain jobs submit`).+# Restore clean files and re-commit as a single new commit — same $PURGE_DIRS+for d in $PURGE_DIRS; do+ [ -d "$CLEAN/$d" ] || continue+ mkdir -p "$d" && cp -r "$CLEAN/$d/." "$d/"+done+git remote add origin <SHARED_REPO_URL> # filter-repo removes remotes+for d in $PURGE_DIRS; do [ -d "$d" ] && git add "$d/"; done+git commit -m "Re-add sanitized directories"++# VERIFY RESTORE COMPLETENESS before the irreversible push — a partial restore+# would ship a smaller tree than was sanitized. Compare file counts (and, for+# extra safety, checksums) between the carrier and the restored tree.+before=$(find "$CLEAN" -type f | wc -l | tr -d ' ')+after=$(for d in $PURGE_DIRS; do [ -d "$d" ] && find "$d" -type f; done | wc -l | tr -d ' ')+[ "$before" = "$after" ] \+ || { echo "restore incomplete ($before → $after files) — ABORT, do not force-push"; exit 1; }+# Optional stronger check: diff -r "$CLEAN/<d>" "<d>" for each purged dir.++# RE-VERIFY the backup immediately before the irreversible step — card-time+# verification is not enough; time has passed and the rewrite could have gone+# sideways. Reuse $BACKUP_PATH (do NOT recompute $(date)); abort if unreadable.+git -C "$BACKUP_PATH" log -1 >/dev/null \+ || { echo "backup missing/unreadable — ABORT, do not force-push"; exit 1; }++git push --force origin main # gbrain-allow-shared-tree-git: the confirmed history purge of a private single-writer clone (data-loss-gate answered)+```-Edge cases: founder/exec pages carry the most; meeting notes are full scope;-grep for nicknames and initials, not just slugs. Neighbors:-[data-loss-gate](../data-loss-gate/SKILL.md) owns a bare "delete X";-[publish](../publish/SKILL.md) shares one page; [maintain](../maintain/SKILL.md)-checks health, not shareability.+**Step 4 — log it (to the PERSONAL brain, NEVER the shared repo).** Per+data-loss-gate, append the deletion under `## Data Deletions` — but write it to+the PERSONAL brain's `$PERSONAL/daily/notes/YYYY-MM-DD.md` (or a local ops+log), never into the shared repo. The log names the purged paths AND the+backup location; in the shared repo those two facts would tell every team+member exactly which paths held sensitive content and where the+pre-sanitization backup lives — the audit trail becomes a treasure map.+Record: timestamp, purged paths, commit counts, and `$BACKUP_PATH` as the+recovery line.++**After the force push:**++- All existing clones must re-clone+- Hosting providers may cache unreachable commits for a time (on the order of+ months); for immediate removal use the provider's sensitive-data removal+ process. For private/internal repos, the SHA being unreachable from any ref+ is usually sufficient+- The sync cursor may reference a rewritten-away SHA; if the next+ `gbrain sync` errors or falls back to a full rescan, that is the cursor+ recovering — run `gbrain doctor` if it doesn't settle+- **Backup retention:** once the rewrite is verified good (team has+ re-cloned, sync settled, no missing content reported), keep the+ mirror-clone backup in `~/.gbrain/backups/` for a retention window+ (~30 days is a sane default), then delete it — it contains the+ pre-sanitization history and should not accumulate indefinitely:+ `rm -rf ~/.gbrain/backups/shared-brain-history-backup-<date>.git`+ (the glob must match the `shared-brain-history-backup-*` name the backup+ step created — a mismatched pattern deletes nothing and silently retains+ the pre-sanitization history forever)+- If the repo carries push hooks or auto-hardening wiring, re-verify remotes+ and hooks survived the rewrite before handing the repo to the team++**Hand the repo to the team — stamp it shared first.** Whichever path+produced the team repo (fresh-history export in Step 0 or the post-purge+force-push), stamp the published brain's audience before handoff:+`gbrain config set brain.audience shared` — run against the TEAM brain,+never the personal one. The stamp declares this a company/team brain, so+the ambient memory writeback consent nudge (a personal-brain ask) never+fires on it. If team members will run `gbrain init` for the shared brain+BEFORE this stamp exists (e.g. a fresh clone initializing its own engine),+have them prefix that one command with `GBRAIN_NO_ONBOARD_NUDGE=1` — a+fresh un-stamped brain classifies personal, and the init-time nudge is+fire-once, so letting it fire there would both ask the wrong question and+burn the sentinel.++### Phase 6: Ongoing hygiene — periodic re-audit++Sensitive data re-accumulates through meeting-transcript ingestion (candid+assessments), enrichment pipelines pulling internal data, and manual writes+during candid conversations. One clean pass is a snapshot, not a state.++**Recommendation:** schedule a monthly re-audit (weekly for high-ingest+brains) that re-runs Phases 1, 2, and 4 in report-only mode — scan and flag,+no edits — and surfaces new hits for human review before they reach the+shared repo. Wire it per+[conventions/cron-via-minions.md](../conventions/cron-via-minions.md): the+cron slot submits a background job (`gbrain jobs submit`), scheduling+guidance in `skills/cron-scheduler/SKILL.md`, job-lane routing in+`skills/minion-orchestrator/SKILL.md`. The report-only run writes its+findings summary; a human (or a gated follow-up run) does the removal.++## Scaling Notes++- **< 20 files:** process sequentially in one pass+- **20-50 files:** 2-3 parallel subagents+- **50-150 files:** 8-12 parallel subagents, batches of 10-15+- **150+ files:** scripted pattern removal for the rote cases only+ (frontmatter fields, phone numbers — machine-emitted shapes, per+ regex-discipline) + subagents for everything needing judgment++## Edge Cases++- **Founders vs. employees:** founder/exec pages often carry the most+ sensitive content (board dynamics, investor relationships, assessments of+ their own team). These need the most careful review.+- **Meeting notes:** meeting pages referencing employee performance need the+ same treatment as people pages — they are in scope, not an afterthought.+- **Cross-references:** after sanitizing people pages, check that no other+ page (meetings, companies, dailies) still references the removed content;+ `gbrain check-backlinks check` plus a grep for the removed section titles.+- **Takes with attribution:** a take like "the user believes+ charlie-example is underperforming" reveals both the opinion and who holds+ it. Remove the entire take, not just the attribution.+- **Aliases and nicknames:** grep for the person's short name and initials,+ not just the slug — candid content rarely uses full names.++## Dedup (sharp boundaries)++- **[data-loss-gate](../data-loss-gate/SKILL.md)** — supplies the+ confirmation-card mechanics and the explicit-yes discipline; company-brainify+ is a specialized caller of it at BOTH destructive steps: Phase 3 (bulk strip+ + take/fact removal) and Phase 5 (history purge + force-push), each with a+ pre-filled card. A standalone "delete/purge/clean up X" intent routes to+ data-loss-gate; the personal→team sanitization WORKFLOW routes here.+- **[publish](../publish/SKILL.md)** — outbound sharing of ONE page as+ encrypted self-contained HTML. company-brainify is whole-brain inbound team+ access. "Share this page" → publish; "share my brain with the team" → here.+- **[maintain](../maintain/SKILL.md)** — structural health (orphans,+ backlinks, stale pages). maintain checks whether the brain is HEALTHY;+ company-brainify checks whether it is SAFE TO SHARE. "Check brain health"+ routes to maintain.+- **frontmatter-guard (host-side)** — validates frontmatter SHAPE.+ company-brainify strips sensitive frontmatter FIELDS; run+ frontmatter-guard after a large pass to confirm what remains still+ parses.## ContractThis skill guarantees:-- Both destructive steps — Phase 3 bulk edits and the Phase 5 history purge —- show the data-loss-gate card and wait for a typed "yes"/"do it"; nothing at- runtime blocks a skipped gate, so skipping it is the cardinal violation.-- Phase 3 sanitizes a staging copy by default, leaving the personal brain's- working tree untouched; its history is never rewritten.-- The scan covers the full scope; every strip decision is a model judgment on a- full read; verification runs on the tree that ships, before any push.-- Nothing unscanned ships; sensitive fact rows are deleted and the facts index- reconciled, never merely expired with `forget`.-- A purge runs only on the shared repo, after a verified mirror backup, with the- filter list and restore manifest covering every sanitized path, and is logged- to the PERSONAL brain only.-- The team brain is stamped `brain.audience=shared` at handoff.-- Routing matches the frontmatter triggers; edits stay in `writes_to`- directories; no real names or fork-specific paths.+- Both destructive steps fire the data-loss-gate confirmation card and wait for+ an explicit typed "yes"/"do it" BEFORE running: Phase 3 (bulk strip + take/+ fact removal) and Phase 5 (history purge + force-push). This is a routing+ convention the agent must follow — nothing in the runtime mechanically blocks+ a skipped gate, which is why skipping it is the cardinal violation of this+ skill.+- Phase 3 defaults to sanitizing a STAGING COPY of the scanned scope, leaving+ the personal brain's working tree untouched; in-place edits are reserved for+ re-auditing an existing shared brain.+- The Phase 5 history purge (Steps 3+) runs only on the SHARED repo cloned to a+ work dir — never `sync.repo_path` — after (a) a mirror-clone backup exists and+ is verified, and (b) a restore-completeness check passes before the+ force-push. The personal brain's history is never rewritten.+- The deletion log is written to the PERSONAL brain (`daily/`) or a local ops+ log, never into the shared repo.+- The scan covers the full scope (people, meetings, dailies, companies,+ projects, analysis, takes, facts, back-links), never `people/` alone.+- Nothing unscanned ships: the fresh-export path includes ONLY directories+ covered by the sanitization scan; everything else is excluded by default,+ and the Phase 4 verification greps run against the exported tree before+ the first push.+- Sensitive fact rows are deleted from the page's Facts fence, re-synced,+ and the facts index reconciled (extract-facts sweep) with the removal+ verified via `gbrain recall --grep`, never merely expired — `gbrain+ forget` retains the row (struck through, served via `--include-expired`)+ and can never certify clean.+- The history-purge filter list and its restore manifest both derive from+ the COMPLETE set of sanitized paths, never a subset.+- Every strip decision is a per-file model judgment grounded in a full read;+ grep output is triage and verification only.+- A verification pass (Phase 4 greps + retrieval checks) runs before any+ commit is pushed to the shared repo.+- Confirmed purges are logged to `daily/notes/YYYY-MM-DD.md` under+ `## Data Deletions` with the backup path as the recovery line.+- A brainified brain is stamped `brain.audience=shared` at handoff and never+ receives the ambient-writeback enablement nudge — that consent ask is+ reserved for personal brains.+- Routing matches the canonical triggers in the frontmatter.+- Output written under the directories listed in `writes_to:` (edits in+ place, plus the daily/ deletion log).+- Privacy contract preserved: no real names, no fork-specific filesystem path+ literals, no upstream-fork references.++The full behavior contract is documented in the body sections above; this+section exists for the conformance test.## Output Format+Three artifacts:++1. **The sanitization report** (every run, including report-only re-audits):+```markdown## Brainify Report — YYYY-MM-DD@@ -285,9 +682,12 @@ This skill guarantees:- Next re-audit: [date / cron slot]```-Plus the confirmation card before each destructive step (the turn stops there)-and the deletion log entry (post-purge only), appended to the PERSONAL brain's-`daily/notes/YYYY-MM-DD.md` (never the shared repo) per data-loss-gate Step 4.+2. **The confirmation card** (Phases 3 and 5) — the pre-filled fenced card,+ presented before the bulk destructive edits (Phase 3) and before any history+ rewrite (Phase 5); the turn stops until the user answers.+3. **The deletion log entry** (post-purge only) — appended to the PERSONAL+ brain's `daily/notes/YYYY-MM-DD.md` (never the shared repo) per+ data-loss-gate Step 4.## When it fails@@ -299,15 +699,35 @@ Follow the [agent operator protocol](../conventions/agent-operator-protocol.md)## Anti-Patterns-- ❌ Scanning only `people/`, or certifying the personal tree instead of the one that ships-- ❌ Stripping the personal brain in place for a new team brain-- ❌ Any destructive step before the typed confirmation-- ❌ `gbrain forget` as sanitization, or removing a take's attribution but keeping its claim-- ❌ Exporting the whole repo — unscanned directories never ship-- ❌ `git filter-repo` or force-push in `sync.repo_path`, without a verified backup, or on a subset of the sanitized paths-- ❌ Writing the deletion log into the shared repo-- ❌ Treating grep as the judge, or bulk-editing without a 3–5 file test--## References--- Purging sensitive history from an existing shared repo → [references/history-purge.md](references/history-purge.md)+- ❌ Scanning only `people/` — meetings, dailies, and cross-references leak+ the same content+- ❌ Sanitizing working-tree files and calling it done — history still carries+ every sensitive version+- ❌ Exporting the whole repo into the team brain — the export ships ONLY+ scanned directories; nothing unscanned ships+- ❌ Using `gbrain forget` as sanitization — forget expires (struck-through+ row retained, served via `--include-expired`); delete the fence row and+ re-sync instead+- ❌ Purging history for a subset of the sanitized paths — the filter list+ derives from the complete scan scope, not just `people/` + `meetings/`+- ❌ Running `git filter-repo` / force-push without the mirror-clone backup+ and the typed confirmation — the card comes BEFORE the rewrite, always+- ❌ Running `git filter-repo` / force-push in `sync.repo_path` — the purge+ targets the SHARED repo cloned to a work dir; the personal brain's history is+ never rewritten+- ❌ Stripping the personal brain in place when standing up a NEW team brain —+ sanitize a staging copy; the founder's private comp/performance notes stay+- ❌ Bulk-editing files and removing takes/facts without the Phase 3+ data-loss-gate card — destructive edits are gated too, not just the purge+- ❌ Writing the deletion log into the shared repo — it names the sensitive+ paths and the backup location; log it to the PERSONAL brain+- ❌ Treating grep as the sensitivity judge — patterns triage, the model+ reads and decides (regex-discipline)+- ❌ Removing the attribution but keeping the take — the claim itself is the+ leak; remove the whole row+- ❌ Bulk-editing 150 files without a 3-5 file test first (test-before-bulk)+- ❌ Tightening grep patterns to eliminate false positives — confirm the hits+ manually instead; a "clean" scan from an over-fitted pattern is a false+ certificate+- ❌ One clean pass with no re-audit — ingestion and enrichment re-accumulate+ sensitive content; schedule Phase 6diff --git a/skills/company-brainify/references/history-purge.md b/skills/company-brainify/references/history-purge.mddeleted file mode 100644index 37dcffcdb9..0000000000--- a/skills/company-brainify/references/history-purge.md+++ /dev/null@@ -1,178 +0,0 @@-# History purge (company-brainify Phase 5)--Read this when an existing SHARED repo still carries pre-sanitization versions-in its git history. A fresh team repo (Phase 5, preferred) needs none of it.--**Step 1 — target the SHARED repo, commit the clean tree, then mirror-clone.**-The purge operates on the SHARED repo, NEVER on `sync.repo_path` (the personal-brain) — Step 0's guarantee that the personal repo keeps full history depends-on it. Clone the shared repo to a durable work dir, stay there for every step-below, and assert the target is not the personal repo before touching anything.--```bash-PERSONAL="$(gbrain config get sync.repo_path)"-mkdir -p "$HOME/.gbrain/backups" && chmod 700 "$HOME/.gbrain/backups"-WORK="$HOME/.gbrain/backups/brainify-purge-$(date +%Y%m%d-%H%M%S)"-git clone <SHARED_REPO_URL> "$WORK/shared"-cd "$WORK/shared"-[ "$(git rev-parse --show-toplevel)" != "$PERSONAL" ] \- || { echo "target IS sync.repo_path (personal brain) — ABORT"; exit 1; }--# Apply the sanitized tree, then COMMIT it BEFORE the mirror clone. A mirror-# captures COMMITTED state only; if the clean tree lives only in volatile-# staging during the rewrite window, a crash loses the sanitization work.-# Committing makes the clean state durable and recoverable; pushing it means-# the remote stops serving the sensitive current versions even if the purge-# below is declined. Only the sanitized directories are committed. On a-# non-zero exit stop: retry once on commit_lock_busy; on integrate_conflict-# someone changed the shared repo meanwhile, so ask the user before going on.-for d in people meetings daily companies projects analysis; do- [ -d "$STAGING/$d" ] && rsync -a "$STAGING/$d/" "./$d/" # or sanitize in place here-done-SANITIZED=""-for d in people meetings daily companies projects analysis; do [ -d "$d" ] && SANITIZED="$SANITIZED $d"; done-gbrain git commit-push -m "Sanitize: strip sensitive content before history purge" -- $SANITIZED--# Mirror-clone backup = the recoverability line on the card. Capture the path-# in a variable NOW and reuse it verbatim at purge time — a run crossing-# midnight must NOT recompute $(date) and false-abort on a mismatched name.-BACKUP_PATH="$HOME/.gbrain/backups/shared-brain-history-backup-$(date +%Y%m%d-%H%M%S).git"-git clone --mirror "$WORK/shared" "$BACKUP_PATH"-git -C "$BACKUP_PATH" log -1 >/dev/null || { echo "backup unreadable — ABORT"; exit 1; }-```--Verify the mirror exists and reads before presenting the card — it is the-card's recoverability line.--**Step 2 — STOP. Present the [data-loss-gate](../../data-loss-gate/SKILL.md)-confirmation card and wait.** History rewrite + force-push is the most-destructive operation in this skill: it permanently discards every prior-version of the purged paths from the remote. Never run it without the card-answered. Pre-filled for this operation:--```-⚠️ DATA DELETION — Confirmation Required--What: rewrite git history to remove all prior versions of [purged paths]- from the SHARED repo, then force-push to [remote/branch]-Count: [N commits rewritten; M files with history purged]-Size: [repo size before → expected after]-Location: [SHARED repo work dir; remote URL; branch]-Target check: this is the SHARED repo, verified ≠ personal sync.repo_path- ($PERSONAL) — the personal brain's history is never rewritten--Why: prior commits contain pre-sanitization versions of pages that were- just cleaned — team access to the repo means team access to history--Recoverable?-- [x] Mirror-clone backup at $BACKUP_PATH- (verified: exists, `git -C "$BACKUP_PATH" log` works)-- [ ] NOT recoverable from the rewritten remote — old SHAs become unreachable--What we'd lose:-- all pre-sanitization history for the purged paths (edit trail, blame,- old versions)-- every existing clone breaks — all collaborators must re-clone--Alternative to deletion:-- fresh-history export to a NEW team repo (Step 0) — personal repo untouched--Proceed? (yes/no)-```--Per data-loss-gate: require a typed **"yes"** or **"do it"** — "ok", "sure",-"go ahead" are not consent. If the user asks a question, answer and re-present-the card. This gate is a routing convention, not a runtime enforcement —-nothing in gbrain mechanically blocks `git filter-repo` — which is exactly why-the agent following this skill must not skip it.--**Step 3 — purge (only after the explicit typed yes).** Requires-`git filter-repo` (not bundled with git; install separately). **Run this ONLY-in the shared-repo work dir from Step 1 (`cd "$WORK/shared"`). NEVER run-`git filter-repo` or `git push --force` in `sync.repo_path` — the personal <!-- gbrain-allow-shared-tree-git: warns against a force push in the personal brain -->-brain's history must stay intact.** The commands below reuse `$WORK` and-`$BACKUP_PATH` from Step 1; they never recompute a date-stamped path.--```bash-cd "$WORK/shared"-[ "$(git rev-parse --show-toplevel)" != "$PERSONAL" ] \- || { echo "target IS sync.repo_path — ABORT, do not filter-repo"; exit 1; }--# The purge list derives from the COMPLETE set of sanitized paths — the same-# directories Phases 1-4 scanned. A filter list narrower than the scan-# (people/ + meetings/ only) leaves pre-sanitization history alive for every-# other scanned directory. The restore carrier below MUST match this same-# list — backed-up set, filtered set, and re-added set are identical.-PURGE_DIRS="people meetings daily companies projects analysis"--# Back up the clean working tree of every purged path to a DURABLE carrier-# (under $WORK in ~/.gbrain/backups — never /tmp, which can vanish mid-rewrite).-CLEAN="$WORK/clean"-mkdir -p "$CLEAN"-for d in $PURGE_DIRS; do- [ -d "$d" ] || continue- mkdir -p "$CLEAN/$d" && cp -r "$d/." "$CLEAN/$d/"-done--# Rewrite history: one --path per purged directory, derived from $PURGE_DIRS-rm -rf .git/filter-repo-git filter-repo --invert-paths $(for d in $PURGE_DIRS; do printf -- '--path %s/ ' "$d"; done) --force--# Restore clean files and re-commit as a single new commit — same $PURGE_DIRS-for d in $PURGE_DIRS; do- [ -d "$CLEAN/$d" ] || continue- mkdir -p "$d" && cp -r "$CLEAN/$d/." "$d/"-done-git remote add origin <SHARED_REPO_URL> # filter-repo removes remotes-for d in $PURGE_DIRS; do [ -d "$d" ] && git add "$d/"; done-git commit -m "Re-add sanitized directories"--# VERIFY RESTORE COMPLETENESS before the irreversible push — a partial restore-# would ship a smaller tree than was sanitized. Compare file counts (and, for-# extra safety, checksums) between the carrier and the restored tree.-before=$(find "$CLEAN" -type f | wc -l | tr -d ' ')-after=$(for d in $PURGE_DIRS; do [ -d "$d" ] && find "$d" -type f; done | wc -l | tr -d ' ')-[ "$before" = "$after" ] \- || { echo "restore incomplete ($before → $after files) — ABORT, do not force-push"; exit 1; }-# Optional stronger check: diff -r "$CLEAN/<d>" "<d>" for each purged dir.--# RE-VERIFY the backup immediately before the irreversible step — card-time-# verification is not enough; time has passed and the rewrite could have gone-# sideways. Reuse $BACKUP_PATH (do NOT recompute $(date)); abort if unreadable.-git -C "$BACKUP_PATH" log -1 >/dev/null \- || { echo "backup missing/unreadable — ABORT, do not force-push"; exit 1; }--git push --force origin main # gbrain-allow-shared-tree-git: the confirmed history purge of a private single-writer clone (data-loss-gate answered)-```--**Step 4 — log it (to the PERSONAL brain, NEVER the shared repo).** Per-data-loss-gate, append the deletion under `## Data Deletions` — but write it to-the PERSONAL brain's `$PERSONAL/daily/notes/YYYY-MM-DD.md` (or a local ops-log), never into the shared repo. The log names the purged paths AND the-backup location; in the shared repo those two facts would tell every team-member exactly which paths held sensitive content and where the-pre-sanitization backup lives — the audit trail becomes a treasure map.-Record: timestamp, purged paths, commit counts, and `$BACKUP_PATH` as the-recovery line.--**After the force push:**--- All existing clones must re-clone-- Hosting providers may cache unreachable commits for a time (on the order of- months); for immediate removal use the provider's sensitive-data removal- process. For private/internal repos, the SHA being unreachable from any ref- is usually sufficient-- The sync cursor may reference a rewritten-away SHA; if the next- `gbrain sync` errors or falls back to a full rescan, that is the cursor- recovering — run `gbrain doctor` if it doesn't settle-- **Backup retention:** once the rewrite is verified good (team has- re-cloned, sync settled, no missing content reported), keep the- mirror-clone backup in `~/.gbrain/backups/` for a retention window- (~30 days is a sane default), then delete it — it contains the- pre-sanitization history and should not accumulate indefinitely:- `rm -rf ~/.gbrain/backups/shared-brain-history-backup-<date>.git`- (the glob must match the `shared-brain-history-backup-*` name the backup- step created — a mismatched pattern deletes nothing and silently retains- the pre-sanitization history forever)-- If the repo carries push hooks or auto-hardening wiring, re-verify remotes- and hooks survived the rewrite before handing the repo to the teamdiff --git a/skills/skill-budgets.tsv b/skills/skill-budgets.tsvindex df06215005..a2de84dec5 100644--- a/skills/skill-budgets.tsv+++ b/skills/skill-budgets.tsv@@ -8,6 +8,7 @@book-mirror 29391 - seeded at 26719 bytesbulk-ingestion 20834 - seeded at 18940 bytescold-start 25930 - seeded at 23572 bytes+company-brainify 41167 - seeded at 37424 bytesconcept-synthesis 24614 - seeded at 22376 bytesconversation-archive 26949 - seeded at 24499 byteseiirp 24677 - seeded at 22433 bytesdiff --git a/skills/skills.lock.history.json b/skills/skills.lock.history.jsonindex 9ce9dbfa69..3d71faa88c 100644--- a/skills/skills.lock.history.json+++ b/skills/skills.lock.history.json@@ -226,7 +226,6 @@"eb10547b5f2fba3edffd47c5023cd3f28335e1ee3b599f98f298c1ccd07090eb"],"company-brainify/SKILL.md": [- "0ed5fd5c7e641c1ad76987e84a19bca70274c901726ed72b09f5f5ccab933703","2c058b39f5364b8ceb5c53b4525cce8645734f16cc3c229a490b005d58a78311","59a19560fe935ce4666ac5b8321e5891bb4e19e078ff751f48bbc5561613b0e9","6f39e2ae59e6722f4afac9134ce7041e584637cf08f387861bf6013306c3bd51",@@ -235,9 +234,6 @@"bed846efe1a89271faac6aa1f7fef57b08dbdbe35a418a21102e738b8add2458","f82a78337021f3cc87ad3e3674b3fbc94698193aff772e458375a3eb144ddf11"],- "company-brainify/references/history-purge.md": [- "c7ae380179ab918f6ccd9e93103428cb6315ff826f13e2ac4499c57731bae179"- ],"company-brainify/routing-eval.jsonl": ["6f27f835eda9ae77a2b694534c78a043a871349820e8c638c3d8bbba6d3aa17b"],@@ -1049,7 +1045,6 @@],"skill-budgets.tsv": ["917ac319b38596369396c3cf98d75c8eed1d6fb2d339bb3cc1084e61cac1ffe0",- "a89aef1c97d039970b4ec5267426dc6c284ef65ee9b4c2851cd3d74336282d56","cb788b50cc3d43e32d549d52cedb6feb7dfb0409cbdc0bd0ef76f226b7e53fd2"],"skill-creator/SKILL.md": [diff --git a/skills/skills.lock.json b/skills/skills.lock.jsonindex 95fbf70f58..31b2b30e05 100644--- a/skills/skills.lock.json+++ b/skills/skills.lock.json@@ -38,8 +38,7 @@"citation-graph-ingest/SKILL.md": "3c8c4abea96769458e9781ce2f5f305c75118fcb5f68cc62b5e1ed7774259035","citation-graph-ingest/routing-eval.jsonl": "a1ba605d35e736b741b9e8aac1e7d50b61a7cbcada893d67099b55bf5a0d2635","cold-start/SKILL.md": "eb10547b5f2fba3edffd47c5023cd3f28335e1ee3b599f98f298c1ccd07090eb",- "company-brainify/SKILL.md": "0ed5fd5c7e641c1ad76987e84a19bca70274c901726ed72b09f5f5ccab933703",- "company-brainify/references/history-purge.md": "c7ae380179ab918f6ccd9e93103428cb6315ff826f13e2ac4499c57731bae179",+ "company-brainify/SKILL.md": "89e8cae702d468628d110119e325cece897cd15066c7cc7d27e990021904fc04","company-brainify/routing-eval.jsonl": "6f27f835eda9ae77a2b694534c78a043a871349820e8c638c3d8bbba6d3aa17b","concept-synthesis/SKILL.md": "a5c67f981c5d0a0ef4f13134ed8602e08b0bfbe289456213b8cd465a7a009220","concept-synthesis/routing-eval.jsonl": "96dbd7d9c1b606e9e06262d0c06282399741e2bccb8eeb7b9ca88c20f44cda0e",@@ -216,7 +215,7 @@"signal-detector/SKILL.md": "426a8a3b01a007dd25638e61adef510c18c3d9ce6f1c18ba3d77fdfcd3281d60","skill-autobench/SKILL.md": "29f5760dcfd823c5f7d4fb50a3cf4e36601b1b8125e57d6bf83645a41f97f613","skill-autobench/routing-eval.jsonl": "8d961ed6403b7e2f690948e4c18529d40f26f6f21064befc56d465966b1a9ec0",- "skill-budgets.tsv": "a89aef1c97d039970b4ec5267426dc6c284ef65ee9b4c2851cd3d74336282d56",+ "skill-budgets.tsv": "cb788b50cc3d43e32d549d52cedb6feb7dfb0409cbdc0bd0ef76f226b7e53fd2","skill-creator/SKILL.md": "06fa8391d3be4fed2da7344677bd798786dda114fbdf8c676f0b77f4f0756f38","skill-optimizer/SKILL.md": "1dea9a5257a60fb29a4c7701c92bce428025fb2321e950533f1367edfca1b8b0","skill-optimizer/routing-eval.jsonl": "48f7fc04414b194ee8674577c3e58e03ebd7f74d836766bd16cb5abfd4effb76",@@ -226,7 +225,7 @@"skillpack-check/SKILL.md": "bcb96d0d231827c9fcd47865f63aaef70c9b9f7a7402464594f24f5fe1eeff8c","skillpack-harvest/SKILL.md": "0f86314b58d25b5511809f567c04aedc3fba6fe35ed642ac52d8216ae365b6eb","skillpack-harvest/routing-eval.jsonl": "cb4783288e95af3132b32ecb40a54cffc095f57b36240f96a25c2d2adf5e68c6",- "skills.lock.history.json": "33275e079726dbad241867d9ae782df36a2739534f3e771091446791d99ca02e",+ "skills.lock.history.json": "683ada41e02bed5814a71e8c4286ce9f2fd22e59ae6ca9177c8c920df9c06d2e","smoke-test/SKILL.md": "f5099e1d2ab9dc6827096249e68414f7ae357c29b39fb069a54bb7fb74f414a5","soul-audit/SKILL.md": "7a48e180849f7502d332878c443397f90a3756f45caa94f76bcfcc7c997469c8","strategic-reading/SKILL.md": "ab2cd3adc79289374cfbc5cb3d5ee17f962fd8f7f3c997a1da708da0ed67797c",