moshcode 0.70.0 → 0.72.0

package/.claude-plugin/marketplace.json

@@ -30,6 +30,30 @@
       },
       "homepage": "https://github.com/moshcoder/moshcode#crypto",
       "keywords": ["crypto", "bitcoin", "markets", "prices", "advis0r"]
+    },
+    {
+      "name": "timer",
+      "description": "Track time against projects from inside your engine, backed by @profullstack/timer: start and stop a clock, log time you forgot, and report billable hours with the agent count that priced them.",
+      "source": "./plugins/timer",
+      "category": "productivity",
+      "author": {
+        "name": "moshcoder",
+        "url": "https://moshcode.sh"
+      },
+      "homepage": "https://github.com/profullstack/timer#readme",
+      "keywords": ["timer", "time-tracking", "billable", "hours", "profullstack"]
+    },
+    {
+      "name": "billing",
+      "description": "Turn tracked hours into an invoice, backed by @profullstack/billing: clients, rate cards written as contract sentences, agent-hour arithmetic, and invoices rendered to HTML you can print to PDF.",
+      "source": "./plugins/billing",
+      "category": "productivity",
+      "author": {
+        "name": "moshcoder",
+        "url": "https://moshcode.sh"
+      },
+      "homepage": "https://github.com/profullstack/billing#readme",
+      "keywords": ["billing", "invoice", "clients", "rates", "profullstack"]
     }
   ]
 }

package/README.md

@@ -62,6 +62,12 @@ or miss one that does. A test fails the build when it drifts.
 | `moshcode crypto` <br>`coins` | tools | crypto market data from advis0r.com |
 | `moshcode news` | tools | headlines from your feeds, or a search |
 | `moshcode rss` | tools | read the same headlines in a full-screen reader |
+| `moshcode timer` | business | track time — on, off, and what it added up to |
+| `moshcode client` <br>`business` `merchant` `customer` | business | who the work is for — clients, businesses, merchants |
+| `moshcode team` <br>`teams` | business | who may do what on this machine |
+| `moshcode rate` <br>`rates` | business | what an hour of agent time costs |
+| `moshcode billing` <br>`invoice` | business | turn tracked time into an invoice |
+| `moshcode payments` | business | the rail invoices go out on |
 | `moshcode plugin` <br>`plugins` | extend | install moshcode's slash commands into Claude Code |
 | `moshcode commands` | script | list built-in moshscript commands |
 | `moshcode completion` | extend | print a shell completion script |
@@ -937,6 +943,120 @@ event, and publishes it to the displayed relays. Both flows leave the final
 confirmation in the browser. If the pit is remote or headless, `/post` prints
 the composer URL instead.
 
+## Getting paid (`/timer`, `/client`, `/rate`, `/billing`, `/payments`)
+
+Every agentic CLI helps you do the work. This one also bills for it. Six words,
+each useful on its own — the timer needs no client, the rate needs no gateway
+(PRD [0012](prd/0012-billing-baked-into-the-agent-cli.md)).
+
+> **`/timer` and `/billing` now prefer their own CLIs.** Tracking time and
+> sending an invoice are not moshcode ideas — they are useful under any agentic
+> CLI, and on Windows, where moshcode does not go. So they also ship standalone:
+> [`@profullstack/timer`](https://github.com/profullstack/timer) and
+> [`@profullstack/billing`](https://github.com/profullstack/billing).
+>
+> ```sh
+> moshcode install timer billing   # or: npm install -g @profullstack/timer @profullstack/billing
+> ```
+>
+> Installing them changes nothing on its own. Switch the hand-over on when you
+> are ready to move:
+>
+> ```sh
+> billing import                       # look at what would come across
+> billing import --apply               # move it
+> export MOSHCODE_EXTERNAL_BILLING=1   # /timer and /billing now run the CLIs
+> ```
+>
+> **It is opt-in for a reason.** Only half this layer has an outside home:
+> `/client`, `/rate`, `/payments` and `/team` stay here, because the rails and
+> the permission model are moshcode's and `/client`'s freeform dotted fields
+> have no shape in the package's typed client model. Handing over the other
+> half automatically would split your records across two stores — `/client` and
+> `/rate` writing `~/.moshcode/business.json` while `/billing` reads the
+> package's own ledger, so the invoice for a client you had just created would
+> not exist. `billing import` is what closes that gap, which is why it comes
+> first.
+>
+> The standalone billing carries the same rate model (`$100/hour/agent/upto:4`)
+> and bills **agent-hours**.
+
+```sh
+moshcode timer on acme --task "batch payments" --agents auto   # auto counts the herd
+moshcode timer off                                             # → 1h 12m, $480.00
+moshcode timer log --week                                      # this week's timesheet
+```
+
+The timer is a stopwatch and a ledger in `~/.moshcode/timers.json`, and it knows
+nothing about money. It does know about **agents**, which is what makes it
+different from every other stopwatch: an hour of moshcode is an hour times
+however many engines ran in it.
+
+```sh
+moshcode client create "Acme Inc", https://acme.com, +1-555-0100
+moshcode client create globex --contact.telephone +1-555-0200 --contact.name Jane
+moshcode client payee acme-inc solana:9xQe…        # where their payments land
+```
+
+Contact details are written the way they arrive: the comma form for what you
+pasted out of a signature, `--a.b` dotted flags for anything else. There is no
+fixed field list — `--billing.po` works because it says what it means.
+`/business`, `/merchant` and `/customer` are the same command.
+
+```sh
+moshcode rate set default $100/hour/agent/upto:4
+moshcode rate set acme-inc 0.5 SOL/day --prefer SOL,USDC --accept fiat
+moshcode rate set initech $5000/project
+```
+
+`$100/hour/agent/upto:4` is the sentence from the contract, parsed: price,
+period, unit, and the cap that made the client sign. Four agents cost four
+hundred an hour and **so do six**. Order after the price does not matter.
+
+```sh
+moshcode billing acme-inc                 # a preview — writes nothing
+moshcode billing acme-inc --month --mark  # claim the time, record the invoice
+moshcode billing acme-inc --send          # compose the gateway command
+moshcode billing acme-inc --send --yes    # …and run it
+```
+
+Two rules the shape enforces: time is never billed twice (an entry carries the
+invoice that claimed it, and `--mark` is the only verb that writes), and nothing
+settles to an address nobody chose — no payee and no wallet rail is a refusal,
+not a guess.
+
+```sh
+moshcode payments connect coinpay                                   # runs `coinpay login`
+moshcode payments connect wallet --chain solana --address 9xQe…     # no gateway at all
+moshcode payments connect paypal --vault profullstack--prod         # keys live in the vault
+```
+
+moshcode composes an invoice; a gateway delivers it. No secret is stored here: a
+CLI gateway keeps its own session, and an OAuth gateway gets a reference to the
+vault its keys live in (`moshcode secrets`), never the keys.
+
+### Teams and grants (`/team`)
+
+For a machine you handed to somebody else:
+
+```sh
+moshcode team create Profullstack
+moshcode team add profullstack preshy --role member --rate '$80/hour'
+moshcode team grant profullstack preshy tools:coinpay
+moshcode team can profullstack/preshy payments:write     # → no
+```
+
+A permission is `surface:target`, written however you say it — `tools:coinpay`,
+`tools/coinpay` and `allow(tools/coinpay)` are one grant. Roles (`owner`,
+`admin`, `member`, `client`) are a starting set; grants add to them.
+
+The pit gates itself only when `MOSHCODE_MEMBER=<team>/<handle>` is set — with
+it unset the owner is at the keyboard and nothing is checked. **This is a
+guardrail, not a security boundary.** moshcode runs as the person at the
+keyboard, and anyone who can type `/team` can also edit
+`~/.moshcode/business.json`. A boundary that has to hold against somebody is an
+OS account, a container, or a scoped credential.
+
 ## The arcade (`/games`)
 
 Twenty-two games, in the pit or straight from a shell. There are no menus, no options

package/bin/moshcode.mjs

@@ -418,6 +418,52 @@ async function main() {
     if (code) process.exitCode = code;
     return;
   }
+  // The business layer. Imported where they are dispatched rather than at the
+  // top of the file: six modules that read two JSON files are dead weight in
+  // the startup path of `moshcode claude`, which is what this binary is mostly
+  // asked to do.
+  if (cmd === "timer") {
+    // @profullstack/timer when it is installed, the built-in otherwise. See
+    // src/business-delegate.mjs for why the external one wins.
+    const { delegate, installHint } = await import("../src/business-delegate.mjs");
+    const handed = await delegate("timer", rest, {});
+    if (handed.delegated) { process.exitCode = handed.code; return; }
+    const { timerCommand } = await import("../src/timer.mjs");
+    process.exitCode = (await timerCommand(rest)) || 0;
+    const hint = installHint("timer");
+    if (hint) process.stderr.write(`${hint}\n`);
+    return;
+  }
+  if (cmd === "client" || cmd === "business" || cmd === "merchant" || cmd === "customer") {
+    const { clientCommand } = await import("../src/clients.mjs");
+    process.exitCode = clientCommand(rest) || 0;
+    return;
+  }
+  if (cmd === "team" || cmd === "teams") {
+    const { teamCommand } = await import("../src/teams.mjs");
+    process.exitCode = teamCommand(rest) || 0;
+    return;
+  }
+  if (cmd === "rate" || cmd === "rates") {
+    const { rateCommand } = await import("../src/rates.mjs");
+    process.exitCode = rateCommand(rest) || 0;
+    return;
+  }
+  if (cmd === "billing" || cmd === "invoice") {
+    const { delegate, installHint } = await import("../src/business-delegate.mjs");
+    const handed = await delegate(cmd, rest, {});
+    if (handed.delegated) { process.exitCode = handed.code; return; }
+    const { billingCommand } = await import("../src/billing.mjs");
+    process.exitCode = billingCommand(rest) || 0;
+    const hint = installHint(cmd);
+    if (hint) process.stderr.write(`${hint}\n`);
+    return;
+  }
+  if (cmd === "payments") {
+    const { paymentsCommand } = await import("../src/payments.mjs");
+    process.exitCode = paymentsCommand(rest) || 0;
+    return;
+  }
   if (cmd === "games" || cmd === "game" || cmd === "arcade") {
     const code = await gamesCommand(rest);
     if (code) process.exitCode = code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.70.0",
+  "version": "0.72.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/plugins/billing/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
+  "name": "billing",
+  "description": "Turn tracked hours into an invoice, backed by @profullstack/billing: clients, rate cards written as contract sentences, agent-hour arithmetic, and invoices rendered to HTML you can print to PDF.",
+  "version": "0.1.0",
+  "author": {
+    "name": "moshcoder",
+    "url": "https://moshcode.sh"
+  },
+  "homepage": "https://github.com/profullstack/billing#readme",
+  "license": "MIT",
+  "keywords": ["billing", "invoice", "clients", "rates", "profullstack"]
+}

package/plugins/billing/README.md

@@ -0,0 +1,42 @@
+# billing
+
+Slash commands for
+[`@profullstack/billing`](https://github.com/profullstack/billing) — clients,
+rates and invoices, built on the hours `@profullstack/timer` tracked.
+
+```
+/billing:rate set acme '$100/hour/agent/upto:4'
+/billing:hours --client acme --month
+/billing:invoice --client acme --from-timer --month
+/billing:report
+```
+
+## Install the CLI
+
+```sh
+npm install -g @profullstack/billing
+```
+
+or, inside moshcode:
+
+```
+moshcode install billing
+```
+
+## What it is for
+
+A rate is the sentence from the contract, parsed. `$100/hour/agent/upto:4` means
+four agents cost four hundred an hour and so do six, and the invoice bills
+**agent-hours** so the client can check the line by hand: `quantity × rate`
+always equals `amount`.
+
+Two rules the shape enforces. The same hour never reaches two invoices — each
+invoice records the timer entry ids it covers, so voiding one releases them.
+And creating an invoice is a proposal: `--dry-run` validates the whole thing and
+writes nothing, a new invoice is a draft, and nothing is ever emailed.
+
+## Coming from moshcode
+
+moshcode used to keep this layer internally. `billing import` brings it across
+from `~/.moshcode/business.json` and `timers.json`, shows the plan first, and
+never modifies the originals.

package/plugins/billing/commands/hours.md

@@ -0,0 +1,37 @@
+---
+description: Tracked hours not yet on an invoice, priced at the client's rate.
+argument-hint: --client <name> [--month|--week]
+allowed-tools: Bash(billing hours:*), Bash(billing client:*), Bash(billing rate:*)
+---
+
+## Task
+
+```bash
+billing hours $ARGUMENTS --json
+```
+
+This is the preview of what `billing invoice new --from-timer` would bill. Same
+filters, same grouping, same arithmetic — it writes nothing.
+
+## Reading the response
+
+- `items[]` — the line items, each with `description`, `quantity` (in the rate's
+  own billing unit), `unitPriceMajor`, `amount`, `hours` and `timerIds`.
+- `unit` — what `quantity` is measured in: `hours`, or `agent-hours` when the
+  rate is priced per agent.
+- `hours` / `units` / `subtotal` — the totals.
+- `skipped` — `{ running, unbillable, alreadyBilled }`.
+
+## Rules
+
+- **Always read `skipped.running` back to the user.** Those hours are not
+  missing, they are on a clock that is still ticking and become billable the
+  moment it stops. "Nothing to bill" is misleading when the real answer is "stop
+  the clock first".
+- Exit 3 means no unbilled hours matched, or the client does not exist. Read the
+  message; it distinguishes them.
+- When `unit` is `agent-hours`, explain the multiplier if the user seems
+  surprised: 3 hours with 2 agents is 6 agent-hours. `quantity * unitPrice`
+  always equals `amount`.
+- If there is no rate, the error says so and names the command that sets one.
+  Do not invent a rate to get past it.

package/plugins/billing/commands/invoice.md

@@ -0,0 +1,39 @@
+---
+description: Draft an invoice from tracked time or fixed line items, for a person to approve.
+argument-hint: --client <name> --from-timer --month
+allowed-tools: Bash(billing invoice:*), Bash(billing hours:*), Bash(billing client:*), Bash(billing rate:*)
+---
+
+## Task
+
+Propose an invoice for `$ARGUMENTS`. **Always dry-run first:**
+
+```bash
+billing invoice new $ARGUMENTS --dry-run --json
+```
+
+Show the user what it would create. Only run it again without `--dry-run` when
+they have said to.
+
+Line items come from `--from-timer` (tracked hours), from `--item
+"Description|quantity|price"`, or both on the same invoice.
+
+## Rules
+
+- **Creating an invoice is a business action. Do not write one unprompted.**
+  `--dry-run` builds and validates the entire invoice — the rate lookup and the
+  double-billing check included — so a dry run that succeeds means the real one
+  will. There is no reason to skip it.
+- A new invoice is a **draft**. `billing invoice mark <n> sent` is a separate,
+  deliberate step and this tool never emails anything. Do not mark an invoice
+  sent or paid unless the user asked.
+- Read `amounts` (decimal) when talking to a person; the bare `total` is in
+  minor units.
+- Exit 3 on `--from-timer` means there were no unbilled hours. Check
+  `billing hours` and report `skipped.running` rather than concluding there is
+  nothing to bill.
+- The same hour cannot reach two invoices: each invoice records the timer entry
+  ids it covers. If the user wants to re-bill something, voiding the old invoice
+  releases those hours.
+- Prefer `billing invoice render <n> --format html --out <file>` when they want
+  something to send: it is one self-contained file that prints to PDF.

package/plugins/billing/commands/rate.md

@@ -0,0 +1,40 @@
+---
+description: Read or set what your time costs, written the way the contract says it.
+argument-hint: "[set <client|default> '$100/hour/agent/upto:4']"
+allowed-tools: Bash(billing rate:*), Bash(billing client:*)
+---
+
+## Task
+
+```bash
+billing rate $ARGUMENTS --json
+```
+
+With no arguments this lists every rate. `set`, `show` and `rm` take a target,
+which is either a client handle or `default`.
+
+## The spec
+
+A price, then any of these in any order:
+
+- a period: `hour`, `day` (8h), `week` (40h), `month` (160h), `project`, `task`
+- a unit that gets multiplied: `agent`, `seat`, `person`, `team`
+- `upto:N` to cap the multiplier, `min:N` for a minimum billed period
+
+`$100/hour/agent/upto:4` means four agents cost four hundred an hour, and so do
+six. `0.5 SOL/day`, `250 USDC/task` and `$5000/project` all parse too.
+
+## Rules
+
+- **Do not set or change a rate unless the user asked.** This is the number in
+  somebody's contract.
+- Read `describes` back to them when confirming — it is the rate as a sentence,
+  and it is how you catch a spec that parsed differently from how it was meant.
+- Settlement (`--prefer SOL --accept fiat`) is deliberately separate from the
+  price. The number in the contract does not change because the rail did, so do
+  not "convert" a rate to a preferred ticker.
+- A price given in a ticker invoices in that ticker. Do not turn `0.5 SOL` into
+  a dollar figure: nobody computed that number.
+- If a spec is rejected, the error names the words that are allowed. Fix the
+  spec rather than falling back to a bare number, which would silently mean
+  "per hour, flat".

package/plugins/billing/commands/report.md

@@ -0,0 +1,28 @@
+---
+description: What has been billed, collected, and what is still owed.
+argument-hint: "[--client <name>] [--year|--month]"
+allowed-tools: Bash(billing report:*), Bash(billing invoice:*)
+---
+
+## Task
+
+```bash
+billing report $ARGUMENTS --json
+```
+
+## Reading the response
+
+- `totals` — `billed`, `collected`, `outstanding`, `overdue`, `draft`, all as
+  decimal numbers in `currency`.
+- `byClient[]` — the same figures per client, biggest outstanding first.
+
+## Rules
+
+- **`draft` is not money anybody owes you.** A draft invoice has not been
+  issued, so keep it out of any "you are owed X" sentence and name it
+  separately.
+- `overdue` is derived from the due date at read time, never stored. It is a
+  subset of `outstanding`, not an addition to it — do not sum them.
+- Windows apply to the **issue date** here, not to when the work was done.
+- For the invoices behind a figure, use `billing invoice list --overdue --json`
+  or `--status sent`. Do not guess at which invoices make up a total.

package/plugins/timer/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
+  "name": "timer",
+  "description": "Track time against projects from inside your engine, backed by @profullstack/timer: start and stop a clock, log time you forgot, and report billable hours with the agent count that priced them.",
+  "version": "0.1.0",
+  "author": {
+    "name": "moshcoder",
+    "url": "https://moshcode.sh"
+  },
+  "homepage": "https://github.com/profullstack/timer#readme",
+  "license": "MIT",
+  "keywords": ["timer", "time-tracking", "billable", "hours", "profullstack"]
+}

package/plugins/timer/README.md

@@ -0,0 +1,36 @@
+# timer
+
+Slash commands for [`@profullstack/timer`](https://github.com/profullstack/timer)
+— a time tracker that runs on Linux, macOS and Windows, and answers `--json` on
+every command so an agent can clock its own work.
+
+```
+/timer:start acme fix the login redirect
+/timer:status
+/timer:stop
+/timer:report --week --group day
+```
+
+## Install the CLI
+
+```sh
+npm install -g @profullstack/timer
+```
+
+or, inside moshcode:
+
+```
+moshcode install timer
+```
+
+## What it is for
+
+An hour of agentic work is an hour times however many engines ran in it, so an
+entry carries an agent count (`--agents 4`). `@profullstack/billing` multiplies
+by it when the rate says to and ignores it when the rate is flat.
+
+Several clocks may run at once. That is deliberate: parallel agents each track
+their own work and do not stop each other.
+
+The timesheet is one JSON file at `~/.profullstack/timer/timesheet.json`, and
+billing reads it directly.

package/plugins/timer/commands/report.md

@@ -0,0 +1,32 @@
+---
+description: Totals for a period, grouped by project, task, day, tag or agent.
+argument-hint: "[--week|--month] [--group project|task|day|tag|agent]"
+allowed-tools: Bash(timer report:*), Bash(timer log:*), Bash(timer projects:*)
+---
+
+## Task
+
+```bash
+timer report $ARGUMENTS --json
+```
+
+Windows: `--today`, `--yesterday`, `--week` (from Monday), `--month`, `--year`,
+or explicit `--since` / `--until`. Groups: `project` (default), `task`, `day`,
+`tag`, `agent`, `none`.
+
+## Reading the response
+
+`rows[]` each carry `key`, `entries`, `hours` and `billableHours`. `totals` has
+the same figures for the whole window.
+
+## Rules
+
+- **A window compares against the entry's start, and `--until` is exclusive.**
+  An entry that ran past midnight belongs to the day it began on. Say so if the
+  user questions a boundary rather than guessing at a bug.
+- Report `hours` and `billableHours` separately whenever they differ.
+- `timer log` is the command for the entries behind a number. Reach for it when
+  the user asks why a total looks the way it does.
+- Do not convert hours into money here. The rate lives in
+  `@profullstack/billing`, which knows about agent multipliers and caps; a
+  hours-times-rate figure invented here will disagree with the invoice.

package/plugins/timer/commands/start.md

@@ -0,0 +1,33 @@
+---
+description: Start the clock on a project, optionally recording how many agents are working.
+argument-hint: <project> [task words…]
+allowed-tools: Bash(timer start:*), Bash(timer status:*), Bash(timer on:*)
+---
+
+## Task
+
+Start a clock for `$ARGUMENTS`.
+
+```bash
+timer start $ARGUMENTS --json
+```
+
+The first word is the project; everything after it is the task, so no quoting is
+needed. Useful flags:
+
+- `--agents N` — how many engines are working. An agent-priced rate multiplies
+  by this, so it is the difference between a $400 afternoon and a $1,600 one.
+- `--at 09:15` or `--at -20m` — the clock you meant to start earlier.
+- `--tag`, `--note`, `--no-billable`.
+
+## Rules
+
+- **Do not pass `--switch` unless the user asked to stop their other clocks.**
+  Several clocks running at once is normal here: parallel agents each track
+  their own work, and stopping someone else's is not recoverable from the log.
+- If `started.alsoRunning` comes back non-empty, mention how many other clocks
+  are running. Do not stop them.
+- Report the entry id — `timer stop --id <id>` needs it, and so does the user if
+  they want to correct the entry later.
+- If the command exits 2, the command line was wrong; read the error and fix it
+  rather than retrying the same thing.

package/plugins/timer/commands/status.md

@@ -0,0 +1,27 @@
+---
+description: What is running right now, and what today adds up to.
+allowed-tools: Bash(timer status:*), Bash(timer log:*)
+---
+
+## Task
+
+```bash
+timer status --json
+```
+
+## Reading the response
+
+- `running[]` — every live clock, each with `seconds` counting up to now.
+- `today` — totals for entries that *started* today: `hours` and `billableHours`.
+- `dataFile` — where the timesheet lives, worth quoting if the user is surprised
+  by what is or is not in it.
+
+## Rules
+
+- An empty `running` array is a normal answer. Exit status is 0 either way, so
+  never report "nothing running" as a failure.
+- `hours` and `billableHours` differ when something is marked `--no-billable`.
+  If they differ, give both — "how long did this take" and "what can I charge
+  for it" are different questions.
+- A running clock's duration is still moving. Do not present it as a final
+  figure, and note that billing will not invoice it until it is stopped.

package/plugins/timer/commands/stop.md

@@ -0,0 +1,30 @@
+---
+description: Stop a running clock and report what it came to.
+argument-hint: "[id]"
+allowed-tools: Bash(timer stop:*), Bash(timer off:*), Bash(timer status:*)
+---
+
+## Task
+
+Stop the clock for `$ARGUMENTS` (empty means the newest one).
+
+```bash
+timer stop $ARGUMENTS --json
+```
+
+Targets: nothing (the most recently started clock), an id or an unambiguous
+prefix of one, `--project <p>`, or `--all`.
+
+## Reading the response
+
+`stopped[]` carries `seconds`, `hours` and `agents` for each entry closed.
+`hours` is the figure an invoice uses.
+
+## Rules
+
+- **`stopped: []` with exit 0 means nothing was running.** That is an answer,
+  not a failure — say so plainly and do not retry or treat it as an error.
+- Do not pass `--all` unless the user asked to stop everything. Other clocks may
+  belong to other agents.
+- `--at` can backdate the stop, but a stop earlier than the start is refused
+  rather than clamped to zero. If that happens, the entry is untouched.