Find a Kin command.

Commands

• kin admit

  Admit the complete exact working tree into graph authority now

  kin admit [OPTIONS]

• kin agent

  Run a task through Kin's own agent loop, or check that it can start

  kin agent [OPTIONS] <COMMAND>

• kin allow

  Approve one blocked sensitive artifact for publication

  kin allow [OPTIONS] --reason <REASON> <PATH>

  1 option

  • --reason <REASON>

    Why this artifact is safe to publish, read by whoever reviews it

• kin approvals

  Manage change approvals

  kin approvals [OPTIONS] <COMMAND>

• kin assistant

  Manage assistant adapters

  kin assistant [OPTIONS] <COMMAND>

• kin audit

  Show audit trail

  kin audit [OPTIONS]

  5 options

  • --actor <ACTOR>

    Filter by actor ID

  • --limit <LIMIT>

    Maximum number of events [default: 50]

  • --action <ACTION>

    Filter by action type

  • --since <SINCE>

    Filter events since date (ISO 8601)

  • --scope <SCOPE>

    Filter by target scope

• kin auth

  Authenticate with KinLab for native remotes

  kin auth [OPTIONS] <COMMAND>

• kin backup

  Back up and restore complete native repository state

  kin backup [OPTIONS] <COMMAND>

• kin bench

  Run benchmarks (delegates to kin-bench binary)

  kin bench [OPTIONS] [ARGS]...

• kin blame

  Show blame (version history) for an entity

  kin blame [OPTIONS] <ENTITY>

  2 options

  • --ref <REF>

    Resolve blame against a specific ref. Accepts `HEAD`, `HEAD~N`, branch names, `branch:<name>`, imported Git commits as `git:<sha>` or bare 40-hex SHAs, and semantic changes as `kin:<id>`, `change:<id>`, or bare change IDs

  • --all-revisions

    List every file-level revision, including ones that did not change this entity

• kin branch

  Repository-v6 branch operations (see subcommand readiness)

  kin branch [OPTIONS] <COMMAND>

• kin cache

  Inspect and bound the on-disk embedding cache

  kin cache [OPTIONS] <COMMAND>

• kin capabilities

  Show which Git-replacement commands are ready on repository-v6

  kin capabilities [OPTIONS]

  2 options

  • --json

    Output the versioned capability inventory as JSON

  • --verbose

    Add the per-command notes under each matrix row

• kin checkout

  Restore an exact path or subtree from immutable repository-v6 history

  kin checkout [OPTIONS] [PATH]

  2 options

  • --path-hex <PATH_HEX>

    Byte-exact repository path as canonical lowercase hexadecimal

  • --change <CHANGE>

    Change ID (defaults to current branch head)

• kin clone

  Clone a repository

  kin clone [OPTIONS] <URL> [PATH]

  1 option

  • --repository <REPOSITORY>

    Native repository identity when URL is a peer daemon HTTP endpoint

• kin commit

  Create an exact semantic and artifact commit

  kin commit [OPTIONS]

  3 options

  • -m, --message <MESSAGE>

    Commit message; amend preserves the existing message when omitted

  • --amend

    Replace the current change with the full working state, preserving its parents

  • -q, --quiet

    Suppress progress output (only print final summary)

• kin completions

  Generate shell completions for bash, zsh, or fish

  kin completions [OPTIONS] <SHELL>

• kin conflicts

  Show the durable merge transaction held for this workspace

  kin conflicts [OPTIONS]

  2 options

  • --json

    Emit the machine-readable merge transaction record

  • --show

    Print each conflict subject's three sides as source, diffed against the common ancestor

• kin context

  Build a context pack for one entity, several, or a question

  kin context [OPTIONS] [ENTITY]...

  5 options

  • --question <TEXT>

    Build the pack from the entities this question ranks for, through kin's own locate ranking

  • -b, --budget <BUDGET>

    Token budget (8k, 16k, 32k, or custom number) [default: 8k]

  • --assistant <ASSISTANT>

    Assistant hint for tuning context pack strategy

  • --max-focals <N>

    Most focal entities a question may resolve to

  • --json

    Emit the resolved targets and the whole context pack as JSON

• kin daemon

  Inspect Kin daemons, stop them gracefully, or ask one to enrich

  kin daemon [OPTIONS] <COMMAND>

• kin dead-code

  Find dead code (whole-repo scan, or seeded by semantic query)

  kin dead-code [OPTIONS]

  3 options

  • --seed <QUERY>

    Seeded mode: run semantic_search(query) → classify each top-N candidate by incoming references → return dead-first ranked JSON. Closes the find-dead-code accuracy gap on large repos where the agent burns the tool-call cap looping search → find_references

  • --limit <N>

    Max candidates to classify in seeded mode (default 20, max 200). Ignored when --seed is not set

  • --name-pattern <SUBSTRING>

    Optional case-insensitive substring filter on the candidate entity name. Lets callers pre-narrow to a known prefix or suffix (e.g., a planted-secret tag like "_eaca1f07") without burning extra tool-call rounds

• kin deps

  Show this repository's recorded cross-repo dependencies

  kin deps [OPTIONS]

  2 options

  • --all

    Report every registered repository instead of this one

  • --json

    Output machine-readable JSON

• kin diff

  Show exact repository-v6 artifact and semantic changes

  kin diff [OPTIONS] [BASE] [HEAD]

  2 options

  • --json

    Output the exact authority-backed report as JSON

  • --full-bodies

    Carry each changed artifact's full old and new body, not just hunks

• kin doctor

  Probe first-run health and optionally apply safe repairs

  kin doctor [OPTIONS]

  6 options

  • --fix

    Apply safe automatic repairs (shell hook, MCP configs, config dirs)

  • --install-language-servers

    Install the missing language servers this build enriches with

  • --json

    Emit the machine-readable health report as JSON

  • --drift

    Compare an explicit projection observation with graph truth

  • --heal

    Rematerialize the derived projection from graph truth, DISCARDING uncommitted changes to tracked files that diverge from it

  • --reclaim-staging

    Delete the staged stores a crashed `kin init` left beside this directory and its parent

• kin eject

  Verify graph-derived projection, install exact Git, and detach Kin

  kin eject [OPTIONS]

  1 option

  • --yes

    Skip the typed "eject" confirmation

• kin embed

  Build embeddings for the current repository's entity graph

  kin embed [OPTIONS]

  4 options

  • --batch-size <BATCH_SIZE>

    Embedding batch size (entities per inference pass) for THIS pass only. Defaults to 64, or the throughput resource plan's per-chunk budget when KIN_RESOURCE_PROFILE=throughput is set. It does not change the daemon's own background queue and does not survive a daemon restart; record a durable one with `kin resources set --embed-batch-size N`

  • --max-seconds <SECONDS>

    Stop after this many seconds, persist completed vectors, and leave the rest pending

  • --rebuild

    Drop the existing vector index and re-embed every entity at the current model's dimension. Use this to migrate a repo indexed with an older model (e.g. a 384-dim index that fails against the 768-dim default)

  • --json

    Output JSON status instead of progress text

• kin exec

  Run a command in an exact graph-derived session workspace

  kin exec [OPTIONS] <COMMAND>...

  5 options

  • --shell

    Interpret the command through the platform shell instead of preserving argv boundaries

  • --keep

    Keep the session workspace after the run and defer reconcile

  • --discard

    Discard all workspace changes after the run (no reconcile)

  • --strategy <STRATEGY>

    Materialization strategy

  • --scope <SCOPE>

    Scope filter

• kin feature

  Create a feature (alias for `kin work create --kind feature`)

  kin feature [OPTIONS] <TITLE>

  1 option

  • -d, --description <DESCRIPTION>

    Optional description

• kin git

  Exact Git interoperability projections

  kin git [OPTIONS] <COMMAND>

• kin graph

  Inspect and validate the semantic graph

  kin graph [OPTIONS] <COMMAND>

• kin help

  Print this message or the help of the given subcommand(s)

  kin [OPTIONS] <COMMAND>

• kin history

  Follow a recorded change

  Show entity history

  kin history [OPTIONS] <ENTITY>

  2 options

  • --ref <REF>

    Resolve history against a specific ref. Accepts `HEAD`, `HEAD~N`, branch names, `branch:<name>`, imported Git commits as `git:<sha>` or bare 40-hex SHAs, and semantic changes as `kin:<id>`, `change:<id>`, or bare change IDs

  • --all-revisions

    List every file-level revision, including ones that did not change this entity

• kin hosted-release

  Manage hosted releases

  kin hosted-release [OPTIONS] <COMMAND>

• kin impact

  Inspect change impact

  Show downstream impact of an entity

  kin impact [OPTIONS] <ENTITY>

  5 options

  • -d, --depth <DEPTH>

    Maximum depth [default: 3]

  • --file <FILE>

    Exact repo-relative file qualifier for stable identity resolution

  • --kind <KIND>

    Exact entity-kind qualifier (for example: function or method)

  • --signature <SIGNATURE>

    Whitespace-normalized declaration signature for overload resolution

  • --json

    Emit the ranked graph-evidence report as JSON; ambiguous identities fail closed

• kin init

  Try Kin alongside Git

  Initialize a new Kin repository

  kin init [OPTIONS] [PATH]

  3 options

  • --json

    Output machine-readable JSON status instead of human text

  • --no-enrich

    Skip the cross-file enrichment phase

  • --adopt-repository-id <ID>

    Adopt an existing repository's identity instead of minting a new one

• kin intent

  Manage agent intents (locks on scopes)

  kin intent [OPTIONS] <COMMAND>

• kin languages

  List the languages Kin extracts semantics from

  kin languages [OPTIONS]

  1 option

  • --json

    Output machine-readable JSON

• kin locate

  Locate files relevant to an issue or problem description

  kin locate [OPTIONS] [TEXT]

  16 options

  • --query <QUERY>

    Additional query variant(s) for multi-query fan-out (repeatable). The primary text plus each variant are retrieved independently and their rankings RRF-fused into one deduped result. Diverse variants (identifiers, behavior, subsystem) recover more relevant files than any single phrasing. Omit for a normal single-query locate

  • --file <FILE>

    Read problem text from file

  • --stdin

    Read from stdin

  • --json

    Output JSON

  • --explain

    Include graph-native projection reasons in the output

  • --diagnose

    Diagnostic mode: enables --json --explain, adds per-stage scoring detail, entity seed dump, and timing breakdown. Compares against --gold files if provided. Use this for debugging locate quality

  • --gold <GOLD>

    Gold file paths for diagnostic comparison (comma-separated). With --diagnose, shows where each gold file appears/disappears in the scoring pipeline and why

  • --max-files <MAX_FILES>

    Max files to return (omit for adaptive sizing)

  • --ref <REF>

    Resolve locate against a specific ref. Accepts `HEAD`, `HEAD~N`, branch names, `branch:<name>`, imported Git commits as `git:<sha>` or bare 40-hex SHAs, and semantic changes as `kin:<id>`, `change:<id>`, or bare change IDs

  • --snippets

    Attach a bounded inline source snippet (signature + first body lines) to each top definition symbol. Default ON for `--json` (the agent surface), so an agent can act on the first locate without a follow-up read; force it on for any output with this flag

  • --no-snippets

    Suppress inline snippets even on the `--json` surface

  • --next

    Fetch the NEXT page of ranked entities from the previous query, reading the cursor persisted in `.kin/locate-cursor`. No retrieval re-run; pages the daemon's cached ranking. Query text is not required

  • --cursor <CURSOR>

    Fetch a specific entity page using an explicit cursor token (from a prior result's `next_cursor`). Lower-level alternative to `--next`

  • --page-size <PAGE_SIZE>

    Entities per page for the graph-native `entities` surface (`KIN_LOCATE_ENTITY_CAP` otherwise)

  • --include-tests

    Rank test-role entities alongside source. Off by default: locate demotes tests unless the query text itself reads as being about them, which is right for "where does this feature live" and wrong when you already know you are asking for a test. The response says how many test paths a default run withheld

  • --surface <SHAPE>

    Which JSON shape `--json` emits: `full` (every field, the default) or `compact` (the agent surface: id, name, kind, file, line, signature and score per hit, ranked file paths, and a `_kin` envelope naming the embedding coverage behind the ranking).

• kin locate-debug

  Debug locate results: show per-signal breakdown, rank gold files, and diagnose why targets were missed

  kin locate-debug [OPTIONS] [TEXT]

  4 options

  • --target <TARGET>

    Gold file to track (report rank and signal breakdown)

  • --task-file <TASK_FILE>

    Load query and gold files from a benchmark task JSON

  • --max-files <MAX_FILES>

    Max files to search (wider than default to find low-ranked targets) [default: 50]

  • --json

    Output machine-readable JSON

• kin log

  Show the immutable repository-v6 change log

  kin log [OPTIONS]

  2 options

  • -n, --count <COUNT>

    Maximum number of entries [default: 10]

  • --json

    Output the exact authority-backed report as JSON

• kin mcp

  MCP server commands

  kin mcp [OPTIONS] <COMMAND>

• kin merge

  Merge semantic and exact-tree changes from another branch

  kin merge [OPTIONS] <BRANCH>

  1 option

  • --json

    Emit the machine-readable merge report

• kin migrate

  Migrate an existing Git repository into graph-owned Kin truth

  kin migrate [OPTIONS] [SOURCE]

  1 option

  • --target <TARGET>

    Distinct destination (defaults to an in-place migration)

• kin note

  Manage annotations (comments, warnings, instructions, reasoning)

  kin note [OPTIONS] <COMMAND>

• kin notify

  Send a user-facing notification through Kin's own identity

  kin notify [OPTIONS] [COMMAND]

  7 options

  • --title <TITLE>

    Notification title

  • --body <BODY>

    Notification body

  • --level <LEVEL>

    Urgency: info (silent), warn (silent), or urgent (sound, breaks through Focus) [default: info] [possible values: info, warn, urgent]

  • --key <KEY>

    Suppression and replacement identity; reposting under the same key replaces the previous notification instead of stacking another

  • --cooldown <COOLDOWN>

    With --key: re-notify only after this many seconds have passed

  • --latch

    With --key: notify once, then stay quiet until `kin notify clear`

  • --json

    Emit the outcome as JSON

• kin open

  Launch an editor over an exact graph-derived session workspace

  kin open [OPTIONS] <EDITOR>

• kin overview

  Show a quick codebase overview (entity counts by kind, language, top files)

  kin overview [OPTIONS]

  2 options

  • --compact

    Compact mode: only show counts, no entity listings

  • --json

    Output all entities as JSON (for programmatic use)

• kin path

  Find the shortest routes from one entity to another over the graph's call, instantiation, reference, import and include edges

  kin path [OPTIONS] <FROM> <TO>

  8 options

  • --from-file <FILE>

    Pin the source to the entity of that name in this file (path or path suffix)

  • --to-file <FILE>

    Pin the target the same way

  • --max-depth <N>

    Hops walked between the two ends (default 6, ceiling 12); containment hops are not counted

  • --limit <K>

    Routes printed, shortest first (default 3, ceiling 25)

  • --direction <DIR>

    `forward` (from reaches to), `reverse` (to reaches from), or `either` (default; forward first, reports which held)

  • --include-type-edges

    Walk through type-annotation edges too

  • --json

    Output machine-readable JSON, `_kin` envelope included

  • --compact

    One line per hop and nothing else, sized for a prompt

• kin pipeline

  Manage CI/CD pipelines

  kin pipeline [OPTIONS] <COMMAND>

• kin publish

  Package and upload crate(s) to the kin-daemon registry

  kin publish [OPTIONS]

  3 options

  • -p, --package <PACKAGES>

    Package(s) to publish (can be repeated: -p foo -p bar)

  • --registry <REGISTRY>

    Registry URL (default: http://localhost:4219, or KIN_REGISTRY_URL env var) [default: http://localhost:4219]

  • --dry-run

    Don't actually publish, just package and show what would be uploaded

• kin pull

  Admit exact repository-v6 history from a native Kin remote and move the workspace onto it [alias: fetch]

  kin pull [OPTIONS]

  4 options

  • --remote <REMOTE>

    Remote name (defaults to the configured default native-kin remote)

  • --url <URL>

    Peer transfer base URL, overriding any configured remote

  • --ref <REFERENCE>

    Ref to admit (defaults to the repository default ref)

  • --json

    Print the negotiated outcome as JSON

• kin purge-ignored

  Retire tracked paths that ignore rules now cover. Reports without changing anything unless --confirm is given

  kin purge-ignored [OPTIONS]

  2 options

  • --confirm

    Publish the removal instead of only reporting it

  • --confirm-mass-deletion

    Accept a purge that removes more than 75% of a non-trivial tree

• kin push

  Publish exact repository-v6 history to a native Kin remote

  kin push [OPTIONS]

  4 options

  • --remote <REMOTE>

    Remote name (defaults to the configured default native-kin remote)

  • --url <URL>

    Peer transfer base URL, overriding any configured remote

  • --ref <REFERENCE>

    Ref to publish (defaults to the repository default ref)

  • --json

    Print the negotiated outcome as JSON

• kin reconcile

  Admit one exact disposable-session observation into repository-v6 authority

  kin reconcile [OPTIONS] [SESSION]

  1 option

  • --confirm-mass-deletion

    Confirm an observation that removes more than 75% of a non-trivial tree

• kin refs

  Find recorded callers

  Show upstream callers/importers/references for an entity

  kin refs [OPTIONS] [ENTITY]

  5 options

  • --kind <KIND>

    Filter relation kinds: all, calls, imports, or references (or Any for bulk mode) [default: all]

  • --bulk-json

    Bulk mode: classify many entities by reachability in one daemon call. Outputs JSON to stdout. Requires --entities

  • --entities <ENTITIES>

    Comma-separated entity UUIDs for --bulk-json. Required when --bulk-json is set

  • --compact

    If true (default) emit compact bulk-mode rows ({entity_id, has_references, reference_count, receiver_name_candidate_count}). Set --no-compact for verbose rows with name/kind/file_path/matched_kinds

  • --no-compact

    Force verbose bulk-mode rows (overrides --compact). Required for clap to accept `--no-compact`

• kin registry

  Show or manage the global Kin repository registry

  kin registry [OPTIONS] [COMMAND]

• kin release

  Cross-repo release orchestration and per-repo release snapshots

  kin release [OPTIONS] <COMMAND>

• kin remote

  Manage native and compatibility remotes

  kin remote [OPTIONS] <COMMAND>

• kin rename

  Bounded graph-native rename; unsupported cases fail closed

  kin rename [OPTIONS] <SYMBOL> <NEW_NAME>

  4 options

  • --file <FILE>

    File hint to disambiguate the target entity

  • --line <LINE>

    1-based line hint in --file; required when --column is provided

  • --column <COLUMN>

    0-based UTF-8 byte column (tree-sitter coordinate), requires --line

  • --json

    Output machine-readable JSON for editor integrations

• kin resolve

  Resolve repository-v6 merge conflicts

  kin resolve [OPTIONS] <--ours <SELECTOR>|--theirs <SELECTOR>|--base <SELECTOR>|--remove <SELECTOR>|--keep-path <PATH=ARTIFACT>|--file <PATH> <FILE>|--all-ours|--all-theirs|--do-continue|--abort>

  11 options

  • --ours <SELECTOR>

    Keep your (target branch) version of a conflicting identity

  • --theirs <SELECTOR>

    Keep the incoming (source branch) version of a conflicting identity

  • --base <SELECTOR>

    Keep the merge base version of a conflicting identity

  • --remove <SELECTOR>

    Settle a conflicting identity by dropping it from the merge

  • --keep-path <PATH=ARTIFACT>

    Settle a contested path by naming the artifact that keeps it

  • --all-ours

    Resolve all remaining conflicts keeping your version

  • --all-theirs

    Resolve all remaining conflicts keeping the incoming version

  • --do-continue

    Complete the merge after all conflicts are resolved

  • --abort

    Abort the merge and discard conflict state

  • --expect <HASH>

    Require the merge transaction to still be the one this identity names

  • --json

    Emit the machine-readable merge transaction record

• kin resources

  Inspect host/accelerator/memory resources and per-profile budgets

  kin resources [OPTIONS] <COMMAND>

• kin review

  Use evidence in review

  Run semantic review on changes, or manage review state

  kin review [OPTIONS] [CHANGE] [COMMAND]

  4 options

  • --json

    Output machine-readable JSON for editor integrations

  • --entities <ENTITIES>

    Comma-separated entity IDs to review

  • --files <FILES>

    Comma-separated file paths to review

  • --changes <CHANGES>

    Comma-separated change IDs to combine into one review

• kin rollback

  Publish an exact restoration of a previous change [alias: revert]

  kin rollback [OPTIONS] [CHANGE_ID]

  1 option

  • --feature <FEATURE>

    Roll back every change the named work item records

• kin scope

  Set, show, or clear a temporal scope for the current session

  kin scope [OPTIONS] [REF_STRING]

  3 options

  • --clear

    Clear the current scope

  • --show

    Show the current scope

  • --session <SESSION>

    Session ID (or set KIN_SESSION_ID env var)

• kin search

  Search entities in the graph

  kin search [OPTIONS] <PATTERN>

  6 options

  • --json

    Output machine-readable JSON for editor integrations

  • -k, --kind <KIND>

    Filter by entity kind

  • -l, --language <LANGUAGE>

    Filter by language

  • --show-body

    Show entity source body inline

  • --limit <LIMIT>

    Max lines per entity body (with --show-body)

  • --semantic

    Use semantic (vector similarity) search instead of name matching

• kin secret

  Manage secrets (org and repo level)

  kin secret [OPTIONS] <COMMAND>

• kin security

  Scan entity graph for security patterns

  kin security [OPTIONS]

  1 option

  • --propagate

    Trace transitive dependency vulnerabilities

• kin semver

  Analyze semver impact from immutable repository-v6 changes

  kin semver [OPTIONS] --base <BASE>

  3 options

  • --base <BASE>

    Explicit base endpoint: a ref, change, HEAD, or WORKSPACE

  • --head <HEAD>

    Explicit head endpoint (defaults to the committed workspace base) [default: HEAD]

  • --json

    Emit the machine-readable impact report as JSON

• kin setup

  Connect your existing agent

  First-time setup and health checks for the Kin system

  kin setup [OPTIONS] [COMMAND]

  8 options

  • --intent <INTENT>

    First-run intent: local, agent, editor, hosted, or advanced

  • --mode <MODE>

    Repository mode: native or compatibility

  • --shell <SHELL>

    Shell to configure: zsh, bash, or powershell

  • --auto-daemon

    Auto-start kin-daemon when entering workspaces

  • --no-interactive

    Run non-interactively using defaults or provided flags

  • --skip-mcp-check

    Skip the MCP round trip that proves each configured AI client can actually call Kin (for a scripted install with no repository yet)

  • --install-language-servers

    Install the missing language servers this build enriches with

  • --check

    Skip the wizard and only run the first-run health check

• kin shell

  Open a shell in an exact graph-derived session workspace

  kin shell [OPTIONS]

  1 option

  • --strategy <STRATEGY>

    Materialization strategy

• kin spec

  Manage specs

  kin spec [OPTIONS] <COMMAND>

• kin stash

  Seal and restore exact graph-owned workspace state

  kin stash [OPTIONS] <COMMAND>

• kin status

  Show coherent repository-v6 workspace status

  kin status [OPTIONS]

  2 options

  • --json

    Output machine-readable JSON for editor integrations

  • --wait-quiesce <SECONDS>

    Seconds to keep re-reading while embedding coverage is only momentarily unobservable, such as an embedding pass or a graph mutation batch spanning the sample. Never waits on a coverage that was observed, nor on an absence a re-read cannot clear. 0 reads once [default: 0]

• kin support

  Show graph observability

  kin support [OPTIONS]

  1 option

  • --json

    Output machine-readable JSON for editor integrations

• kin tag

  Publish an exact repository-v6 tag ref

  kin tag [OPTIONS] <TAG>

  3 options

  • --require-proof

    Block release if entities lack linked passing tests

  • --require-approval

    Require known-human approval for every reachable non-root change

  • --force

    Force release even with low coverage

• kin telemetry

  Manage local telemetry consent and the spool

  kin telemetry [OPTIONS] <COMMAND>

• kin todo

  Import inline TODOs as work items

  kin todo [OPTIONS] <COMMAND>

• kin trace

  Trace a focal entity in one shot: resolve it, show the body, and summarize nearby context

  kin trace [OPTIONS] <ENTITY>

  9 options

  • --file <FILE>

    Exact repo-relative file qualifier for stable identity resolution

  • --kind <KIND>

    Exact entity-kind qualifier (for example: function or method)

  • --json

    Output machine-readable JSON for editor integrations

  • --compact

    Render a smaller, cheaper trace tuned for assistant workflows

  • -b, --budget <BUDGET>

    Token budget (8k, 16k, 32k, or custom number) [default: 8k]

  • --assistant <ASSISTANT>

    Assistant hint for tuning context pack strategy

  • --max-lines <MAX_LINES>

    Max lines to print for any single source snippet [default: 40]

  • --nearby <NEARBY>

    Max nearby entries to print [default: 4]

  • --transitive <TRANSITIVE>

    Max transitive entries to print [default: 2]

• kin trace-data-flow

  Trace the call/data-flow chain rooted at a focal entity

  kin trace-data-flow [OPTIONS] --focal <ENTITY>

  8 options

  • --focal <ENTITY>

    Focal entity to start tracing from. Accepts a UUID or an exact entity name (resolved via the same ranking path as `graph source`)

  • --depth <N>

    Maximum traversal depth from the focal (default 3, capped at 8)

  • --direction <DIR>

    Traversal direction: `calls`, `callers`, or `both` (default both)

  • --limit-per-step <M>

    Max relations expanded per step (default 5, capped at 25)

  • --target <ENTITY>

    A symbol you are trying to reach. Neighbors from which it is still reachable inside the requested depth survive the per-step cap ahead of ones that are not, so the question decides what a narrow walk keeps instead of proximity deciding it

  • --no-bodies

    Return the chain's shape - names, kinds, roles, spans, edges - without inlining any source body

  • --max-response-chars <C>

    Serialized characters this response may occupy before the tool cuts bodies, and then steps, to fit. Defaults to the same budget every retrieval tool answers under, and is clamped to the same ceiling; the numbers live in one place, `kin_mcp::budget`, rather than being written out here to go stale

  • --include-type-edges

    Walk through a type-annotation edge to a type this repository defines. Off by default, because a shared type name otherwise joins every entity that annotates with it to every other one. A target this repository does not define stays a leaf either way

• kin traffic

  Show traffic (active intents) on a scope

  kin traffic [OPTIONS] <COMMAND>

• kin update

  Update Kin to the latest release

  kin update [OPTIONS]

  14 options

  • --skip-verify

    Skip SHA-256 checksum verification (NOT recommended)

  • --channel <CHANNEL>

    Release channel: `stable` (default) or `alpha` (latest pre-release, unstable). A mutating update saves the choice; check-only never writes it

  • --expect-version <SEMVER>

    Require the selected release to have this exact SemVer. This selects a release; it does not authenticate archive bytes. Automation must provide the complete pinned expectation tuple

  • --expect-sha <40HEX>

    Require the selected release tag to peel to this exact Kin commit. This selects the tag source; it does not authenticate archive bytes

  • --expect-archive-sha256 <64HEX>

    Require the downloaded platform archive to match this exact SHA-256. Supply it only after external cryptographic attestation verification pins firelock-ai/kin, release.yml, the release tag, and source commit

  • --check-only

    Check whether an update is available without downloading or installing it

  • --json

    Emit the check-only result as JSON

  • --ack-restart

    Verify the durable restart fence and exact installed binary identities for the release awaiting acknowledgement. Legacy markers may additionally require explicit replacement-session evidence

  • --runtime-session <KIND=PID>

    Legacy-marker live replacement proof: `daemon=PID`, `mcp=PID`, or `vfs=PID`. New stop-before-update markers reject these arguments and require no replacement session evidence

  • --set-policy <POLICY>

    Set how an available update should reach this machine and exit. `auto` (the default) installs unattended through the gated executor: it waits for a moment with no managed Kin process or agent session, defers at most a bounded window, and runs the full stop-install-acknowledge chain. `prompt` notifies with the remedy attached and waits to be told. `manual` never notifies; checks still run

  • --apply

    Bring this machine current in one gesture: install the release, acknowledge the restart fence, and repair agent configs, in that order. This is what the update notification's button runs

  • --dry-run

    With --apply: print the ordered steps and change nothing

  • --unattended

    Run the unattended executor (what the update watchdog invokes on a stale install with policy auto): evaluate the machine-activity gates, and on proceed stop every managed Kin process cooperatively and run the full --apply chain. Blocked runs persist a deferral clock instead of installing. The final stdout line is one JSON record (also appended to ~/.kin/update-ledger.jsonl) carrying the decision, reason, blocked_seconds, and window_seconds

  • --force-window

    With --unattended: apply despite the activity gates. For the watchdog once a deferred record shows blocked_seconds >= window_seconds (24h). Never overrides a recorded prompt or manual policy, only the executor's own activity gates

• kin verify

  Verify test coverage for entities

  kin verify [OPTIONS] <COMMAND>

• kin vfs

  Engage, disengage, or report the filesystem projection for this repository

  kin vfs [OPTIONS] <COMMAND>

• kin with

  Launch an assistant in an exact graph-derived session workspace

  kin with [OPTIONS] <ASSISTANT> [-- <TASK>...]

  1 option

  • --semantic-only

    Deny the assistant's native discovery tools for this launch, leaving Kin's semantic tools as the only discovery surface; the enforcement tier is printed at launch and differs per assistant

• kin work

  Manage work items (features, tasks, issues, debt, TODOs)

  kin work [OPTIONS] <COMMAND>

• kin xref

  Show federated cross-repo references (xrefs) for an entity

  kin xref [OPTIONS] <ENTITY>