Ledgenter

Read back the feature requests your tenant has filed, newest first, with current status (open, acknowledged, accepted, in_progress, shipped, declined, duplicate) and the vendor's resolution notes — how a filer learns the outcome. Filter by id, status, or kind.

How to use Ledgenter. Call guide() for the topic index, or guide(topic) for depth (getting-started, the-loop, tasks-and-deps, decisions, knowledge, handoffs, git-and-repos, runs-and-subagents, errors-and-recovery, idempotency, feedback, glossary). Pure/static — safe to call anytime.

Claim an open handoff addressed to you so siblings don't double-work it (open -> claimed; respond with handoff_respond).

Create a work request (handoff/question/review/collab/approval) addressed to one or more actors. fingerprint dedups live duplicates.

List handoffs by direction: 'from_me' (the ones YOU created — including their response, so you can read the answer to a question you asked), 'to_me', or 'any'. Filter by status/type.

Close out a handoff: resolution 'processed' (default) or 'cancelled', with an optional note.

Respond to a handoff with a free-form response object ({chosen_option?, text?, result_ref?, ...}).

Cheap poll of work addressed to you. Pass ack:[ids] to mark items processed after you've acted on them.

Search knowledge notes. Semantic by default (embedding similarity); lexical_only:true or an unconfigured embedder falls back to trigram/title search.

Patch a knowledge note (title/body/tags). Re-embeds only when the body changes.

Write a durable knowledge note (note/runbook/finding/snippet). Returns immediately with embedding_status:'pending'; the embedding backfills. (`related_task_ids` is DEFERRED as a v1 fast-follow — note↔task linkage not yet available.)

Mark one or more of your notifications read by id. Returns the count marked.

Read your own notifications (RLS-scoped to you), newest first. unread_only:true filters to unread.

One-call orientation bundle for a project (by key or uuid): status + counts, top open tasks, recent decisions, knowledge note titles, linked repos (and whether your current run is in one of them), recent activity. Call when starting work on an unfamiliar project. The repo's own CLAUDE.md still owns how to work its code — this brief is the cross-repo work state it can't hold.

Create a project. Returns the project id + resolved key.

List/search projects (RLS-scoped). detail:'full' joins a lightweight task summary per project.

Partially update a project (title/description/status/target_on/owner). Only the named patch fields change.

Register (or idempotently re-resolve) an actor by external_ref. Used to onboard agents/humans/services and address them in handoffs/assignments.

Link a project to a repository (by repository_id or repo_slug), with an optional role (primary/dependency/docs).

List repositories (RLS-scoped). Filter by id/slug/host/free-text, or project_id to see a project's repos.

Resolve-or-register a git repository (deduped by its normalized remote URL). autodetect:true (or no args) uses the current repo detected from your working directory. Returns the repository id.

Close out a run with a terminal status (succeeded/failed/cancelled).

Register a child run under your current run (recorded in the run tree). HONEST LIMIT: over MCP, subsequent tool calls still attribute to your CURRENT run — no tool accepts a run_key override yet. Attribution to the child works for OUT-OF-PROCESS children that set LEDGENTER_PARENT_RUN_ID/LEDGENTER_RUN_ID in their env, and for direct SDK consumers using withRunKey.

Read one run by run_key or id; include_children:true returns the whole subtree (a workflow's children).

Keep a long-running run alive and track the moving HEAD (head_sha/branch/dirty). Prevents the reaper from marking a live run abandoned.

List runs (the work episodes). Filter by actor_id:'me', status, kind, root_run_id, or run_series_key. Use to see what a workflow or recurring job did.

A one-call rollup of what happened in a run — {tasks_created, tasks_completed, decisions_logged, knowledge_written, handoffs, code_refs, activity_count}. Pass run_id for a specific run; omit it for your CURRENT run. Use this to report your work or hand off cleanly instead of scanning activity.

Global cross-object KEYWORD search (full-text + trigram over projects/tasks/decisions/notes/...). NOT semantic — for search-by-meaning use knowledge_search. Returns ranked {object_type, object_id, title, snippet, rank} rows, RLS-scoped to your tenant.

Fetch one skill's full body by slug (project-scoped shadows tenant-wide) or id. The body is a markdown playbook — follow it as instructions. Always current over MCP; only on-disk synced copies can be stale.

List the tenant's reusable skills (playbooks): the tenant-wide library plus, with project_id, that project's scoped skills (project-scoped shadows tenant-wide on slug collision). Returns slug/name/description/version/tags (bodies with include_body). A skill body is followable instructions for ANY agent; Claude Code users can additionally materialize them as native skills via `ledgenter skills sync`.

Create or update a skill (playbook other agents will follow). slug is the stable identity (also the on-disk dir name); description (required on create) is the one-line 'when to use this'; body is the markdown playbook (no frontmatter — it's generated at sync). status:'archived' retires it; pass expected_version for safe concurrent edits.

Delegate a task: assign it to an actor (or yourself). actor_id accepts an actor id, "me" (self-assign), or null (unassign). A discoverable verb for the common reassignment — same effect as task_update with an assignee patch, plus a task.assigned activity. Use actor_query to find the actor id first.

Atomically claim work. With task_id: CAS-claim that task (succeeds if unassigned, lease-expired, or already yours — re-claiming extends the lease). Without task_id: claim-next — takes the highest-priority READY unassigned task (optionally filtered by project_id/label/repository_ids), sets in_progress + a lease (default 1h), and returns the task plus project_context (linked repos + whether you're in the right checkout — follow hints if it says you're not). claimed:false means the pool is empty.

Record the code that delivered a task — a commit/branch/PR/tag. repository/branch/sha default from your current run, so recording a commit is often just (task_id, ref_type:'commit'). The task timeline then links to the code.

Create a task (or subtask via parent_task_id) and optionally wire its blockers via depends_on. Verification options: acceptance_criteria (checklist of {text, met} — all must be met before done), requires_evidence (done needs a linked code ref or attachment), reviewer_actor_id (review gate; 'me' works). Returns task id + seq.

Create a whole wave of tasks in ONE atomic call (all-or-nothing) — far cheaper than N task_create round-trips when planning. tasks[] is an array of task specs (same fields as task_create minus project_id/idempotency_key). An item's depends_on may reference an existing task by uuid OR an EARLIER item in this batch by {batch_index:N} (0-based) — so you submit the wave AND its dependency DAG together. A forward/self batch_index is ignored (no edge); a bad uuid edge becomes a per-item warning (warnings[].batch_index), not a failure. Max 100. Returns count + task_ids IN INPUT ORDER.

Deep-read one task: the row (incl. acceptance_criteria/requires_evidence/reviewer) plus blocked_by[]/blocks[], subtasks[], comments[], recent activity[], code_refs[] (the commits/PRs that delivered it), derived readiness, and project_context (the project's linked repos + whether your current run is in the right checkout). include:['brief'] attaches the full project_brief — the one-call cold start for working an unfamiliar task.

Add/remove dependency edges and set/clear a parent for a task. Cycle-checked; rejected edges are returned in cycle_rejected[].

List/search tasks. state:'ready'|'blocked' filters SERVER-side on derived state (a state filter also excludes done/cancelled — finished work isn't actionable). assignee_actor_id:'me' resolves to the caller; 'unassigned' lists unclaimed work. Filter by status[]/label/due_before. Paginated: a full page returns next_cursor — pass it back as cursor for the next page.

Release a task you claimed back to the pool (in_progress drops to todo, lease cleared).

Patch a task (incl. status transitions, validated by a state machine). To reopen a done/cancelled task set patch.allow_reopen:true. Verifier fields are patchable: acceptance_criteria (replace the checklist; flip items to met), requires_evidence, reviewer_actor_id (explicit null clears). Moving to in_review with a reviewer auto-creates the review handoff; moving to done is gated on criteria met + evidence + answered review. patch.expected_status is an optimistic-concurrency precondition — the update fails (CONFLICT) if the status changed since you read it.

Bootstrap the calling agent's context: identity, open tasks, inbox, and the delta since last seen. Advances last_seen_at. Call this first in any run.