soul-refinement
Daily SOUL.md refinement process — mine sessions for lessons, apply corrections, codify principles. Optional per-agent Bible insight integration for daily Scripture reading.
- License 许可
- MIT
- 最近更新
- 2026-11-14
- Stars
- ★ 4
- Forks
- 1
01 前言 Front Matter
- name
- soul-refinement
- author
- Steadfaste Fleet
- license
- MIT
- version
- 1.0.0
- metadata
- { "hermes": { "tags": [ "soul", "identity", "refinement", "daily", "bible", "lessons" ], "related_skills": [ "soul-authoring", "memory-architecture", "hermes-agent-skill-authoring", "cron-engineering" ] } }
- platforms
- [ "macos", "linux" ]
- description
- Daily SOUL.md refinement process — mine sessions for lessons, apply corrections, codify principles. Optional per-agent Bible insight integration for daily Scripture reading.
03 SKILL.md 正文
Soul Refinement — Daily Identity Update
What This Is
A daily process that refines an agent's SOUL.md by mining the day's sessions for corrections and insights, plus optional daily Bible reading. The result is a living identity document that gets sharper over time.
Agents who use this process grow alongside their operator — applying lessons from both daily work and Scripture.
Two Channels
Channel A — Bible Insight (cron: 1am daily, Python script)
Handled by agent-daily-bible-reading.py (no_agent cron script). It:
- Generates a short behavioral statement (verse + one-line commitment) for SOUL.md
- Saves the full analysis (archaeology, language, Jewish perspective) to
~/brain/<agent>/bible/<book>.md - Updates the brain index
Output format for SOUL.md (short form only):
### {Book} — *"{Key verse}"* ({Ref})
I will [one-line behavioral commitment for a system operator].
<!-- Added {YYYY-MM-DD} -->
Full analysis goes to ~/brain/<agent>/bible/<book>.md — not SOUL.md.
Channel B — Session Mining (recommended cron: 23:00 daily)
Reviews the sessions since the last run for user corrections and distills lessons into principle updates. The window is a bounded lookback from RUN TIME, never a calendar date — see Pitfalls.
Setup (do once):
hermes cron create --name "local-daily-soul-refinement" \
--schedule "14 23 * * *" \
--skill "soul-refinement" \
--prompt "Load the soul-refinement skill. Mine the last 24 hours of sessions (run-time window, not the calendar date) for user corrections and lessons. Distill into principle or skill patches. Report the window and its row counts; stay silent only if the window is non-empty and nothing changed."
The fleet's live per-host job runs 14 23 * * * (docs/cron-schedules.md); any evening
slot works, but a late dispatch can land after midnight — so the window must never be derived
from the date.
Decision Rules
| Situation | Action |
|---|---|
| User corrected a specific behavior | Check existing principle. If covered: strengthen. If gap: add principle. |
| Correction already landed by a same-day cycle | Verify before writing. The window's corrections are often codified within hours — grep the repo for the correction's own artifact (and read the day's commits) before proposing a principle. Measured 2026-10-20: 3 of the window's 4 corrections already had committed same-day fixes, so a fresh principle for them would have duplicated landed work. Measured again 2026-10-22: 4 of the 4 operator rows in the window already had same-day landed fixes (the human-exemption guard + its evidence; the skills-loader repair + a doctor FAIL gate + the skill-curation loader rules), so the pass's entire deliverable was a refinement of this skill's own mining recipe — not a principle. Measured a third time 2026-10-23: all 4 prose corrections already had same-day committed fixes (reviewer sibling-target c9169092; orchestrator-only review→completed 5ae8645d; repo cleanup ca9de57f; Cloudflare vendored 36460672). Expect that outcome on a busy day and report it as a result, not as "nothing to refine". |
| Corrections all already landed | Then land the fleet-hygiene work the day's own activity re-broke. A busy day closes many cycles and each one can re-strand a deployed skill. Run check-skill-drift-parity.py; if it FAILs, that is the pass's deliverable — reconcile, deploy, push (measured 2026-10-23: 5 re-stranded, parity FAIL → PASS). A parity PASS is NOT the deploy being current — run the doctor's own check too, because the two measure opposite directions. Parity reports the STRANDED direction (content that exists only deployed) and reads PASS while the doctor's Skill drift line FAILs on the repo-ahead direction: a lesson committed to the repo that no deploy has yet propagated, so the fleet has not received it either. Measured 2026-10-24: parity --check rc=0 with 0 stranded / 0 absent beside ⚠️ Skill drift: devops/fleet-commands — the day's 22:38 commit added an envelope-allowlist lesson the fleet had not received. The fix for THAT direction is a deploy (fleet-dogfood.sh --force), never reconcile-stranded-skills.py, which only ever moves deployed→repo; after the deploy the doctor reads 386 skills in sync and no per-skill line remains. Read the doctor's per-check line before concluding the tree is clean. |
| User taught a workflow discovery | Save as a skill, not in SOUL.md. |
| I made a mistake | Trace root cause. Only principle failures go in SOUL.md. |
| Deeper understanding discovered | Add nuance to relevant section. |
| Bible insight for the day | Append to Scripture Insights section. |
Read Tracking (Agent Inbox)
The Agent Inbox already tracks read/unread per message via status: frontmatter field.
status: unread— message has not been processedstatus: read— message has been processed
When your inbox polling script processes a message:
- Call
GET /read/{filename}to mark it as read - Next poll with
?unread_only=truewill skip it
Each message has a unique ID (its filename, e.g. 20260613163202-luke). This serves as a session marker — you can track which messages have been acknowledged by saving seen IDs to a local state file.
Principles for Good Refinements
- Be concise. A refinement is 1-4 sentences.
- Be precise. Name the specific behavior, not a general virtue.
- Be actionable. Must be verifiable in practice.
- Don't bloat. One-off edge cases → memory or lesson, not SOUL.md.
- Mark additions. Prefix new entries with
<!-- Added YYYY-MM-DD -->.
Template Curation — Consolidation & Size Budget (learned 2026-08-03)
The template (docs/templates/SOUL.md) and deployed ~/.hermes/SOUL.md had a
size budget enforced by the doctor (check_soul_sync) until 2026-11-04, when
the SOUL-decoupling removed it (SOUL.md is now Hermes-owned, not fleet-synced):
previously WARN >15K, FAIL >20K. Keep SOUL lean for loading — growing past
~20K bloats what every session loads — but nothing fleet-side fails on it now.
Canonical structure: 12 principles
Principles accumulate from user corrections. When the count drifts toward 20-30+, consolidate by theme back to the canonical 12 (2026-08-03: 34 → 12):
- Loop Governance — Mandatory Pre-Work Sequence (MCP-Enforced)
- Inbox Message Decision Framework (+ audit trail)
- Verify Before Declare — Real Work, Real Output
- Be Proactive — Fix, Test, Document
- Own Every Issue — Fix First, Prove Second
- Always Do the Right Way — Canonical Paths
- Be Concise — Every Word Earns Its Place
- Protect the System — Security, Privacy, Stability
- Design for the Full Deployment Matrix
- Test Small Before Scaling
- Agent Cron Management
- Not Done Until Tested — End-to-End Verification
Consolidation rules
- Merge by theme, preserve every guardrail. Each merged principle carries the actionable content of all its source principles (provenance dates inline).
- Marker preservation is good practice (no longer enforced). The doctor's
_extract_soul_markers(removed 2026-11-04) used to extract bolded phrases (- **What I did**,- **Proactive**, etc.) and require template ↔ deployed parity. Even without enforcement, keep the audit-trail markers ("What I did", "How I verified", "How the user learns about it", "Where it's logged") as bold list items so they stay consistent across the fleet template. - Scripture stays at ONE anchor entry. The daily-bible cron needs the LAST
### Book —entry to know the next book. Keep exactly one (e.g. Colossians); archive older entries (full content lives in~/brain/<agent>/bible/). - Do NOT raise the doctor thresholds to accommodate a bloated template — the content must fit the budget, not the budget stretch to the content.
- Keep the template under 20K (ideally ≤16K so a fresh deploy lands at WARN, not FAIL).
Sync after curation
Since the 2026-11-04 SOUL-decoupling, soul-merge.py/soul-sync-all.sh are
removed — the fleet no longer auto-syncs ~/.hermes/SOUL.md. To land a change:
- Patch the template
docs/templates/SOUL.md(the shared reference) AND the deployed~/.hermes/SOUL.md— they are independent copies now; there is no sync step that pushes one to the other - Rebuild deployed
~/.hermes/SOUL.mdfrom template + agent-specific sections (Identity / Core Mission / Core Traits / Final Directive) as needed - Verify
agents-doc-audit.pymandatory sections still pass - Commit template + skill together; broadcast via
agents-doc-broadcast.py(SOUL is identity — the broadcast tells other agents to review, it no longer propagates content)
- Passing a PATH where the reviewed material must be CONTENT is not a review — it is the same
unverified-claim CLASS the reviewer exists to catch (observed 2026-10-14, cycle 12624).
adversarial-review.py --materialtakes the material itself; a path is reviewed as the literal string, the reviewer correctly refuses to judge substance, and a CLEAN verdict on a path proves nothing. Rules, all measured the same day: (1) build the material from the artifact's CONTENTS (orgit diff --cached) and paste it inline — a pointer to a file or a commit SHA is never material. (2) Do NOT put worker questions or directives in the material — "answer Q1-Q3", "report as JSON" are filed asinjectionfindings and the questions are NOT answered; state the proposal as a checkable claim instead. (3) Quote existing text by COPY-PASTE, never from memory: a "from:" line reading "never delete or weaken enforcement" against a file reading "never weaken enforcement" was filedfabrication— the strongest severity — for a memory-drift typo. Runsed -n '<a>,<b>p' <file>first, then diff against those bytes. Expect 3+ rounds; each refusal explains itself in itsrecommendationfield. - A standing rule must land as a GATE, and the repo template is now gated (observed 2026-10-14,
cycle 12624). When the operator says "put in ENFORCEMENT against this move", the deliverable is a
machine-enforced control that fires without the agent's cooperation (a doctor FAIL or pre-push
block) — a skill note, a memory entry, or the agent's own diligence is not a control. Live
exemplar:
ops/scripts/quality/review-provenance-check.py+check_review_provenance, where an undeclared review artifact FAILs the doctor and blocks every push on the host. For the identity document the writer gate has TIGHTENED since the 2026-10-07 probe: writingdocs/templates/SOUL.mdfrom a cron is REFUSED — "write to protected agent-instruction file(s) (SOUL.md) requires approval but no interactive user or gateway is present to approve it" — while the DEPLOYED~/.hermes/SOUL.mdremains ungated (_protected_instruction_reason(deployed,'cron')->None; the template path ->SOUL.md). So an unattended cron CANNOT amend the canonical template: it may update its OWN deployed copy (still requiring operator approval by policy), and it must SUBMIT the exact proposed template wording for approval. Do not route around the refusal — a fresh cycle's lock is NOT authorization. (Correction to the "observed 2026-10-07" note above: that probe's success was real but scoped to the DEPLOYED path — it does not mean the cron can write the template.) - The cron commit gate now blocks on a reflexion check; editing the pre-commit hook is the wrong
repair (observed 2026-10-14, cycle 12624).
git commitfrom a cron is refused with "Reflexion check not completed — NOT-LOADED reflexion-check (session <id>)": load the skill withskill_view(name='reflexion-check'), answer its questions, then commit. Do NOT editops/scripts/pre-commit-score— that path andops/scripts/pre-push-pullare both inops/scripts/lib/always-review-paths.txt, so touching them converts a one-line convenience into an always-review change. Notegit commit -F -m <msg> -- <pathspec>still fires the gate.
Pitfalls
-
A long lookback OVERLAPS the previous run's window, so the same correction is re-reviewed. Read the previous pass's own reported window (the previous soul-refine cron session's final report) and start from its END, not from
now - 30 h; otherwise the overlap re-derives corrections that were already codified and the overlap looks like fresh work. Measured 2026-10-21: the 10-20 pass ended at23:17while a 30 h window began at17:18, so one of that day's corrections (doctor-warning dispositions) sat inside both windows. -
Resolve the previous pass's END mechanically, and classify the window by
sessions.source(measured 2026-10-22). Query it, don't recall it:SELECT id,title,started_at,last_activity_at,ended_at FROM sessions WHERE title LIKE '%soul-refinement%' ORDER BY COALESCE(last_activity_at,started_at) DESC LIMIT 3— the newest row that is not THIS run is the previous pass, and itslast_activity_atis the start bound (last_activity_at23:25:02 vsended_at23:25:53, 51 s apart; anow - 24 hstart at 23:15:45 reached 9 minutes BACK into the previous window). Classify withsessions.sourcein one column rather than by an id prefix — that day's 31 sessions splitcron24 /subagent5 /telegram2 — because asubagentsession stores its dispatching prompt asrole='user'exactly like cron does, and the note below names only cron: those 5 fan-out rows would otherwise read as operator prose and inflate the "corrections" count before you read a single sentence. Read only the human transports, keepactive=1, and notetime.strptimerejects GNUdate's'%F %T'(ValueError: 'F' is a bad directive) — the format is'%Y-%m-%d %H:%M:%S'. -
Verify the skill file you patched is REPO-SOURCED, not stranded in the deployed tree. Content written only to
~/.steadfaste-fleet/skills/...is invisible to the fleet: the deploy's drift guardrail refuses to overwrite it, so it never reaches the repo or any peer. Runpython3 ops/scripts/manage/check-skill-drift-parity.pyafter every skill patch, and if your path is underStranded in place:land it into the repo source in the same cycle (measured 2026-10-21: the day's verbosity lesson lived deployed-only; landing it moved the detector 18 → 17 stranded and took the path out of the list). -
Parity can regress WITHIN the same day it was fixed — a recovery commit is not a permanent state (measured 2026-10-23).
ca9de57flanded a full recovery at 18:18 (0 stranded, 0 absent), yet the 23:15 pass measured 5 stranded again:devops/fleet-bus,devops/shared-repo-push-gates,devops/shell-scripting,skill-vetting,software-development/change-checklist. Each was a lesson written to the deployed tree by a later cycle that same day — the drift guardrail then refused to overwrite it, so the fleet never received it. Never inherit yesterday's PASS: re-measure every pass. Reconcile with the tool's own modes —reconcile-stranded-skills.py(report first, then--applyfor the pure-superset class) — and treat aREVIEW/DROPline as a CLAIM to check, not a fact: all three ofca9de57f's drop lines were false positives (deployed side reflowed and extended), and the 10-23change-checklistDROP was the same shape, so merge that one addition by hand instead of believing the tool. Then regenerate the parity evidence artifact, commit by PATHSpec, deploy, and push. -
fleet-update.shis NOT at the repo root — it lives atops/scripts/fleet-update.sh(bash fleet-update.shgivesrc=127, No such file or directory, which reads like a broken deploy). Runbash ops/scripts/fleet-update.shfrom the repo root;rc=0is the pass signal. -
Cron sessions writing SOUL.md — verify the gate for the EXACT path; do not assume it. Hermes core has a protected-instruction gate (
_check_protected_instruction_write,tools/file_tools_write_guards.py) withsoul.mdin_PROTECTED_INSTRUCTION_BASENAMES. BUT the same module returns early for any path under the Hermes home (_hermes_exempt_homes(), lines ~236-238) before the basename test — so a write to the DEPLOYED~/.hermes/SOUL.mdis NOT gated, while a write to the repo templatedocs/templates/SOUL.md(not under the home) IS. Verified 2026-10-07 on esther/Hermes v0.21.5: a probe patch to~/.hermes/SOUL.mdfrom a cron SUCCEEDED; calling_protected_instruction_reason('/home/<user>/.hermes/SOUL.md', 'cron')returnedNonewhile_protected_instruction_config()returned(True, []). Probe the actual target path with the above call before claiming the gate blocks (or protects) you. Regardless of the gate, an identity change still needs operator approval by policy — the cron's job is DETECTION: report the corrections found so the operator codifies them in an interactive session. Never bypass a gate that DOES fire via terminal/execute_code. -
The pass's FIRST call dies on the enforcer's third block shape, and it is not a lock problem (measured 2026-10-25). With no governed repo yet resolved, every write-class-classified call is refused — including a bare
dateand this pass's ownpython3 <mining-script>— with "No governed repo could be resolved for this call". That is its OWN message, not the gate-2 lock rule, and acquiring a lock is not the remedy: resolving a repo is. It cost this pass two calls retrying the same shape from~beforeworkdir=was passed, and the deployed-copy location never helps (~/.steadfaste-fleethas no.git). The remedy is ORDER: runbegin_changefirst (step 2 of the sequence this pass runs anyway) and the identical shape then returns rc=0 from any cwd. So when a mining call is refused, do not reword it and do not go hunting for a lock — open the cycle, then re-issue it unchanged. -
Don't append the same lesson twice. If a principle already covers the gap, strengthen it rather than adding another.
-
Don't treat skills as identity. Workflow discoveries go in SKILL.md, not SOUL.md.
-
Bible insights must be genuine. Don't force-fit a lesson. If the day's book has nothing obvious for the agent's role, say so honestly.
-
Resolve the mining window from RUN TIME, never from the calendar date (observed 2026-10-18). This job's dispatch can slip past midnight: on esther
hermes cron listrecorded the14 23 * * *slot dispatching at00:03(49 min late), and~/.hermes/cron/usage_audit.jsonlholds two earlier after-midnight runs (00:03and00:26) among its 63 logged runs. A literal reading of "today's sessions" at 00:03 is a three-minute-old day: the pass finds nothing, reports[SILENT], and the PREVIOUS day's corrections are lost with no signal — a zero-row window and a genuinely quiet day look identical in the output. So compute a bounded lookback ending at NOW (the last ~30 h, as an epoch-float bound —timestampis a float, not ISO), print the resolved window and the row counts it returned, and never report "nothing to refine" for a window you have not first shown to be non-empty. -
The window's counts DRIFT between the pass and any later re-run, so an evidence artifact must FREEZE the bounds it documents (measured 2026-10-24). The window is resolved from RUN TIME, so a generator re-run twenty minutes later derives different bounds — the 24 h bound advances with the clock — and then prints different counts for the same pass: the pass itself resolved 23:26:13 → 23:16:37 holding 15 sessions / 16 rows, while the identical script re-run at 23:29 printed 23:29:06 → 23:29:06 over 24.00 h with 15 sessions and 16 rows. A transcript that recomputes them contradicts the cycle note it exists to support, which is the shape a reviewer files as fabrication. Freeze BOTH bounds as generator defaults (env-overridable), say in the artifact that they are frozen and why, and reconcile the two counts EXPLICITLY when they differ: a ROW is selected by its own
timestampand a SESSION byCOALESCE(last_activity_at,started_at), so they are different sets by construction — a row can belong to a session whose bound sits outside the window (a telegram carrier session, or THIS run, whose own prompt predates the frozen end). Size the end bound exactly, too: a probe that used<= NOW + 60swept this run's own session in and reported one session too many, a figure that then had to be withdrawn. -
role='user'is NOT the operator: most rows in a window are not corrections (measured 2026-10-20). A 24 h window on esther returned 46active=1user rows across 29 sessions, but only 4 were human sessions — the other 25 were cron sessions, and a cron session stores its OWN task prompt asrole='user', so every cron run contributes a row that reads like operator input. Of the 21 rows inside the 4 human sessions, 8 still carried a machine marker (internal background-process notifications, gateway-origin wrappers, a pasted cron delivery) and only 13 were prose to read. Classify BEFORE reading: splitcron_*sessions from the rest, then drop rows opening with a machine marker ([IMPORTANT: The user has invoked,[IMPORTANT: You are running as a scheduled cron job,[IMPORTANT: Background process,[INTERNAL NOTIFICATION,[Cron delivery:,Gateway message origin), and read only what is left. Treating raw user rows as corrections over-reports by roughly 3.5x and buries the operator's real message; keepactive=1too (46 of 52 rows here — the 6 dropped are compaction artifacts, not a quiet day). -
Implement the marker rule as
startswithon the LSTRIPPED content — a substring test silently deletes real operator prose (measured 2026-10-27, and it cost this pass the day's only still-open-looking request). Amarker in content[:200]test dropped "Time to fix the mycortex nightly dream for all agents. Ex: Cronjob Response: …" — an operator request that merely QUOTES a peer's report — so the pass read 5 prose rows instead of 6 and never opened the item. The rule above says "drop rows OPENING with a machine marker": implement that rule, not a stricter approximation of it. Use ONE shared classifier for the mining pass and any evidence generator — two implementations printed 5-vs-6 prose rows for the same frozen window, i.e. the artifact contradicted the pass it documents, which is the shape a reviewer files as fabrication. When a regenerated count differs from the pass's, reconcile it EXPLICITLY before shipping: this pass's session delta (28 → 27) was solely THIS run's own session leaving the frozen end bound as itslast_activity_atadvanced, while the row count held at 38 because a ROW is bound by its owntimestamp— a prose delta (5 → 6) is never drift, it is a defect to fix or a defect to report. -
Landing a REVIEW-class stranded skill:
cpthe deployed file, but check for the deploy's SOURCE banner first. The parity tool ignores the 3-line banner by design, so a banner-carrying deployed copy copied straight over the repo source would inject it into the fleet's source. Confirm withdiff -uthat the only hunks are content and the headers match byte-for-byte (measured 2026-10-27: all 3 were banner-free, so the copy was content-only). Read the FULL diff before copying, and count the drops: that pass's REVIEW lines claimed 14/1/4 dropped lines and every one was present — rewritten — in the deployed text, the 7th consecutive pass where a REVIEW/DROP line was a false positive of the same "deployed side reflowed and extended" shape. -
Silence is better than forced growth. If no corrections or lessons exist for a given day, produce nothing.
-
Watchdog scripts must update their state/timestamp file BEFORE checking for work, to avoid stale state readings.
-
Mining large sessions via session_search: the scroll shape ignores
role_filter(discovery-only), and windows >100KB spill to~/.hermes/cache/spillover/*.txt— extract user messages from the spilled JSON with one terminalpython3pass instead of re-requesting.execute_codeis blocked in cron mode; terminal under a governance lock is the path (observed 2026-09-28). (observed 2026-09-29) Skip discovery of the store itself: the real sessions store is~/.hermes/state.db(1GB WAL) —~/.hermes/state/sessions.dbis a 0-byte stub, and there is nosqlite3CLI on esther. One read-only pass:python3heredoc withsqlite3.connect('file:…state.db?mode=ro', uri=True)+PRAGMA query_only=1, selectrole='user' AND active=1rows for the day's session ids, dump JSON to scratch, then triage previews. (Gate behavior: in a cron session an active lock sufficed — no skills gate; the 7-always-skills gate was observed in an interactive session, 2026-09-29.) (observed 2026-10-09)timestampis a Unix epoch float, not ISO — an ISO>=bound silently returns 0 rows; compute the day's midnight as a float. Derive that bound withtime.mktime(time.strptime(...))ortime.time(), never by arithmetic on a remembered epoch: a hand-derived bound during the 2026-10-18 run landed ~13 h early and returned 0 rows — and 0 rows is exactly what a quiet day looks like through this window, so the mistake is silent. If the count comes back 0, re-derive the bound and print it before concluding anything about the day. -
PII guard trips on the day's own session IDs (observed 2026-10-09). The shared-surface
write_fileguard rejects the report as a "phone number" when it contains Hermes session IDs (<8digits>_<6digits>_<hex>) or 10-digit gateway chat/user ids — long digit runs match its phone heuristic. Write the report with session references generalized ("the lock session", "the drift session"); the evidence lives in the DB, not the report. Also generalize nginx/IP filenames if they embed numbers. Redact at the GENERATOR, never in the committed copy: mask runs of 7 or more digits (re.sub(r'\d{7,}', ...)) and collapse/home/<user>and/Users/<user>to~, so the artifact's own command line stays reproducible instead of being hand-patched into disagreeing with the text above it. -
A concurrent session's commit can sweep YOUR staged files, and its message can claim YOUR fix. Observed 2026-10-13: a peer session's plain
git commitcaptured the loop-gov edits staged by this cycle and committed them under its own message; separately, a peer committedfix(review): refuse a degenerate reviewer responsewhose own message said "NO TEST SHIPPED", and re-measuring the committed file showed the guard was not present at all — the crash was still live. Two lessons: (1) commit by PATHSpec every time (git commit -F <msg> -- <your paths...>) and assert the staged set first, or a peer's staged work rides into your commit; (2) when the day's session history contains a commit claiming a code fix, RE-MEASURE the claim against the committed file before believing it — the "unverified-claim" pattern is exactly a commit message asserting a result whose producing artifact was never written. A claimed-but-absent fix is worse than an open bug: the record says otherwise, so nobody looks again. -
repo_pathon a cron session's lock can be empty, and then NOTHING can mint a review receipt. Observed 2026-10-13: the soul-refine cron cycle's lock carriedrepo_path='', so every close loggedreview receipt NOT written: lock has no repo identityand the pre-push always-review gate refused the push with no way to satisfy it. Cause is by DESIGN, not a bug:_session_repo_path()returnsNonefor a Hermes caller that has an injectedsession_idbut no injected repo ("never guessed for a Hermes caller"). The documented escape hatch isFLEET_SESSION_REPO=<repo path>in the environment the MCP server reads — a non-Hermes harness sets it. Practical recovery in a cron: open a FRESHbegin_changefor the push (a later lock in the same session may resolverepo_pathfrom cwd), close it to mint the receipt, then push. Checkrepo_pathwithcheck_lock()BEFORE relying on a receipt ever appearing. -
git stash/stash popsilently un-stages your work. Observed 2026-10-13:git stash -q -uthengit stash pop -qused to compare a baseline left only ONE of four files staged. After any stash round-trip, re-rungit add -- <paths>and assertgit diff --cached --name-onlyshows exactly your set before committing. -
The recurring reviewer finding is "unverified-claim": commit the artifact, don't narrate it (observed 2026-10-09 — 102
unverified-claimmentions in one day). When a worker note asserts a result ("13 cases all pass", "dogfood passed", "the wrapper is host-local by design"), the self-adversarial reviewer refuses the close unless the producing artifact is committed and re-executable (test file + run output transcript, the automation's definition, the operator's authorization transcript). Classify findings bytechniquefor the day with onepython3regex pass over tool rows — the dominant technique IS the day's lesson.
Template: Initial SOUL.md Structure
If you don't have a SOUL.md yet, create one at ~/.hermes/SOUL.md with this structure:
# SOUL.md — {Agent Name}
## Identity
Brief description of who you are and your role.
## Core Mission
What you exist to do.
## Behavioral Principles
### 1. {First Principle}
{Description}
### 2. {Second Principle}
{Description}
## Scripture Insights
<!-- Entries appended here by daily cron -->
Then run the setup commands above to start the daily refinement cycle.
04 同仓库更多 Skills
macbook-linux-maintenance
Legacy MacBook Linux fixes: GPU wedge, reboot hang, thermal.
governance-regression-triage
Triage a host's governance issues: what changed.
enforcement-immutability
Use when enforcement files lose their immutable flag.
steadfaste-fleet-repo-deploy
Use when committing to the steadfaste-fleet repo.
steadfaste-fleet-maintenance
Maintain an installed Steadfaste Fleet instance — update both the upstream Hermes Agent and the fleet repo layer, merge diverged histories, sync skills safely, and troubleshoot common issues. Covers the dual-update workflow (hermes update + fleet-update.sh), encrypted brain data backup, mycortex import, and recovery techniques.
fleet-preflight
DEPRECATED alias — merged into survey-before-action (2026-08-20). Load survey-before-action instead; its "Repo-Specific Pre-Flight" section covers git search, Hermes boundary, and deployment verification.