Command one-liners

Recall is operated entirely by one-line commands. This page collects them all in one place, grouped by how often you reach for them. Each block below is a single runnable line — no $ prompt sigil, no output pasted underneath — so the copy button hands you exactly what you run, nothing to trim. For flag tables, defaults, exit codes, and real output for every command, use the full CLI reference; this page is the card you keep open.

The lines assume the repo checkout at ~/code/pibmo-recall and the macOS platform-default dataset root. Set these two once per shell and every line below pastes as-is (replace mymac with the friendly name you gave the installer):

ROOT="$HOME/Library/Application Support/pibmo/recall"; MACHINE=mymac

There is no config file to point commands at — the root travels on the command line (--root) or in PIBMO_ROOT, nothing else (Configuration).

Once per machine

Clone the repo. The scheduler unit will point into this checkout, so put it somewhere durable:

git clone https://github.com/attilabalogh/pibmo-recall.git ~/code/pibmo-recall

Run the installer — it proposes the local root, registers the machine, seeds the shared config, and writes the native scheduler unit. On a single computer it is two prompts and Enter:

cd ~/code/pibmo-recall && bash install.sh

Update, at any later date. The unit runs straight from the checkout, so the next hourly tick runs the new code — there is no deployed copy and no self-updater:

git -C ~/code/pibmo-recall pull

Activate the schedule

The installer prints these; they are idempotent, and they are the only step it leaves to you. On macOS (bootout first is deliberate — re-writing an active unit needs it):

launchctl bootout gui/$UID com.pibmo.recall.sync 2>/dev/null || true

launchctl bootstrap gui/$UID ~/Library/LaunchAgents/com.pibmo.recall.sync.plist

On Linux:

systemctl --user daemon-reload

systemctl --user enable --now pibmo-recall-sync.timer

Prefer plain cron? Paste the fallback line the installer printed instead — never schedule both.

Day to day

Preview what a sync would do without writing a byte:

python3 ~/code/pibmo-recall/scripts/sync/sync-transcripts.py --root "$ROOT" --dry-run

Sync now, verbosely. Safe at any time — a concurrent run exits immediately via the lock, and append-only preservation means a manual run can never overwrite or shrink anything the hourly tick wrote:

python3 ~/code/pibmo-recall/scripts/sync/sync-transcripts.py --root "$ROOT" -v

Is this machine actually archiving? Registration, write canary, scheduler unit and its embedded paths, heartbeat age, log recency — every failure prints its exact fix:

python3 ~/code/pibmo-recall/scripts/sync/doctor.py --root "$ROOT"

Watch what the scheduled runs log (two lines per tick):

tail "$ROOT/$MACHINE/logs/cron.log"

Project the raw archive into merged per-project Markdown under {root}/processed/ — deterministic, idempotent, zero LLM involvement (Processing). This is the one command that needs PyYAML, hence the system interpreter on macOS:

/usr/bin/python3 ~/code/pibmo-recall/scripts/process/process_root.py --root "$ROOT"

Occasionally

Verify the installed scheduler unit still byte-matches a fresh render (the doctor runs the same check):

python3 ~/code/pibmo-recall/scripts/sync/scheduler.py --check --root "$ROOT" --machine "$MACHINE"

Classify a path before trusting it as a root — one line of verdict, exit 0 always:

python3 ~/code/pibmo-recall/scripts/sync/rootcheck.py --describe ~/Dropbox/Datasets/pibmo

Propose consolidate_into groupings for projects.json from git remotes. Dry run by default; nothing is written without --apply:

python3 ~/code/pibmo-recall/scripts/process/propose_consolidation.py --root "$ROOT"

Preview a one-time import of a pre-reset keyed archive (same lock, same append-only rules as the sync):

python3 ~/code/pibmo-recall/scripts/sync/import_legacy.py --root "$ROOT" --legacy ~/Datasets/pibmo-legacy --dry-run

Audit Claude Code’s session-name structures for schema drift — read-only, writes nothing, anywhere:

python3 ~/code/pibmo-recall/scripts/probe/session_names.py --check

Run the sync-layer test suite from the checkout:

cd ~/code/pibmo-recall && /usr/bin/python3 -m pytest scripts/sync/tests -q

Which line, when

Situation	One-liner	Full reference
New machine	`bash install.sh`	install.sh
”Did anything change?”	`sync-transcripts.py --dry-run`	sync-transcripts.py
Archive now	`sync-transcripts.py -v`	sync-transcripts.py
”Is it actually running?”	`doctor.py`	doctor.py
Repo moved, interpreter changed	`scheduler.py --check`	scheduler.py
”Is this path safe as a root?”	`rootcheck.py --describe`	rootcheck.py
Read the archive as Markdown	`process_root.py`	process_root.py
~100 unedited project rows	`propose_consolidation.py`	propose_consolidation.py
Absorb the old archive	`import_legacy.py --dry-run`	import_legacy.py
Did the tools’ format drift?	`session_names.py --check`	session_names.py

Every Python command answers -h. The sync layer is pure stdlib — any python3 >= 3.9 works; only process_root.py needs PyYAML.

What a one-liner does not prove

A manual sync that succeeds proves the pipe: the paths resolve, the archive accepts writes, your interactive shell can reach both ends. It does not prove the hourly loop — the scheduled run executes from launchd or systemd with a different environment, and a unit whose embedded repo path has moved, or a permission fence between the scheduler and the root, stops preservation without an error you would ever see. The only line on this page that answers “is this machine archiving?” is the doctor, whose heartbeat row reads what the last completed run recorded in pibmo.db. When a row goes red, its fix: lines are the remediation — start at Troubleshooting.