Adds Dial — a real phone number for SMS and AI voice\ncalls. Native adapter (no Chat SDK bridge): both directions go through the\ndial CLI — outbound via dial message, inbound via its command-target daemon. NanoClaw doesn't ship\nchannels in trunk — this skill copies the Dial adapter, its pairing helper, and\ntheir tests in from the channels branch. The pair-dial setup step is\nmaintained in trunk, so it is not copied here.
The mechanical steps under Apply carry nc: directive fences: an agent\nreads the prose and applies them, and a parser can apply them deterministically\nfrom the same document. Every directive is idempotent, so the whole skill is\nsafe to re-run; anything a parser can't apply falls back to the prose beside it.
Fetch the channels branch and copy the Dial adapter, its pairing store and\nuser-agent helper (each with its test), and the registration test into place\n(overwrite — the branch is canonical):
src/channels/dial.ts\nsrc/channels/dial-pairing.ts\nsrc/channels/dial-pairing.test.ts\nsrc/channels/dial-user-agent.ts\nsrc/channels/dial-user-agent.test.ts\nsrc/channels/dial-registration.test.ts\nsrc/channels/dial-grant.test.ts\nThe dial-cli container skill is deliberately not copied here.\ncontainer/skills/ is mounted read-only into every agent container\n(src/container-runner.ts), and a group with skills:'all' picks up whatever\nit finds there — so shipping the skill with the adapter would hand it to agents\non installs that never configured Dial. It is installed only by\n/add-dial-tool, offered under Add phone superpowers below, which is the\nskill that actually provisions the CLI the skill documents.
dial.ts imports dial-user-agent.js at module scope, so omitting that helper\nbreaks the build and every test that loads the channel barrel.
Append the self-registration import to the channel barrel (skipped if present).\nThis one line is the skill's only reach-in into the channel core:
\nimport './dial.js';\nAdd the pair-dial loader to the STEPS map in setup/index.ts, inside the\ndormant marker region (skipped if already present — pair-dial ships in core, so\nthis idempotent-skips on a normal install, but is expressed for a clean-upstream\nrebuild). The pairing handshake below spawns this step:
'pair-dial': () => import('./pair-dial.js'),\nPinned to exact versions — the supply-chain policy rejects ranges and latest.\nqrcode renders the scannable pairing card:
qrcode@1.5.4\nThe adapter needs no Dial client library: it shells out to the dial CLI, which\nthis skill already requires for inbound. @getdial/sdk was dropped because it\ndepends on pubnub, which pulls react-native, Metro and Hermes into the\nlockfile for what is a single send — and the CLI ships in lockstep with the Dial\nAPI, so a contract change arrives as a CLI release rather than breaking a\nrequest pinned in the adapter.
Build first: it guards the adapter's typed core calls and proves the dependency\nis installed. Then run the one integration test.
\npnpm run build\npnpm exec vitest run src/channels/dial-registration.test.ts\ndial-registration.test.ts imports the real channel barrel and asserts the\nregistry contains dial — it goes red if the import line drifts. End-to-end\nSMS/voice is verified manually once the service runs.
Dial's CLI owns the account credential (an auth file it writes on sign-in), so\nthe setup uses the dial CLI here. Ensure it's installed — this installs it if\nit's missing (for the full onboarding/auth reference, see the dial-cli skill or\ncurl -fsSL https://getdial.ai/skills.md):
command -v dial || curl -fsSL https://getdial.ai/install | bash\nCalls this setup makes to Dial identify the install. The dial CLI prepends\nDIAL_USER_AGENT to its own token, so the account's requests stay attributable\nto this NanoClaw install in Dial's server-side logs. Resolve the token once\n(nanoclaw/<version>; an unreadable package.json degrades to\nnanoclaw/unknown rather than blocking the install) and prefix every dial\ncommand below with it:
node -p \"'nanoclaw/'+(require('./package.json').version||'unknown')\" 2>/dev/null || echo nanoclaw/unknown\nNow pin the CLI's absolute path into .env. The adapter shells out to dial\nto register its inbound command target, and it runs inside the NanoClaw service,\nwhich does not inherit your interactive shell's PATH. The CLI usually lands in\na version-manager bin directory (~/.nvm/versions/node/*/bin, ~/node/bin, …)\nthat the service cannot see, so a bare dial fails with ENOENT, the command\ntarget is never registered, and the channel comes up connected but deaf — no\ninbound SMS or calls, with only a line in logs/nanoclaw.error.log to show for\nit. DIAL_CLI_PATH removes the guesswork; dial.ts already prefers it:
command -v dial\nDIAL_CLI_PATH={{dial_cli_path}}\nCheck whether you're already signed in:
\nDIAL_USER_AGENT={{dial_ua}} dial doctor --json\nIf you're not signed in, go straight to email verification — default the\nchoice so the branch guard below stays single-valued:
\necho switch\nIf you are signed in, read which account (for the prompt below) and ask\nwhether to reuse it or sign in as a different one (matches the old wizard's\n\"Reuse this account?\" prompt, with an explicit way to switch):
\nDIAL_USER_AGENT={{dial_ua}} dial doctor --json\nYou're already signed in to Dial as {{connected_email}}.\nReuse this Dial account, or sign in as a different one? (reuse/switch)\nReuse — no verification needed; with no --code the command just (re)installs\nthe NanoClaw agent skill:
DIAL_USER_AGENT={{dial_ua}} dial auth verify-otp --agent nanoclaw\nSwitch (or not signed in) — verify an email with a one-time code. Collect the email:
\nWhat's your email? Dial sends a one-time code to verify it. By continuing you create a Dial account and agree to Dial's Terms of Service (https://getdial.ai/terms) and Privacy Policy (https://getdial.ai/privacy).\nSend the code (--force re-sends even if a prior code is pending):
DIAL_USER_AGENT={{dial_ua}} dial auth login {{owner_email}} --force\nCollect the code (resolves inline, right after the send above):
\nEnter the 6-digit code from your email\nVerify it and provision your number (this also installs the NanoClaw agent skill):
\nDIAL_USER_AGENT={{dial_ua}} dial auth verify-otp --code {{otp}} --agent nanoclaw\nConfirm the account's number — this becomes the agent's public line (its\nplatform_id):
DIAL_USER_AGENT={{dial_ua}} dial number list --json | jq -er '.numbers[0].number'\nYour agent's Dial line is {{platform_id}}.\nSet the line's inbound behavior — the system prompt the AI uses on calls into\nthis number. Verification no longer takes an instruction, so a fresh number\nstarts on Dial's default greeting until this runs:
\nDIAL_USER_AGENT={{dial_ua}} dial number set {{platform_id}} --inbound-instruction \"You are a friendly AI receptionist answering calls to this number. Greet the caller, ask how you can help, and take a clear message — their name, number, and reason for calling — if you cannot help directly.\"\nMake that line the CLI's default sender. Verification saves whichever number\nthe account considers primary — the oldest one — while the line picked above\nis the newest (numbers[0]). On a single-number account those coincide, so\nnothing looks wrong; with two or more they diverge permanently, and every\ndial call / dial message that omits --from-number goes out from a number\nthis install isn't listening on. Replies to it are dropped as no_agent_wired.
Rewriting phoneNumber/phoneNumberId in the auth file makes the no-flag path\nland on the wired line, so an agent that forgets the selector is still correct:
f=\"${XDG_DATA_HOME:-$HOME/.local/share}/dial/auth.v1.json\"; i=$(DIAL_USER_AGENT={{dial_ua}} dial number list --json | jq -er --arg n '{{platform_id}}' '.numbers[]|select(.number==$n)|.id') && jq --arg n '{{platform_id}}' --arg i \"$i\" '.phoneNumber=$n|.phoneNumberId=$i' \"$f\" > \"$f.new\" && mv -f \"$f.new\" \"$f\" && chmod 600 \"$f\" && echo \"default sender pinned to {{platform_id}}\"\nA phone number is guessable, and whoever reaches the agent gets a turn with it —\nincluding its dial CLI, which is authenticated for the whole Dial account. An\nadmitted stranger can ask the agent to list every SMS and call on the account,\nread call transcripts, or buy another number. Session isolation doesn't prevent\nthis: the credential is the exposure, not the conversation.
So decide who gets in. owner is the safe default; pick public only if you\nwant a line strangers can start conversations on (an inbound receptionist, or\noutbound sales where prospects text back):
Who may text this line — `owner` (only the phone you pair next; everyone else is refused) or `public` (anyone who knows the number reaches the agent)?\nYour answer is written to the line's own unknown_sender_policy when the line is\nregistered below, after the restart (ncl is socket-only, so it needs the\nservice up). It lives in the database from then on — per line, so a second number\nadded later carries its own answer — and the adapter never rewrites it.
Locked to you: only the phone you pair in a moment can reach the agent on {{platform_id}}. Anyone else who texts it is refused — including people your agent calls, so they can't reply by text. To open it later: `ncl messaging-groups update --id <id> --unknown-sender-policy public` (find the id with `ncl messaging-groups list`).\nOpen line: anyone who knows {{platform_id}} can text the agent and will get a reply. Each person gets their own conversation, but they all reach an agent holding your Dial account credentials — so don't hand out this number casually. To lock it to just you later: `ncl messaging-groups update --id <id> --unknown-sender-policy strict` (find the id with `ncl messaging-groups list`).\nRestart the service so it loads the Dial adapter, and wait for its CLI socket.\nThe adapter must be live and polling before pairing — it's the thing that\nobserves the code you text:
\nbash setup/lib/restart.sh\nWire inbound event delivery and the command target. Both are best-effort: a\nsandbox/CI without a user-service supervisor can't run the listen daemon, but\noutbound still works and inbound can be started manually later (see\nTroubleshooting), so these never fail the run:
DIAL_USER_AGENT={{dial_ua}} dial listen install || true\nDIAL_USER_AGENT={{dial_ua}} dial local-target add cmd \"$PWD/data/dial/handle-dial-event.sh\" || true\nRegister the line, carrying the access choice from above onto its own row. One\nplatform_id serves many correspondents, so it's a group (--is-group 1) and\neach texter becomes a thread inside it. Idempotent — a re-run returns the\nexisting row, and does NOT reset a policy you have since changed with ncl:
ncl messaging-groups create --channel-type dial --platform-id {{platform_id}} --is-group 1 --name \"Dial {{platform_id}}\" --unknown-sender-policy strict\nncl messaging-groups create --channel-type dial --platform-id {{platform_id}} --is-group 1 --name \"Dial {{platform_id}}\" --unknown-sender-policy public\nDial account auth carries no per-sender binding, so the agent proves you own the\nphone you'll text from with a one-time pairing handshake: it issues a 6-digit\ncode, you text those exact 6 digits to the Dial line, and the live adapter\nmatches them. Tell the user:
\nA 6-digit pairing code (and a scannable QR) is about to appear in this terminal. From the phone you want to use, text just those 6 digits to your Dial line {{platform_id}} — or scan the QR, which opens Messages pre-filled so you just press Send.\nRun the pairing handshake. It prints the code/QR, streams \"waiting…\" while it\nwatches for your text, and resolves the sender's number once the code matches:
\npnpm exec tsx setup/index.ts --step pair-dial -- --line {{platform_id}}\nowner_handle (the phone you paired from) and platform_id (your Dial line) are\nwhat the owner-wiring step needs. The greeting goes out over your Dial line as\nsoon as pairing completes.
Now set expectations about outbound SMS, before the operator hits it as a silent\ncarrier rejection. Calls both ways and inbound texts work from this moment; US\ncarriers drop outbound SMS from a number that has no 10DLC registration, and the\nadapter reports that as a delivery-failure notice rather than anything the\noperator can fix in NanoClaw:
\nYour number {{platform_id}} can receive texts and calls now. To text US numbers it needs 10DLC registration: $25, usually 3-5 business days, here's the link: https://getdial.ai/dashboard/numbers\nShow the pitch as a boxed note, then ask — mirrors the old wizard's p.note
Add phone superpowers to your assistant? Say yes so your assistant can send SMS and make AI calls for you from every channel you use it on — Telegram, WhatsApp, and more.\nInstall the Dial tool now?\nIf yes, apply the /add-dial-tool skill now, as its own document describes. It\nasks which agents may use Dial (and blocks the rest at the gateway), puts the\nCLI and its skill in the agent image, and registers the account's key with\nOneCLI. It needs OneCLI; if that isn't set up it says so, and the channel\nstill works without the tool:
pnpm exec tsx setup/lib/skill-driver.ts .claude/skills/add-dial-tool\nThen tell the sandboxed agent which line is its own. The container authenticates\nthrough the OneCLI proxy and has no auth file, so defaultNumberId is null\nin there — an agent that omits --from-number gets an error, and one that picks\nfrom dial number list gets whichever number sorts first, which is unrelated to\nwhat's wired. Only this skill knows the answer, so it has to write it down —\ninto the mounted skill file, which every container reads on its next spawn:
if [ ! -f container/skills/dial-cli/SKILL.md ]; then echo \"dial-cli skill not installed (the tool installer did not complete) — skipping the wired-line note\"; else printf '\\n## This install'\"'\"'s line\\n\\nAlways pass `--from-number {{platform_id}}` on every `dial call` and `dial message`. That is the line this NanoClaw install is wired to; any other number on the account reaches nobody and replies to it are dropped.\\n' >> container/skills/dial-cli/SKILL.md && echo \"wired line recorded for the sandbox: {{platform_id}}\"; fi\nIf you're in the middle of /setup, return to the setup flow now. Otherwise wire\nthis channel with /init-first-agent (or /manage-channels). To add a second\nDial number later, see the /add-dial-number skill.
dial+14155550123) — unlike prefixed channels, the number itself is the id.pnpm exec tsx setup/index.ts --step pair-dial -- --line <E.164>. The step prints a 6-digit code + QR; tell the user to text just those 6 digits to the Dial line. Success emits a PAIR_DIAL block with STATUS=success, PLATFORM_ID (the bare line), and PAIRED_NUMBER (the bare sender E.164). The service must be running — the adapter is what observes the code.inbound_access): owner admits only the paired phone, public admits everyone. Defaults to owner-only.dial: command not found / the CLI gate fails. The Dial CLI isn't on PATH. Run curl -fsSL https://getdial.ai/skills.md and follow its install steps, then re-run this step.
The email code never arrives. Check spam, confirm the address is one you can read, and re-run — dial auth login <email> --force re-sends. The code is sent by Dial's servers, not NanoClaw.
Inbound texts/calls don't reach the agent. dial listen install needs a user-service supervisor (launchd/systemd --user); sandboxes/CI don't have one. Outbound still works. Start it manually with dial listen install once a supervisor is available, and confirm the command target with dial local-target list.
Pairing never completes. The live adapter observes the code, so the service must be running — the restart step comes before pairing for exactly this reason. Text just the 6 digits to the Dial line; a wrong message is ignored. Codes expire after 10 minutes, so if it times out (5 min) or the code goes stale, re-run this step for a fresh one.
\n\"Pairing is paused for about N min.\" Five wrong codes texted to the line inside 10 minutes locks that line for 15 — a brute-force guard, and while it holds even the correct code is refused. The wizard prints this warning when it happens; nothing is texted back to the sender, by design. Wait it out and re-run this step for a fresh code, or override the thresholds with DIAL_PAIRING_MAX_ATTEMPTS / DIAL_PAIRING_ATTEMPT_WINDOW_MS / DIAL_PAIRING_COOLDOWN_MS / DIAL_PAIRING_TTL_MS.
Everything green but no replies. Run pnpm exec vitest run src/channels/dial-registration.test.ts — red means the barrel import drifted, so re-run the Apply steps. If green, restart again (bash setup/lib/restart.sh) and check logs/nanoclaw.error.log.