localthink-org/gbrain-localthink

Review signals: 2 known vulnerability. 1 static matches retained as context.

OSV reports a known vulnerability in this dependency version. pytest 2 findings.

1 hardcoded secret matches retained as context; full list in the evidence.

OSV scanned supported lockfiles; unpinned dependencies and unsupported formats are outside this check.

A short run cannot establish that code is safe.

Connections show IP addresses; proxies can hide the final hostname.

Tracing covers dispatched commands and their children, not the whole OS; guest root can interfere with tracing.

Full safety evidence →

• Converts agent session JSONL to LTF markdown: Real input produced the expected result: written=1

  Source: - **Converts** agent session JSONL to clean LTF v1.0 markdown (redacts secrets and incidental private IPs, MACs, and emails; elides inline base64 images; summarizes tool output per LTF spec §5.2)

  Input: <guest-path> (one demo session JSONL)

  Expected: one session written

  Command: python3 ltf/ltf_converter.py <guest-path> --out <guest-path> --overwrite

  Observed: written=1 skipped_unchanged=0 skipped_empty=0 blocked=0 stale_removed=0

• Scans export and conversations for plaintext secret patterns: Real input produced the expected result: scan_hits=0

  Source: - **Scans** `export/` and `conversations/` for plaintext secret patterns before pushing — blocks the backup if anything looks like a credential

  Input: <guest-path> (converted LTF file with redacted secrets)

  Expected: no secret hits

  Command: python3 ltf/ltf_converter.py --scan <guest-path>

  Observed: scan_hits=0 files=1

• Exports GBrain pages to markdown: Real input produced the expected result: Exported 1 pages

  Source: - **Exports** your GBrain pages to markdown (`gbrain export --dir`)

  Input: gbrain brain holding one page (notes/backup-bridge-demo)

  Expected: page exported to the fresh directory

  Command: gbrain export --dir <guest-path>

  Observed: Exported 1 pages to <guest-path> [export.pages] start [export.pages] 1/1 (100%) [export.pages] 1/1 (100%) done

Examples

• Repository tests run with pytest: command completed successfully

  Source: README.md Tests section (python3 -m pytest)

  Input: tests/ directory

  Expected: all offline tests pass

  Command: <guest-path> -m pytest

  Observed: ============================= test session starts ============================== platform linux -- Python 3.12.3, pytest-9.1.1, pluggy-1.7.0 rootdir: <guest-path> configfile: pytest.ini testpaths: tests collected 27 items tests/test_converter.py ................... [ 70%] tests/test_scripts.py ........ [100%] ============================== 27 passed in 8.59s ==============================

• Shell scripts pass shellcheck: command completed successfully with no output

  Source: README.md Tests section (shellcheck scripts/backup.sh scripts/restore.sh)

  Input: scripts/backup.sh scripts/restore.sh

  Expected: no findings, exit 0

  Command: shellcheck scripts/backup.sh scripts/restore.sh

• Restore imports a backup clone into GBrain: command completed successfully

  Source: README.md Restore on a new machine section

  Input: <guest-path> (fresh clone of the backup remote with export/)

  Expected: gbrain import runs and restore prints restore done.

  Command: <guest-path> <guest-path>

  Observed: ck/conversations/ open any .ltf.md in a markdown reader; tools can search this tree directly. → gbrain import (no embeddings; run 'gbrain embed' later for semantic recall) Found 1 markdown files Import complete (0.1s): 0 pages imported 1 pages skipped (1 unchanged, 0 errors, 0 malformed filenames) 0 chunks created restore done. [gbrain phase] import.collect_files start dir=<guest-path> strategy=markdown [gbrain phase] import.collect_files done 36ms files=1 [import.files] start [import.files] 1/1 (100%) imported=0 skipped=1 errors=0 [import.files] 1/1 (100%) done

Cycles

• Scheduled daily backup run: Triggered one cycle by hand (run-once wrapper: one manual run of scripts/backup.sh against a fresh empty local bare remote (no external push, no source edits); normal trigger: daily at 18:00 via system cron): written=1 skipped_unchanged=0 skipped_empty=0 blocked=0 stale_removed=0 scan_hits=0 files=4 2026-10-24 02:07:18 backup pushed: 1b2d4cc backup: gbrain+ltf 2026-10-24 02:07 To <guest-path> * [new branch] main -> main

  Source: cron/README.md

  Input: SESSIONS_DIR=<guest-path> and the gbrain brain with one page

  Expected: converter, scan and commit/push run; output ends with backup pushed

  Command: bash <guest-path>

  Observed: written=1 skipped_unchanged=0 skipped_empty=0 blocked=0 stale_removed=0 scan_hits=0 files=4 2026-10-24 02:07:18 backup pushed: 1b2d4cc backup: gbrain+ltf 2026-10-24 02:07 To <guest-path> * [new branch] main -> main

Local or hosted: local

Set up gbrain-localthink at pin 176a515e66f80c88717ba3198fb902760760fe82 and run the README's documented operations: LTF session conversion, secret scan, backup.sh (export, convert, scan, commit, push), restore.sh, pytest, shellcheck.

cd <guest-path> && pwd && ls -la && id -u && python3 --version && git --version 2>&1; cat /etc/os-release | head -3; ls /inputs 2>&1
cd <guest-path> && cat README.md 2>/dev/null | head -300
cd <guest-path> && git init -q && git remote add origin https://github.com/localthink-org/gbrain-localthink && git fetch --depth 1 origin 176a515e66f80c88717ba3198fb902760760fe82 2>&1 | tail -5; git reset --mixed FETCH_HEAD 2>&1; git log --oneline -1; git status --short | head; ls scripts ltf tests cron examples docs .coldpass; cat requirements-dev.txt pytest.ini; which gbrain; ls ~/.gbrain 2>&1 | head -2
cd <guest-path> && cat scripts/backup.sh; echo ----; cat scripts/restore.sh; echo ----; cat cron/README.md; echo ----; cat .github/*/* 2>/dev/null | head -80
cd <guest-path> && sed -n 1,80p ltf/ltf_converter.py; echo; grep -n "argparse\|add_argument\|__main__\|def main" ltf/ltf_converter.py; cat tests/conftest.py | head -30
cd <guest-path> && sed -n 610,680p ltf/ltf_converter.py; (python3 -m venv <guest-path> 2>&1 || (sudo -n apt-get update -qq && sudo -n apt-get install -y -qq python3-venv >/dev/null 2>&1 && python3 -m venv <guest-path>)) && <guest-path> -m pip install -q -r requirements-dev.txt 2>&1 | tail -3; <guest-path> -m pip --version
cd <guest-path> && <guest-path> -m pytest --version && <guest-path> -m pytest -q 2>&1 | tail -5; echo "rc=$?"; which shellcheck || (sudo -n apt-get install -y -qq shellcheck >/dev/null 2>&1; which shellcheck); shellcheck scripts/backup.sh scripts/restore.sh && echo SHELLCHECK_OK
mkdir -p <guest-path> && cd <guest-path> && cat > demo-session-0001.jsonl <<'EOF'
{"role":"session_meta","timestamp":"2026-10-18T09:00:00","tools":[]}
{"role":"user","content":"What does this repo do? my key is <secret>","timestamp":"2026-10-18T09:00:01"}
{"role":"assistant","content":"It is a backup bridge kit for agent logs and GBrain.","timestamp":"2026-10-18T09:00:02"}
{"role":"tool","content":"host <internal-ip> contact <email>","timestamp":"2026-10-18T09:00:03"}
EOF
mkdir -p <guest-path> && cd <guest-path> && <guest-path> ltf/ltf_converter.py <guest-path> --out <guest-path>; echo rc=$?; ls -la <guest-path>; cat <guest-path>
which node npm bun gbrain 2>&1; node --version 2>&1; curl -sI -m 20 https://github.com/garrytan/gbrain | head -3; echo; curl -s -m 20 https://raw.githubusercontent.com/garrytan/gbrain/master/README.md | head -60
curl -s -m 30 https://raw.githubusercontent.com/garrytan/gbrain/master/README.md > <guest-path>; grep -n -i "install\|bun\|curl \|npm\|postgres\|pglite" <guest-path> | head -50
export NODE_USE_ENV_PROXY=1; cd /tmp && curl -fsSL -m 180 https://bun.sh/install -o <guest-path> && echo "downloaded bun installer, $(wc -l < <guest-path>) lines" && bash <guest-path> 2>&1 | tail -5; ls ~/.bun/bin 2>&1; ~/.bun/bin/bun --version 2>&1
export NODE_USE_ENV_PROXY=1; sudo -n apt-get install -y -qq unzip ><guest-path> 2>&1; echo "apt rc=$?"; cd /tmp && bash <guest-path> 2>&1 | tail -4; export PATH="$HOME/.bun/bin:$PATH"; bun --version
grep -n -i "telemetry\|analytics" <guest-path> | head; grep -n -i "telemetry" <guest-path> | wc -l
export NODE_USE_ENV_PROXY=1; export PATH="$HOME/.bun/bin:$PATH"; cd /tmp && timeout 900 bun install -g github:garrytan/gbrain > <guest-path> 2>&1; echo "rc=$?"; tail -15 <guest-path>; command -v gbrain && gbrain --version 2>&1 | tail -3
export PATH="$HOME/.bun/bin:$PATH"; export GBRAIN_TELEMETRY=0 DO_NOT_TRACK=1; cd /tmp && timeout 600 gbrain init --pglite --no-embedding > <guest-path> 2>&1; echo "rc=$?"; tail -20 <guest-path>; gbrain --help 2>&1 | grep -i "export\|import\|put\|create\|get\|query\|search" | head -20
export PATH="$HOME/.bun/bin:$PATH"; export GBRAIN_TELEMETRY=0 DO_NOT_TRACK=1; mkdir -p <guest-path> && printf -- '---\ntitle: "Backup bridge demo"\ntype: note\n---\n\nThe backup bridge kit exports GBrain pages to markdown and converts agent sessions to LTF.\n' > <guest-path> && cd /tmp && gbrain put notes/backup-bridge-demo < <guest-path>; echo "put rc=$?"; gbrain get notes/backup-bridge-demo 2>&1 | head -12; echo; gbrain search "backup bridge" 2>&1 | head -5
cd <guest-path> && rm -rf memory-backup-remote.git memory-backup && git init -q --bare -b main memory-backup-remote.git && git clone -q memory-backup-remote.git memory-backup 2>&1; cd memory-backup && git config user.name "coldpass-probe" && git config user.email "coldpass-probe@localhost" && git checkout -q -b main 2>/dev/null; git branch --show-current; cd <guest-path> && ls -l scripts/ && export BACKUP_REPO_DIR=<guest-path> SESSIONS_DIR=<guest-path> REPO_REMOTE=origin BRANCH=main && ./scripts/backup.sh; echo "backup rc=$?"; cat /tmp/gbrain_export.log 2>/dev/null | tail -3
export PATH="$HOME/.bun/bin:$PATH"; cd <guest-path> && rm -rf memory-backup && git clone -q memory-backup-remote.git memory-backup 2>/dev/null; cd memory-backup && git config user.name "coldpass-probe" && git config user.email "coldpass-probe@localhost"; cd <guest-path> && export BACKUP_REPO_DIR=<guest-path> SESSIONS_DIR=<guest-path> REPO_REMOTE=origin BRANCH=main && <guest-path>; echo "backup rc=$?"; cd <guest-path> && git log --oneline | head -3; git ls-files | head -20
export PATH="$HOME/.bun/bin:$PATH"; cd <guest-path> && export BACKUP_REPO_DIR=<guest-path> SESSIONS_DIR=<guest-path> REPO_REMOTE=origin BRANCH=main && <guest-path>; echo "rerun rc=$?"; echo ---; mkdir -p <guest-path> && printf 'token: <secret>\n' > <guest-path> && <guest-path> ltf/ltf_converter.py --scan <guest-path>; echo "scan rc=$?"
cat /tmp/gbrain_export.log; echo ---; export PATH="$HOME/.bun/bin:$PATH"; cd <guest-path> && gbrain export --help 2>&1 | head -30
cd <guest-path> && grep -n "Scans\*\* \|Exports\*\* \|Converts\*\* \|Commits and pushes\|Safe to re-run\|python3 -m pytest\|^shellcheck\|claim" README.md | head; echo ---; grep -n "0 18 \* \* \*" cron/README.md; echo ---; rm -rf <guest-path> && mkdir -p <guest-path> <guest-path> <guest-path> <guest-path> <guest-path> && cp <guest-path> <guest-path> && <guest-path> -c "print(1)" >/dev/null; python3 ltf/ltf_converter.py --scan <guest-path>; echo rc=$?; git status --short
cat > <guest-path> <<'EOF'
#!/bin/bash
# Manual stand-in for the cron line in cron/README.md: one run of scripts/backup.sh
# against a fresh, empty local bare remote (no external push).
set -euo pipefail
export PATH="$HOME/.bun/bin:$PATH"
mkdir -p <guest-path>
run=$(mktemp -d <guest-path>)
git init -q --bare -b main "$run/remote.git"
git clone -q "$run/remote.git" "$run/memory-backup" 2>/dev/null
cd "$run/memory-backup"
git config user.name "cycle-probe"
git config user.email "cycle-probe@localhost"
BACKUP_REPO_DIR="$run/memory-backup" SESSIONS_DIR=<guest-path> \
  REPO_REMOTE=origin BRANCH=main <guest-path>
EOF
chmod +x <guest-path> && cd <guest-path> && bash <guest-path>; echo "cycle rc=$?"
export PATH="$HOME/.bun/bin:$PATH"; cd <guest-path> && rm -rf restore-check && git clone -q memory-backup-remote.git restore-check && cd <guest-path> && ./scripts/restore.sh <guest-path> > <guest-path> 2>&1; echo "restore rc=$?"; tail -12 <guest-path>; ls <guest-path> | head
cd <guest-path> && mkdir -p .coldpass && cat > .coldpass/probe.json <<'EOF'
{"kind":"cli","argv":["python3","ltf/ltf_converter.py","<guest-path>","--out","<guest-path>","--overwrite"],"cwd":"<guest-path>","expected_text":"written=1"}
EOF
cat > .coldpass/claims.json <<'EOF'
[
{"kind":"claim","claim":"Converts agent session JSONL to LTF markdown","source":"- **Converts** agent session JSONL to clean LTF v1.0 markdown (redacts secrets and incidental private IPs, MACs, and emails; elides inline base64 images; summarizes tool output per LTF spec §5.2)","input":"<guest-path> (one demo session JSONL)","expected":"one session written","probe_kind":"cli","argv":["python3","ltf/ltf_converter.py","<guest-path>","--out","<guest-path>","--overwrite"],"stdin":null,"expected_text":"written=1","cwd":"<guest-path>"},
{"kind":"claim","claim":"Scans export and conversations for plaintext secret patterns","source":"- **Scans** `export/` and `conversations/` for plaintext secret patterns before pushing — blocks the backup if anything looks like a credential","input":"<guest-path> (converted LTF file with redacted secrets)","expected":"no secret hits","probe_kind":"cli","argv":["python3","ltf/ltf_converter.py","--scan","<guest-path>"],"stdin":null,"expected_text":"scan_hits=0","cwd":"<guest-path>"},
{"kind":"claim","claim":"Exports GBrain pages to markdown","source":"- **Exports** your GBrain pages to markdown (`gbrain export --dir`)","input":"gbrain brain holding one page (notes/backup-bridge-demo)","expected":"page exported to the fresh directory","probe_kind":"cli","argv":["gbrain","export","--dir","<guest-path>"],"env":{"PATH":"<guest-path>"},"stdin":null,"expected_text":"Exported 1 pages","cwd":"<guest-path>"}
]
EOF
cat > .coldpass/examples.json <<'EOF'
[
{"kind":"example","claim":"Repository tests run with pytest","source":"README.md Tests section (python3 -m pytest)","input":"tests/ directory","expected":"all offline tests pass","argv":["<guest-path>","-m","pytest"],"cwd":"<guest-path>","env":{},"expected_text":"27 passed"},
{"kind":"example","claim":"Shell scripts pass shellcheck","source":"README.md Tests section (shellcheck scripts/backup.sh scripts/restore.sh)","input":"scripts/backup.sh scripts/restore.sh","expected":"no findings, exit 0","argv":["shellcheck","scripts/backup.sh","scripts/restore.sh"],"cwd":"<guest-path>","env":{}},
{"kind":"example","claim":"Restore imports a backup clone into GBrain","source":"README.md Restore on a new machine section","input":"<guest-path> (fresh clone of the backup remote with export/)","expected":"gbrain import runs and restore prints restore done.","argv":["<guest-path>","<guest-path>"],"cwd":"<guest-path>","env":{},"expected_text":"restore done."}
]
EOF
cat > .coldpass/cycles.json <<'EOF'
{"detected":true,"checks":[{"claim":"Scheduled daily backup run","source":"cron/README.md","quote":"0 18 * * * cd $HOME/path/to/gbrain-localthink && ./scripts/backup.sh >> $HOME/.hermes/scripts/backup.log 2>&1","schedule":"daily at 18:00 via system cron","method":"run-once wrapper: one manual run of scripts/backup.sh against a fresh empty local bare remote (no external push, no source edits)","input":"SESSIONS_DIR=<guest-path> and the gbrain brain with one page","expected":"converter, scan and commit/push run; output ends with backup pushed","kind":"cli","argv":["bash","<guest-path>"],"cwd":"<guest-path>","expected_text":"backup pushed:"}]}
EOF
for f in probe claims examples cycles; do python3 -m json.tool .coldpass/$f.json >/dev/null && echo "$f ok"; done; <env-var>=<guest-path> python3 -I <guest-path> --validate --replay 2>&1 | tail -40; echo "checker rc=${PIPESTATUS[0]}"
cd <guest-path> && python3 - <<'EOF'
import json
p='.coldpass/claims.json'
c=json.load(open(p))
for x in c:
    if x['claim']=='Exports GBrain pages to markdown':
        x['argv']=['<guest-path>','export','--dir','<guest-path>']
        x['env']={'HOME':'<guest-path>','PATH':'<guest-path>'}
json.dump(c,open(p,'w'),ensure_ascii=False,indent=1)
print('ok')
EOF
<env-var>=<guest-path> python3 -I <guest-path> --validate --replay > <guest-path> 2>&1; echo "checker rc=$?"; python3 -I -c "
import json,sys
d=json.load(open('<guest-path>'))
print('valid:',d.get('valid'),'problems:',d.get('problems'))
r=d['replay']; print('replay:',r['status'])
for c in r['details']['claims']: print(' claim:',c['claim'],'->',c['verdict'],'|',c['outcome'][:90])
for c in r['details']['example_checks']: print(' example:',c['claim'],'->',c['verdict'] if 'verdict' in c else c.get('returncode'))
" 2>&1 | head -30
cd <guest-path> && env -i HOME=<guest-path> PATH=<guest-path> <guest-path> export --dir <guest-path> ; echo "rc=$?"; ls <guest-path>; head -1 <guest-path>
grep -n "env" <guest-path> | head -40
sudo -n ln -sf <guest-path> /usr/local/bin/bun && sudo -n ln -sf <guest-path> /usr/local/bin/gbrain && command -v gbrain && gbrain --version && cd <guest-path> && python3 - <<'EOF'
import json
p='.coldpass/claims.json'
c=json.load(open(p))
for x in c:
    if x['claim']=='Exports GBrain pages to markdown':
        x['argv']=['gbrain','export','--dir','<guest-path>']
        x['env']={}
json.dump(c,open(p,'w'),ensure_ascii=False,indent=1)
print('claims updated')
EOF
rm -rf <guest-path>; <env-var>=<guest-path> python3 -I <guest-path> --validate --replay > <guest-path> 2>&1; echo "checker rc=$?"; python3 -I -c "
import json
d=json.load(open('<guest-path>'))
print('valid:',d.get('valid'),'problems:',d.get('problems'))
print('replay:',d['replay']['status'])
" ; tail -c 600 <guest-path>
mkdir -p <guest-path> && cd <guest-path> && python3 - <<'EOF'
import json
report = {
  "outcome": "partial",
  "fault_owner": "product",
  "operation": "Set up gbrain-localthink at pin 176a515e66f80c88717ba3198fb902760760fe82 and run the README's documented operations: LTF session conversion, secret scan, backup.sh (export, convert, scan, commit, push), restore.sh, pytest, shellcheck.",
  "operation_scope": "Local VM only. Local bare git remote used for backup. GBrain 0.60.416.0 installed via Bun 1.4.4 with keyless PGLite init. No external services, credentials, browser, or X/Twitter contact.",
  "steps": [
    "Checked out pinned commit and confirmed clean tree.",
    "Installed python3-venv and unzip with sudo apt-get; created <guest-path> and installed requirements-dev.txt.",
    "Installed Bun and gbrain via bun install -g github:garrytan/gbrain (README's documented install path).",
    "Ran gbrain keyless init and page put/get/search.",
    "Ran LTF converter on a fixture with a fake API key; confirmed redaction and written=1.",
    "Ran --scan on a clean LTF directory; scan_hits=0.",
    "Ran backup.sh via absolute path against a local bare remote; first run pushed.",
    "Ran restore.sh into a fresh clone; restore done.",
    "Ran pytest (27 passed) and shellcheck on scripts/backup.sh and scripts/restore.sh.",
    "Symlinked bun and gbrain into /usr/local/bin so the checker's child PATH can resolve them; re-ran checker: valid True, no problems."
  ],
  "deviations": [
    "scripts/backup.sh fails when invoked via a relative path (./scripts/backup.sh) because CONVERTER is resolved from $0 before cd into the backup repo. Workaround: invoke with an absolute path. This is a repo defect.",
    "scripts/backup.sh is not re-runnable: gbrain export --dir ./export/ fails on the second run with 'Export destination has an occupied, aliased or unsafe planned path'. This contradicts the README's 'Safe to re-run' claim. The skip-if-unchanged path was not verified.",
    "Checker child PATH comes from its own process environment, so a claim env PATH override does not make a ~/.bun/bin tool resolvable. Workaround: symlink bun and gbrain into /usr/local/bin (sudo) and use plain 'gbrain' in argv. This is an environment change outside the repo.",
    "Installed tools (python3-venv, unzip, bun, gbrain) were installed as prerequisites, not product source changes. No product source was hand-edited."
  ],
  "stuck_step": None,
  "main_blocker": "Two repo defects in backup.sh (relative-path invocation and non-idempotent re-run) and a checker PATH constraint for Bun-installed tools.",
  "plain_failure": "backup.sh cannot be invoked with ./scripts/backup.sh and cannot be re-run against the same export directory; both are product behavior. The first failure was 'can't open file .../ltf/ltf_converter.py'. The second was gbrain's 'unsafe planned path' error.",
  "suggested_fix": "Resolve CONVERTER to an absolute path before cd (or use cd of script dir), and either use a fresh export destination per run or pass a clean export dir each time, so re-runs work. Document that gbrain must be on PATH for the checker or install it system-wide."
}
json.dump(report, open('.coldpass/report.json','w'), indent=2)
print('report written')
EOF
<env-var>=<guest-path> python3 -I <guest-path> --validate --replay > <guest-path> 2>&1; echo "rc=$?"; python3 -I -c "
import json
d=json.load(open('<guest-path>'))
print('valid:',d.get('valid'),'problems:',d.get('problems'))
"
cd <guest-path> && rm -rf <guest-path> && <env-var>=<guest-path> python3 -I <guest-path> --validate --replay > <guest-path> 2>&1; echo "rc=$?"; python3 -I -c "
import json
d=json.load(open('<guest-path>'))
print('valid:',d.get('valid'),'problems:',d.get('problems'))
"
cd <guest-path> && python3 - <<'EOF'
import json
p='.coldpass/report.json'
r=json.load(open(p))
r['deviations'].append("The GBrain export claim writes to a fixed destination (<guest-path>). Replay fails with 'Export destination has an occupied ... path' if that directory already exists, so it must be removed before each checker run. This reflects the same non-idempotent export defect.")
r['outcome']="pass_with_deviations"
json.dump(r,open(p,'w'),indent=2)
print('ok')
EOF
rm -rf <guest-path> && <env-var>=<guest-path> python3 -I <guest-path> --validate --replay > <guest-path> 2>&1; echo "rc=$?"; python3 -I -c "
import json
d=json.load(open('<guest-path>'))
print('valid:',d.get('valid'),'problems:',d.get('problems'))
"; rm -rf <guest-path>; ls <guest-path>