A git include step clones into a throwaway temp dir that changes every run, and a file's identity was taken relative to that temp dir. The stored path in the ledger from one run could never be matched by the next run, so up failed with step not found for any git included file whenever the ledger already held a path from an earlier run.

A file's identity is now taken relative to the fetched source root, so a git include file is identified by its path inside the source repo, such as prophet/database/V1.0__claimius_roles.sql, independent of the throwaway clone dir. Local includes are unchanged and stay relative to the db dir. The right base is detected from the include itself, so no extra config is needed. The clone is still fetched once per run and reused, and up reads a file's bytes from the resolved clone path rather than reconstructing it from the identity.

With stable identities the ledger matches across runs on any machine, so up no longer reports step not found, and destroy then up rebuilds a database cleanly.

Relative db-dir with git include steps

A git include step clones into an absolute temp dir, so the ledger has to store a path that resolves back later. Path handling is now absolute safe end to end: the stored file path is derived from absolute forms of both the db dir and the clone, and every reconstruction that reads a file back joins the db dir only when the stored path is relative. A relative --db-dir such as ./database now works with git include steps instead of failing with a file missing on disk.

Destroy drops the ledger and skips extension owned objects

destroy now leaves the target in a truly clean state.

• Objects owned by an extension, such as the functions pgcrypto installs, are excluded from the plan so the individual drops do not fail.
• The samna_migrate ledger is always dropped with DROP SCHEMA samna_migrate CASCADE, so a following up re-applies from scratch.
• --extensions adds DROP EXTENSION <name> CASCADE for every extension the tree creates. plpgsql is never dropped.

Dump table data to json

dump writes the rows of each selected table to <schema>.<table>.json, limited to the base tables in the schemas declared by migrate.yml. --all takes every such table, --table=<schema.table> a subset, --out=<dir> the destination. With no selection flag and a terminal it opens an arrow key list. Postgres encodes each file with jsonb_agg(to_jsonb(...)), so uuid, numeric, jsonb, and timestamptz round trip exactly.

Insert rows back

insert loads those files back into their tables. Point it at a folder or individual files; the target table is read from each file name and rows load through jsonb_populate_recordset so every column is typed from the table itself. --no-triggers disables user triggers on the table for the load.

Destroy what the tree creates

destroy builds the tree into a throwaway Postgres, inventories exactly the objects those files produce, and drops that set from the live server: declared schemas other than public with DROP SCHEMA CASCADE, objects in public one by one with DROP ... IF EXISTS CASCADE. It then resets samna_migrate.file so a following up re-applies from scratch. The plan is printed and the database name is required to confirm.

• destroy needs docker for the candidate build, and objects in public the tree does not create are left untouched.
• --dry-run prints the plan and drops nothing.

Prune orphaned migration entries

rebase --prune folds every applied migration row whose file is absent from the source tree, setting state = 'folded' and writing a fold history row per entry. It touches only orphaned migration entries and leaves pending files untouched, so a following up applies the genuinely new migrations with their SQL actually executing.

• Run reconcile --db first to confirm the tree still produces the folded migrations' objects against live.
• The fold is reversible: it is recorded in history and reversed by restoring the source file.
• A whole-tree rebase stamps pending files as applied without running their SQL, so --prune is the correct tool for orphaned entries.