tellur
sydneyvb-nl/tellur
Local-first AI code provenance: line-level attribution, PR risk reports, policy checks, and tamper-evident audit trails for AI-assisted software.
Instalação
npx convez-ai sydneyvb-nl/tellur1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
README
A tradução para o português deste README ainda está na fila.
Tellur
Local-first AI code provenance for teams shipping AI-assisted software.
Git tells you what changed. Tellur tells you how AI participated.
Tellur records AI-assisted development evidence in your repository: which agent changed which lines, what model and prompt hash were involved, whether tests ran, and whether sensitive changes need human review. It is open source, local-first, and built for developers, maintainers, security reviewers, and teams that need an audit trail for AI-generated code.
Website: tellur.dev
Why Developers Star Tellur
- AI code attribution: explain whether a line was human-written, AI-generated, or mixed.
- Local-first provenance: store evidence in
.tellur/; source code does not need to leave your machine. - Tamper-evident audit trail: append-only JSONL events are sealed with a SHA-256 hash chain.
- PR risk reports: surface AI involvement, sensitive paths, test evidence, and review gaps before merge.
- Multi-agent adapters: capture or import evidence from Codex, Claude Code, Cursor, VS Code/Copilot, Gemini CLI, Antigravity, Aider, and generic tools.
- Policy-as-code: define rules for auth, payments, secrets, infra, blocked AI reads, required tests, and required human review.
If Tellur helps you make AI-assisted code review safer, star the repo so other developers can find it.
The Problem
AI coding agents are now part of everyday software development, but most teams still review AI-assisted changes with standard Git metadata only. That leaves important questions unanswered:
- Which lines were AI-generated, human-written, or mixed?
- Which model, tool, prompt hash, and session produced a change?
- Did the agent touch security-sensitive code such as auth, payments, secrets, or infrastructure?
- Were tests run before the change was merged?
- Does a PR need extra review because of AI involvement?
Tellur turns those questions into local, queryable evidence for code review, compliance, supply-chain provenance, and engineering governance.
What Tellur Does
| Capability | What you get |
|---|---|
| Line-level attribution | Code ranges mapped to agent, model, session, prompt hash, evidence strength, and confidence score. |
| Session capture | AI-assisted activity from CLI commands, editor hooks, importers, MCP, and the local daemon. |
| PR risk reports | AI involvement, sensitive paths, test evidence, review gaps, and policy warnings. |
| Tamper-evident logs | Append-only JSONL with a SHA-256 hash chain for local verification. |
| Fast local queries | SQLite index powering CLI, VS Code/Cursor extension, MCP tools, daemon, and dashboard views. |
| Portable exports | Provenance bundles for developer, OSS, corporate, audit, release, and CI workflows. |
| Secret redaction | Cleanup for common keys, tokens, passwords, and private key material. |
Status
Tellur is in beta. The local pipeline is functional end to end:
capture -> attribution -> event log -> SQLite index -> CLI/editor/reports
Implemented surfaces include the CLI, global Codex/Claude Code/Gemini
CLI/Antigravity hooks, Cursor MCP/settings, VS Code/Cursor extension capture,
importers for Cursor, Aider, Codex CLI, Gemini CLI, Antigravity, GitHub
Copilot, Windsurf/Cascade, JetBrains AI/Junie, Devin, Continue, and
Cline/Roo Code, a local token-authenticated daemon, an MCP stdio server,
provenance export, Git notes interop, a static session replay dashboard backed
by daemon data, and a self-hosted tellur-server hub preview for team
ingest/read/report/policy/export workflows.
Install
From source:
cargo install --path crates/cli
For development:
cargo build
cargo test
cargo run -p tellur-cli -- --help
Tellur currently targets Rust stable with edition 2024.
Quickstart
Initialize Tellur in a Git repository:
tellur init
tellur init --profile accepts default, team, and oss-maintainer.
Unsupported profile names fail fast instead of silently using default setup.
Check the local setup and detected AI tools:
tellur doctor
Start capturing file changes:
tellur watch
Install one-time global agent/editor integrations:
tellur setup agents
Import activity from supported tools:
tellur import cursor path/to/agent-trace.json
tellur import aider path/to/repo
tellur import codex path/to/codex-events.jsonl
tellur import copilot path/to/copilot-metadata.jsonl
tellur import windsurf path/to/cascade-session.jsonl
tellur import jetbrains path/to/ai-assistant-export.json
tellur import devin path/to/devin-run.json
tellur import continue path/to/.continue/dev_data/chat.jsonl
tellur import cline path/to/tasks/<id>/ui_messages.json
Query attribution:
tellur explain src/auth/session.ts:84
tellur blame src/auth/session.ts
Generate a PR report:
tellur pr-report --base main --head HEAD
Verify the event log:
tellur verify
CLI Reference
tellur init # Initialize .tellur/
tellur doctor # Check setup and detect tools
tellur status # Show repository capture status
tellur watch # Capture working tree changes
tellur explain <file:line> # Explain attribution for one line
tellur blame <file> # Show file attribution ranges
tellur sessions # List captured sessions
tellur pr-report --base main # Generate a PR risk report
tellur policy check # Evaluate configured policies
tellur event --event-type file.write --session <id> --file <path>
tellur import <adapter> <source> # Import external AI tool data
tellur export --format json # Export provenance data
tellur notes export # Write Git AI-compatible refs/notes/ai
tellur notes import # Import refs/notes/ai into the local index
tellur notes push # Push refs/notes/ai to origin
tellur notes fetch # Fetch refs/notes/ai from origin
tellur team report # Aggregate AI involvement across a commit range (no server)
tellur daemon # Run local HTTP ingestion/dashboard API
tellur mcp # Run MCP server over stdio
tellur setup agents # Install one-time global agent/editor integrations
tellur setup cursor # Install Cursor MCP/settings integration
tellur setup vscode # Install VS Code extension settings
tellur setup windsurf # Install Windsurf MCP/settings integration
tellur setup gemini-cli # Install Gemini CLI hooks
tellur setup antigravity # Install Antigravity hooks/MCP integration
tellur setup status # Check global agent integration status
tellur gc --dry-run # Garbage-collect expired events
tellur redact # Redact secrets from stored events
tellur verify # Verify hash-chain integrity
explain, blame, and sessions support --json for machine-readable output.
Supported Adapters And Integrations
| Tool | Mechanism | Status |
|---|---|---|
| Claude Code | User/project lifecycle hooks + transcript import | Working |
| Codex CLI/App | User lifecycle hooks, local personal plugin, JSONL import | Working |
| Gemini CLI | User lifecycle hooks, JSONL import | Working |
| Google Antigravity 2.0 | User hooks, MCP config, JSONL import | Working |
| Cursor IDE/CLI | Cursor MCP/settings, VS Code-compatible extension save/watch capture, JSON/JSONL import | Working |
| VS Code/Copilot | VS Code extension auto-init, watch, save capture, explicit prompt hashing, metadata import | Working with VS Code API limits |
| Aider | Git commit attribution import | Working |
| GitHub Copilot | Metadata JSON/JSONL import | Working |
| Windsurf / Cascade | Windsurf MCP/settings, VS Code-compatible extension save/watch capture, Cascade session JSON/JSONL import | Working |
| JetBrains AI Assistant / Junie | JetBrains plugin save/watch capture (editor/tellur-jetbrains) + action-log JSON/JSONL import | Working |
| Devin | Live capture via daemon webhook (POST /webhook/devin) + cloud agent run/session export import | Working |
| Continue | dev_data JSONL import; live save/watch capture when running in a VS Code-family editor | Working |
| Cline / Roo Code | Task-history JSON/JSONL import; live save/watch capture when running in a VS Code-family editor | Working |
| Generic | CLI events, JSONL, local HTTP daemon | Working |
Import adapters preserve source event IDs, source timestamps, session IDs, actor, event type, and payload while recomputing Tellur's local hash chain. Invalid non-empty JSON/JSONL lines fail the import instead of being silently skipped. Prompt-like fields are stored as hashes, not raw prompt text; secret-looking strings in retained metadata are redacted.
tellur import aider <source> expects <source> to be a Git repository path.
Other import adapters expect a file path unless the adapter-specific docs say
otherwise.
The adapter layer is pluggable, so additional tools can normalize their events
into Tellur's schema without changing the core attribution engine.
See docs/ADAPTERS.md for current adapter guarantees,
known limits, and the adoption roadmap.
Live Capture Beyond Import
Some tools have no documented local lifecycle hook, so Tellur captures them through the durable surface each one does expose:
- JetBrains IDEs (AI Assistant / Junie) — the
editor/tellur-jetbrainsplugin subscribes to the IDE's virtual-file changes and reports saved/created files totellur hooks ingest --source jetbrains --auto-init. Edits made by the JetBrains AI Assistant and the Junie agent land on disk through the same path, so they are captured live. JetBrains MCP is configured in-IDE, so Tellur does not auto-write it. The plugin deduplicates repeated VFS events for the same file/repository while a capture is queued or running, re-runs capture once more when a new save arrives during an active capture, sends captures through a disposable bounded single-worker queue, and logs CLI failures/timeouts for troubleshooting. - Devin (cloud agent) — has no local file surface. Point a Devin webhook (or
a small relay) at the local daemon's authenticated
POST /webhook/devinendpoint, which normalizes Devin's native run/session payload (messages, shell commands, file edits, status) into Tellur events and recomputes the hash chain. The endpoint is generic:POST /webhook/{source}works for any tool whose webhook posts a similar shape.
The daemon webhook requires the same bearer token as the other mutating
endpoints (see .tellur/daemon.token) and only accepts loopback hosts:
curl -X POST http://127.0.0.1:4917/webhook/devin \
-H "Authorization: Bearer $(cat .tellur/daemon.token)" \
-H 'Content-Type: application/json' \
-d '{"devin_run_id":"run-1","messages":[{"type":"edit","file_path":"src/app.py"}]}'
One-Time Agent Setup
For Codex, Claude Code, Gemini CLI, Antigravity, Cursor, VS Code, and Windsurf, Tellur supports user-level installation so users do not need to invoke a skill or plugin in every project:
tellur setup agents
This installs global hooks for Claude Code (~/.claude/settings.json) and Codex
(~/.codex/hooks.json). It publishes a local Codex personal plugin under
~/.codex/plugins/tellur-provenance with a marketplace entry in
~/.agents/plugins/marketplace.json for manual workflows such as status,
verification, and PR reporting. It writes Gemini CLI hooks to
~/.gemini/settings.json, Antigravity hooks to ~/.gemini/config/hooks.json,
Antigravity MCP config to ~/.gemini/antigravity/mcp_config.json and
~/.gemini/antigravity-cli/mcp_config.json, Cursor MCP/settings
(~/.cursor/mcp.json plus Cursor user settings), VS Code user settings, and
Windsurf MCP/settings (~/.codeium/windsurf/mcp_config.json plus Windsurf user
settings) so the Tellur extension can auto-init, watch, and capture saved files
in every Git workspace.
Global hooks call the absolute path of the installed tellur executable:
/absolute/path/to/tellur hooks ingest --source <agent> --auto-init
When a hook runs outside a Git repository it no-ops. When it runs inside a Git
repository without .tellur/, --auto-init creates the local Tellur storage
with safe defaults. To disable capture for a repository, create
.tellur/disable. Invalid hook payloads no-op, and tool hooks only capture
working-tree changes when the hook payload includes a concrete file path.
Use tellur setup status to inspect installed global integrations and
tellur setup uninstall to remove Tellur-installed global hooks and the local
Codex plugin, Cursor MCP/settings, VS Code settings, and Windsurf MCP/settings.
Cursor, VS Code, and Windsurf do not have the same documented local lifecycle hook model as Codex. Tellur therefore uses the durable editor surfaces they do expose: extension save/watch capture, MCP tools, explicit prompt hashing, Git policy checks, and import adapters. Because Windsurf is a VS Code-compatible editor, the same Tellur extension capture also records edits made by agents that run inside it, including Cline / Roo Code and Continue.
Integration Mechanisms
| Surface | Setup command | Files written | Runtime behavior |
|---|---|---|---|
| Claude Code | tellur setup claude-code or tellur setup agents | ~/.claude/settings.json | Lifecycle hooks call tellur hooks ingest --source claude-code --auto-init; project hooks remain available via tellur hooks install claude-code. |
| Codex CLI/App | tellur setup codex or tellur setup agents | ~/.codex/hooks.json, ~/.codex/plugins/tellur-provenance, ~/.agents/plugins/marketplace.json | User hooks call tellur hooks ingest --source codex --auto-init; local plugin exposes manual Tellur workflows through Codex's plugin directory. |
| Gemini CLI | tellur setup gemini-cli or tellur setup agents | ~/.gemini/settings.json | Gemini BeforeTool/AfterTool/agent/session hooks call tellur hooks ingest --source gemini-cli --auto-init --json-response. |
| Antigravity 2.0 | tellur setup antigravity or tellur setup agents | ~/.gemini/config/hooks.json, ~/.gemini/antigravity/mcp_config.json, ~/.gemini/antigravity-cli/mcp_config.json | Antigravity lifecycle hooks call tellur hooks ingest --source antigravity --auto-init --json-response; MCP exposes Tellur tools to Antigravity agents. |
| Cursor | tellur setup cursor or tellur setup agents | ~/.cursor/mcp.json, Cursor user settings.json | Cursor can call Tellur MCP tools; the installed Tellur extension uses auto-init, watch, and save capture with source cursor. |
| VS Code | tellur setup vscode or tellur setup agents | VS Code user settings.json | The installed extension auto-inits Git workspaces, starts tellur watch, and captures saved files through safe hook ingestion with source vscode. |
| Windsurf / Cascade | tellur setup windsurf or tellur setup agents | ~/.codeium/windsurf/mcp_config.json, Windsurf user settings.json | Windsurf can call Tellur MCP tools; the installed VS Code-compatible extension uses auto-init, watch, and save capture with source windsurf. |
All setup commands write absolute tellur executable paths. Existing malformed
JSON settings are not overwritten; setup fails so the user can repair or back up
the file.
Data Model
Tellur stores repository-local data under .tellur/:
.tellur/
├── config.yml # Configuration, intended to be committed
├── policies/
│ └── default.yml # Policy rules, intended to be committed
├── traces/
│ └── sessions/ # JSONL event logs, gitignored by default
├── index/
│ └── tellur.db # SQLite index, gitignored by default
└── exports/ # Generated provenance bundles
Versioned JSON schemas live in schemas/:
| Schema | Description |
|---|---|
tellur.session.v1 | A bounded AI-assisted development interaction |
tellur.event.v1 | A timestamped action within a session |
tellur.attribution.v1 | Line-level origin mapping for a file |
tellur.pr-report.v1 | PR risk report with AI involvement stats |
tellur.provenance.v1 | Portable export bundle |
Policy Example
# .tellur/policies/default.yml
version: 1
sensitive_paths:
- path: "src/auth/**"
tags: ["auth", "security-sensitive"]
require_human_review: true
require_tests: true
- path: "**/.env*"
tags: ["secrets"]
block_ai_read: true
rules:
- id: require-tests-for-ai-code
description: "AI code changes > 20 lines require test evidence"
when:
attribution.origin: ai
changed_lines.greater_than: 20
action: warn
require:
tests_run: true
Architecture
Tellur/
├── crates/
│ ├── core/ # Schemas, attribution, storage, policy, export, daemon, MCP
│ ├── cli/ # tellur command
│ ├── adapters/ # Claude Code, Cursor, Aider, Codex, Copilot, Gemini, Antigravity, Windsurf, JetBrains, Devin, Continue, Cline, Generic
│ └── server/ # Tier 1 team hub (tellur-server) — FSL-1.1-ALv2 (in progress)
├── editor/ # VS Code extension + JetBrains plugin (tellur-jetbrains)
├── schemas/ # JSON Schema definitions
├── dist/ # npm wrapper and Homebrew formula
└── web/ # Session replay dashboard
Core storage is intentionally simple: append-only JSONL for auditability, SQLite for query speed, and Git blob SHAs for stable attribution across file states.
Git Notes Interop
Tellur can publish compact authorship attestations as Git notes using the Git
AI-compatible refs/notes/ai namespace:
tellur notes export --print # inspect the note payload
tellur notes export # attach it to HEAD
tellur notes push # publish refs/notes/ai
tellur notes fetch # fetch refs/notes/ai
tellur notes import # import a note back into Tellur's local index
Git notes are treated as an interoperability and transport layer, not as Tellur's primary database. Prompts, transcripts, redaction state, replay data, and policy evidence remain in Tellur's local/private storage; notes contain only line ranges, lightweight session metadata, and commit-scoped attribution.
Team Reports (no server)
Because authorship notes travel over your existing Git remote, a whole team can
share AI provenance without running any server. After contributors push their
refs/notes/ai, anyone can aggregate a PR or branch range into one view:
tellur notes fetch # get teammates' notes from origin
tellur team report --base main --head HEAD # Markdown summary
tellur team report --base main --head HEAD --json
The report shows AI-assisted vs. human lines, a breakdown by tool / model /
author, and provenance coverage (which commits in the range carry a note). It is
tolerant: commits with no note — or an unparseable one — are listed under
"without provenance" rather than failing the report. This is the no-server
("Tier 0") slice of the team/server roadmap; see
docs/proposals/TEAM_SERVER_MODE.md.
To post the report automatically on pull requests, copy the example workflow in
docs/examples/github-actions-team-report.yml
into .github/workflows/.
Self-Hosted Team Hub (preview)
For teams that want a shared, server-backed view, Tellur ships an optional
self-hostable hub, tellur-server (in crates/server). It is source-available
under FSL-1.1-ALv2 (the Apache-2.0 core/CLI/adapters are unaffected) and is
under active development — see
docs/proposals/TEAM_SERVER_MODE.md and
docs/proposals/TEAM_SERVER_IMPLEMENTATION.md.
Local-first stays the default: the hub is opt-in, loopback-bound unless you explicitly allow otherwise, token-authenticated, and tenant-isolated. Bootstrap and run it:
tellur-server admin create-org --name "Acme"
tellur-server admin create-token --org <org-id> --role admin # printed once
tellur-server admin set-policy --org <org-id> --file policy.yml # optional
tellur-server # serve (default 127.0.0.1:4920)
Authenticated, org-scoped API (Bearer token): provenance ingest
(POST /v1/orgs/{org}/repos/{repo}/events, with inbound secret redaction and a
re-verified per-repo hash chain), reads (GET .../repos, .../events,
.../report), central policy distribution (PUT/GET .../policies[/{name}]),
attribution ingest (POST .../repos/{repo}/attributions), and an admin export
portal (POST .../export/events|audit enqueues a durable job, polled at
GET .../jobs/{id}; plus per-repo GET .../repos/{repo}/export/slsa|spdx
for SLSA v1.0 / SPDX SBOM compliance attestations). Cross-org access is
denied and audited; the audit log is itself tamper-evident. Operational
endpoints GET /healthz, /readyz, and /metrics (Prometheus) need no auth and
expose no tenant data.
Pull a central policy into a repo, and run the hub in Docker:
tellur policy pull --org <org-id> --hub http://hub:4920 --token <token>
docker compose -f dist/docker/docker-compose.yml up --build
Implemented through milestone B5 (identity/tenancy, ingest, read/report, policy &
export, metrics, packaging, policy pull). Storage runs on the embedded SQLite
backend by default (zero-config, single-node) or on Postgres for horizontal
scale — set TELLUR_DATABASE_URL (e.g. postgres://user:pass@host:5432/tellur)
to switch. Postgres is reached over NoTls, so keep it on a private network or
front it with a TLS-terminating proxy. A background retention loop keeps the
store tidy: expired sessions and stale login transactions are always pruned;
finished export/compliance jobs are pruned after TELLUR_RETENTION_DAYS; and the
audit log can be minimised after TELLUR_AUDIT_RETENTION_DAYS via a sealed
checkpoint — old entries are deleted but the pruned prefix's tip hash is kept,
so the chain still verifies and truncation stays detectable (both default 0 =
keep forever). The event provenance log is never pruned.
Authorization is RBAC (viewer /
contributor / admin) with fine-grained, additive per-repo grants: an org
admin can elevate a member on a specific repo (e.g. make an org viewer a
contributor or admin on one repo) via
PUT /v1/orgs/{org}/repos/{repo}/roles/{member} or the
tellur-server admin grant-repo-role CLI; grants only elevate, never restrict.
Enterprise SSO is supported via OIDC (Authorization Code + PKCE): set
TELLUR_OIDC_ISSUER / TELLUR_OIDC_CLIENT_ID / TELLUR_OIDC_CLIENT_SECRET /
TELLUR_OIDC_REDIRECT_URI to enable /auth/login, /auth/callback, and
/auth/logout. A successful login issues an opaque, server-stored session cookie
(HttpOnly/Secure/SameSite=Lax). There is no open self-registration —
pre-provision who may sign in with tellur-server admin add-member --org <id> --name <name> --email <email> --role <role>; the member is matched by verified
email on first login and bound to their stable OIDC subject thereafter.
SCIM 2.0 provisioning lets an IdP manage users and groups automatically.
Mint an org-scoped token with tellur-server admin create-scim-token --org <id>
and point your IdP at /scim/v2/Users and /scim/v2/Groups with it as the
bearer token. Creating a user provisions a member (userName→email, optional
roles→org role, default viewer); deprovisioning (DELETE or
PATCH active=false) deactivates the member so every credential type — API
token, dashboard session, and SSO — is revoked immediately. Group-based role
sync: a group whose displayName is tellur-admin, tellur-contributor, or
tellur-viewer sets its members' org role (recomputed when membership changes).
Durable exports & dashboard. Large org exports run as background jobs:
POST /v1/orgs/{org}/export/events (or /audit) returns 202 with a job_id;
poll GET /v1/orgs/{org}/jobs/{id} until completed to fetch the result, or list
an org's job history with GET /v1/orgs/{org}/jobs (admin). Per-repo SLSA/SPDX
can also run as jobs for large repos (POST .../repos/{repo}/export/slsa|spdx),
and POST /v1/orgs/{org}/export/evidence produces a full evidence pack (every
repo's SLSA provenance + latest policy compliance + audit-chain status) in one
downloadable bundle. Admins can also read the tamper-evident audit log directly
with GET /v1/orgs/{org}/audit[?actor=&action=&range=&before=&limit=] (paginated,
newest-first; the first page reports chain_intact for the hash chain).
Policy compliance & People/Access (admin): POST /v1/orgs/{org}/policies/compliance
enqueues a durable job that evaluates the org's default policy against every
repo's attribution and stores timestamped snapshots; read the latest per repo
with GET .../policies/compliance. GET .../members, GET .../groups (a
session-auth mirror of /scim/v2/Groups), and GET .../sso-status back the
People & Access screen — counts and health only, never secrets. An admin can
optionally set per-repo source templates (PUT .../repos/{repo}/source,
https:// only): a template deep-links each range to your provider's web view,
and a raw_template lets the file view's opt-in Show source gutter fetch the
actual lines in the browser, straight from the provider (raw.githubusercontent.com,
gitlab.com, bitbucket.org). Either way the hub stores and serves no source
code. The
hub ships a built-in team dashboard at /app (Svelte SPA embedded in the
binary, served same-origin so it uses your first-party SSO session): sign in at
/auth/login, then open /app. It is being built out in phases per
docs/proposals/TEAM_DASHBOARD_UI.md:
Overview (org rollup + activity trend), Repositories + per-file provenance,
Sessions + replay, and — for admins — a Policies compliance view (per-repo
violations by severity + one-click re-evaluation), a People & Access view
(members, SCIM groups, SSO/SCIM health), an Audit log browser, and an
Exports console (start exports, watch job status, download results). The Overview
loads in a single round-trip from GET /v1/orgs/{org}/overview (org totals,
AI-share + review-coverage rollups, activity trend, and repos ranked by review
gap). A command palette (⌘K / Ctrl-K) jumps between screens, and topbar
controls switch the theme (system / light / dark), density (cozy / compact), and
language (English / Dutch).
Development
cargo fmt --check
cargo test
cargo run -p tellur-cli -- doctor
VS Code extension:
cd editor/tellur-vscode
npm install
npm run compile
npm test
npm run package
Tellur's VS Code extension supports VS Code/Copilot Bring Your Own Key model
metadata for watch sessions. Configure BYOK in VS Code with
Chat: Manage Language Models, then run Tellur: Select VS Code AI Model if
more than one model is available. Tellur: Diagnose VS Code AI Models shows
which models VS Code exposes to extensions and what Tellur will attach to new
watch sessions.
VS Code does not expose a public API that lets one extension intercept arbitrary
Copilot/BYOK chat prompts from other chat participants. For prompt provenance,
use Tellur: Record AI Prompt; Tellur records a SHA-256 prompt hash plus model
metadata, not the raw prompt text.
Roadmap
- A richer team/server web dashboard UI (the hub API, SSO login, durable exports, and SCIM user+group provisioning are implemented)
- Live lifecycle-hook capture (beyond import) for editors that expose it
- Richer policy templates for security-sensitive repositories
- Packaged releases for npm, Homebrew, and GitHub Releases
The tellur-core binary is an internal diagnostic entrypoint for packaging
smoke tests. Use the tellur binary for normal CLI workflows.
Contributing
See CONTRIBUTING.md.
License
Apache-2.0 — see LICENSE.