agent-bios 0.9.9 → 0.11.0

package/compose/domains.json

@@ -48,51 +48,19 @@
     {"anchor": "Treat a produced field, flag, signal", "tier": "domain", "domains": ["llm-pipeline-dev"]},
     {"anchor": "Hard-block only deterministically decidable structural", "tier": "domain", "domains": ["llm-pipeline-dev"]},
     {"anchor": "Runtime/code may enforce the contract", "tier": "domain", "domains": ["llm-pipeline-dev"]},
-    {"anchor": "Keep the concept graph compact by reusing", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Treat lasting or shared names as concept", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Before adding or changing a concept", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Prefer broad, stable concepts with precise", "tier": "domain", "domains": ["builder-base"]},
+    {"anchor": "When adding, changing, renaming, splitting, or exposing anything lasting or shared", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Before fixing a review finding or test failure", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Split or promote a concept when it changes", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Keep derived values as properties or projections", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Keep internal projections and helper outputs internal", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Distinguish authority from visibility", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Reuse existing enum values, failure kinds", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Use fallback paths, compatibility shims", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Keep comments and active docs aligned", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "When a split is necessary, name the parent", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "In ontology work, check existing entities", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "In code work, follow existing naming patterns", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Let the repository's shape mirror its concept graph", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "For `.xlsx` editing, generation, reconciliation", "tier": "domain", "domains": ["office-work"]},
-    {"anchor": "For meaningful development work, read and use", "tier": "domain", "domains": ["builder-base"]},
+    {"anchor": "For development work, read and use", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "For mock, fixture, fake, stub, simulated-provider", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "When the user asks to", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Think before coding: state key assumptions", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Build the smallest viable functional path", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Treat viability as real behavior against", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Make surgical changes. Touch only what", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Clean up issues introduced by the current", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Own the full lifecycle of what you create", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Define success criteria before multi-step coding work", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "For bugs, prefer a reproducing test", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Every changed line should trace back", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Fix the root cause at its authority", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Land risky or behavior-changing work behind", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "For composing a review request, packet", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "After every meaningful code, ontology, config", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Use static checks broadly: typecheck, lint", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Add the narrowest reliable runtime or semantic test", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Pick each domain's verification mix", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Let the LLM derive scenarios from the diff", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Keep E2E stable with deterministic data", "tier": "domain", "domains": ["builder-base"]},
+    {"anchor": "For choosing verification depth, the per-domain mix, the case space, what makes a completion criterion falsifiable", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Report the checks run, results", "tier": "core", "domains": []},
     {"anchor": "Trust a green check only when it traversed", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Make completion criteria falsifiable", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Before comparing two of anything", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "For non-trivial designs or high-risk changes", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Proportion verification to cost, risk, and information gain", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Trust a green / zero-findings verdict only", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "For concrete shell/CLI traps", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Ambient state — the active shell", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Before relying on any model id", "tier": "domain", "domains": ["builder-base"]},
@@ -100,7 +68,6 @@
     {"anchor": "Never accept secrets through transcript- or history-logged channels", "tier": "core", "domains": []},
     {"anchor": "When a secret must be supplied", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Treat a coarse runtime signal", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Before reasoning about what a branch contains", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "Standing spawn policy: check the spawn gates", "tier": "domain", "domains": ["multi-agent-orchestration"]},
     {"anchor": "Down-spawns carry a machine-checkable done-when", "tier": "domain", "domains": ["multi-agent-orchestration"]},
     {"anchor": "For work spanning multiple models or CLI agents", "tier": "domain", "domains": ["multi-agent-orchestration"]},
@@ -111,11 +78,7 @@
     {"anchor": "Never retry-storm a live rate limit", "tier": "domain", "domains": ["multi-agent-orchestration"]},
     {"anchor": "On any resumed, cleared, or relocated session", "tier": "domain", "domains": ["multi-agent-orchestration"]},
     {"anchor": "Keep runtime code, active docs, and execution-facing", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Use comments for non-obvious current behavior", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Put backward-compatibility notes, deprecated behavior", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Link from active docs or code to isolated notes", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Phrase guidelines as desired behavior", "tier": "domain", "domains": ["builder-base"]},
-    {"anchor": "Prefer established docs such as", "tier": "domain", "domains": ["builder-base"]},
+    {"anchor": "For where a comment, a compatibility note, deprecated behavior, a rejected alternative", "tier": "domain", "domains": ["builder-base"]},
     {"anchor": "For SVG diagrams, service blueprints", "tier": "domain", "domains": ["visualization-docs"]},
     {"anchor": "When a concept is easier to understand visually", "tier": "domain", "domains": ["visualization-docs"]},
     {"anchor": "Use HTML for comparisons, flows, state changes", "tier": "domain", "domains": ["visualization-docs"]},
@@ -126,10 +89,12 @@
     {"anchor": "`learn!` — session learning", "tier": "core", "domains": []}
   ],
   "guides": {
-    "claude-prompting.md": {"tier": "domain", "domains": ["multi-agent-orchestration"]},
-    "cli-multi-model-workflow.md": {"tier": "domain", "domains": ["multi-agent-orchestration"]},
+    "claude-prompting.md": {"tier": "domain", "domains": ["multi-agent-orchestration"], "handles": ["per-family prompting guide", "계열별 prompting guide"]},
+    "cli-multi-model-workflow.md": {"tier": "domain", "domains": ["multi-agent-orchestration"], "handles": ["multi-model guide", "multi-model 가이드"]},
     "coding-staged-workflow.md": {"tier": "domain", "domains": ["builder-base"]},
-    "gpt-prompting.md": {"tier": "domain", "domains": ["multi-agent-orchestration"]},
+    "concept-economy.md": {"tier": "domain", "domains": ["builder-base"]},
+    "documentation-hygiene.md": {"tier": "domain", "domains": ["builder-base"]},
+    "gpt-prompting.md": {"tier": "domain", "domains": ["multi-agent-orchestration"], "handles": ["prompting guides for gpt-family"]},
     "implementation-map.md": {"tier": "domain", "domains": ["visualization-docs"]},
     "llm-capability-boundary-examples.md": {"tier": "domain", "domains": ["llm-pipeline-dev"]},
     "llm-capability-boundary-patterns.md": {"tier": "domain", "domains": ["llm-pipeline-dev"]},
@@ -139,6 +104,7 @@
     "session-distill-workflow.md": {"tier": "infra", "domains": []},
     "learning-flow.md": {"tier": "infra", "domains": []},
     "svg-visualization-guide.md": {"tier": "domain", "domains": ["visualization-docs"]},
+    "verification-discipline.md": {"tier": "domain", "domains": ["builder-base"]},
     "tooling-gotchas.md": {"tier": "domain", "domains": ["builder-base"]}
   },
   "hooks": {

package/install.sh

@@ -238,9 +238,15 @@ assemble_corpus() {
     for g in "$REPO"/codex/guides/*.md; do
       [ -f "$g" ] || continue
       dst="$CODEX_DIR/guides/$(basename "$g")"
-      [ -f "$dst" ] && printf '%s\n' "$dst" >> "$MANIFEST"
+      # if-form, not `[ -f ] && printf`: when the alphabetically LAST guide is
+      # not deployed (a partial domain selection on a fresh machine), the
+      # compound's false status became the loop's, the loop's became the
+      # function's, and the install died silently right after ASSEMBLED —
+      # a latent first-user bug the I9 scenario exposed.
+      if [ -f "$dst" ]; then printf '%s\n' "$dst" >> "$MANIFEST"; fi
     done
   fi
+  return 0
 }
 
 add_zsh_hook() {
@@ -602,6 +608,13 @@ cmd_install() {
   deploy_file "$REPO/launch/agent-launch.toml" "$LAUNCH_DIR/profiles.toml"
   deploy_file "$REPO/launch/agent-launch.zsh"   "$LAUNCH_DIR/shell.zsh"
   deploy_file "$REPO/launch/agent-launch.py"  "$BIN_DIR/agent-launch" "+x"
+  # UI text catalogs: deploy-managed siblings of the config, one per language.
+  # The launcher resolves them from the config path, so the deployed home is
+  # $LAUNCH_DIR/i18n exactly as the checkout's is launch/i18n.
+  local lang
+  for lang in en ko ja; do
+    deploy_file "$REPO/launch/i18n/$lang.toml" "$LAUNCH_DIR/i18n/$lang.toml"
+  done
   log ""
   log "Optional dependencies (missing ones only degrade the routes that need them)..."
   handle_capabilities "$WITH" || exit 1
@@ -622,11 +635,27 @@ cmd_install() {
   # package.json (version + releaseDate) — distinct from the corpus content
   # version. Best-effort: a failure here never fails the install.
   if [ "$DRY_RUN" != 1 ]; then
-    if python3 - "$REPO/package.json" "$STATE_DIR/version.json" <<'PY' 2>/dev/null
-import json, sys
+    if python3 - "$REPO/package.json" "$STATE_DIR/version.json" "$REPO/provenance.json" \
+         "$([ -e "$REPO/.git" ] && echo clone || echo package)" <<'PY' 2>/dev/null
+import json, os, sys
 pkg = json.load(open(sys.argv[1]))
+out = {"version": pkg.get("version"), "releaseDate": pkg.get("releaseDate"),
+       "source": sys.argv[4]}
+# Publication provenance rides along ONLY for a package-layout source: in a
+# clone, git itself is the live provenance and a provenance.json on disk is by
+# definition residue (a failed pack's leftover stamp) — ingesting it once let a
+# clone deployment of commit B carry a stale label A into the state marker.
+if sys.argv[4] == "package" and os.path.isfile(sys.argv[3]):
+    try:
+        prov = json.load(open(sys.argv[3]))
+        if prov.get("commit"):
+            out["commit"] = prov["commit"]
+        if prov.get("dirty"):
+            out["dirty"] = True
+    except Exception:
+        pass
 with open(sys.argv[2], "w") as f:
-    json.dump({"version": pkg.get("version"), "releaseDate": pkg.get("releaseDate")}, f)
+    json.dump(out, f)
     f.write("\n")
 PY
     then
@@ -656,8 +685,8 @@ verify_present() { if [ -f "$1" ]; then return 0; else log "missing  $1"; return
 
 cmd_verify() {
   local fail=0 gp gb
-  if [ ! -d "$REPO/.git" ] && [ "$(drift_state)" = "drift" ]; then
-    log "deploy drift: deployed $(deployed_version), package $(source_version) — run: agent-bios install"
+  if [ ! -e "$REPO/.git" ] && [ "$(drift_state)" = "drift" ]; then
+    log "deploy drift: $(drift_detail) — run: agent-bios install"
     fail=1
   fi
   # Not mode-specific: an author-only guide must be absent from EVERY directory any
@@ -950,14 +979,44 @@ cmd_onboard() {
   fi
   DOMAINS_ARG="$sel"; DOMAINS_SET=1
   log "selection: ${sel:-<core+infra only>}"
-  cmd_install
+  # Subshelled so a failing install can still record its outcome: the launcher's
+  # corpus checklist reads `last_apply` from corpus-status.json, and an exit with
+  # nothing recorded reads as "nothing happened". cmd_install's shell state stays
+  # in the subshell; everything after here uses only top-level globals.
+  local apply_rc=0
+  # NOT `( cmd_install ) || apply_rc=$?`: a command list that tests the subshell
+  # suppresses errexit for everything inside it, so an unguarded failure in
+  # cmd_install would run through to a zero return (probed on bash 3.2/5.x).
+  # Toggling -e around a STANDALONE subshell keeps errexit live inside while the
+  # outer shell survives to record the outcome.
+  set +e
+  ( set -e; cmd_install )
+  apply_rc=$?
+  set -e
+  if [ "$apply_rc" -ne 0 ]; then
+    python3 "$REPO/compose/corpus-state.py" record-apply \
+      --requested "$sel" --outcome install_failed >/dev/null 2>&1 || true
+    exit "$apply_rc"
+  fi
   log ""
   log "Activation canary (proves the bundle loads in a live session)..."
   if [ "$DRY_RUN" = 1 ]; then info "[dry-run] skip canary probe"; return; fi
-  bash "$REPO/compose/canary.sh" || {
+  local canary_rc=0
+  bash "$REPO/compose/canary.sh" || canary_rc=$?
+  if [ "$canary_rc" -ne 0 ]; then
+    # rc=1 is a real probe that answered "not loading"; rc=3 is "could not
+    # probe" (no CLI/auth). Both leave the apply unproven, so both record as
+    # canary_failed — the tail carries which, so the panel's loud line does
+    # not send the operator to debug imports over an auth problem.
+    python3 "$REPO/compose/corpus-state.py" record-apply \
+      --requested "$sel" --outcome canary_failed \
+      --error-tail "canary exit $canary_rc$([ "$canary_rc" = 3 ] && printf ' (could not probe)')" \
+      >/dev/null 2>&1 || true
     log "ONBOARDING INCOMPLETE: the bundle is installed but not loading — fix the cause above and re-run: agent-bios verify"
     exit 1
-  }
+  fi
+  python3 "$REPO/compose/corpus-state.py" record-apply \
+    --requested "$sel" --outcome applied >/dev/null 2>&1 || true
   # The prune is authorized by the canary's proof, and cmd_install ran before the canary existed
   # for this bundle rev — so it kept everything. Now that loading is proven, run it for real.
   migrate_learnings
@@ -982,30 +1041,131 @@ sys.exit(0) if v is None else print(v)' "$1" "$2" 2>/dev/null
 deployed_version() { json_field "$STATE_DIR/version.json" version; }
 source_version()   { json_field "$REPO/package.json" version; }
 
+json_true() {  # exit 0 iff $2 in $1 is JSON true — json.dump writes '"k": true'
+  # with a space, so byte-matching a compact spelling read the real writer's
+  # output as false forever.
+  [ -f "$1" ] || return 1
+  python3 -c 'import json,sys
+try:
+    v=json.load(open(sys.argv[1])).get(sys.argv[2])
+except Exception:
+    sys.exit(1)
+sys.exit(0 if v is True else 1)' "$1" "$2" 2>/dev/null
+}
+
+current_commit() {  # the CURRENT side's commit: git HEAD in a clone, the stamp in a package
+  # A clone's provenance is its live HEAD — a provenance.json on its disk is a
+  # failed pack's residue, and reading it once let a stale label A match a
+  # checkout sitting at B.
+  if [ -e "$REPO/.git" ]; then
+    git -C "$REPO" rev-parse HEAD 2>/dev/null || true
+  else
+    json_field "$REPO/provenance.json" commit 2>/dev/null || true
+  fi
+}
+
+current_dirty() {  # exit 0 iff the current side is a dirty-stamped PACKAGE artifact
+  [ ! -e "$REPO/.git" ] && json_true "$REPO/provenance.json" dirty
+}
+
 drift_state() {  # prints: match | drift | unknown
-  local d s
+  local d s dc sc
   d="$(deployed_version)" || { echo unknown; return; }
   s="$(source_version)"   || { echo unknown; return; }
   [ -n "$d" ] && [ -n "$s" ] || { echo unknown; return; }
-  [ "$d" = "$s" ] && echo match || echo drift
+  [ "$d" = "$s" ] || { echo drift; return; }
+  # Same VERSION is not same SOURCE: two locally packed tarballs keep one
+  # version across different commits (npm pack is an accommodated flow), and
+  # the commit was persisted into version.json exactly so this comparison
+  # could read it. Judged only when both sides carry one — a clone deploy
+  # stamps no commit, and half a comparison is none.
+  dc="$(json_field "$STATE_DIR/version.json" commit 2>/dev/null || true)"
+  sc="$(current_commit)"
+  # Dirt is judged BEFORE the commit comparison: a dirty artifact's bytes are
+  # described by no commit, so differing commit labels prove nothing about
+  # differing payloads — unknown, not drift, or npm-layout verify fails on a
+  # mismatch nobody proved.
+  if json_true "$STATE_DIR/version.json" dirty || current_dirty; then
+    echo unknown; return
+  fi
+  if [ -n "$dc" ] && [ -n "$sc" ] && [ "$dc" != "$sc" ]; then
+    echo drift; return
+  fi
+  # UNPROVABLE is not drift: an unbound side (npm layout without a commit — a
+  # lifecycle-disabled pack, or the hook's materialized tree) and a DIRTY side
+  # (bytes no commit describes; parsed via json_true, never byte-matched,
+  # because json.dump's spacing defeated the compact grep) both make the
+  # correspondence unprovable. Drift is a PROVEN mismatch and makes verify
+  # fail; branding the unprovable as drift made D-0050's accepted install path
+  # fail its own verification. Clone deployments stay version-compared — git
+  # itself is their live provenance, and they persist no commit by design.
+  if [ "$(json_field "$STATE_DIR/version.json" source 2>/dev/null || true)" = "package" ] \
+     && [ -z "$dc" ]; then
+    echo unknown; return
+  fi
+  if [ ! -e "$REPO/.git" ] && [ -z "$sc" ]; then
+    echo unknown; return
+  fi
+  echo match
+}
+
+drift_detail() {  # one line naming WHAT drifted: versions, or commits behind one version
+  local d s dc sc
+  d="$(deployed_version)"; s="$(source_version)"
+  dc="$(json_field "$STATE_DIR/version.json" commit 2>/dev/null || true)"
+  sc="$(current_commit)"
+  if [ "$d" = "$s" ] && { json_true "$STATE_DIR/version.json" dirty || current_dirty; }; then
+    printf 'a DIRTY-packed artifact is involved — its bytes are described by no commit; a clean-pack redeploy restores a provable match'
+  elif [ "$d" = "$s" ] && [ -n "$dc" ] && [ -n "$sc" ] && [ "$dc" != "$sc" ]; then
+    printf 'deployed commit %s but this source is at %s (both version %s)' "$dc" "$sc" "$s"
+  elif [ "$(json_field "$STATE_DIR/version.json" source 2>/dev/null || true)" = "package" ] \
+       && [ -z "$dc" ]; then
+    printf 'the deployed artifact is UNBOUND (packed with lifecycle scripts disabled) — its bytes are proven by no commit; a bound redeploy restores a provable match'
+  elif [ ! -e "$REPO/.git" ] && [ -z "$sc" ]; then
+    printf 'this package is UNBOUND (no provenance) — its bytes are proven by no commit'
+  else
+    printf 'deployed %s but this package is %s' "$d" "$s"
+  fi
 }
 
 cmd_status() {
   local version p
-  if [ -d "$REPO/.git" ]; then
+  if [ -e "$REPO/.git" ]; then
     version="$(git -C "$REPO" describe --tags --always --dirty 2>/dev/null || git -C "$REPO" rev-parse --short HEAD 2>/dev/null || echo '?')"
     log "agent-bios  (git clone: $version)"
   elif [ -f "$REPO/package.json" ]; then
     version="$(node -e "try{process.stdout.write(require('$REPO/package.json').version)}catch(e){process.stdout.write('?')}" 2>/dev/null || echo '?')"
     log "agent-bios  (npm package: $version)"
+    if [ -f "$REPO/provenance.json" ]; then
+      local built_from
+      # Tolerated, never trusted: a malformed stamp used to kill status via
+      # set -e mid-output, and a well-formed one with no commit passed in
+      # silence — both are UNBOUND states, not absences of the question.
+      built_from="$(json_field "$REPO/provenance.json" commit 2>/dev/null || true)"
+      if [ -n "$built_from" ]; then
+        info "built from commit ${built_from}$(
+          grep -q '"dirty":true' "$REPO/provenance.json" && printf ' (DIRTY tree at pack time)')"
+      else
+        info "UNBOUND  provenance.json is unreadable or names no commit — this artifact is not usably bound"
+      fi
+    else
+      # The absence is the finding: D-0050 accepts lifecycle-disabled packs as
+      # residual BECAUSE this line makes an unbound artifact visible — a silent
+      # skip here would unmake that decision's premise.
+      info "UNBOUND  no provenance stamp — packed with lifecycle scripts disabled, or a pre-provenance release; this artifact names no commit"
+    fi
   else
     log "agent-bios"
   fi
   log "  source:  $REPO"
   case "$(drift_state)" in
     match)   info "deployed version $(deployed_version) (matches this package)" ;;
-    drift)   log  "DRIFT    deployed $(deployed_version) but this package is $(source_version) — run: agent-bios install" ;;
-    unknown) info "deployed version unknown (no state marker yet)" ;;
+    drift)   log  "DRIFT    $(drift_detail) — run: agent-bios install" ;;
+    unknown) if [ -f "$STATE_DIR/version.json" ]; then
+               info "correspondence unprovable: $(drift_detail)"
+             else
+               info "deployed version unknown (no state marker yet)"
+             fi ;;
   esac
   for p in "$CLAUDE_DIR/CLAUDE.md" "$CODEX_DIR/AGENTS.md" "$BIN_DIR/agent-launch" \
            "$LAUNCH_DIR/profiles.toml" "$LAUNCH_DIR/shell.zsh"; do
@@ -1015,7 +1175,7 @@ cmd_status() {
 }
 
 cmd_update() {
-  if [ -d "$REPO/.git" ]; then
+  if [ -e "$REPO/.git" ]; then
     log "Updating from git..."
     run git -C "$REPO" pull --ff-only
     cmd_install
@@ -1067,7 +1227,7 @@ EOF
   # than naming none: a clone can roll the corpus back to a registered mining window, while an
   # npm install has no git history to read and rolls the whole package back by version instead.
   # Derived from which install this is, for the same reason --with names is.
-  if [ -d "$REPO/.git" ]; then
+  if [ -e "$REPO/.git" ]; then
     printf '\nRecover: python3 %s/compose/corpus-state.py list, then rollback --version V\n' "$REPO"
   else
     printf '\nRecover: npm install -g agent-bios@<older-version> && agent-bios install\n'