CLI reference

Generated page. Do not edit by hand — built from the SEIF CLI command tree by scripts/sync-docs.mjs and refreshed when main is updated.

Auto-generated from the registered Cobra tree. Regenerate:

go run ./tools/generate_cli_reference --commands-only docs/reference/commands.md

Details

admin audit

Audit workspace .seif/ integrity (read-only)

audit walks .seif/{cycles,seeds,modules} in the given workspace, parses each artifact as JSON, and reports counts + any parse failures.

This is a Wave-6 light audit. Heavier modes (host-discipline, canonical-layout, integrity-signature verification, cross-file reference validation) are implemented in the Python seif CLI's --audit-* family and are not yet ported to Go.

Exit codes: 0 clean (all files parsed) 1 partial (one or more parse failures) — see Report.parse_errors 2 workspace has no .seif/ directory

admin circuit

Circuit heartbeat/liveness — use seif daemon (circuit capability) + engine /v1/inbox

admin client add

Register (or override) a client

add registers a client. When --adapter is omitted it is inferred from the bin basename (claude→claude-code, gemini→gemini, agy/antigravity→antigravity). No confident match → error listing the available adapters (register explicitly with --adapter raw for a launch-only wrapper). raw is never auto-selected and cannot be the default.

admin client list

List registered clients

admin client parity

Report cross-client SEIF integration parity (read-only)

parity renders the SEIF client capability matrix as a measured parity report: one row per client, a ✓/◑/✗ per canonical lifecycle event (session-start, user-prompt-submit, pre-tool, post-tool, session-end), the integration channel + grounding delivery, and a trailing parity percentage.

claude-code is the 100% reference. Weighting: Full=1.0, Partial=0.5, Advisory=0.25, Absent=0; Pct = weighted / 5 canonical events.

This is read-only — it inspects the static capability matrix and changes no installer or hook behavior.

seif admin client parity # full matrix, human table seif admin client parity --json # machine-readable matrix + scores seif admin client parity --client gemini # one client

admin client remove

Remove a registered client

admin client set-default

Mark a registered client as THE default

admin cycle audit-coherence

Report cycle-internal coherence (parent refs + per-track OPEN lock)

admin cycle close

Seal the open cycle + clear the host pointer [free]

admin cycle gc

(moved) garbage-collect stale OPEN cycles — use seif gov cycle gc

admin cycle list

List cycles in .seif/cycles/ (filter with --status)

admin cycle open

Open a new cycle + bind the host pointer [free]

admin cycle seal

(moved) seal a cycle — use seif gov cycle close

admin cycle sealed-list

List sealed cycles (alias for list --status sealed)

admin cycle status

Show the active cycle from the per-workspace active-cycle pointer

admin cycle verify

(no crypto verify exists for cycles) use seif admin cycle audit-coherence

admin hooks

Hook installation — both surfaces are native: seif setup <adapter> (AI) / seif setup git-hooks (git)

admin parity

CLI × MCP × hooks parity matrix (read-only inventory)

parity walks the Cobra command tree, MCP tool registry, and embedded hook assets to emit a capability × surface matrix (CLI / MCP / Claude Code / Cursor / Generic).

Use --markdown to print the matrix or --output to write docs/PARITY.md. Use --check to verify the committed matrix matches live registries (exit 1 on drift).

This is admin maintenance tooling — not part of the public stable CLI surface.

admin proxy

Local-LLM (Ollama) proxy — native home pending (not a daemon capability)

admin seed amend

(moved) append to a seed's _amendments[] — use seif gov amend

admin seed consume

(deprecated) → seif gov seed consume

admin seed create

(moved) create a seed — use seif gov seed create

admin seed list

(deprecated) → seif gov seed list

admin session convert-ext

Rename envelope-bearing session-.json → session-.seif (dry-run default)

convert-ext scans session-*.json and classifies each file:

envelope — SEIF-ENVELOPE-v1 content; rename candidate (--apply) raw_json — plain JSON legacy record; NOT converted (GC path, separate pending) skip_* — already .seif, missing, or target exists

Default = dry-run inventory. --apply git-style renames envelope files only (content untouched) and appends a JSONL manifest under .seif/sessions/.convert-ext-archive//. Idempotent.

admin session gc

Inventory (dry-run) or archive legacy template-only session records

gc scans .seif/sessions/session-*.{json,seif} using the c282 dual-parser and classifies each record:

template_only — eager-era writeSessionContract pollution, zero contributions dup_redundant — redundant numbered copy in a session_id dup group real — conversation payload or non-skeleton closure substance protected — keep-since cutoff, open-cycle reference, or post-lazy record unparseable — reported, never moved silently named_record — *.seif named records (report only)

Default = dry-run. --apply moves template_only + dup_redundant to --archive-dir and reconciles mapper.json session_count in the same run.

admin watch

File vigilant/watcher — engine-hosted; native register surface pending

artifact format

Canonicalize .seif envelope (sorted JSON body, standard frontmatter order)

audit-coherence

Report workspace coherence (free local; --signed = engine-mediated paid envelope)

audit-coherence — fsck for AI artifacts.

Phase A (free, local): --scope=workspace (default) reports cycle-internal coherence over .seif/cycles/ — multiple OPEN cycles on the same track and parent_cycle refs that do not resolve to a known cycle_id.

Phase B (engine-mediated, paid): --signed POSTs the audit to the engine, which re-runs the audit, signs the result with its Ed25519 key, and writes an entry to the transparency log. Use --verify-trail to verify the trust chain offline: depth-2 (engine_signature over the report body) and depth-3 (RFC-6962 inclusion proof fetched from the transparency log + Ed25519 STH signature over the reconstructed tree root). Use --output FILE.seif to render the result as a SEIF-ENVELOPE-v1 archival artifact.

Auth (priority): --token VALUE | --token-file PATH | $SEIF_ENGINE_TOKEN Engine URL (priority): --engine-url URL |$SEIF_ENGINE_URL | https://api.seifprotocol.com Log URL (priority): --log-url URL | $SEIF_LOG_URL | https://log.seifprotocol.com Workspace ID (priority): --workspace-id ID |$SEIF_WORKSPACE_ID Engine pubkey (priority): --engine-pubkey-file PATH | $SEIF_ENGINE_PUBKEY | ~/.seif/keys/engine_pubkey

Memo↔PIR corpus audit (free, local): --scope=memo — audit the whole design-memo corpus against the Product Invariant Registry + coherence-graph (.seif/coherence/): missing-grounding, dangling-ref, superseded-ref [HIGH], stale-grounding, invariant-source-integrity, assertion-guard [REVIEW], and decision↔cycle symmetry. Exits non-zero on HIGH. --scope=memo: — same audit, findings filtered to that memo's subject.

Still deferred (not yet implemented): --scope=cycle: — single-cycle filter. Not yet implemented.

The same audit is also exposed at 'seif admin cycle audit-coherence' for back-compat; both verbs share the same implementation.

audit-cross-refs

Audit decision↔cycle edge integrity (c260 D8): cycle_ref ↔ cycle.decisions[]

audit-cross-refs reports decision↔cycle edge coherence (c260 D8=C):

HIGH dangling-cycle-ref decision.cycle_ref names a cycle that does not exist HIGH dangling-decision-ref cycle.decisions[] names a decision that does not exist HIGH edge-mismatch cycle lists decision D, but D.cycle_ref names another cycle MEDIUM one-sided-d2c decision.cycle_ref=X, but X.decisions[] omits the decision MEDIUM one-sided-c2d cycle lists decision D, but D has no cycle_ref

One-sided edges are repairable with 'seif gov cycle decision-add'. By default only HIGH findings fail the audit; --strict fails on MEDIUM too.

audit-discipline

Report observed Write/Edit on reserved .seif/ subdirs (s83 t3 audit log)

audit-discipline — retrospective view over .seif/audit/discipline.jsonl.

Reads the runtime observer log (populated by the PreToolUse discipline hook on .seif/{cycles,sessions,seeds,memory,memos,modules,coherence}/**) and reports:

• per-subdir counts + the seif CLI verb each subdir SHOULD route through;
• top-N most-rewritten file paths;
• cross-workspace + shell-bypass + refused (hard-block) + unauthorized_write counters surfaced for forensics.

Read-only: never writes or clears the log. Hard-block enforcement lives in the PreToolUse hook; this verb is for prioritization (which subdirs lack CLI coverage?) and post-hard-block audit.

Parity target: seif-dev --audit-discipline in the Python dev-tool.

audit-layout

Audit per-role canonical filesystem layout for this host

audit-layout — per-role canonical filesystem audit.

Loads the embedded SEIF-CANONICAL-NODE-LAYOUT-v1 schema, detects this host's role (via ~/.seif/machine_id::label first, then hostname pattern), and verifies:

• common_to_all_roles artifacts (CLI symlink, venv, kernel envelope, owner state directory, …)
• role-specific expected_artifacts (admin volume, install cache, launch agents, …)
• drift_violations (with severity HIGH/MEDIUM/LOW)
• forbidden_artifacts (with reason)

Read-only: NEVER mutates the filesystem.

Distinct from audit-host: audit-host audits the 5-layer SEIF init artifact structure inside ~/.seif/. audit-layout audits the per-role canonical layout across the whole machine. They are sibling verbs.

Exit codes (per schema audit_exit_codes): 0 all required artifacts present, no HIGH/MEDIUM drift 1 drift violation(s) detected (any severity), or forbidden artifact 2 required artifact missing (kernel envelope, CLI symlink, owner state) 3 role detection failed (no machine_id::label and no hostname pattern match)

Parity target: seif-dev --audit-layout in the Python dev-tool (seif/src/seif/cli/cli.py:5126).

claim acquire

Mint a claim record under .seif/claims/active/

claim check

Check a path against active claims (informational; exit 3 on conflict)

claim list

List active (default), released, or all claims

claim override

Record a human override for a conflicting claim (does NOT release it)

claim release

Move an active claim to released/

claim show

Print a claim record (active or released) as JSON

claim sweep

Release stale claims (TTL expired or holder PID gone)

claim validate

Validate a claim record file against SEIF-CLAIM-v1

classify

Classify content sensitivity (PUBLIC | INTERNAL | CONFIDENTIAL)

Classify reads (or stdin when given "-"), scans for sensitive markers and keywords, and reports the resulting classification level.

By default, prints only the level (one of PUBLIC, INTERNAL, CONFIDENTIAL). With --json, prints the full reasoning record (level, matched patterns, escalation chain, classifier version).

PUBLIC is never auto-assigned — that classification requires explicit user assertion (this matches the Python reference implementation).

clone

Clone a workspace's remote HEAD into a new directory [PAID]

clone materializes a workspace's current engine HEAD into (a fresh directory). Refuses to overwrite an existing /.seif/ unless --force; to update an existing workspace use seif pull.

Login-required; entries classification-filtered server-side.

compress

Compress a source project into a code_topology SEIF module

compress scans a source project, extracts its semantic topology (imports, functions, types, routes, classification) and writes a compact SEIF-ENVELOPE-v1 module to .seif/projects//code.seif — "webpack for machines": an AI can read the topology instead of every file.

input_kind is code_topology (non-prose), so the quality gate is skipped. The output slug is git-root-aware (--name to override); an existing module from the same source needs --force to overwrite (fails closed in non-interactive mode).

Parser scope: Go + python (regex) + a generic fallback (Rust/Java/Kotlin/ others). JavaScript/Dart and the Python AST path are not yet ported. Output destinations (Store-V2): absorb, ingest, extract → .seif/knowledge/.seif (+ mapper registration) compress → .seif/projects//code.seif (+ mapper registration) context sync → {repo}/.seif/projects//project.seif (+ mapper registration)

Every write registers the artifact in the sovereign mapper.json so it is consumable at next session-start (Φ×λ=1 — no unregistered orphans). Slug derivation (git-root-aware): Slugs combine the git repository basename with the target path so same-named subdirs in different repos stay distinct — e.g. repo-a/docs → repo-a-docs, repo-b/docs → repo-b-docs. Override with --name on any verb.

ingest: --name is required for stdin/raw string sources; file paths derive the slug from the filename when --name is omitted. Image binding (--image): Every knowledge unit belongs to one workspace image (never Pod-global). Resolution order: explicit --image > workspace.seif.json container.name (walk-up from cwd) > git-root basename (standalone). In a multi-image Pod (SEIF_POD_CONTEXT=pod) with no resolvable image, verbs fail closed — pass --image explicitly.

config get

Print value at key

config list

Show all keys and values

config set

Write value at key

confirm-action

Pre-action human gate for hookless AI clients (exit 0/1/2) [free, local]

confirm-action is the pre-action human gatekeeper for AI clients WITHOUT hooks (Copilot, Cursor, AGENTS.md) — the cross-platform stand-in for the PreToolUse classification gate. A SEIF-aware AI calls it before any destructive operation:

• Non-interactive (an AI reading stdout): prints AWAITING_HUMAN_CONFIRMATION and exits 2 — the AI MUST stop and surface the block to the human, never proceed.
• Interactive (a real terminal): prompts y/N — exit 0 approve, 1 deny.

Every call is audit-logged to /.seif/circuit/confirmations.log and, inside a workspace, to .seif/sessions/session--confirmations.log. With --target-path it also warns about active claims held by other sessions. Free and local — no engine.

container bootstrap

Scaffold an envelope-native SEIF container (no Python required)

container-acknowledge

Clear container-dirty.seif after reviewing local changes

context absorb

Absorb a directory into a SEIF-KNOWLEDGE-v1 unit

absorb ingests text-bearing files from [path] (default: cwd) into the local sovereign store as a SEIF-KNOWLEDGE-v1 unit under .seif/knowledge/, registered in the mapper so it is consumable at next session-start.

When [path] is a git repository, project.seif is refreshed first (same as sync). Output destinations (Store-V2): absorb, ingest, extract → .seif/knowledge/.seif (+ mapper registration) compress → .seif/projects//code.seif (+ mapper registration) context sync → {repo}/.seif/projects//project.seif (+ mapper registration)

Every write registers the artifact in the sovereign mapper.json so it is consumable at next session-start (Φ×λ=1 — no unregistered orphans). Slug derivation (git-root-aware): Slugs combine the git repository basename with the target path so same-named subdirs in different repos stay distinct — e.g. repo-a/docs → repo-a-docs, repo-b/docs → repo-b-docs. Override with --name on any verb.

ingest: --name is required for stdin/raw string sources; file paths derive the slug from the filename when --name is omitted. Image binding (--image): Every knowledge unit belongs to one workspace image (never Pod-global). Resolution order: explicit --image > workspace.seif.json container.name (walk-up from cwd) > git-root basename (standalone). In a multi-image Pod (SEIF_POD_CONTEXT=pod) with no resolvable image, verbs fail closed — pass --image explicitly.

Equivalent to the Python dev-tool's seif-dev --absorb.

context bootstrap

Print the verified constitutional core (grounding + axioms) from the embedded kernel

bootstrap resolves the SEIF constitutional core from the kernel embedded in this binary and verified against its canonical_hash — it does NOT read a file from a private store. Use it on demand AFTER the grounding challenge to load the behavioral axioms; the full human+AI reference is SEIF.md.

seif context bootstrap # human-readable: grounding challenge + axioms seif context bootstrap --json # machine-readable constitution (protocol, axioms, pin)

Drift-immune: a tampered or stale embedded kernel makes the binary refuse to run.

context query

Lexical pre-filter over structural chunks (dogfood --refs for hybrid C)

query runs the local chunk-ref pre-filter (ChunkFile + lexical rank) over files visible in the workspace under --root (same visibility rules as absorb + CompressProject per the memo §3.1).

It emits unresolved ChunkRefs only: {anchor, path, parent_hash, score}. Never bytes (resolution + CONFIDENTIAL gate is engine/MCP only).

Use --refs --top N for the dogfood JSON output. Pure offline, deterministic, read-only, INV-THIN-CLIENT. Token regex matches absorb scorer (w/ _).

context reindex

Register forward orphan .seif artifacts in mapper.json (one-shot K4 migration)

reindex scans the sovereign .seif/ store for consumable SEIF-MODULE and SEIF-KNOWLEDGE artifacts whose on-disk path is absent from mapper.json and registers each via RegisterKnowledge (forward orphan → mapper upsert).

Ghost entries (mapper paths with no on-disk file) are left untouched by default; pass --prune-ghosts to remove them from mapper.json (this is the fix verb for the doctor mapper check). Re-pointing (K5) stays out of scope. Output destinations (Store-V2): absorb, ingest, extract → .seif/knowledge/.seif (+ mapper registration) compress → .seif/projects//code.seif (+ mapper registration) context sync → {repo}/.seif/projects//project.seif (+ mapper registration)

Every write registers the artifact in the sovereign mapper.json so it is consumable at next session-start (Φ×λ=1 — no unregistered orphans).

Default is register-only at the artifact's current path. With --relocate, legacy flat outputs (modules/.seif, extract_.seif, nucleus.seif) are copy-only relocated to .seif/knowledge/.seif with provenance; originals are never deleted (memo §8).

context retrieve

Orchestrator retrieval loop (local refs → engine slices)

retrieve runs the token-economy retrieval loop for code/doc lookup:

1. LOCAL (always): lexical chunk-ref prefilter — anchor/path/score only, never bytes.
2. ENGINE (unless --refs-only): POST /v1/retrieve-chunks with classification gate; returns resolved byte slices. Fail-soft: ~5s timeout, then degraded local refs.

Workspace ID: --workspace-id, $SEIF_WORKSPACE_ID, or engine binding from workspace marker. Engine URL: --engine-url or$SEIF_ENGINE_URL (default http://localhost:7331 for this verb). Auth: --token, --token-file, $SEIF_ENGINE_TOKEN, session token, or ~/.seif/serve_token.

context sow

Plant a garden's structural roots: conduct roots + the coherence layer

sow plants the structural roots a healthy SEIF garden is born with — the same step seif init runs at workspace creation, runnable standalone to equip an existing garden or recover a lost/corrupted store:

1. Conduct roots → .seif/memory/ — the curated process-feedback memories that bridge the grounding kernel into situated action ("measure the ground truth before hypothesizing", "a merge is not a deploy"). They surface at session_orient like any memory.
2. Coherence layer → .seif/coherence/ (PIR + graph) + .seif/memos/ — the garden's starter constitution (universal SEIF-governance invariants) so seif gov memo works from day one.

Idempotent and non-destructive: existing conduct roots are left as the garden evolved them, and an existing PIR/graph is NEVER overwritten. --force re-syncs existing CONDUCT ROOTS to canonical content (the coherence layer is never clobbered); --dry-run previews without writing.

context sync

Re-extract git context into .seif/projects//project.seif

sync extracts git metadata (commits, manifest, README, structure) from [path] (default: cwd) and writes a SEIF-MODULE-v1 summary to .seif/projects//project.seif (the repo-local git-context module, single-writer per DESIGN-MEMO-2026-05-30 §2.1). Updates the sovereign mapper.json index when reachable. Output destinations (Store-V2): absorb, ingest, extract → .seif/knowledge/.seif (+ mapper registration) compress → .seif/projects//code.seif (+ mapper registration) context sync → {repo}/.seif/projects//project.seif (+ mapper registration)

Every write registers the artifact in the sovereign mapper.json so it is consumable at next session-start (Φ×λ=1 — no unregistered orphans).

Equivalent to the Python dev-tool's seif-dev --sync.

contribute

Capture a signal: classify + sign stdin, append to .seif/contributions/.jsonl

contribute reads stdin, classifies the content (auto by default), builds a signed SEIF evidence frame, and appends one compact-JSON line to .seif/contributions/.jsonl in the workspace.

No engine call — the contribution lives entirely in the local workspace and is signature-verifiable offline.

Signing key: --key-file or $SEIF_SIGNING_KEY (base64 Ed25519 64-byte secret). Workspace ID: --workspace-id (default "ws_local").

Classification: pass --classification PUBLIC|INTERNAL|CONFIDENTIAL to override the auto-classifier (Wave 4 heuristics). Auto-classification escalates to CONFIDENTIAL when sensitive markers or keywords are present.

daemon adopt-legacy

Re-home legacy launchd seif daemons as capability legs (dry-run; --apply; stays PAUSED)

adopt-legacy scans ~/Library/LaunchAgents for the paused seif coordination daemons and wires each one's EXACT command as the matching capability's leg, so the daemon supervises the existing scripts instead of launchd. It re-homes; it does not reimplement, and it does NOT enable anything — every capability stays PAUSED, so this changes no behavior until you run seif daemon enable <cap>.

Mapped: com.seif.circuitd→circuit, com.seif.claude-responder→responder, com.seif.hub→hub, com.seif.peer-drainer→peer-drainer, com.seif.context-sync→context-sync, (com.)seif.personal-sync→personal-sync. Infra plists (docker, cloudflared, engine, health, …) carry no mapping and are never adopted.

Without --apply this is a DRY-RUN. With --apply the legs are written to daemon.json (still paused).

daemon clear-command

Remove a capability's leg (revert to pure toggle)

daemon disable

Disable a capability (record --reason)

daemon down

Stop a running daemon (or reap a stale socket)

daemon enable

Enable a capability

daemon publish

Publish a real-time event to the daemon bus (R2)

daemon set-command

Declare the leg command the daemon runs for a capability

daemon status

Show capability toggle state + daemon liveness

daemon subscribe

Stream real-time events for a topic (R2)

daemon up

Lazily spawn the daemon host process

debate

Multi-AI debate: ask several models, measure agreement, synthesize [free, local]

debate orchestrates a multi-AI consensus over a question using the models you already have — local Ollama, an installed Claude/Gemini CLI, or your own API key (ANTHROPIC_API_KEY / XAI_API_KEY). It is FREE and LOCAL: SEIF never supplies the inference and never gates the feature; you bring your own model access.

Round 1 collects independent answers and measures Jaccard coherence between them. --rounds 2 adds a cross-examination pass (each model critiques the others and refines); --rounds 3 adds a synthesis pass (the dominant voice unifies the debate). Each answer is graded by the native quality gate.

Classification routing protects your data: CONFIDENTIAL forces local Ollama only (nothing leaves the device); SECRET is refused outright.

Examples: seif debate --list seif debate "Should we adopt trunk-based development?" seif debate "design X" --rounds 3 --backends ollama_local,claude_cli seif debate "private notes" --classification CONFIDENTIAL

diff

Compare two SEIF artifact-local refs (free, local)

diff compares two .seif/ artifact refs in ARTIFACT-LOCAL mode (Phase B-early per DESIGN-MEMO-2026-05-26-seif-diff-and-time-trail-log §3).

Refs (Q-DIFF-4 — typed artifacts only): cycle: sealed or open cycle memo: DEFERRED (markdown memos route to git diff for now) pending: pending module (subdir + flat-root shim-aware) decision: ratified decision module

Output formats (Q-DIFF-3): --output unified git-diff-style unified text (default) --output structural-json AI-consumable {added,removed,modified} shape --json emit machine-readable result regardless of --output

Workspace-mode (Phase B-mid — Q-DIFF-2 ratified 2026-05-27): workspace@HEAD current shadow object-model workspace@HEAD~N walk N parents back through delta-log workspace@ 12-hex prefix (>=4) of a recorded rev_id workspace@ newest rev recorded on/before the named date

Not yet shipped: cycle:@ revision-pinning needs object-model wiring

INV-THIN-CLIENT: this verb runs entirely against local .seif/ — zero engine roundtrip, no quota, free tier.

doctor

Diagnose workspace + runtime install health — one read-only report [free, local]

doctor aggregates the SEIF workspace checks into one read-only report: stale OPEN cycles, orphaned writer sessions (class-c), MEMORY.md index integrity, mapper ghost modules, and active claims — plus the machine RUNTIME checks: PATH seif vs the binary the Claude hooks invoke (shadow install), dead shims (--version probe), binary freshness across installs, and legacy hook entries in ~/.claude/settings.json.

It mutates nothing — each finding points at the verb that fixes it (e.g. seif gov cycle gc, seif heal, seif context reindex --prune-ghosts, seif runtime heal). Runtime install drift is a FAILURE: doctor exits nonzero on it (store-level warnings stay exit 0). Free and local, no engine.

embed verify

Verify an embedded C2PA manifest (signature + hard binding)

verify extracts the C2PA manifest from a media file and checks the signature over the claim and the hard-binding hash over the asset bytes. It reports the signer, but does NOT evaluate trust-list membership — a sovereign self-signed key is reported as untrusted, which is expected.

extract

Extract knowledge from files/dirs into a SEIF module

extract scans a file or directory, pulls text / JSON-structure / code-signatures from supported files, classifies them, and writes a SEIF-KNOWLEDGE-v1 unit to .seif/knowledge/.seif, registered in the mapper so it is consumable at next session-start.

input_kind is resolved automatically (knowledge_extraction): prose-dominant input → prose (the native quality gate runs); code-dominant → code_sketch (gate skipped). The output slug is git-root-aware (--name to override); an existing module from the same source needs --force to overwrite.

--classification sets the ceiling: files above it (e.g. CONFIDENTIAL when the ceiling is INTERNAL) are excluded. PDF extraction is not supported. Output destinations (Store-V2): absorb, ingest, extract → .seif/knowledge/.seif (+ mapper registration) compress → .seif/projects//code.seif (+ mapper registration) context sync → {repo}/.seif/projects//project.seif (+ mapper registration)

Every write registers the artifact in the sovereign mapper.json so it is consumable at next session-start (Φ×λ=1 — no unregistered orphans). Slug derivation (git-root-aware): Slugs combine the git repository basename with the target path so same-named subdirs in different repos stay distinct — e.g. repo-a/docs → repo-a-docs, repo-b/docs → repo-b-docs. Override with --name on any verb.

ingest: --name is required for stdin/raw string sources; file paths derive the slug from the filename when --name is omitted. Image binding (--image): Every knowledge unit belongs to one workspace image (never Pod-global). Resolution order: explicit --image > workspace.seif.json container.name (walk-up from cwd) > git-root basename (standalone). In a multi-image Pod (SEIF_POD_CONTEXT=pod) with no resolvable image, verbs fail closed — pass --image explicitly.

gate check

Run a discipline gate check on stdin JSON or an explicit command

check is the dispatcher hooks call from PreToolUse. Three modes:

seif gate check --shell --json Reads {tool, path, command} JSON from stdin (Claude Code shape: {tool_name, tool_input: {command|file_path|...}}). Routes to the shell scanner. Emits a JSON decision envelope on stdout. Exit 0 = allow, 2 = deny.

seif gate check --shell Direct invocation for testing / one-off CI checks. Emits the block message on stderr; exit 0/2.

seif gate check --classification --json Same JSON shape but routes to the classification scanner. The hook passes the file_path + content/new_string fields; the scanner dispatches on extension (.py / .md / .json / .ts / .tsx / fallback). Exit 0/2; the reason lands on stderr (text mode) or in user_message/agent_message (JSON mode).

Both modes share the same exit-code contract — 0 allow, 2 deny — so the embedded bash shims can substitute the verb wherever they previously called the Python shell_gate_cli.

gate classify

Classify a file's sensitivity tier; --strict applies sensitivity-based escalation

classify reports the classification tier (PUBLIC | INTERNAL | CONFIDENTIAL) of a file's contents. By default it prints the base tier (protocol.Classify).

With --strict it applies the strict-mode wrapper (gate.ClassifyStrict): the base verdict escalates one tier when the density of soft-sensitivity signals crosses an internal threshold. Strict mode only ever escalates — never de-escalates, never skips a tier.

gate emit-block

Print the canonical block message for a reserved .seif// and exit 2

emit-block is the Go-side replacement for emit_block.py — the helper classification-gate.sh calls when refusing a raw Write/Edit on a reserved subdir. Prints the per-subdir gov/flag remediation block on stderr, exits 2. Used by the embedded bash shims to drop the Python dependency on the hard-block path. Unknown subdir → generic block message, still exit 2.

gate quality

Measure text quality natively, or blend caller-supplied scores [free tier]

quality computes a score, grade, and status for a piece of text.

With TEXT (positional argument or --text) it MEASURES natively: internal/resonance scores verifiability (stance, 6/9) and coherence (hedging, 3/9) and composes the H(0) blend bit-identically to the Python reference — free and offline, no engine roundtrip.

With --pro, it calls the SEIF engine (POST /v1/quality/assess) to get a signed, logged, and tier-gated verdict with a full component breakdown. Requires Pro tier authentication.

With no text it runs the Wave B Lite arithmetic blend (gate.Assess) over the scores you supply via --stance/--resonance(/--hedging); offline there is no stance breakdown, so flags/suggestions stay empty unless text is measured.

Weights: default two-component (stance 6/9, resonance 3/9). With --three the equal-weights variant (3/9, 3/9, 3/9) blends stance + resonance + hedging.

gov amend

Append an _amendments[] entry to a SEIF JSON artifact (append-only, no re-sign) [free]

amend appends a provenance-stamped entry to a SEIF artifact's _amendments[] list — the sanctioned escape hatch for cycles, sessions, seeds, pending modules, and memos that the classification gate blocks from raw edits.

It is APPEND-ONLY: it never re-signs or recomputes the artifact's integrity_hash (amendments are out-of-band by design — they record a change without re-signing a host artifact that may be offline or immutable). Existing key order is preserved; the output matches the Python dev-tool byte-for-byte.

Raw-markdown memos (.md with no JSON body / frontmatter envelope) cannot hold a JSON _amendments[] array, so they are amended by appending a '## _amendments' markdown section (one block per amendment, body above untouched) — the same --entry fields and provenance auto-fields apply.

The entry is a JSON object supplied via --entry (inline) or --entry-file (path, or '-' for stdin). These auto-fields are injected only when absent: id amend-NNN- (override with --id) appended_at current UTC timestamp appended_by --author, else $USER, else "anonymous"

Local-only — free tier.

gov cycle close

Seal the open cycle + clear the host pointer [free]

gov cycle close-ritual

Run the full 7-step closure ritual locally [free]: checkpoint→audit→quality→meditate→absorb→seal →seed

close-ritual runs the canonical 7-step closure ritual (CHECKPOINT, AUDIT, QUALITY, MEDITATE, ABSORB, CIRCLE, SEED) for the named cycle, honoring the EXPLICIT + --track. Every step is LOCAL and FREE — no engine, no token — at parity with the Python dev-tool.

QUALITY grades --summary with the CLI's native, language-stable resonance math (stance 6/9 + hedging 3/9, ζ-grounded grades); the engine's fragile multilingual triple-gate is intentionally NOT used. The load-bearing step is CIRCLE (the hardened cycle seal); analytical steps are non-fatal. Use --dry-run to preview.

gov cycle decision-add

Bind a decision to a cycle: cycle.decisions[] += id + decision.cycle_ref (D8) [free]

decision-add records the bidirectional decision↔cycle edge (c260 D8=C). It appends the decision's module_id to the cycle's decisions[] list and sets the decision's cycle_ref to the cycle id. Both halves are written so 'seif audit-coherence' (the D8 integrity check) sees a coherent edge. Idempotent: a decision already bound to this cycle is a no-op; binding it to a DIFFERENT cycle is refused.

gov cycle gc

Garbage-collect stale OPEN cycles (dry-run by default) [free]

gc finds OPEN cycles that should be archived or swept, and (with --apply) acts on them:

• leftovers : a -OPEN.seif whose cycle is already SEALED (a stale APFS/sync copy) is SWEPT (removed).
• variants : a -OPEN-.seif (excluding -OPEN-archived.seif) whose cycle is already SEALED is ARCHIVED to cycles/archive/ (preserves pause-rename state; not unlinked like plain leftovers).
• stale : a live -OPEN.seif with no SEALED sibling, NOT named by the host active-cycle pointer, older than --threshold-days (default 7), is ARCHIVED (renamed → -OPEN-archived.seif). An unparseable opened_at is treated as stale.

Without --apply this is a DRY-RUN: it reports what WOULD happen and mutates nothing. With --apply it renames/removes the files and appends one JSONL provenance line per action to .seif/audit/cycle_gc.jsonl. Cycle CONTENT is never modified — only whole files are moved/removed.

gov cycle list

List cycles in .seif/cycles/ (alias for seif admin cycle list; filter with --status)

gov cycle open

Open a new cycle + bind the host pointer [free]

gov cycle set-manifest

Update OPEN cycle title, vision, branches [free]

set-manifest patches the OPEN cycle manifest (title, vision, branch_add, branch_done).

gov decision create

Create a SEIF-DECISION-v1 module skeleton [free]

create emits the minimum-viable SEIF-DECISION-v1 skeleton in .seif/modules/decisions/. With --from-memo PATH the decision is derived from a design memo: slug, title, and ratification hash are auto-populated from the memo file and its coherence-graph node. Body fields are appended via 'seif gov amend' entries.

gov decision promote-retroactive

Retroactively derive decisions for a curated top-N backlog of memos (D4) [free]

promote-retroactive (c264 IMPL-7, c260 D4=B) reads a curated critical-decisions backlog and derives a backing SEIF-DECISION-v1 for every listed memo that does not already have one. The backlog is a JSON file:

{ "entries": [ {"memo_ref": ".seif/memos/DESIGN-MEMO-YYYY-MM-DD-.md", "rationale": "why this is load-bearing", "classification": "INTERNAL", "allow_non_ratified": false} ], "curated_by": "owner+orchestrator", "curated_at": "YYYY-MM-DD" }

Dry-run by default — it prints what WOULD be created. Pass --apply to write the decisions. Entries already covered by an existing decision are skipped.

gov invariant add

Append a new invariant to the PIR [free]

add appends a new invariant to .seif/coherence/product-invariant-registry.seif.

The id must match INV-* and be unique; --tier must be a member of the registry's tier_priority; --statement is required. Status defaults to STARTER-UNRATIFIED (owner ratification is applied later via 'gov invariant amend' under the owner gate). A provenance entry is appended to _amendments[] (who/when).

gov invariant amend

Append an append-only _amendments[] entry scoped to an invariant [free]

amend appends a provenance-stamped entry to the PIR's _amendments[] list, scoped to an existing invariant (the entry's "inv" field is set to when absent). It is APPEND-ONLY: it never rewrites an invariant's statement in place (the audit trail is preserved). Mirrors 'gov amend' semantics.

The entry is a JSON object via --entry (inline) or --entry-file (path, or '-' for stdin). Auto-fields id/appended_at/appended_by are injected when absent.

gov memo classify

Classify a memo as load-bearing or not (decision-required gate) [free]

gov memo coherence-register

Create/refresh a memo's coherence node WITHOUT rewriting the .md [free]

coherence-register is the node-only counterpart to new/update: it creates or refreshes the coherence-graph node of an EXISTING memo without requiring --content. Use it for edge/status/note-only changes (which 'update' would force full --content for) and to register a node for a memo that is missing one. --constrained-by (>=1 INV-*) is mandatory only when CREATING a new node.

gov memo new

Write a new design memo + register its coherence node [free]

gov memo ratify

Ratify a memo in one step: flip status to RATIFIED + derive its decision [free]

ratify is the one-step path to ratify a design memo. It flips the memo's coherence-graph node to RATIFIED and derives the backing SEIF-DECISION-v1 audit anchor as a single transaction, in the order that avoids the gate deadlock between 'gov decision create --from-memo' (needs RATIFIED) and 'gov memo update --status RATIFIED' (needs a decision). If the decision write fails, the status flip is rolled back. Idempotent: a memo already RATIFIED with a backing decision is a no-op; a RATIFIED memo missing its decision is repaired (decision derived).

gov memo update

Rewrite an existing memo + optionally update its coherence node [free]

gov memory add

Create a memory (.md + MEMORY.md pointer) locally [free tier]

Write a new memory file and insert its MEMORY.md pointer alphabetically under the section derived from the frontmatter type:. Local-only — free tier writes memory locally; cloud sync/validation is the paid tier.

gov memory audit

Audit .seif/memory/ ↔ MEMORY.md integrity

gov memory audit-lifecycle

Report memory lifecycle operations from audit log

Read-only aggregate over .seif/audit/memory-lifecycle.jsonl.

gov memory delete

Hard-delete a memory with conjugate-pair confirmation [gated]

DELETE tier (A18): irreversible removal of .md + pointer after a second actor confirms (--conjugate-confirm). Content SHA-256 is recorded in audit. For provenance tombstone use gov memory purge.

gov memory flag

Flag a memory for accelerated decay [architect]

FLAG tier (A18): apply 2× relevance decay without deleting content. Sets flagged:true in frontmatter and logs to memory-lifecycle audit.

gov memory purge approve

Approve a pending purge request

gov memory purge execute

Execute purge after cooling + approvals

gov memory purge status

Show pending purge request status

gov memory remove

Deprecate a memory (reversible; file kept) [free]

DEPRECATE tier (A18): mark .seif/memory/.md deprecated, move its MEMORY.md pointer to ## Deprecated, and append an audit row. The file is NOT deleted — irreversible erasure is gov memory purge (PR-2).

BREAKING: prior releases hard-deleted on remove. Handles canonical (file+pointer), dangling (pointer only), and orphan (file only). --force-noop makes an absent slug a no-op (exit 0). Rate limit: 5/month/actor.

gov memory security-purge

Immediate security-exception purge [gated]

Security exception (A18): declarer ≠ executor, immediate purge + tombstone, must be ratified by a second party within 24h via security-ratify.

gov memory security-ratify

Ratify a security-exception purge within 24h

gov memory update

Replace a memory's content + refresh its MEMORY.md pointer [free tier]

Atomically rewrite an existing memory and refresh its MEMORY.md pointer. Idempotent: identical content + pointer is a no-op.

gov orchestration init

Create default .seif/orchestration.json when missing

gov orchestration set

Update registry fields (maestro, dispatch mode)

gov orchestration show

Show .seif/orchestration.json

gov pending consume

Mark a registered pending module consumed [free]

gov pending consume-path

Consume a pending module by filesystem path [free]

consume-path marks a module consumed without requiring a registry entry. Updates the module status in-place (free, local). To also relocate the artifact into the resolved/ dir, run "seif store move" after consuming.

gov pending create

Create a SEIF-PENDING-v1 module skeleton in .seif/modules/pending/ [free]

create emits the minimum-viable SEIF-PENDING-v1 skeleton. After creation use 'seif gov pending register ' to index it in the global registry so it surfaces in pending lists.

gov pending list

List pending modules (current workspace + owner-targeted) [free]

gov pending quarantine

Quarantine a pending module (move to modules/_quarantine/) [free]

gov pending register

Register a pending module into the global registry [free]

register indexes a SEIF-PENDING module file into ~/.seif/registry.json so it surfaces in pending lists. Required module fields: module_id, target_consumer. Visibility is --visibility, else the module's "visibility", else inferred: under ~/.seif → personal; under a workspace .seif/ → team.

Canonical usage: seif gov pending register [--visibility personal|team]

gov seed consume

Print a seed and mark it consumed (writes a .consumed_at sidecar)

gov seed create

Write a new SEIF-SEED-v2 seed file [free]

gov seed list

List seeds in .seif/seeds/ (active vs consumed)

gov session close

Close session (deferred — use dev-tool or MCP)

gov session contribute

Append a message to the conversation payload (SEIF-CONVERSATION-v1)

gov session create

Create a SEIF-SESSION-v1 contract (explicit only — not auto-created by hooks)

create materializes a session contract on demand. Hooks, session_orient, and ambient MCP calls do NOT create sessions — only this verb (or MCP seif_invoke action=session_create) when an agent or human explicitly requests it.

gov session list

List SEIF-SESSION-v1 session-*.{json,seif} files [free]

gov session log

Print the conversation payload (messages + sync points)

gov session seal

Seal an ACTIVE/CLOSED session contract → SEALED (≠ close; mirrors --session-seal) [free]

seal transitions a SEIF-SESSION-v1 contract from ACTIVE or CLOSED to SEALED, stamping sealed_at / sealed_by / host (and closed_at + duration when the record was still ACTIVE). With an explicit session-N it seals that record; with no argument it seals the single ACTIVE/CLOSED record (highest session_number when several qualify). When the tiered layout (sessions/active/) is in use the sealed record is moved to sessions/closed/.

Unlike 'gov session close' (deferred to the engine), seal is a local terminal state-transition on an existing contract — the Go port of 'seif-dev --session-seal'.

gov session show

Print a session contract [free]

heal

Self-heal workspace cycle/session coherence (dry-run by default) [free, local]

heal repairs the class-(c) coherence violation: a SEALED cycle whose declared writer session is still sitting in .seif/sessions/active/. It MOVES that session into .seif/sessions/sealed/<cycle_id>/ — move-not-delete (nothing for a sync to undo), idempotent, and the session body is preserved as audit evidence. Pure local and deterministic: no engine, no model, no token.

Dry-run by default — reports what WOULD be healed. Re-run with --apply to perform the moves (one JSONL provenance line per move under .seif/audit/cycle_heal.jsonl).

how

Find the most relevant SEIF verbs for a natural-language intent [free, local]

how ranks the shipped capability catalog by lexical overlap with your intent and returns the top verb-docs (verb · one-line summary · key flags · example).

Offline, free, no classification gate — the long-tail fallback behind the static capability map injected at session start. When a local embedding backend (Ollama) is available it adds a semantic rerank on top of the lexical match; otherwise it stays purely lexical. Use --lexical to force the offline ranker.

Examples: seif how "pick up the next queued task" seif how "devolver trabalho ao orquestrador" --json

inbox disable

Remove a receptor registration

inbox enable

Register this workspace as an inbox receptor on a named engine

inbox list

List all configured receptors (merged view)

inbox status

Query the engine for pending inbound artifacts addressed to the receptor

ingest

Append external prose into a SEIF-KNOWLEDGE-v1 unit via the native quality gate

ingest reads external text (a file path, a raw string, or "-" for stdin) and contributes it into a SEIF-KNOWLEDGE-v1 unit under .seif/knowledge/.seif as a new hash-chained version (self-bootstrapping the unit if absent).

The native quality gate (6/9 stance + 3/9 coherence) measures the prose and records a quality_assessment on the unit; weak content is contributed with a warning, never blocked. input_kind is always prose — a code_* override is ignored with a warning.

project.seif is the workspace's git-context module and is single-writer (refreshed only by seif context sync); ingest refuses to target it.

This is the OFFLINE deterministic path: it contributes the text as given. AI relevance filtering (extract only what is relevant to this project) routes through the engine and is not part of the free offline core.

Self-bootstrap: if .seif/knowledge/.seif is absent, ingest creates it. Output destinations (Store-V2): absorb, ingest, extract → .seif/knowledge/.seif (+ mapper registration) compress → .seif/projects//code.seif (+ mapper registration) context sync → {repo}/.seif/projects//project.seif (+ mapper registration)

Every write registers the artifact in the sovereign mapper.json so it is consumable at next session-start (Φ×λ=1 — no unregistered orphans). Slug derivation (git-root-aware): Slugs combine the git repository basename with the target path so same-named subdirs in different repos stay distinct — e.g. repo-a/docs → repo-a-docs, repo-b/docs → repo-b-docs. Override with --name on any verb.

ingest: --name is required for stdin/raw string sources; file paths derive the slug from the filename when --name is omitted. Image binding (--image): Every knowledge unit belongs to one workspace image (never Pod-global). Resolution order: explicit --image > workspace.seif.json container.name (walk-up from cwd) > git-root basename (standalone). In a multi-image Pod (SEIF_POD_CONTEXT=pod) with no resolvable image, verbs fail closed — pass --image explicitly.

Equivalent to the Python dev-tool's seif-dev --ingest (no-AI path).

init

Initialize a SEIF-WORKSPACE-v2 workspace in the current directory

init scaffolds a SEIF-WORKSPACE-v2 workspace at [path] (default: cwd): workspace.seif.json — container marker (workspace_id, share_allowlist, members) .seif/{memory,modules,cycles,seeds} — sovereign store skeleton .seif/config.json — thin local config

When [path] is inside an existing v2 container, init writes .seif-pointer.json instead of a local scaffold (sub-project membership).

This is the local free-tier workspace — sign and sync work against it immediately once you have an engine token. Next: seif key generate then seif sign <file>.

Use --lite for a minimal SEIF Lite layout (README.md, AGENTS.md, .seif-lite/{BOOT.md,refs.md}, session-log.md, decisions-pending.md) — no kernel, no signing. Upgrade it later with seif workspace upgrade-lite.

key generate

Generate an Ed25519 signing key under ~/.seif/keys/

key show

Show the public key + key path

link add

Register a peer workspace (creates stub import if missing)

link export-list

List configured SEIF-LINK exports

link import-pull

Pull a scoped, read-only export from a linked peer (SEIF-LINK phase B, §7.10)

import-pull resolves one import binding from orchestration.json against a linked peer and materializes the peer's scoped, ceiling-filtered export subtree READ-ONLY under its mount_as namespace.

Flow (login-required; the engine emits the manifest, the existing pull blob chain writes the blobs from the shared CAS):

1. POST /v1/workspaces/{id}/links/{peer}/import-pull -> a scoped manifest (conflict:false) or a re-pull conflict report (conflict:true).
2. clean -> fetch each entry blob, verify its sha, write read-only (0o444) under mount_as (quarantined; never folded into authored content).
3. conflict-> print the upstream/local divergence and REFUSE (non-zero exit, no write). The owner resolves manually (A26).

The peer and its import bindings come from orchestration.json peers[].imports[]. --from selects the binding by export name; it may be omitted when the peer declares exactly one import.

Auth sources (priority): --token VALUE | --token-file PATH | $SEIF_ENGINE_TOKEN | ~/.seif/session_token (seif login) Engine URL (priority): --engine-url URL | orchestration.json sync.engine.url |$SEIF_ENGINE_URL | https://api.seifprotocol.com Importer ID (priority): --workspace-id ID | orchestration.json sync.engine.workspace_id | workspace.seif.json

log get

Fetch a single transparency-log entry by id

log list

List recent transparency-log entries

log ping

Probe the configured log endpoint (/healthz)

log verify

Independently verify an entry's inclusion proof

Fetches the entry + the log's public key, then runs the local RFC-6962 inclusion + Ed25519 STH verification (translog.Verify). The engine's "verified" flag is never trusted on its own.

login

Authenticate with the SEIF engine and store credentials

Opens GitHub OAuth against the engine, captures the session token on localhost, and saves it to ~/.seif/session_token (mode 0600).

After login: seif workspace create , then mint an API key at /dashboard/settings (customers) or seif auth api-key create (operators, Python).

logout

Clear stored SEIF engine credentials

Removes ~/.seif/session_token and ~/.seif/api_key if present.

mcp serve

Run the SEIF MCP server over stdio (or Streamable HTTP with --http)

memory proposals

List pending memory proposals awaiting review [free, local]

memory propose

Propose a memory for owner review (autonomous-memory curation) [free, local]

propose records a candidate memory as PENDING under .seif/proposals/. The owner later runs 'seif memory proposals' to see them and 'seif memory review' to approve (absorb as a real memory) or reject. This is the AI-self-proposes / owner-ratifies loop — free and local, no engine.

memory query

Recall the most relevant memories + absorbed knowledge for a query [free, local]

query ranks your .seif/memory entries AND absorbed knowledge modules (including debates persisted via 'seif debate --absorb') by lexical relevance to the query text. Pure local and offline — no embeddings, no engine, no token.

This is the recall half of autonomous durable memory: the AI absorbs knowledge, it decays over time, and query brings the relevant pieces back.

memory reindex

Rebuild the derived semantic embedding cache for memory query

reindex pre-computes Ollama embeddings for all memory (+ knowledge) documents and stores them under .seif/.cache/memory-embeddings/ (rebuildable derived state).

Run when session-start surfaces [MEMORY EMBEDDINGS] STALE or before heavy --semantic query workloads. Requires local Ollama with an embedding model.

memory review

Approve (absorb) or reject a pending memory proposal [free, local]

memory surface

Emit capped cross-AI memory bootstrap from .seif/memory/MEMORY.md

Emit a capped (budgeted) cross-AI memory bootstrap surface.

This is the Go thin-client implementation of the Python seif-dev --memory-surface. It delivers functional parity for session bootstrap across AI clients without invoking the genesis Python dev-tool at runtime (INV-THIN-CLIENT).

The surface includes:

• Recent entries (by mtime within --days window) first
• Full index (alpha) for older entries
• Integrity note when orphans exist (run seif gov memory audit)
• Truncation footer with guidance to increase budget

Output formats: text (default, human/MCP-friendly markdown) or json (machine).

Examples: seif memory surface seif memory surface --max-chars 4096 --format json seif memory surface --days 14 --workspace /path/to/workspace

objectmodel build

Compute the merkle tree over .seif/ and write the shadow store

objectmodel build — content-addressed merkle build.

Walks /.seif/, hashes each artifact via the parity-locked HashArtifact dispatch (SCOPE_V3 envelopes / SCOPE_V2 JSON dicts / raw blobs), composes the tree-of-trees, and writes the shadow at /.seif-object-store/. Idempotent — re-running on an unchanged workspace re-emits the same on-disk bytes.

Exit codes: 0 success 1 scope/hash error 2 no .seif/ at workspace

objectmodel preflight

Run client-side write-path gates (G0, secret-scan, G1, G3)

objectmodel preflight — composed client gates.

Composes the client-authoritative subset of the G0-G5 pipeline: G0 substrate — nucleus.git_head matches the current .seif/ store HEAD secret-scan — no secret VALUES in the staged .seif/ diff G1 coherence — cycle audit reports 0 HIGH G3 integrity — VerifyModel reports 0 HIGH

G2 doc-code, G4 nucleus regen, and G5 manifest signing are engine- authoritative and NOT part of the client preflight.

Exit codes: 0 all gates pass 1 at least one gate fails (blocked_by populated)

objectmodel verify

Re-hash the live store and compare to the shadow nucleus

objectmodel verify — drift detection.

Re-builds the merkle tree from the live store and compares to the shadow's mapper + nucleus. Reports root-drift, missing-object, hash-mismatch, and stale-object findings.

Exit codes: 0 clean (or MEDIUM-only findings) 1 HIGH severity drift 2 no shadow built

open

Open SEIF Desktop on a workspace (local cockpit)

Resolve path to a SEIF workspace/container root and launch (or focus) SEIF Desktop.

Default path is the current directory. Pointer members resolve to the container root. When the path is not a SEIF workspace, exits with code 2 and does not launch the app.

Remote mode (--remote --remote-workspace ) skips local workspace resolve, preflights SSH (exit 4) and remote .seif/ (exit 5), then spawns the desktop with --remote-host and --remote-workspace only (no loopback port/token).

Use --print-shim to emit a shell function so literal seif . works as seif open ..

Examples: seif open . seif open /path/to/project seif open --remote my-server --remote-workspace /path/to/workspace eval "$(seif open --print-shim)" # install shim in ~/.zshrc

orchestrate init

Create default orchestration.json if missing

orchestrate status

Show orchestration.json summary

pod add-workspace

Add a workspace to a pod's composition (D2)

Adds a workspace ref to the pod manifest (POST /v1/pods/{id}/workspaces).

Manifest-CRUD only — this relates the workspace into the pod; it does not materialize. Run 'seif push' (or 'seif compose push') to materialize, exactly as before (anti-syncopathy: /v1/sync stays the one orchestrator).

The workspace may be given as an engine workspace_id (ws_) or a slug resolved against your workspace list.

pod bind

Bind this local workspace to an existing engine pod

Attach the local .seif workspace to an EXISTING pod — the pod analogue of 'seif workspace bind': you created the pod on the web/engine, now point your local folder at it.

<pod_id> accepts a namespace (user-slug/pod-slug) or a bare pod slug. The ref is resolved against your signed-in pod list; use --force to skip verification (e.g. offline), binding the ref verbatim.

Writes engine_pod_id into the nearest workspace.seif.json, so pod-scoped verbs need no --pod afterwards. Idempotent: re-binding the same id is a no-op; binding a different id rebinds.

To create a NEW pod instead, use 'seif pod create '.

pod create

Create a pod on the engine (like gh repo create, but for a pod)

Creates a pod slug under your account. The slug is alphanumeric with optional hyphens. Pods do not count against the free-tier workspace limit.

pod list

List the pods in your account

pod remove-workspace

Remove a workspace from a pod's composition (D2)

Detaches a workspace ref from the pod manifest (DELETE /v1/pods/{id}/workspaces/{workspace_id}). Idempotent — removing a non-member is a no-op. The workspace itself is untouched.

pod show

Show one pod by its namespace (user-slug/pod-slug)

publish

Sign locally and publish to the transparency log (sign → log → verify URL)

publish is the one-command path from a local artifact to a publicly verifiable, Merkle-logged evidence URL.

It (1) builds a locally-signed SEIF evidence frame with your workspace Ed25519 key — exactly like seif sign (sovereign: the engine never sees your secret key); (2) registers your workspace public key with the engine (idempotent); (3) submits the frame to POST /v1/evidence, which verifies your signature, appends it to the transparency log, and returns the public verify URL + log entry id.

Unlike server-side signing, publish keeps signing LOCAL. It needs an engine bearer (--token / --token-file / $SEIF_ENGINE_TOKEN / seif login) and a workspace signing key (seif key generate). Pass --workspace-id to name your registered workspace.

Examples: seif publish CHANGES.md --workspace-id ws_proj_x git diff | seif publish - --kind diff --workspace-id ws_proj_x seif publish report.txt --classification PUBLIC --quiet

pull

Materialize the workspace's remote HEAD into the local .seif/ [PAID]

pull downloads the workspace's current engine HEAD (the object-model read path) and materializes it into the local .seif/ tree.

Flow (login-required; entries classification-filtered server-side):

1. GET /v1/sync/head -> the current accepted nucleus root.
2. GET /v1/sync/manifest/{root} -> the filtered entries (path/sha/size/class).
3. GET /v1/sync/blob/{sha} per entry -> verify content sha -> write file.

Genesis (the remote has no accepted HEAD yet) is a successful no-op.

WARNING: pull overwrites local files covered by the remote HEAD. Use --dry-run to preview.

Auth sources (priority): --token VALUE | --token-file PATH | $SEIF_ENGINE_TOKEN | ~/.seif/session_token (seif login) Engine URL (priority): --engine-url URL | --remote NAME (seif remote list) |$SEIF_ENGINE_URL | https://api.seifprotocol.com Workspace ID (priority): --workspace-id ID | $SEIF_WORKSPACE_ID

--from-inbox NAME shorthand: resolves BOTH engine URL and workspace_id from seif inbox list (the receiver-side store, c273 Wave 10). Mutually exclusive with --engine-url / --remote / --workspace-id — the inbox is a bound (engine, workspace_id) tuple so accepting overrides would silently target a different receptor than the named one. Pull semantics are unchanged; only the resolution layer differs.

push

Push .seif/ workspace state to the engine mirror, gated [PAID]

push carries the workspace object-model to the engine over the gated /v1/sync write path (protocol-spec-v0 §11.1, v0.5).

What it does (thin client — s230 FASE 3, no python dependency):

1. Scans .seif/ natively and computes the push SCOPE: every non-layer-5 artifact under a share-allowlist-INCLUDED top-level entry (fail-closed).
2. Reads the engine's current HEAD (GET /v1/sync/head) as the CAS parent.
3. Submits a v0.5 manifest — flat entries[] (path, raw-content sha256, size, classification) + nucleus{parent} — uploads the blobs the engine does not yet hold, and finalizes.
4. The ENGINE rebuilds the merkle tree, runs the G0-G5 reliability gate in-process, signs the nucleus with its own key, and advances HEAD. push surfaces the engine's gate verdict.

For local store self-healing (dry-run by default), use seif sync. Engine mirror only: seif push (or seif sync --apply --push).

Auth sources (priority): --token VALUE | --token-file PATH | $SEIF_ENGINE_TOKEN | ~/.seif/session_token (seif login) Engine URL (priority): --engine-url URL | --remote NAME (seif remote list) |$SEIF_ENGINE_URL | https://api.seifprotocol.com Workspace ID (priority): --workspace-id ID | $SEIF_WORKSPACE_ID

With a single "seif login" the session token is used automatically — no --token needed. It is user-scoped: one login works for every workspace you own.

quality-gate

Score text quality via the SEIF engine [PAID]

quality-gate reads (or stdin when given "-"), POSTs the text to the SEIF engine's POST /v1/quality-gate endpoint, and renders the resulting verdict (grade, score, stance, triple-gate breakdown, flags, suggestions).

This command is a thin engine caller — the actual heuristic computation runs server-side. Requires engine authentication (Bearer token).

Auth sources (priority): --token VALUE --token-file PATH $SEIF_ENGINE_TOKEN

Engine URL (priority): --engine-url URL $SEIF_ENGINE_URL https://api.seifprotocol.com (default)

quota

Show current usage, limits, and tier [PAID — engine]

quota fetches GET /v1/workspaces/{id}/tier and renders the workspace tier plus all counter fields returned by the engine. Counter fields (signatures_used, log_entries_used, …) are iterated dynamically, so new counters added server-side (sync_ops_used, watermark_ops_used, stream_minutes_used per the s150 E4 migration) auto-display without a follow-up CLI release.

With --account (or when no workspace is resolvable) it queries the ACCOUNT-level view (GET /v1/quota) instead: your tier + per-resource usage windows, resolved from the token — available before any workspace is pushed. A workspace lookup that 404s (not yet registered) also falls back to this.

Auth sources (priority): --token VALUE --token-file PATH $SEIF_ENGINE_TOKEN

Engine URL (priority): --engine-url URL $SEIF_ENGINE_URL https://api.seifprotocol.com (default)

Workspace ID (priority): --workspace-id ID $SEIF_WORKSPACE_ID workspace.seif.json (walk-up from cwd) .seif/workspace.json (legacy walk-up)

recap

What you & your AI did — a standup / accountability narrative from the captured record

recap assembles a time-windowed narrative of workspace activity from records SEIF already captured — cycles opened/sealed, sessions, and decisions — and renders it as a daily standup, a manager report, or a changelog. The report writes itself; you don't fill a form.

Sister to seif report:

report — current-state snapshot (identity, pending, memory, audit) recap — narrative of what happened in a time window

--since accepts keywords or an explicit instant: today (default) | yesterday | week | month | Nd (e.g. 3d) | YYYY-MM-DD | RFC3339

--as selects the shape: standup (default) — terse bullets grouped by day report — grouped by day then category, with summaries changelog — flat reverse-chronological list

--for is a best-effort actor filter (events without attribution are kept, since they cannot be excluded).

Exit codes: 0 recap rendered (may be empty) 2 workspace has no .seif/ directory

reconstruct

Materialize a historical workspace tree as a hardlink farm

reconstruct walks the delta-log to rebuild the workspace shadow tree at the named rev, then materializes every blob as a HARDLINK under

<workspace>/.seif-object-store/reconstruct/<rev-id>-<pid>/

and prints that path (one line, no trailing chatter) to stdout. The farm is walkable by any tool: find, grep -r, IDE indexers — all see the historical state as a regular directory tree.

Concurrent invocations of the same rev get separate per-pid farm subdirs (Q-FARM-4) so two operators (or two pipelines) never collide.

Cleanup is MANUAL (Q-FARM-3): farms persist until seif-dev --reconstruct-gc is run, which removes any farm whose owner pid is dead.

INV-THIN-CLIENT: pure local FS — no engine roundtrip, no quota.

relay assignments

List ACTIVE handoff assignments (optionally by executor)

relay board

Relay accountability board (SEIF-RELAY-BOARD-v1)

board is the read-only actionability source for relay orchestration.

relay brief

Create .seif/relay/brief/.md with a starter template

relay claim

Claim ACTIVE ownership of a relay slug for an executor

relay close

Terminally close an assignment (or sweep stale claims)

close sets handoff status to CLOSED (idempotent). Closed assignments leave the default assignments view; use assignments --all to list them.

Bulk hygiene: close --stale --dry-run prints a table; add --confirm to apply.

relay draft publish

Write a draft to the draft/ lane and publish a draft bus event

publish writes the --note body to the reserved .seif/relay/draft/ lane with a unique name and publishes a {from,to:"*",kind:"draft",ref,draft_path} bus event. Semantics: thinking aloud, not yet a decision — peers can see drafts without it being a brief.