agentlinkops 0.6.11 → 0.6.16

package/cli/report.js

@@ -18,13 +18,15 @@
 // evidence reference that resolves to the observation itself. One dataset feeds both exports:
 // this HTML view for a human client, and `report --json` for an agent, so the two can never
 // disagree about what was observed.
+// v3 freezes activity separately from retained receipts. Older v2 datasets still render with
+// their original columns and wording; activity never changes an old observation's date/hash.
 import {indexRowsForUrl} from './index-observations.js';
 import {reconcileIndexObservations} from '../src/index-observation.js';
 import { createHash } from 'node:crypto';
-import { latestByEntry } from './mirror.js';
+import { projectPlacements } from './placement-projection.js';
 import { mirrorEvidenceReference } from '../src/evidence-reference.js';
 
-export const REPORT_VERSION = 2;
+export const REPORT_VERSION = 3;
 
 /** HTML-escape. Every value below is publisher or customer content and none of it is trusted. */
 export const escape = value => String(value ?? '')
@@ -35,6 +37,10 @@ const STATE_LABEL = Object.freeze({
   present: 'Present', absent: 'Not found', unknown: 'Could not check',
   source_unavailable: 'Page unavailable', unchecked: 'Never checked',
 });
+const CURRENT_STATE_LABEL = Object.freeze({
+  ...STATE_LABEL,
+  suspected_missing: 'Suspected missing', confirmed_missing: 'Confirmed missing',
+});
 
 /**
  * The frozen dataset a report renders.
@@ -42,12 +48,10 @@ const STATE_LABEL = Object.freeze({
  * Selection happens here and nowhere else, so a caller can hold this object, assert it, and know
  * the rendered document is a pure function of it.
  */
-export function freezeDataset(entries, observations, { asOf, title = 'Backlink report', includeNotes = false, includeRetired = false, indexObservations = [] } = {}) {
-  const latest = latestByEntry(observations);
-  const rows = entries
-    .filter(entry => includeRetired || entry.intent !== 'retired')
-    .map(entry => {
-      const row = latest.get(entry.id) ?? null;
+export function freezeDataset(entries, observations, { asOf, title = 'Backlink report', includeNotes = false, includeRetired = false, indexObservations = [], activityState = null } = {}) {
+  const rows = projectPlacements(entries.filter(entry => includeRetired || entry.intent !== 'retired'), observations, { state: activityState })
+    .map(projection => {
+      const { entry, row } = projection;
       const indexRows=indexRowsForUrl(indexObservations,entry.source);
       const origin = row?.source === 'cloud' ? 'cloud' : (row?.source ?? null);
       return {
@@ -57,6 +61,16 @@ export function freezeDataset(entries, observations, { asOf, title = 'Backlink r
         reason: row?.reason ?? null,
         occurrences: row?.occurrences ?? 0,
         checked_at: row?.checked_at ?? null,
+        current_state: projection.current_state,
+        uncertain: projection.uncertain,
+        activity: {
+          available: projection.activity_available,
+          identity_status: projection.identity_status,
+          latest_attempt: projection.latest_attempt,
+          last_successful_observation: projection.last_successful_observation,
+          last_link_verification: projection.last_link_verification,
+          first_present: projection.first_present,
+        },
         checked_by: row?.source ?? null,
         anchor: row?.result?.occurrences?.[0]?.anchor ?? null,
         rel: row?.result?.occurrences?.[0]?.rel ?? [],
@@ -105,10 +119,16 @@ export function freezeDataset(entries, observations, { asOf, title = 'Backlink r
     // Stated rather than implied. A report over a ledger nobody has checked is not a report about
     // links, and the reader should see that before the table.
     coverage: {
-      checked: rows.filter(row => row.checked_at).length,
-      never_checked: rows.filter(row => !row.checked_at).length,
+      checked: rows.filter(row => row.activity.latest_attempt).length,
+      never_checked: rows.filter(row => !row.activity.latest_attempt).length,
+      retained_receipt_entries: rows.filter(row => row.checked_at).length,
+      missing_receipt_entries: rows.filter(row => !row.checked_at).length,
       observed_from: dates[0] ?? null,
       observed_to: dates.at(-1) ?? null,
+      activity_entries: rows.filter(row => row.activity.available).length,
+      identity_unmatched_entries: rows.filter(row => row.activity.identity_status === 'not_matched').length,
+      denominator: includeRetired ? 'all_ledger_entries' : 'non_retired_ledger_entries',
+      known_present_after_unknown: rows.filter(row => row.current_state === 'present' && row.uncertain).length,
     },
   };
 }
@@ -149,6 +169,18 @@ export function renderReport(dataset, { brand = null } = {}) {
   const digest = createHash('sha256').update(JSON.stringify(dataset)).digest('hex');
   const card = (label, value) => `<div class="card"><b>${escape(value)}</b><span>${escape(label)}</span></div>`;
   const coverage = dataset.coverage;
+  const hasActivity = dataset.v >= 3;
+  const activityCell = row => {
+    const activity = row.activity ?? {};
+    const describe = (label, attempt) => `<div>${escape(label)}: ${attempt ? `${escape(attempt.state)} · ${escape(attempt.checked_at)}` : 'not retained'}</div>`
+      + (attempt ? `<div class="note">${escape(attempt.reason ?? 'reason not recorded')} · ${escape(attempt.method ?? 'method not recorded')}</div>`
+        + `<div class="ref">${escape(attempt.evidence_reference ?? 'no retained receipt reference')}</div>` : '');
+    return `<div>${escape(CURRENT_STATE_LABEL[row.current_state] ?? row.current_state ?? 'Unknown')}${row.uncertain ? ' · latest attempt inconclusive' : ''}</div>`
+      + describe('Latest attempt', activity.latest_attempt)
+      + describe('Last conclusive check', activity.last_successful_observation)
+      + describe('Last link verification', activity.last_link_verification)
+      + `<div class="note">Activity ${activity.available ? 'recorded' : 'not supplied or not retained'}; identity ${escape(activity.identity_status ?? 'not retained')}</div>`;
+  };
   // The receipt column. "hash not recorded" is stated rather than papered over: a local check
   // that never completed a fetch has no hash, and a cloud-synced row may carry its snapshot key
   // without a hash in an older event. Neither is a claim about the link.
@@ -164,10 +196,10 @@ export function renderReport(dataset, { brand = null } = {}) {
   const rows = dataset.rows.map(row => `<tr>
       <td class="url"><a href="${escape(row.source)}">${escape(row.source)}</a></td>
       <td class="url">${escape(row.target)}</td>
-      <td><span class="state ${escape(row.state)}">${escape(STATE_LABEL[row.state] ?? row.state)}</span></td>
+      <td><span class="state ${escape(row.state)}">${escape(hasActivity && !row.evidence && row.activity?.latest_attempt ? 'No retained observation' : (hasActivity ? CURRENT_STATE_LABEL : STATE_LABEL)[row.state] ?? row.state)}</span></td>
       <td>${row.anchor ? escape(row.anchor) : '<span class="note">&mdash;</span>'}${(row.rel ?? []).length ? `<div class="note">rel: ${escape(row.rel.join(' '))}</div>` : ''}</td>
       <td>${row.checked_at ? escape(row.checked_at.slice(0, 10)) : '<span class="note">never</span>'}</td>
-      <td>${evidenceCell(row)}</td>
+      <td>${evidenceCell(row)}</td>${hasActivity ? `\n      <td>${activityCell(row)}</td>` : ''}
       ${hasIndex?`<td>${(row.index_observations??[]).map(o=>`${escape(o.tier)} · ${escape(o.reason)}<div>${escape(o.checked_at)} · ${escape(o.backend)}</div><div class="ref">${escape(o.locator)}</div>`).join('<hr>')||'Not checked'}</td>`:''}
       ${dataset.include_notes ? `<td class="note">${escape(row.ref ?? '')}${row.note ? `<div>${escape(row.note)}</div>` : ''}</td>` : ''}
     </tr>`).join('\n');
@@ -188,21 +220,21 @@ export function renderReport(dataset, { brand = null } = {}) {
 <p class="sub">${brand ? `${escape(brand)} &middot; ` : ''}Prepared ${escape(dataset.as_of)}</p>
 <div class="cards">
 ${card('links in report', dataset.totals.entries)}
-${card('present', dataset.totals.present ?? 0)}
-${card('not found', dataset.totals.absent ?? 0)}
-${card('could not check', (dataset.totals.unknown ?? 0) + (dataset.totals.source_unavailable ?? 0))}
-${card('never checked', dataset.totals.unchecked ?? 0)}
+${card(hasActivity ? 'retained present' : 'present', dataset.totals.present ?? 0)}
+${card(hasActivity ? 'retained not found' : 'not found', dataset.totals.absent ?? 0)}
+${card(hasActivity ? 'retained could not check' : 'could not check', (dataset.totals.unknown ?? 0) + (dataset.totals.source_unavailable ?? 0))}
+${card('never checked', hasActivity ? coverage.never_checked : dataset.totals.unchecked ?? 0)}
 </div>
 <p class="caveat"><strong>What these dates mean.</strong> Every row shows the date that link was
 last observed, between ${escape(coverage.observed_from ?? 'n/a')} and ${escape(coverage.observed_to ?? 'n/a')}.
 The date at the top is when this document was prepared and does not make any observation newer
-than it is. ${coverage.never_checked ? `${coverage.never_checked} of ${dataset.totals.entries} links have never been checked and are listed as such.` : ''}</p>
+than it is. ${coverage.never_checked ? `${coverage.never_checked} of ${dataset.totals.entries} links have never been checked and are listed as such.` : ''}</p>${hasActivity ? '\n<p class="caveat"><strong>Activity and verification.</strong> The result and receipt date describe the retained observation. Activity lists later attempts and complete checks separately; an unchanged recheck can be newer than that receipt. An inconclusive attempt preserves the earlier verified state, and does not prove loss. A complete unavailable source is a conclusive source check, not a link verification. Missing activity is not inferred from a report preparation date.</p>' : ''}
 <p class="caveat"><strong>What a result means.</strong> &ldquo;Present&rdquo; means the link was in
 the observed HTML. &ldquo;Could not check&rdquo; is not the same as
 &ldquo;not found&rdquo;: it means the page could not be read, and no conclusion was drawn.
 Each receipt identifies the check method when it was recorded. A snapshot alone does not prove the link was visible on screen.</p>
 <table><thead><tr>
-<th>Source page</th><th>Target</th><th>Result</th><th>Anchor</th><th>Observed</th><th>Evidence</th>${hasIndex?'<th>Index evidence</th>':''}${dataset.include_notes ? '<th>Notes</th>' : ''}
+<th>Source page</th><th>Target</th><th>Result</th><th>Anchor</th><th>Observed</th><th>Evidence</th>${hasActivity ? '<th>Activity and verified state</th>' : ''}${hasIndex?'<th>Index evidence</th>':''}${dataset.include_notes ? '<th>Notes</th>' : ''}
 </tr></thead><tbody>
 ${rows}
 </tbody></table>
@@ -219,7 +251,7 @@ ${receiptRows}
 </tbody></table>` : ''}
 <footer>
 AgentLinkOps report v${dataset.v}. Dataset digest <code>${escape(digest)}</code> &mdash; the same
-ledger and observations always produce this digest. The same dataset exports as JSON
+ledger and observations${hasActivity ? ' and frozen activity' : ''} always produce this digest. The same dataset exports as JSON
 (<code>agentlinkops report --json</code>) and carries the same digest.
 ${dataset.include_notes ? 'Private notes are included in this document.' : 'Private notes and references are excluded.'}
 </footer>

package/cli/state.js

@@ -10,8 +10,20 @@
 // was this last confirmed" — is exactly what a small, rewritten map answers better.
 import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { placementIdentity, attemptSummary, isConclusive, isLinkVerification, validTime } from './placement-projection.js';
 
-export const STATE_VERSION = 2;
+export const STATE_VERSION = 3;
+
+// A newer activity format may carry semantics this reducer cannot preserve.
+// Refuse before loading, reducing or replacing it; unknown fields in supported
+// versions still round-trip through the existing migration rules.
+function assertSupportedStateVersion(raw) {
+  const version = Number.isInteger(raw?.v) ? raw.v : 1;
+  if (version <= STATE_VERSION) return;
+  const error = new Error(`Activity state format ${version} is unsupported; this CLI supports up to ${STATE_VERSION}. Keep the original state and history; use a compatible CLI.`);
+  error.code = 'UNSUPPORTED_STATE_VERSION';
+  throw error;
+}
 
 /**
  * Brings a state file forward without losing anything it already held.
@@ -24,6 +36,7 @@ export const STATE_VERSION = 2;
  * cursor. Seeding it would skip every target event ever emitted, and the feed would look quiet.
  */
 export function upgradeState(raw) {
+  assertSupportedStateVersion(raw);
   const state = { ...(raw ?? {}) };
   const version = Number.isInteger(state.v) ? state.v : 1;
   const cursors = { ...(state.cursors ?? {}) };
@@ -49,6 +62,7 @@ export async function readState(path) {
 }
 
 export async function writeState(path, state) {
+  assertSupportedStateVersion(state);
   await mkdir(dirname(path), { recursive: true });
   const temporary = join(dirname(path), `.${crypto.randomUUID()}.state.tmp`);
   // Sorted keys so a run that changes one entry produces a one-line diff.
@@ -58,49 +72,82 @@ export async function writeState(path, state) {
 }
 
 /** When each entry was last checked, whatever the answer was. */
-export function lastCheckedMap(state) {
-  return new Map(Object.entries(state.entries ?? {}).map(([id, record]) => [id, record.last_checked]));
+export function lastCheckedMap(state, entries = null) {
+  const identities = entries ? new Map(entries.map(entry => [entry.id, placementIdentity(entry)])) : null;
+  return new Map(Object.entries(state.entries ?? {}).filter(([id, record]) => !identities
+    || identities.get(id) && record.last_placement === identities.get(id)).map(([id, record]) => [id, record.last_checked]));
+}
+
+const methodOf = row => row.result?.evidence?.method ?? null;
+const eligible = (row, previous) => validTime(row.checked_at)
+  && (!validTime(previous?.last_checked) || Date.parse(row.checked_at) > Date.parse(previous.last_checked));
+const repeats = (row, previous) => previous
+  && previous.last_placement === placementIdentity(row)
+  && previous.last_state === row.state
+  && (previous.last_reason ?? null) === (row.reason ?? null)
+  && (previous.last_signature ?? null) === (row.result?.linkSignature ?? null)
+  && previous.last_complete === (row.complete === true)
+  && (previous.last_method ?? null) === methodOf(row)
+  && (previous.last_checker_version ?? null) === (row.checker_version ?? row.result?.evidence?.checkerVersion ?? null);
+
+function applyRow(previous, row) {
+  const identity = placementIdentity(row);
+  const samePlacement = previous?.last_placement === identity;
+  const attempt = attemptSummary(row, { retained: !repeats(row, previous) });
+  const knownPresent = isConclusive(attempt) && attempt.state === 'present';
+  const priorFirst = samePlacement && previous?.first_present_observation?.placement === identity
+    && isConclusive(previous.first_present_observation) && previous.first_present_observation.state === 'present'
+    ? previous.first_present_observation : null;
+  const firstPresent = priorFirst ?? (knownPresent ? attempt : null);
+  return {
+    ...previous,
+    last_checked: row.checked_at,
+    last_complete: row.complete === true,
+    last_placement: identity,
+    last_state: row.state,
+    last_reason: row.reason ?? null,
+    last_signature: row.result?.linkSignature ?? null,
+    last_method: methodOf(row),
+    last_checker_version: row.checker_version ?? row.result?.evidence?.checkerVersion ?? null,
+    checks: (previous?.checks ?? 0) + 1,
+    last_attempt: attempt,
+    last_successful_observation: isConclusive(attempt) ? attempt : samePlacement ? previous?.last_successful_observation ?? null : null,
+    last_link_verification: isLinkVerification(attempt) ? attempt : samePlacement ? previous?.last_link_verification ?? null : null,
+    first_present: firstPresent?.checked_at ?? null,
+    first_present_placement: firstPresent ? identity : null,
+    first_present_observation: firstPresent,
+    ...(samePlacement && previous?.first_present && !previous.first_present_observation
+      ? { legacy_first_present: previous.first_present } : {}),
+  };
 }
 
 /**
  * Splits a run's rows into the ones worth recording and the ones that repeat.
  *
- * A row is worth recording when it is the first for its entry, or when the state, the reason or
- * the link signature moved. The signature is in there deliberately: a link that is still present
- * but whose anchor or rel changed is a real event, and comparing only the state would miss it.
+ * A row is worth recording when it is the first for its placement, or when the state, reason,
+ * link signature, completeness or method moved. A link that is still present but whose anchor
+ * or rel changed is a real event, and comparing only the state would miss it.
  */
 export function selectChanged(rows, state) {
-  const changed = [], repeated = [];
+  const changed = [], repeated = [], ignored = [];
+  const entries = { ...(state.entries ?? {}) };
   for (const row of rows) {
-    const previous = state.entries?.[row.id];
-    const signature = row.result?.linkSignature ?? null;
-    const same = previous
-      && previous.last_state === row.state
-      && (previous.last_reason ?? null) === (row.reason ?? null)
-      && (previous.last_signature ?? null) === signature;
-    (same ? repeated : changed).push(row);
+    const previous = entries[row.id];
+    if (!eligible(row, previous)) { ignored.push(row); continue; }
+    (repeats(row, previous) ? repeated : changed).push(row);
+    entries[row.id] = applyRow(previous, row);
   }
-  return { changed, repeated };
+  return { changed, repeated, ignored };
 }
 
 /** Applies a run to the activity record. Every check counts, recorded or not. */
 export function applyRun(state, rows) {
+  assertSupportedStateVersion(state);
   const entries = { ...(state.entries ?? {}) };
   for (const row of rows) {
-    const previous = entries[row.id] ?? { checks: 0 };
-    entries[row.id] = {
-      ...previous,
-      last_checked: row.checked_at,
-      last_complete: row.complete === true,
-      last_placement: row.result?.sourceUrl && row.result?.targetUrl ? JSON.stringify([row.result.sourceUrl, row.result.targetUrl, row.result.targetScope ?? 'exact']) : null,
-      last_state: row.state,
-      last_reason: row.reason ?? null,
-      last_signature: row.result?.linkSignature ?? null,
-      checks: (previous.checks ?? 0) + 1,
-      // The date a placement was first seen is worth keeping where nothing can compact it away.
-      first_present: previous.first_present ?? (row.state === 'present' ? row.checked_at : null),
-      first_present_placement: previous.first_present ? previous.first_present_placement ?? null : row.state === 'present' && row.result?.sourceUrl && row.result?.targetUrl ? JSON.stringify([row.result.sourceUrl, row.result.targetUrl, row.result.targetScope ?? 'exact']) : null,
-    };
+    const previous = entries[row.id];
+    if (!eligible(row, previous)) continue;
+    entries[row.id] = applyRow(previous, row);
   }
   return { ...state, v: STATE_VERSION, entries };
 }

package/cli/status.js

@@ -4,32 +4,28 @@
 // expectation, closes the laptop, and three weeks later an agent opens the repository and reads
 // this. So it answers in the order a person cares about, not the order the data is stored in:
 // what appeared, what was lost, what we cannot say, and what needs a decision.
-import { latestByEntry } from './mirror.js';
+import { projectPlacements } from './placement-projection.js';
 
 /** A ledger entry whose observations disagree with its declared intent. */
-export function disagreements(entries, observations) {
-  const latest = latestByEntry(observations);
+export function disagreements(entries, observations, { state = null } = {}) {
   const out = [];
-  for (const entry of entries) {
-    const row = latest.get(entry.id);
-    if (!row) { out.push({ entry, kind: 'never_checked' }); continue; }
+  for (const projection of projectPlacements(entries, observations, { state })) {
+    const { entry, row, latest_attempt: attempt } = projection;
+    const activity = { current_state: projection.current_state, uncertain: projection.uncertain,
+      latest_attempt: attempt, last_successful_observation: projection.last_successful_observation,
+      last_link_verification: projection.last_link_verification,
+      evidence_observed_at: projection.evidence_observed_at, identity_status: projection.identity_status };
+    if (!attempt) { out.push({ entry, kind: 'never_checked', activity }); continue; }
     if (entry.intent === 'expected') {
-      const hostedState = row.source === 'cloud' ? row.result?.watchState : null;
-      const confirmed = row.state === 'confirmed_missing'
-        || (row.state === 'absent' && hostedState === 'confirmed_missing');
-      const suspected = row.state === 'suspected_missing' || row.state === 'absent'
-        || (row.state === 'unknown' && hostedState === 'suspected_missing');
-      const missing = ['absent', 'suspected_missing', 'confirmed_missing'].includes(row.state);
-      // The change mirror omits repeated checks, so raw absence cannot prove confirmation.
-      if ((confirmed || suspected) && row.complete === true) {
-        out.push({ entry, row, kind: confirmed ? 'lost' : 'suspected_missing' });
-      } else if (missing || ['unknown', 'source_unavailable'].includes(row.state)) {
-        out.push({ entry, row, kind: 'cannot_say' });
+      if (projection.uncertain || attempt.state === 'source_unavailable') {
+        out.push({ entry, row, kind: 'cannot_say', activity });
+      } else if (['suspected_missing', 'confirmed_missing'].includes(projection.current_state)) {
+        out.push({ entry, row, kind: projection.current_state === 'confirmed_missing' ? 'lost' : 'suspected_missing', activity });
       }
     }
     // Nothing is promoted automatically: whether a link that appeared is one we now EXPECT is
     // a judgement about a relationship, not about HTML. So this proposes the edit and stops.
-    if (entry.intent === 'wanted' && row.state === 'present') out.push({ entry, row, kind: 'appeared', suggest: { intent: 'expected' } });
+    if (entry.intent === 'wanted' && !projection.uncertain && projection.current_state === 'present') out.push({ entry, row, kind: 'appeared', activity, suggest: { intent: 'expected' } });
   }
   return out;
 }

package/cli/sync.js

@@ -12,6 +12,24 @@ import { CloudError } from './client.js';
 
 const PUSH_BATCH = 100;
 
+function completeImportRows(result, expected) {
+  const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+  const text = value => typeof value === 'string' && value.trim().length > 0;
+  const refuse = () => { throw new CloudError('INVALID_IMPORT_RESPONSE', 502, null,
+    'The cloud returned an incomplete or invalid watch import result. Some watches may already have been stored. Inspect accessible watches and their local references before retrying sync; this request was not automatically replayed.'); };
+  if (!record(result) || !Array.isArray(result.rows) || result.rows.length !== expected) refuse();
+  const seen = new Set();
+  for (const row of result.rows) {
+    if (!record(row) || !Number.isInteger(row.index) || row.index < 0 || row.index >= expected || seen.has(row.index)) refuse();
+    seen.add(row.index);
+    const watch = Object.hasOwn(row, 'watch'), error = Object.hasOwn(row, 'error');
+    if (watch === error) refuse();
+    if (watch && (!record(row.watch) || !text(row.watch.id) || typeof row.watch.created !== 'boolean')) refuse();
+    if (error && (!record(row.error) || !text(row.error.code) || !text(row.error.message))) refuse();
+  }
+  return result.rows;
+}
+
 export function syncPlan(entries, state, { includeWanted = false, ledgerIds = null } = {}) {
   if (ledgerIds !== null && (!Array.isArray(ledgerIds) || ledgerIds.some(id => typeof id !== 'string') || ledgerIds.some(id => !entries.some(entry => entry.id === id))))
     throw new CloudError('INVALID_SYNC_SELECTION', 0);
@@ -38,12 +56,13 @@ export async function pushExpectations(client, entries, state, { projectId, onPr
   for (let index = 0; index < watched.length; index += PUSH_BATCH) {
     const batch = watched.slice(index, index + PUSH_BATCH);
     const result = await client.importWatches(projectId, batch.map(toWatchInput));
-    for (const row of result.rows ?? []) {
+    // Validate the complete acknowledgement before adopting any of this batch.
+    // Earlier POSTs may have committed; a malformed response never authorizes a replay.
+    for (const row of completeImportRows(result, batch.length)) {
       const entry = batch[row.index];
-      if (!entry) continue;
       if (row.error) { failed.push({ id: entry.id, code: row.error.code, message: row.error.message }); continue; }
       mapping[entry.id] = row.watch.id;
-      if (row.watch.created !== false) created.push(entry.id);
+      if (row.watch.created) created.push(entry.id);
     }
     onProgress?.(Math.min(index + PUSH_BATCH, watched.length), watched.length);
   }
@@ -53,7 +72,7 @@ export async function pushExpectations(client, entries, state, { projectId, onPr
   for (const entry of entries.filter(item => actions.get(item.id) === 'pause')) {
     const watchId = mapping[entry.id];
     if (!watchId) continue;
-    try { await client.updateWatch(watchId, { status: 'paused' }); retired.push(entry.id); }
+    try { await client.updateWatch(watchId, { status: 'paused', intent: 'retired' }); retired.push(entry.id); }
     catch (error) { failed.push({ id: entry.id, code: error.code, message: error.message }); }
   }
   return { pushed: watched.length, created: created.length, retired: retired.length, failed, watches: mapping, local: plan.filter(row => row.action === 'stay_local').length };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlinkops",
-  "version": "0.6.11",
+  "version": "0.6.16",
   "description": "Backlink checks with dated evidence and portable results, optional repository ledgers, supplier-export imports and sync to AgentLinkOps.",
   "author": "AgentLinkOps (https://agentlinkops.com)",
   "license": "Apache-2.0",
@@ -22,6 +22,8 @@
     "references",
     "scripts",
     ".mcp.json",
+    "PACKS.json",
+    "PACK-ARTIFACT.json",
     ".claude-plugin",
     ".codex-plugin",
     "README.md",
@@ -46,24 +48,21 @@
     "mcp",
     "backlinks",
     "seo",
-    "citation-monitoring",
-    "ai-citations",
     "agent",
     "cli",
     "link-monitoring",
-    "citation-watch",
     "ledger",
     "jsonl"
   ],
   "dependencies": {
-    "@modelcontextprotocol/client": "2.2.0",
-    "@modelcontextprotocol/server": "2.0.0",
+    "@modelcontextprotocol/client": "2.3.1",
+    "@modelcontextprotocol/server": "2.3.1",
     "ipaddr.js": "2.2.0",
     "koffi": "3.3.2",
     "parse5": "8.0.1",
     "turndown": "^7.2.4",
-    "undici": "7.29.1",
-    "zod": "4.6.0"
+    "undici": "7.30.1",
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "esbuild": "^0.28.2"

package/references/citation-panels.md

@@ -1,5 +1,7 @@
 # Citation panels
 
+Status: AI citation measurement is not part of the AgentLinkOps offer. No default skill links to this page, and the hosted service lists no citation commands for customers. This reference covers the local `agentlinkops citation` commands, which stay in the CLI for existing panels.
+
 A panel records the questions, target sites, engines and sample budget for a citation check. Start with questions your audience has actually asked. Keep each question's source and collection date in your own research notes. Search Console queries, support conversations and public discussion threads can help when you already have access; the panel builder does not fetch or validate them.
 
 Create an editable draft without calling a provider:

package/references/cli.md

@@ -1,8 +1,8 @@
 # Local CRM contract
 
 Version 0.2.0; SQLite schema version 4. Python 3.10+ is the only prerequisite.
-Examples assume the working directory is this plugin root. Resolve paths from
-the installed plugin location when running from a skill. Choose a database
+Resolve example helper paths from the plugin root for shared references, or from
+the skill directory for a standalone archive's bundled references. Choose a database
 path in the user's working directory, outside the replaceable plugin cache.
 
 ```sh

package/references/disavow.md

@@ -16,7 +16,7 @@ checked September 9, 2026.
 
 ## Commands
 
-Run from the installed plugin root and keep the database outside its cache:
+Resolve example helper paths from the plugin root for shared references, or from the skill directory for a standalone archive's bundled references. Keep the database outside the installation directory:
 
 ```sh
 python3 scripts/agentlinkops.py --db ./agentlinkops.sqlite migrate

package/references/discovery-handoff.md

@@ -29,4 +29,4 @@ The local check includes wanted entries; `--all` rechecks the selected rows even
 
 For an already connected workspace, `agentlinkops tools monitoring` and `agentlinkops describe monitor_link` expose the current hosted contract. Inspect project IDs and usage first. Enroll selected source/target pairs only when recurring monitoring is within the user's request; record the returned watch IDs. A successful import or local check alone does not create a recurring hosted job.
 
-The [campaign skill](../skills/agentlinkops-campaigns/SKILL.md) handles subsequent campaign judgment. The [CRM reference](cli.md) covers optional records when the user needs contacts and activities beside the ledger. Outreach stays in the user's chosen tool and requires their instruction.
+Use the customer's brief and evidence to decide the next campaign step. For additional guidance, select `agentlinkops agent setup --skill agentlinkops-campaigns` and read that installed skill. The [CRM reference](cli.md) covers optional records when the user needs contacts and activities beside the ledger. Outreach stays in the user's chosen tool and requires their instruction.

package/references/local-crm-draft-handoff.md

@@ -7,7 +7,7 @@ This adapter writes an inert body and companion manifest under that project's
 drafts directory. It does not write contacts, replies, suppression, send logs or
 sequence state. Native vendor APIs remain unsupported by this adapter.
 
-Run from the plugin root:
+Resolve example helper paths from the plugin root for shared references, or from the skill directory for a standalone archive's bundled references:
 
 ```sh
 python3 scripts/outreach-crm-draft.py --crm-root /path/to/customer-crm --request request.json --body-file reviewed-body.txt

package/references/portable-ledger-handoff.md

@@ -36,15 +36,16 @@ Keep a distinct output for a new snapshot; this is a dated artifact, not a monit
 
 Read the saved JSON back before claiming persistence. Its destination outcome is
 `not_attempted`, and `send_eligible` remains false on every row. Passing this helper
-does not prove a CRM import or sequencer readback. Follow the
-[qualified campaign handoff](recipes/qualified-campaign-handoff.md) for explicit
-mapping, original-operation reconciliation and destination readback. After a
-response-lost import, preserve its actual operation identity and unknown outcome;
-do not replace it with this file's operation ID or repeat a create to repair an
-artifact error. [Placement reconciliation](recipes/placement-reconciliation.md)
-keeps monitoring facts apart from sent/replied/suppressed records.
-
-Package invocation assumes the plugin's root directory. Local source invocation
-uses toolkit/plugin/agentlinkops/scripts/portable-handoff.py. Unsupported native
+does not prove a CRM import or sequencer readback. Before a destination write,
+retain the exact mapping and request, then read the destination back when authorized.
+After a response-lost import, preserve its actual operation identity and unknown
+outcome; do not replace it with this file's operation ID or repeat a create to
+repair an artifact error. Keep monitoring facts apart from sent/replied/suppressed
+records. For additional guidance, select `agentlinkops agent setup --recipe qualified-campaign-handoff`
+or `agentlinkops agent setup --recipe placement-reconciliation` and read the selected
+recipe. Neither is required to prepare this local file.
+
+Resolve example helper paths from the plugin root for shared references, or from
+the skill directory for a standalone archive's bundled references. Unsupported native
 vendors, mailbox access and automatic suppression synchronization remain outside
 this helper. No account, credential or send action is installed by it.