AGENT SKILL

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:

  1. Generates a short behavioral statement (verse + one-line commitment) for SOUL.md
  2. Saves the full analysis (archaeology, language, Jewish perspective) to ~/brain/<agent>/bible/<book>.md
  3. 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 processed
  • status: read — message has been processed

When your inbox polling script processes a message:

  1. Call GET /read/{filename} to mark it as read
  2. Next poll with ?unread_only=true will 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):

  1. Loop Governance — Mandatory Pre-Work Sequence (MCP-Enforced)
  2. Inbox Message Decision Framework (+ audit trail)
  3. Verify Before Declare — Real Work, Real Output
  4. Be Proactive — Fix, Test, Document
  5. Own Every Issue — Fix First, Prove Second
  6. Always Do the Right Way — Canonical Paths
  7. Be Concise — Every Word Earns Its Place
  8. Protect the System — Security, Privacy, Stability
  9. Design for the Full Deployment Matrix
  10. Test Small Before Scaling
  11. Agent Cron Management
  12. 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:

  1. 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
  2. Rebuild deployed ~/.hermes/SOUL.md from template + agent-specific sections (Identity / Core Mission / Core Traits / Final Directive) as needed
  3. Verify agents-doc-audit.py mandatory sections still pass
  4. 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 --material takes 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 (or git 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 as injection findings 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 filed fabrication — the strongest severity — for a memory-drift typo. Run sed -n '<a>,<b>p' <file> first, then diff against those bytes. Expect 3+ rounds; each refusal explains itself in its recommendation field.
  • 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: writing docs/templates/SOUL.md from 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.md remains 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 commit from a cron is refused with "Reflexion check not completed — NOT-LOADED reflexion-check (session <id>)": load the skill with skill_view(name='reflexion-check'), answer its questions, then commit. Do NOT edit ops/scripts/pre-commit-score — that path and ops/scripts/pre-push-pull are both in ops/scripts/lib/always-review-paths.txt, so touching them converts a one-line convenience into an always-review change. Note git 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 at 23:17 while a 30 h window began at 17: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 its last_activity_at is the start bound (last_activity_at 23:25:02 vs ended_at 23:25:53, 51 s apart; a now - 24 h start at 23:15:45 reached 9 minutes BACK into the previous window). Classify with sessions.source in one column rather than by an id prefix — that day's 31 sessions split cron 24 / subagent 5 / telegram 2 — because a subagent session stores its dispatching prompt as role='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, keep active=1, and note time.strptime rejects GNU date'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. Run python3 ops/scripts/manage/check-skill-drift-parity.py after every skill patch, and if your path is under Stranded 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). ca9de57f landed 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 --apply for the pure-superset class) — and treat a REVIEW/DROP line as a CLAIM to check, not a fact: all three of ca9de57f's drop lines were false positives (deployed side reflowed and extended), and the 10-23 change-checklist DROP 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.sh is NOT at the repo root — it lives at ops/scripts/fleet-update.sh (bash fleet-update.sh gives rc=127, No such file or directory, which reads like a broken deploy). Run bash ops/scripts/fleet-update.sh from the repo root; rc=0 is 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) with soul.md in _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.md is NOT gated, while a write to the repo template docs/templates/SOUL.md (not under the home) IS. Verified 2026-10-07 on esther/Hermes v0.21.5: a probe patch to ~/.hermes/SOUL.md from a cron SUCCEEDED; calling _protected_instruction_reason('/home/<user>/.hermes/SOUL.md', 'cron') returned None while _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 date and this pass's own python3 <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 ~ before workdir= was passed, and the deployed-copy location never helps (~/.steadfaste-fleet has no .git). The remedy is ORDER: run begin_change first (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 list recorded the 14 23 * * * slot dispatching at 00:03 (49 min late), and ~/.hermes/cron/usage_audit.jsonl holds two earlier after-midnight runs (00:03 and 00: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 — timestamp is 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 timestamp and a SESSION by COALESCE(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 + 60 swept 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 46 active=1 user 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 as role='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: split cron_* 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; keep active=1 too (46 of 52 rows here — the 6 dropped are compaction artifacts, not a quiet day).

  • Implement the marker rule as startswith on 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). A marker 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 its last_activity_at advanced, while the row count held at 38 because a ROW is bound by its own timestamp — 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: cp the 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 with diff -u that 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 terminal python3 pass instead of re-requesting. execute_code is 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.db is a 0-byte stub, and there is no sqlite3 CLI on esther. One read-only pass: python3 heredoc with sqlite3.connect('file:…state.db?mode=ro', uri=True) + PRAGMA query_only=1, select role='user' AND active=1 rows 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) timestamp is a Unix epoch float, not ISO — an ISO >= bound silently returns 0 rows; compute the day's midnight as a float. Derive that bound with time.mktime(time.strptime(...)) or time.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_file guard 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 commit captured the loop-gov edits staged by this cycle and committed them under its own message; separately, a peer committed fix(review): refuse a degenerate reviewer response whose 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_path on 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 carried repo_path='', so every close logged review receipt NOT written: lock has no repo identity and 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() returns None for a Hermes caller that has an injected session_id but no injected repo ("never guessed for a Hermes caller"). The documented escape hatch is FLEET_SESSION_REPO=<repo path> in the environment the MCP server reads — a non-Hermes harness sets it. Practical recovery in a cron: open a FRESH begin_change for the push (a later lock in the same session may resolve repo_path from cwd), close it to mint the receipt, then push. Check repo_path with check_lock() BEFORE relying on a receipt ever appearing.

  • git stash/stash pop silently un-stages your work. Observed 2026-10-13: git stash -q -u then git stash pop -q used to compare a baseline left only ONE of four files staged. After any stash round-trip, re-run git add -- <paths> and assert git diff --cached --name-only shows 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-claim mentions 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 by technique for the day with one python3 regex 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