Documentation Dalo assistant

Use Dalo through your agent

Talking to your agent is the recommended way to install and use Dalo. Describe the result you want: add your team's skills, check for updates, connect another agent, or get an old setup working again. Your agent inspects the installation, runs the right Dalo commands, and explains what changed. You do not need to learn the CLI or interpret its reports yourself. Dalo's approval, audit, and ownership checks apply to the operations your agent runs through Dalo.

The skill lives in skills/dalo. It contains instructions and supporting references, with no separate model, API key, server, or background service. The agent needs filesystem access and permission to run commands for changes. It can inspect existing folders before Dalo is installed.

Start with an ordinary request

Paste this into your local coding agent:

Install Dalo, the agent skill manager.

The agent follows the installation guide to install the binary, connect the intended skill folder, deliver the bundled assistant, and verify the result. No Dalo skill is needed first. The agent needs web or repository access to find the instructions and local command access to perform the installation.

If your agent cannot find the official project, include the guide directly:

Install Dalo from https://dalo.sh/install.md and set it up for this agent.

Discovery depends on the host's tools. The site's llms.txt is an additional documentation index. The same installation path is linked from normal HTML and the README, so it does not depend on automatic llms.txt support.

Keep using Dalo through conversation

Installation is the first request. The same agent can manage your skills from then on. Select the Dalo skill in your agent, or use its skill invocation syntax, such as $dalo in Codex. Ask in your own language:

Understand your setup

“Dalo, what skills are installed and what needs attention?”

Add your team's skills

“Add our skill repository at this URL and make its skills available here.”

Review updates

“Update my skills and show me what changed.”

Automate team updates

“Update my global team setup each morning and tell me when something changes or needs attention. Keep my personal catalog pins.”

Connect another agent

“Make the same skills available in Claude Code.”

Preserve existing work

“I used skills.sh before. Move these skills to Dalo and keep my changes.”

Keep your own skills private

“Bring my own skills under version control without sharing them publicly.”

Recover an old setup

“I installed Dalo months ago. Get this setup working again.”

You supply the goal and decide which sources and changes to trust. The agent checks the actual folders, previews changes, and turns Dalo's reports into an explanation and next step. It can account for the store and target paths already in use, local edits, and skills installed by another tool.

A bare invocation starts with a local assessment and a suggested next step. It does not install software or change your setup. A concrete request continues through the relevant work, asking about choices that cannot be inferred, such as two different versions of a skill with the same name.

Automate updates

Ask your agent or host to run updates when you need them: on demand, at session start where supported, or on a schedule you choose. The automation owns the timing, retries, and notifications. Dalo performs the requested update and reports its result through the CLI.

Choose the scope and update policy explicitly. A global team sync refreshes tracking sources and follows catalog pins declared by the team; personal catalog pins change only in a separately requested update. In a project, installation restores the checked-in dalo-project.toml, while project update authors a new pin. A normal Git pull does not run Dalo's installation or synchronization step. If the declaration sets approval = "declaration", the reviewed declaration approves its selection, so the agent does not ask you to approve each skill in every clone or worktree; otherwise each project store keeps its own local approvals. See Approval modes.

For an initialized store, an automation can run:

dalo --store <store-path> --json sync --check

--check still applies the sync and exits nonzero when the result needs review. It is not a read-only upstream check. A project automation instead uses dalo --project <project-path> --json install to restore the current definition. The CI guide describes JSON reports, exit codes, and read-only catalog drift checks.

The agent reads the result and uses its own notification channel for meaningful changes or required decisions. Pending approvals, security findings, conflicts, and local edits need attention; an unattended run does not grant new trust or discard work. A request for recurring updates does not select a cadence or notification policy for you.

Existing OS-native autosync commands remain supported in Dalo 1.x. Agent-managed update workflows use the host's automation facilities; desktop, webhook, and mail notifications are handled there.

Dalo's checks still apply in conversation

Your agent turns the request into a plan and explains the decisions. When it runs Dalo, the same approval, audit, and ownership checks apply as in the terminal. Catalog skills need approval, sync preserves unmanaged files and reports unresolved conflicts, and dirty source checkouts block refresh so local edits are preserved.

Before an approval the agent shows what a skill needs from the machine: its compatibility text, commands it expects on PATH, and release binaries it declares. A declared binary keeps its own approval, which downloads and verifies the pinned asset only when you ask for it.

If a check blocks an operation, the agent can explain the finding and help you choose what to do next. You keep the decisions about sources, skills, and risk; the agent handles command syntax and reports. The security overview describes these protections and their limits. They apply to Dalo operations; the assistant is not a sandbox for everything your agent can do.

Bundled installation

Every supported binary includes the complete skill that matches that CLI release. The first normal invocation, including bare dalo, next, or JSON status, prepares the bundle automatically. No separate init, skill manager, or skill download is required. The local store is created when needed; existing incomplete or ambiguous stores remain blocked for inspection.

For the default global store, Dalo places only its own companion skill in existing known agent skill directories. These folders do not become general Dalo targets: adding sources or running sync does not deliver other skills to them. Shared physical folders receive one link. An explicit custom store only uses targets already linked to that store, so sandbox use cannot install skills into global agent folders. If no agent folder is known yet, the bundle remains prepared and Dalo reports the target setup needed. init and target link remain available as explicit setup steps.

Every normal invocation verifies the complete bundle against the running binary. An unmodified older bundle is replaced with the matching packaged content; existing owned links see the update immediately. Extra files, edited content, foreign links, and assistants supplied by another source remain preserved. This is an offline package consistency check, not an independent internet update of the skill.

Normal invocations print an assistant: line on stderr only when that invocation changed something: the bundle was prepared for the first time or updated, or a new agent folder received the companion link. A blocked setup, or an assistant that another installer owns, is reported once per store and then stays quiet; the store keeps a small .assistant-notice marker so it remembers. A custom or project store never announces an assistant it finds outside its own bundle, because from a sandbox the global store's companion links look exactly like that. The state stays visible in dalo assistant status, in assistant.state of dalo --json status, and as the info finding assistant_external in dalo doctor.

JSON and noninteractive calls use the same first-use setup. --help, --version, dry runs, plan, explicit assistant inspection, and independent team/tool/hook/scheduler commands do not trigger it. Set DALO_ASSISTANT_CHECK=never to disable automatic setup and freshness updates. An installed bundle remains eligible for ordinary sync. Explicit dalo assistant install remains a manual recovery route for initialized stores.

Project use stays project-local: install prepares the bundle in the project store and delivers it to declared targets. Later normal project invocations check it only after project validation and consider only linked project targets. A project invocation never discovers or installs global companions.

dalo assistant status --json and status --json report local freshness, verified delivered_paths, external entries, and any configured undelivered_targets. Native agent discovery may require a skill reload or a new session. Companion-only links have a versioned assistant-links.toml ownership receipt in the store; ordinary target ownership remains separate.

For an existing setup, keep its store and target paths and inspect it first. Review a whole-store sync preview before applying it: existing team sources may refresh, and all configured targets receive active skills. Other skills are not adopted as part of assistant setup. A customized local dalo skill must be preserved and deliberately moved before that slot can hold a bundle.

A foreign assistant in an agent folder also remains untouched. The assistant can help plan a handover, but the installer does not take ownership of it. Once the files are delivered, the agent can read dalo/SKILL.md to continue the same conversation. If native discovery is delayed, reload skills or start a new session as required by that host.

Other installation routes

On a release without dalo assistant install, upgrade through your existing installation channel or install the complete skills/dalo folder through your agent's skill installer. Keep references and agents alongside SKILL.md. For example, with the skills CLI:

npx skills add sebastian-software/dalo --skill dalo --agent codex --global

To try unpublished work from this repository checkout:

npx skills add ./skills/dalo --skill dalo --agent codex --global

For Claude Code, use --agent claude-code. This route installs the skill first; ask it to set up Dalo and it can install the missing binary. Installing the skill alone does not migrate existing folders. Keep its installer ownership explicit if you later switch to the bundled route.

What the assistant accounts for

It combines Dalo's reports with inspection of relevant existing skill folders. This includes folders not linked to Dalo, shared symlinks, project-only skills, and available installer metadata. Missing permissions and uncertain provenance remain visible instead of being treated as an empty installation.

For migration, the assistant distinguishes a preserved local snapshot from a skill reconnected to an upstream repository. A snapshot keeps your content but does not receive upstream updates. Installer metadata helps identify a source; it does not prove that your local copy is unchanged or grant Dalo approval.

Real skill directories can use Dalo's audited adoption flow. Foreign symlinks need an explicit handover with preserved content and recovery paths. The assistant reports anything that remains managed by another installer, including old lock records that might still cause that installer to update migrated paths. Project-only skills stay a separate scope; moving them to a user-level target would make them available in other projects too.

The assistant uses the capabilities of the installed Dalo version. It does not add a native import command, first-class project profiles, or automatic foreign lockfile conversion. It cannot guarantee that every unknown installer layout can be migrated automatically. Dalo's own protections still enforce approvals, dirty-source handling, and ownership during CLI operations; any necessary manual handover is prepared and verified separately.

See Getting started for the command-line path and Troubleshooting for diagnostic details.

Source: docs/assistant.md