agentlinkops 0.5.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "agentlinkops",
+  "version": "0.5.0",
+  "description": "Connect an agent to AgentLinkOps and run backlink work with it: the connect skill (views, the three discovery verbs, evidence rules), local ledger and campaign skills, a portable CRM, the source-cited content pipeline, user-managed disavow lists, HTML reports and monitoring-event sync.",
+  "author": {
+    "name": "AgentLinkOps"
+  },
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json"
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,24 @@
+{
+  "name": "agentlinkops",
+  "version": "0.5.0",
+  "description": "Connect an agent to AgentLinkOps and run backlink work with it: the connect skill (views, the three discovery verbs, evidence rules), local ledger and campaign skills, a portable CRM, the source-cited content pipeline, user-managed disavow lists, HTML reports and monitoring-event sync.",
+  "author": {
+    "name": "AgentLinkOps"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "AgentLinkOps",
+    "shortDescription": "Run backlink campaigns with your own agent.",
+    "longDescription": "Plan campaigns and preserve contacts, outreach references and placements in a local SQLite CRM. Manage property-scoped disavow lists and generate branded HTML reports offline. Optional account-connected event sync preserves local notes and costs.",
+    "developerName": "AgentLinkOps",
+    "category": "Productivity",
+    "capabilities": [
+      "Write"
+    ],
+    "defaultPrompt": [
+      "Plan a backlink campaign for my product.",
+      "Set up my local link and outreach CRM.",
+      "Review changes to my monitored placements."
+    ]
+  }
+}

package/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to the `agentlinkops` package are recorded here. The version follows the
+plugin manifests in `.claude-plugin/` and `.codex-plugin/`.
+
+## 0.5.0 (unreleased; DP-0036 agent surface)
+
+- `agentlinkops tools [TOOLSET]`, `agentlinkops describe NAME` and `agentlinkops call NAME`:
+  the three discovery verbs, answered offline from the bundled catalog snapshot (`--refresh`
+  reads the live one). The index prints each toolset's summary; `call` adds `--set`,
+  `--dry-run` and `-y`, and retired command names resolve to their canonical command.
+- `agentlinkops agent setup` and `agentlinkops agent status`: install the skill pack and the
+  right MCP view for each detected client (Claude Code, Codex, Cursor, Gemini CLI, Hermes)
+  without storing a credential.
+- Skill pack v2: the new `agentlinkops-connect` skill (views, verbs, evidence rules), per-client
+  `allowed-tools` and Codex `agents/openai.yaml` metadata, the plugin's `.mcp.json`, and a
+  discovery index with deterministic per-skill archives served at
+  `/.well-known/agent-skills/index.json`.
+- Skill-first onboarding (DP-0037): `agentlinkops skill [--url]` prints the agent reference
+  that ships inside the connect skill (`references/agentlinkops.md`); the connect skill is a
+  stub that has the agent read it once per session; `init`, a terminal `tools` and
+  `agent setup` point at it once. The discovery index now follows the Agent Skills discovery
+  specification (`$schema`, `type: archive`) so `npx skills add https://agentlinkops.com`
+  installs the four product skills; the content pipeline sits behind
+  `https://agentlinkops.com/content`.
+- `agentlinkops check --source URL --target URL [--out FILE]`: one accountless local check that
+  produces a portable result artifact, and `agentlinkops adopt-result FILE` to save that artifact
+  into a ledger once, validated and under the ledger writer lock.
+- `agentlinkops setup --plan --goal verify-links|prepare-campaign|build-content [--mode …]`: a
+  read-only setup plan from metadata-only workspace inspection; no writes, network or account.
+- `agentlinkops receipt history --performance FILE.json`: attaches dated Search Console and
+  optional GA4 context from the local context files beside a claim, without claiming causation.
+- `node cli/context-mcp.js --root DIR`: the repository-local stdio MCP host for the eight
+  context tools. Adds the runtime dependency `@modelcontextprotocol/server` 2.0.0.
+
+## 0.4.0 (2026-09-15)
+
+First public release under the Apache License 2.0.
+
+- `agentlinkops` command: `init`, `add`, `check`, `status`, `diff`, `report`, `import`, `adopt`,
+  `sync`, `connect`, `doctor`, `migrate`, `tools`, `call`, `fleet`, `platforms`, `context`,
+  `mix`, `receive`, `receipt`, `fmt` and `compact`.
+- `linktrail` alias: runs the same command with a one-line notice on stderr. The alias, the
+  `LINKTRAIL_*` environment variables and the `.linktrail/` ledger directory stop working on
+  2026-10-15; `agentlinkops migrate` renames the directory.
+- Shared verifier (`src/verifier/`): the module the hosted service runs, unchanged.
+- Import adapters for Ahrefs, Semrush, Majestic, Moz, DataForSEO, Linkody, Google Search Console
+  and generic CSV, with an explicit `--map` for any other layout.
+- Agent plugin manifests and skills (`agentlinkops-crm`, `agentlinkops-campaigns`,
+  `agentlinkops-assets` and the content-pipeline skills), campaign templates and the Python
+  CRM helper.
+- Dependencies declared instead of vendored: parse5 8.0.1 and zod 4.6.0.

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 AgentLinkOps
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,17 @@
+AgentLinkOps CLI
+Copyright 2026 AgentLinkOps
+
+This product includes software developed by AgentLinkOps (https://agentlinkops.com/).
+
+Licensed under the Apache License, Version 2.0. See LICENSE.
+
+Third-party components redistributed with this package:
+
+- skills/content-defingerprinting/scripts/watermarks/vendor/: files from
+  watermarks-remover (https://github.com/guillaumemeyer/watermarks-remover),
+  MIT License, Copyright (c) 2026 watermarks-remover contributors. The files are
+  byte-identical to the pinned upstream commit named in the sibling UPSTREAM.json;
+  the upstream license text is at vendor/LICENSE.upstream.
+
+Runtime dependencies installed by npm and not redistributed here: parse5 (MIT),
+zod (MIT).

package/README.md

@@ -0,0 +1,202 @@
+# agentlinkops
+
+A backlink ledger that lives in your repository. `agentlinkops check` fetches a source page,
+looks for the link you declared and records an observation with the HTTP status, redirect
+chain, robots posture and a SHA-256 of the fetched bytes. Page HTML never enters the repository.
+A check that cannot conclude says `unknown` with a named reason, and unknown never means the
+link was removed.
+
+The CLI imports the same verifier module the hosted AgentLinkOps service runs, and its tests
+assert both paths return the same shape. The hosted checks, evidence store and MCP server are a
+separate service; this package is the local half and needs no account.
+
+## Give your agent AgentLinkOps
+
+Four steps, the same ones the docs and the landing page show. Node.js 22.13 or later.
+
+1. **Install the skill.** Detects the agent clients on this machine (Claude Code, Codex,
+   Cursor, Gemini CLI, Hermes), installs the skill pack at each one's skills path and writes
+   its MCP entry; stores no credential and prints what it changed.
+
+   ```sh
+   npx -y agentlinkops agent setup
+   ```
+
+   With the `skills` CLI instead: `npx -y skills add https://agentlinkops.com`, then add
+   `https://app.agentlinkops.com/mcp` as a remote HTTP MCP server in your client.
+2. **Sign in when your agent asks.** The client opens the AgentLinkOps sign-in; you pick the
+   account, workspace and scopes. Nothing is pasted into a chat.
+3. **Verify.** Ask your agent to list your AgentLinkOps projects, or run `agentlinkops doctor`.
+4. **Check a placement.** Ask: "check whether [publisher page] links to [my page], show the
+   dated observation and any uncertainty." No account yet? The same verifier runs locally:
+
+   ```sh
+   npx -y agentlinkops check --source https://publisher.example/resources --target https://your-site.example/guide
+   ```
+
+The skill is a short door: the first time your agent uses AgentLinkOps in a session it reads
+the full agent reference, which `agentlinkops skill` prints and
+https://agentlinkops.com/SKILL.md serves. Hosted monitoring is an invitation-only pilot; the
+local commands below need no account.
+
+## Install the CLI on its own
+
+```sh
+npm install -g agentlinkops
+agentlinkops --help
+```
+
+Or run it once without installing:
+
+```sh
+npx agentlinkops check
+```
+
+## Check one link with no account
+
+```sh
+cd your-repository
+agentlinkops init
+agentlinkops add --source https://publisher.example.com/resources --target https://example.com/guide --intent expected
+agentlinkops check
+agentlinkops status
+```
+
+`init` creates `.agentlinkops/` with an empty ledger. `add` writes one entry. `check` fetches
+the source page and appends an observation to the mirror. `status` names every entry whose
+observations disagree with its intent and proposes the edit; applying it is a commit you make.
+
+Exit codes: `0` when every expected link is present, `1` only when an expected link is observed
+absent with complete evidence, `2` for a usage, configuration or ledger error. An unknown never
+fails the run. Pass `--fail-on-unknown` when your CI wants it to.
+
+`agentlinkops doctor` verifies the ledger, the verifier self-test, cloud reachability and the
+token, and prints a fix line for anything that fails.
+
+## The ledger
+
+Intent and fact never share a file. You write intent; the verifier writes fact.
+
+```
+.agentlinkops/
+  config.json          project identity, cloud origin, defaults. Yours, committed
+  links.jsonl          the ledger: intent. Yours, committed
+  observations.jsonl   fact mirror, tool-owned, committed
+  events.jsonl         cloud event mirror by cursor, tool-owned, committed
+  candidates.jsonl     imported and discovered rows, tool-owned, committed
+  state.json           cursors and last-check marks, tool-owned, committed
+```
+
+One ledger entry:
+
+```json
+{"id":"lk_9f3ac1","intent":"expected","source":"https://publisher.example.com/resources","target":"https://example.com/guide","scope":"exact","expect":{"anchor":"guide","rel":["nofollow"]},"cadence":"daily","ref":"q3-resource-pages/441","tags":["resource-page"],"added":"2026-09-11","note":"editor confirmed"}
+```
+
+Three intents: `wanted` (we want this publisher to link to us; present is the news),
+`expected` (it should be there now; absent is the alarm) and `retired` (stop checking, keep
+the history). Nothing promotes an entry automatically. `id` is random and permanent, so a
+corrected URL keeps its history. Everything is plain JSON Lines, one entry per line, that you
+can read without this tool.
+
+## Imports and adoption
+
+Supplier exports import through presets or an explicit column map, and a preview writes nothing:
+
+```sh
+agentlinkops import ahrefs-export.csv --target example.com --from ahrefs
+agentlinkops import any-export.csv --target example.com --map "source=Referring page URL,target=Target URL"
+```
+
+Presets: Ahrefs, Semrush, Majestic, Moz, DataForSEO, Linkody, Google Search Console and generic
+CSV. A preset is a convenience over `--map`, never a requirement. Every rejected row is reported
+with its line and reason. Count-per-site Search Console exports are refused, because importing
+them would invent placements.
+
+An existing SQLite CRM (the reference adapter in `scripts/agentlinkops.py`) adopts into ledger
+entries read-only with `agentlinkops adopt crm.sqlite`; there is no reverse direction.
+
+One page can be checked without a ledger or an account: `agentlinkops check --source URL
+--target URL [--scope exact] [--json] [--out result.json]` runs the same verifier and prints one
+result. `--out` reserves the file before the fetch and refuses to overwrite. A saved result later
+joins a ledger with `agentlinkops adopt-result result.json [--intent wanted|expected]`, which
+validates the artifact (no raw HTML, a checksum that must match, a state consistent with its
+evidence) and appends the entry and observation once under a writer lock.
+
+## Sync with the hosted service
+
+Local commands need no account. Sync pushes expectations and pulls events and evidence
+references into the mirror. It never writes into `links.jsonl`.
+
+```sh
+export AGENTLINKOPS_TOKEN=...   # from Agent access > Create API key in the hosted workspace
+agentlinkops connect --workspace WORKSPACE_ID --project-id PROJECT_ID --origin https://app.agentlinkops.com
+agentlinkops sync --dry-run
+agentlinkops sync
+```
+
+Hosted access is an invitation-only pilot. The hosted checks, evidence store and MCP server are a
+separate service and are not part of this package.
+
+## Citation watches
+
+An AI citation is a placement: a reference to your asset on a surface you do not control,
+re-decided by the model on every ask. So the CLI watches it the way it watches a link — a prompt
+panel, run against engine APIs on cadence, with dated evidence and honest statistics. A citation
+is never reported as "removed": each epoch states the citation rate with a Wilson interval and
+its sample size, classified against the previous epoch as declined, grown or
+not_distinguishable, or `insufficient_data` when n is too thin to interpret.
+
+```sh
+export PERPLEXITY_API_KEY=...          # live engine; omit it and the mock engine runs at $0
+agentlinkops citation run panel.json --max-usd 1.00
+```
+
+The panel is JSON: `targets` (domain or url, brand, aliases), `prompts`, `engines`
+(`mock` or `perplexity`), optional `samples` and `maxUsd`. Every run writes immutable
+content-addressed answer snapshots plus append-only observation and epoch rows under
+`.agentlinkops/citations/`. The USD cap is checked before each call, so it can be approached
+but never exceeded, and a budget abort leaves a partial-epoch receipt and exit code 2. A cell
+that declined with complete evidence exits 1, like an expected link observed absent.
+
+## Environment variables
+
+| Variable | Purpose |
+| --- | --- |
+| `AGENTLINKOPS_TOKEN` or `AGENTLINKOPS_API_KEY` | Scoped credential for `connect`, `sync`, `tools`, `call` and the token probe in `doctor`. If both are set they must agree. |
+| `AGENTLINKOPS_API_URL` | Hosted origin when it is not in `config.json`. |
+| `AGENTLINKOPS_WEBHOOK_SECRET` | Verifies signed deliveries in `agentlinkops receive`. |
+| `AGENTLINKOPS_GSC_TOKEN`, `AGENTLINKOPS_GA4_TOKEN` | First-party context commands under `agentlinkops context`. |
+| `PERPLEXITY_API_KEY` | Live engine credential for `agentlinkops citation`. Presence is reported by `doctor`; the value is never printed. |
+
+No value is ever printed. The `LINKTRAIL_*` spellings, the `linktrail` command and a `.linktrail/`
+ledger directory are still accepted with a one-line notice on stderr until 2026-10-15; run
+`agentlinkops migrate` once to rename the directory. It refuses to merge or delete anything.
+
+## Agent plugin
+
+The package doubles as a plugin: `.claude-plugin/plugin.json` and `.codex-plugin/plugin.json`
+point at `skills/`, which holds the connect, CRM, campaign and asset skills plus the
+content-pipeline skills, with templates in `templates/` and contracts in `references/`.
+`agentlinkops agent setup` installs the same skills for any detected client, and the discovery
+index at `https://agentlinkops.com/.well-known/agent-skills/index.json` serves them to
+`npx skills add` (the content pipeline sits behind `https://agentlinkops.com/content`). Node.js
+runs the ledger CLI; Python 3.10 or later runs the optional CRM helper and the watermark
+scanner.
+
+## What it does not do
+
+It holds no backlink index, sends no email, verifies no contact address and runs no JavaScript:
+observations are static HTML only, and each one says so. Literal IP addresses, reserved hostnames
+and non-default ports are refused before any fetch.
+
+## Documentation and source
+
+- Guides: https://docs.agentlinkops.com/guides/first-result and https://docs.agentlinkops.com/guides/connect-cli
+- Product: https://agentlinkops.com/
+- Source: https://github.com/sunlover7/agentlinkops-cli
+- Contract references shipped in this package: `references/cli.md`, `references/disavow.md`, `references/reports.md`
+
+## License
+
+Apache License 2.0. See `LICENSE` and `NOTICE`.

package/bin/agentlinkops.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// The `agentlinkops` executable. `linktrail.mjs` beside it is the compatibility alias.
+import { main } from '../cli/main.js';
+process.exitCode = await main();

package/bin/linktrail.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// Compatibility alias for the rename window: the executable is `agentlinkops`. The alias stops
+// working on 2026-10-15. One line to stderr, then the same main; stdout stays clean for --json readers.
+import { main } from '../cli/main.js';
+process.stderr.write('linktrail: this command is now `agentlinkops`; the old name keeps working during the pilot compatibility window.\n');
+process.exitCode = await main();

package/cli/adapters/csv.js

@@ -0,0 +1,68 @@
+// A dependency-free RFC 4180 reader.
+//
+// Written rather than depended on because the CLI is meant to run anywhere with no install, and
+// because the failure that matters here is silent: a parser that mishandles a quoted field
+// containing a comma does not throw, it shifts every column right and imports nonsense.
+export class CsvError extends Error {
+  constructor(message, line) { super(message); this.name = 'CsvError'; this.line = line; this.exitCode = 2; }
+}
+
+/** Rows of raw string cells. Quoted fields may contain commas, quotes and newlines. */
+export function parseCsv(text, { delimiter = ',' } = {}) {
+  // A BOM at the start of a spreadsheet export becomes part of the first header name, and then
+  // the first column never matches anything. Excel writes one by default.
+  const input = text.replace(/^/u, '');
+  const rows = [];
+  let row = [], field = '', quoted = false, line = 1, started = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (quoted) {
+      if (char === '"') {
+        if (input[i + 1] === '"') { field += '"'; i++; continue; }
+        quoted = false; continue;
+      }
+      if (char === '\n') line++;
+      field += char;
+      continue;
+    }
+    if (char === '"' && field === '') { quoted = true; started = true; continue; }
+    if (char === delimiter) { row.push(field); field = ''; started = false; continue; }
+    if (char === '\r') continue;
+    if (char === '\n') {
+      line++;
+      if (row.length || field !== '' || started) { row.push(field); rows.push(row); }
+      row = []; field = ''; started = false;
+      continue;
+    }
+    field += char; started = true;
+  }
+  if (quoted) throw new CsvError('the file ends inside a quoted field', line);
+  if (row.length || field !== '' || started) { row.push(field); rows.push(row); }
+  return rows;
+}
+
+/** Normalised for matching: case, punctuation and spacing are not information here. */
+export const normalizeHeader = name => String(name).toLowerCase().replace(/[\s_\-.()/]+/gu, '').trim();
+
+/**
+ * Header row plus objects keyed by the ORIGINAL header, so an unmapped column keeps the name
+ * the customer's tool gave it.
+ */
+export function readTable(text, options = {}) {
+  const rows = parseCsv(text, options);
+  if (!rows.length) throw new CsvError('the file is empty', 1);
+  const header = rows[0].map(cell => cell.trim());
+  if (!header.some(Boolean)) throw new CsvError('the first row is blank, so there are no column names', 1);
+  const records = [];
+  rows.slice(1).forEach((cells, index) => {
+    // A short or long row is a REPORT, not a silent pad or truncate: it usually means the file
+    // is not the delimiter we think it is, and padding hides that until the numbers are wrong.
+    if (cells.length !== header.length && cells.some(Boolean)) {
+      records.push({ line: index + 2, error: `${cells.length} value(s) for ${header.length} column(s)` });
+      return;
+    }
+    if (!cells.some(Boolean)) return;
+    records.push({ line: index + 2, values: Object.fromEntries(header.map((name, position) => [name, cells[position] ?? ''])) });
+  });
+  return { header, records };
+}

package/cli/adapters/sqlite-crm.js

@@ -0,0 +1,79 @@
+// The SQLite CRM as one adapter, not the local surface.
+//
+// The toolkit's six-table CRM works, is tested, and fits an agency that wants contacts and
+// outreach activity in the same place. What it is no longer is the ONLY way to keep links
+// locally — the ledger file is — so this reads a CRM into ledger entries and leaves the CRM
+// untouched. **Read-only, and no new required schema**: the adapter adapts to what is there.
+//
+// Adopting an existing CRM is a MIGRATION rather than a discovery import, which is why it is
+// `adopt` and not `import`. An import brings in a supplier's index of backlinks the customer has
+// not decided about; a CRM holds decisions they already made.
+import { DatabaseSync } from 'node:sqlite';
+import { createHash } from 'node:crypto';
+import { normalizeEntry } from '../ledger.js';
+
+export class CrmError extends Error {
+  constructor(message) { super(message); this.name = 'CrmError'; this.exitCode = 2; }
+}
+
+// Words that mean "stop watching this". Everything else keeps the default for its table,
+// because `status` in this CRM is free text and refusing every unrecognised value would refuse
+// nearly every row. What the adapter does instead is REPORT the statuses it saw.
+const RETIRING = new Set(['rejected', 'declined', 'dead', 'lost', 'removed', 'abandoned', 'closed-lost', 'disavowed']);
+
+const idFor = (table, value) => `lk_${createHash('sha256').update(`crm:${table}:${value}`).digest('hex').slice(0, 10)}`;
+
+export function readCrm(path, { defaultScope = 'exact' } = {}) {
+  let db;
+  try { db = new DatabaseSync(path, { readOnly: true }); }
+  catch (error) { throw new CrmError(`could not open ${path}: ${error.message}`); }
+  try {
+    const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(row => row.name));
+    const missing = ['placements', 'opportunities'].filter(name => !tables.has(name));
+    if (missing.length === 2) throw new CrmError(`${path} has no placements or opportunities table, so it is not an AgentLinkOps CRM`);
+
+    const entries = [], unmapped = [], statuses = { placement: {}, opportunity: {} };
+    const placementSources = new Set();
+
+    const add = (table, row, intent) => {
+      try {
+        entries.push(normalizeEntry({
+          id: idFor(table, row.id), intent,
+          source: row.source_url, target: row.target_url, scope: defaultScope,
+          ref: `crm/${table}/${row.id}`,
+          ...(row.notes ? { note: String(row.notes).slice(0, 200) } : {}),
+          added: (row.created_at ?? '').slice(0, 10) || undefined,
+        }, { assignId: false }));
+      } catch (error) { unmapped.push({ table, id: row.id, reason: error.message }); }
+    };
+
+    if (tables.has('placements')) {
+      for (const row of db.prepare('SELECT * FROM placements').all()) {
+        const status = String(row.status ?? '').trim().toLowerCase();
+        statuses.placement[status || '(blank)'] = (statuses.placement[status || '(blank)'] ?? 0) + 1;
+        // A placement is a link the customer believes exists, so it is EXPECTED — absence is the
+        // alarm. That is the whole difference between the two intents.
+        add('placements', row, RETIRING.has(status) ? 'retired' : 'expected');
+        if (row.opportunity_id) placementSources.add(row.opportunity_id);
+      }
+    }
+    if (tables.has('opportunities')) {
+      for (const row of db.prepare('SELECT * FROM opportunities').all()) {
+        // An opportunity that became a placement is superseded by it; carrying both would watch
+        // one link twice and report it twice.
+        if (placementSources.has(row.id)) continue;
+        const status = String(row.status ?? '').trim().toLowerCase();
+        statuses.opportunity[status || '(blank)'] = (statuses.opportunity[status || '(blank)'] ?? 0) + 1;
+        add('opportunities', row, RETIRING.has(status) ? 'retired' : 'wanted');
+      }
+    }
+    return {
+      entries, unmapped, statuses,
+      // Named so an operator can see what was ASSUMED active rather than discovering it later.
+      assumed_active: {
+        placement: Object.keys(statuses.placement).filter(status => !RETIRING.has(status)),
+        opportunity: Object.keys(statuses.opportunity).filter(status => !RETIRING.has(status)),
+      },
+    };
+  } finally { db?.close(); }
+}