Install, update, remove¶

Choose the agent you already use. Install the skills once, then open that agent in the project you want to work on. Installation adds commands; it does not create or upgrade a project's memory bank.

Your setup	Install
Claude Code	The `memory-bank` plugin from the `tabilet` marketplace
Codex	The same `memory-bank` plugin through the Codex CLI
agy	Install directly via `agy plugin install https://github.com/tabilet/skills`
DSH Web or headless	The `tabilet-skills` companion, or the seven source-checkout filesystem bundles
Manual installation	Complete skill folders in your agent's skill directory

The canonical seven skills and the DSH companion use the same project Markdown. Version 2.0.0 places project-owned files under tabilet/. Existing v1.5.0 projects need an explicit one-time migration. Python is required for that migration and for the optional API runner.

Claude Code¶

Run these inside Claude Code:

/plugin marketplace add tabilet/skills
/plugin install memory-bank@tabilet

Open a fresh session in your project, then send:

/memory-bank:memory-bank-init

Use Init only when the project has no initialized memory bank. Otherwise, choose the workflow for the work you want to do.

Codex¶

Run these in a terminal:

codex plugin marketplace add tabilet/skills
codex plugin add memory-bank@tabilet

Then open a fresh Codex session in your project and send:

$memory-bank:memory-bank-init

The @tabilet qualifier identifies the marketplace. If your Codex build does not expose plugin commands, use the plain-file route.

agy¶

Run this in a terminal:

agy plugin install https://github.com/tabilet/skills

(Or from a local clone: agy plugin install .)

Open a fresh agy session in your project and send:

/memory-bank:memory-bank-init

agy automatically loads AGENTS.md as a project rule and registers the seven skills as slash commands. If you prefer plain files, agy also discovers skills in ~/.agents/skills/.

DeepSeek Harness¶

For the Memory Bank sidebar and all seven skills, install the prebuilt v2.0.0 companion in your Web profile. Run this in a terminal on the machine running DSH:

dsh plugin --profile web add \
  https://github.com/tabilet/tabilet-skills/releases/download/v2.0.0/tabilet-skills-2.0.0.tgz \
  --ignore-scripts

For headless use, replace --profile web with --profile headless. Install only in the profiles where you want it. This GitHub release route needs no npm account.

Restart DSH, select a session for your project, and open Memory Bank in the right sidebar. Expand Prepare a workflow request, choose a skill, review the preview, and insert it into an empty draft. You send the request yourself. If the draft already contains text or attachments, copy the preview instead. Headless profiles load the skills without a sidebar.

The companion was verified on Linux with Node 24.14.1 and locked DSH 0.1.5-rc.2 components, plus an isolated rc.1 launcher using rc.2 components.

For skills without the dashboard, use the plain-file route. Copy all seven complete folders from the v2.1.0 checkout into $DSH_HOME/skills, normally ~/.dsh/skills. The filesystem route retains its separately tested all-rc.1 compatibility.

Using the Memory Bank panel¶

The panel follows the selected session's project. Overview shows active milestones and task counts; Tasks provides filters, search, and full notes. Acceptance shows recorded verification and review evidence. Memory holds current project facts, and History opens preserved records on demand. Compatibility reports missing files, unsupported formats, conflicting task states, and which installed skill source takes precedence.

External file edits appear through change notifications and a five-second refresh cycle while the panel is visible. It also refreshes on focus and offers manual refresh. Incomplete or denied reads remain visible as warnings.

Browsing and preparing requests make no model calls and do not write project files. A preview is not execution or approval: you send it in the conversation, and the chosen skill retains its approval boundaries. Completed task markers alone do not establish milestone acceptance. For older project formats, prepare an Upgrade request and include the displayed warnings.

Approval email setup¶

Interactive Goal and Next accept --email ADDRESS for workflow approval alerts. The optional helper is included in their complete skill folders and uses Python's standard library with Cloudflare's REST API. No additional skill, background service or audit database is needed.

Configure your Cloudflare account and sender domain, and verify the intended destination. Create a token restricted to that account with Email Sending: Edit permission. Availability and sender verification must be established in your account; installing Tabilet does not do this. See Cloudflare setup and REST authentication.

Create private ${XDG_CONFIG_HOME:-~/.config}/tabilet/email.json, outside projects, with your actual values:

{
  "account_id": "<32 hexadecimal characters from your Cloudflare account>",
  "from": "alerts@your-onboarded-domain.example",
  "allowed_recipients": ["abc@def.gh"],
  "token_env": "CLOUDFLARE_EMAIL_TOKEN"
}

On Linux/macOS, use file mode 0600. Keep the token value in the named private account environment, never in project files, command arguments or this JSON. The selected address must be in allowed_recipients; no CC/BCC or attachments are sent. Protect this account configuration from project-controlled changes.

The skill runs the helper's local-only check before work; it sends no test email and makes no account-verification request. At an actual workflow approval need, only the owner sends a bounded plain-text alert with project, task, sanitized reason and session ID when available. Private attempt records live under ${XDG_STATE_HOME:-~/.local/state}/tabilet/email-notifications/, outside projects. Duplicate/uncertain attempts never replay automatically. accepted or queued describes the provider response, not confirmed inbox delivery. Each network attempt has a 10-second total deadline, including slow responses. The helper reports expected input/protocol failures as JSON unavailable with exit 2, including malformed command arguments (--help still shows usage). Worker input uses bounded UTF-8. The worker starts waiting for input before the attempt is reserved, and receives its job only after the reservation is durable. A process-launch or preflight failure sends nothing and leaves no attempt record; fixing it allows the same alert to be attempted. Once dispatch may have occurred, uncertain reservations remain suppressed. Empty or relative XDG settings use the documented home defaults. Recipient local-part case must match configuration; domains ignore case. If notification identity cannot be recovered on resume, report an alert gap. After resolving a failed/uncertain outcome, an explicitly requested additional alert uses the original run ID and a new hash including the human resend request; changing credentials alone does not resend or remove prior records.

An unavailable sender is reported, and an email failure leaves the existing approval pause intact. Approval is supplied in the agent session. No flag means no email for a new run; resumes retain that run's explicit selection. This feature covers workflow approval requests, not native host tool-approval prompts. The API runner/controller do not consume the option.

Invoke a skill¶

Skill requests go in the agent conversation, not your shell. The prefix depends on how you installed them:

Installation	Example conversation request
Claude Code plugin	`/memory-bank:memory-bank-next`
Codex plugin	`$memory-bank:memory-bank-next`
agy plugin	`/memory-bank:memory-bank-next`
DSH companion or filesystem	`/memory-bank-next`
Claude Code plain files	`/memory-bank-next`
Codex plain files	`$memory-bank-next`
agy plain files	`/memory-bank-next`

Substitute init, archive, propose, reconcile, upgrade, or goal for next as needed. The skill guides explain each input and approval boundary. For Goal, include an explicit order and commit policy.

As plain files you own¶

Clone the v2.1.0 source into a separate directory (seven skills):

git clone --branch v2.1.0 --depth 1 https://github.com/tabilet/skills.git

Copy each memory-bank-* folder from that checkout's skills/ directory into the destination for your agent:

Agent	Personal skill directory
Codex and agy	`~/.agents/skills/`
Claude Code	`~/.claude/skills/`
DSH	`$DSH_HOME/skills/`, normally `~/.dsh/skills/`

Copy complete folders, including their bundled templates and references. Copying only SKILL.md leaves some workflows incomplete. Inspect and back up an existing folder with the same name before replacing it; leave unrelated skills alone. Start a fresh session after changing an installation.

The project files¶

Init prepares project-specific files after you approve its proposal. If you prefer to set them up by hand, copy template/ from the release checkout into a new project:

cp -R /path/to/skills/template/. /path/to/new-project/

The bracketed placeholders are intentional: fill them with your project's facts, plan, and verification commands. For an existing project, merge applicable rules and preserve its instructions; do not copy the template over its current state. Before execution, record a concrete delivery boundary, milestone acceptance, task rows, and verification commands. Keep AGENTS.md as the entry point; if your agent reads another instruction filename, make that file point to AGENTS.md. The first-project walkthrough shows what to check before selecting a task.

The optional API harness¶

The separate API runner needs Python 3.9 or later and Git, plus credentials for your chosen model provider. It uses the Python standard library only.

mkdir -p ~/.local/bin
cp /path/to/skills/harness/tackle-memory-bank-api-loop ~/.local/bin/
chmod +x ~/.local/bin/tackle-memory-bank-api-loop

You can skip the runner when using your existing coding agent. To use it, start with an initialized project at its Git worktree root, a clean committed baseline, and one approved actionable task. Run it inside a disposable sandbox: the runner itself executes model commands in a host shell and does not supply isolation. ALLOW_UNSANDBOXED_SHELL=1 acknowledges that access.

With OPENAI_API_KEY already set in your environment, replace the model and project placeholders and run:

ALLOW_UNSANDBOXED_SHELL=1 LLM_PROVIDER=openai LLM_MODEL=your-model MAX_RUNS=1 \
  ~/.local/bin/tackle-memory-bank-api-loop /absolute/path/to/project

For Anthropic, set ANTHROPIC_API_KEY and use LLM_PROVIDER=anthropic with a compatible model. Provider requests may incur charges. Use the executable's --help for endpoint settings, timeouts, retries, and additional limits.

The API runner requires a commit for each run and stops on dirty state, missing commits, invalid task transitions, or multiple in-progress rows. Exit 7 means the requested run limit was reached; exit 3 means only blocked work remains. Exit 0 means no actionable rows remain, not that every milestone passed its review. Check the recorded verification and closure evidence afterward. Do not run another agent against the same active ledger at the same time.

API-only workflow¶

An API-only setup uses the project's Markdown as authoritative memory and the tabilet/audit.sqlite3 database for observed workflow history. The runner rereads AGENTS.md, active milestones and tasks, current facts, retired history, and evolution files on each run. SQLite records its observed lifecycle, task transitions, verification, and commits, while its index makes current and historical Markdown searchable.

Enable the recorder before starting the runner:

tabilet-audit audit enable /absolute/path/to/project
ALLOW_UNSANDBOXED_SHELL=1 LLM_PROVIDER=openai LLM_MODEL=your-model MAX_RUNS=1 \
  ~/.local/bin/tackle-memory-bank-api-loop /absolute/path/to/project

Audited workflows normally refresh the index when they finish. For manual edits or stale lookup data, use the sync and repair guidance. Use tabilet-audit audit runs --project /absolute/path/to/project to review recorded runs. The API runner owns its own audit lifecycle; do not start a duplicate manual run. Commit the setup ignore file before a clean-Git workflow.

metadata is the default. TABILET_AUDIT_CAPTURE=relevant retains selected visible messages supplied by the runner. It does not capture every API prompt, tool result, hidden reasoning, or surrounding chat. Exact raw text requires the host to submit selected messages as described in the SQLite operator guide.

The optional Tabilet controller sandbox¶

The controller is a separate API workflow; it does not change the standalone runner's host-shell behavior. The first release requires Linux and a running local Docker daemon on a Unix socket. Remote Docker contexts and daemon override variables are rejected because bind mounts must refer to the controller's local project files. Use an Engine version that supports bind-recursive=disabled.

Install tabilet and its seven verified planning bundles from a skills checkout:

python3 harness/tabilet_install.py --source skills --controller-source harness
export PATH="$HOME/.local/bin:$PATH"

The installer places the command in ~/.local/bin, its runtime modules in ~/.local/lib/tabilet/controller, and the canonical skill bundles with a generated SHA-256 manifest under ${XDG_DATA_HOME:-~/.local/share}/tabilet/. It does not write to a project. Keep the source checkout available for later updates, or rerun the installer from a newer checkout.

Prepare a local image yourself before starting a controller proposal. For example, this provides a small Python and shell base; add project-specific tools in your own image when a task needs them:

docker pull python:3.12-slim

The controller never pulls or builds images. It resolves the selected local tag to an immutable image ID before any provider call. The image must contain /usr/bin/env, /bin/sh, and the tools and packages required for the task. Commands run with networking disabled, a read-only container root, a private writable /tmp, and the project mounted writable with .git and existing audit files read-only. The proposal shows the 4 CPU, 8 GiB memory, 512 process, and 300-second per-command limits. Provider credentials remain on the host and are not passed into the container.

Once the optional tabilet command is installed, select the prepared image with tabilet chat PROJECT --image IMAGE. The command asks which planning contract to use (init, propose, or reconcile) and what to deliver. You can provide those without prompts with --operation and --request. The image reference and resolved ID are part of the visible proposal. Before confirm, the full planning diff and row, attempt, turn, commit, elapsed-time, CPU, memory, process, and command-time limits are shown. reject asks for changes and renders a new proposal; it makes no project writes.

Use tabilet status PROJECT for a read-only report and tabilet resume PROJECT to reconcile a receipt and continue a proved checkpoint. If more than one horizon is open, choose it with --receipt UUID. Required manual evidence is collected during resume; if it is missing, the horizon pauses. Extend a reached cap only with tabilet extend-limit PROJECT --limit NAME --value NUMBER, which shows current use and requires a separate exact confirm. A resumed horizon keeps its original counters and elapsed-time clock.

The image reference and resolved ID are part of the visible proposal. Missing tools or Docker setup pauses with exit 17; prepare an updated local image outside the controller and resume from the receipt. External actions are listed for separate handling and never run under the general confirmation. See the controller guide for receipt states, recovery behavior, host Git protections, and exits.

Optional SQLite audit and lookup¶

Markdown stays authoritative. The optional toolkit stores a local audit at tabilet/audit.sqlite3 and builds a rebuildable index of milestones, tasks, history, evolution, and archives.

It needs Python 3.9 or later with the sqlite3 module, built with SQLite 3.24.0 or later. The python.org, Homebrew, and standard Linux distribution builds include it; a Python compiled from source without the SQLite development headers does not. Check with python3 -c 'import sqlite3; print(sqlite3.sqlite_version)'. Text search uses SQLite's FTS5 when available and otherwise falls back to literal matching. The same Python CLI commands support Linux, macOS, and Windows. The audit is optional: if enabled project storage or these requirements are unavailable, the API runner and skills report an audit gap and continue unchanged.

From a checkout containing this feature:

mkdir -p ~/.local/bin
install -m 755 harness/tackle-memory-bank-api-loop ~/.local/bin/
install -m 644 harness/tabilet_audit.py harness/tabilet_index.py ~/.local/bin/
install -m 755 harness/tabilet_explorer.py ~/.local/bin/
install -d ~/.local/share/tabilet/explorer
install -m 644 harness/explorer/index.html harness/explorer/explorer.css harness/explorer/explorer.js ~/.local/share/tabilet/explorer/
install -m 755 harness/tabilet_audit_host.py ~/.local/bin/tabilet-audit
export PATH="$HOME/.local/bin:$PATH"
tabilet-audit audit enable /absolute/project
tabilet-audit index sync /absolute/project
tabilet-audit index search /absolute/project 'authentication' --kind task
tabilet-audit explorer /absolute/project --port 8000

The user manually enables each project; the saved setting survives new sessions. Commit the generated tabilet/.gitignore with /audit.sqlite3*; the database and its sidecars remain ignored. Index creation does not enable audit, and disabling preserves history. Deleting storage leaves audit disabled. Installing skills alone never creates storage. For Windows or an uninstalled CLI, run the same commands with py -3 C:\path\to\skills\harness\tabilet_audit_host.py instead of tabilet-audit. Relevant message capture is separately opt-in; exact chat text requires host capture. The index stores current Markdown text even in metadata-only audit mode. Index results show the last refresh and source location; reread live Markdown before execution. New full-file snapshots are deferred, and existing snapshot evidence is preserved. The toolkit uses Python's standard library and requires no npm package.

The loopback-only explorer opens Overview, Timeline, and To-do. It reads recorded audit runs and the current derived index while Markdown remains authoritative. Timeline groups goal children and keeps its filters and selected detail in the URL. To-do keeps blockers, dependencies, and closure evidence visible even when the live ledger requires further review. Refresh is explicit, migrates supported older databases, and writes the project SQLite database. Setup also adds its Git exclusion. Follow-up buttons prepare copyable prompts after rechecking live source hashes; they never run an agent or edit project files. From a Chromebook, tunnel a remote server with ssh -N -L 8000:127.0.0.1:8000 user@host and open http://localhost:8000/. Missing captures and stale sources remain visible as diagnostics, and the live ledger remains the source for task selection. Non-loopback --host values are rejected.

See the repository's operator guide for host lifecycle, filters, fallback search, migration, backup, and recovery. The separate DSH dashboard continues reading project Markdown. Installing the Explorer adds this local graphical view; it does not add host transcript hooks.

Update¶

For Claude Code, run the CLI update commands in your terminal:

claude plugin marketplace update tabilet
claude plugin update memory-bank@tabilet

(Or inside an active session: /plugin marketplace update tabilet, then /plugin install memory-bank@tabilet, followed by /reload-plugins.)

For Codex, refresh the marketplace snapshot and reinstall the plugin:

codex plugin marketplace upgrade tabilet
codex plugin add memory-bank@tabilet

For agy, re-run agy plugin install https://github.com/tabilet/skills to pull the latest version.

For the DSH companion, install the chosen published release archive in each applicable profile, then restart it. For filesystem installs, stop sessions using the bundles, inspect and back up the installed folders, then replace them with complete folders from the chosen release. Preserve unrelated skills and review project or user overrides that may take precedence over the new bundles.

Updating installed skills does not migrate project rules. Use Upgrade to inspect an existing project and approve specific rule merges. Keep task state, permanent IDs, local policies, and history intact.

Remove¶

Use the uninstall command for your installation:

Installation	Command and where to run it
Claude Code plugin	`claude plugin uninstall memory-bank@tabilet` in a terminal, or `/plugin` in Claude Code
Codex plugin	`codex plugin remove memory-bank@tabilet` in a terminal
agy plugin	`agy plugin uninstall memory-bank` in a terminal
DSH Web companion	`dsh plugin --profile web remove tabilet-skills` in a terminal

Remove the DSH headless installation separately if you installed it there. For plain-file installs, remove only the identified memory-bank skill folders. Project Markdown remains in the project and is still usable after removal.

If a skill or dashboard is missing¶

Confirm the selected session points at the project you intended.
Start a fresh session after installation. Restart DSH after changing a profile.
Check the invocation prefix above. A DSH Web installation does not install the companion in the headless profile.
In DSH's Compatibility view, inspect the winning skill source. An existing project or user copy can take precedence over the bundled one.
The skills repository itself contains a sample at template/tabilet/memory-bank/; it has no active project memory bank for the dashboard to display.