convez.ai
MCP Server
sydneyvb-nl

tellur

sydneyvb-nl/tellur

Ver no GitHub
BomPluginScore · de 0 a 100

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/tellur

1 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

Estrelas
5
Forks
0
Acompanhando
0
Saúde
71%
Último commit
há 3 meses
Versão
v0.1.0
Issues abertas
0
Contribuidores
2

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.

Website License Rust Adapters

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

CapabilityWhat you get
Line-level attributionCode ranges mapped to agent, model, session, prompt hash, evidence strength, and confidence score.
Session captureAI-assisted activity from CLI commands, editor hooks, importers, MCP, and the local daemon.
PR risk reportsAI involvement, sensitive paths, test evidence, review gaps, and policy warnings.
Tamper-evident logsAppend-only JSONL with a SHA-256 hash chain for local verification.
Fast local queriesSQLite index powering CLI, VS Code/Cursor extension, MCP tools, daemon, and dashboard views.
Portable exportsProvenance bundles for developer, OSS, corporate, audit, release, and CI workflows.
Secret redactionCleanup 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

ToolMechanismStatus
Claude CodeUser/project lifecycle hooks + transcript importWorking
Codex CLI/AppUser lifecycle hooks, local personal plugin, JSONL importWorking
Gemini CLIUser lifecycle hooks, JSONL importWorking
Google Antigravity 2.0User hooks, MCP config, JSONL importWorking
Cursor IDE/CLICursor MCP/settings, VS Code-compatible extension save/watch capture, JSON/JSONL importWorking
VS Code/CopilotVS Code extension auto-init, watch, save capture, explicit prompt hashing, metadata importWorking with VS Code API limits
AiderGit commit attribution importWorking
GitHub CopilotMetadata JSON/JSONL importWorking
Windsurf / CascadeWindsurf MCP/settings, VS Code-compatible extension save/watch capture, Cascade session JSON/JSONL importWorking
JetBrains AI Assistant / JunieJetBrains plugin save/watch capture (editor/tellur-jetbrains) + action-log JSON/JSONL importWorking
DevinLive capture via daemon webhook (POST /webhook/devin) + cloud agent run/session export importWorking
Continuedev_data JSONL import; live save/watch capture when running in a VS Code-family editorWorking
Cline / Roo CodeTask-history JSON/JSONL import; live save/watch capture when running in a VS Code-family editorWorking
GenericCLI events, JSONL, local HTTP daemonWorking

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-jetbrains plugin subscribes to the IDE's virtual-file changes and reports saved/created files to tellur 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/devin endpoint, 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

SurfaceSetup commandFiles writtenRuntime behavior
Claude Codetellur setup claude-code or tellur setup agents~/.claude/settings.jsonLifecycle hooks call tellur hooks ingest --source claude-code --auto-init; project hooks remain available via tellur hooks install claude-code.
Codex CLI/Apptellur setup codex or tellur setup agents~/.codex/hooks.json, ~/.codex/plugins/tellur-provenance, ~/.agents/plugins/marketplace.jsonUser hooks call tellur hooks ingest --source codex --auto-init; local plugin exposes manual Tellur workflows through Codex's plugin directory.
Gemini CLItellur setup gemini-cli or tellur setup agents~/.gemini/settings.jsonGemini BeforeTool/AfterTool/agent/session hooks call tellur hooks ingest --source gemini-cli --auto-init --json-response.
Antigravity 2.0tellur setup antigravity or tellur setup agents~/.gemini/config/hooks.json, ~/.gemini/antigravity/mcp_config.json, ~/.gemini/antigravity-cli/mcp_config.jsonAntigravity lifecycle hooks call tellur hooks ingest --source antigravity --auto-init --json-response; MCP exposes Tellur tools to Antigravity agents.
Cursortellur setup cursor or tellur setup agents~/.cursor/mcp.json, Cursor user settings.jsonCursor can call Tellur MCP tools; the installed Tellur extension uses auto-init, watch, and save capture with source cursor.
VS Codetellur setup vscode or tellur setup agentsVS Code user settings.jsonThe installed extension auto-inits Git workspaces, starts tellur watch, and captures saved files through safe hook ingestion with source vscode.
Windsurf / Cascadetellur setup windsurf or tellur setup agents~/.codeium/windsurf/mcp_config.json, Windsurf user settings.jsonWindsurf 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/:

SchemaDescription
tellur.session.v1A bounded AI-assisted development interaction
tellur.event.v1A timestamped action within a session
tellur.attribution.v1Line-level origin mapping for a file
tellur.pr-report.v1PR risk report with AI involvement stats
tellur.provenance.v1Portable 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.

Ver o original no GitHub

Bom para

Relacionados