agentlinkops 0.6.13 → 0.6.16

package/cli/key-store.js

@@ -0,0 +1,115 @@
+// Where `agentlinkops connect` keeps the API key a person pastes, so cloud commands work in any
+// folder without environment variables. Never inside a repository:
+//
+//   macOS  the login Keychain, through /usr/bin/security. `security -i` takes the key on stdin,
+//          so it never appears in a process listing.
+//   Linux  ~/.agentlinkops/keys/, one file per cloud origin, mode 600 in a mode 700 directory
+//          owned by the person; anything looser is ignored rather than trusted.
+//   other  nothing is saved; AGENTLINKOPS_API_KEY keeps working everywhere.
+//
+// One key per cloud origin. Reads are synchronous because cloudConnection() is.
+import { execFile, execFileSync } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { lstatSync, readFileSync } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { ConfigError } from './config.js';
+
+export const API_KEY_PATTERN = /^lt_[0-9a-f]{64}$/;
+// main() attaches the reader to the environment object it hands every command, under this
+// symbol: it never reaches a child process, a JSON dump or a test that passes its own env.
+export const STORED_KEY = Symbol.for('agentlinkops.storedKey');
+
+const SECURITY = '/usr/bin/security';
+const SERVICE = 'agentlinkops-cli';
+// An origin is a Keychain account name and a file-name input: canonical https only, no spaces
+// or quotes, so it can sit unquoted in a `security -i` command line.
+const canonical = origin => {
+  try { const url = new URL(origin); return url.protocol === 'https:' && url.origin === origin && !/[\s"'\\]/.test(origin); }
+  catch { return false; }
+};
+
+const runSync = (file, args) => execFileSync(file, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 });
+const run = (file, args, input) => new Promise((resolve, reject) => {
+  const child = execFile(file, args, { encoding: 'utf8', timeout: 10000 }, (error, stdout) => error ? reject(error) : resolve(stdout));
+  child.stdin.end(input);
+});
+
+function keychainStore({ exec = runSync, execInput = run }) {
+  const store = {
+    where: 'your macOS Keychain',
+    readSync(origin) {
+      if (!canonical(origin)) return null;
+      try {
+        const key = exec(SECURITY, ['find-generic-password', '-s', SERVICE, '-a', origin, '-w']).trim();
+        return API_KEY_PATTERN.test(key) ? key : null;
+      } catch { return null; } // 44: no such item. Anything else reads as no saved key.
+    },
+    async save(origin, key) {
+      if (!canonical(origin) || !API_KEY_PATTERN.test(key)) throw new ConfigError('Only a complete API key for an https origin can be saved.');
+      await execInput(SECURITY, ['-i'], `add-generic-password -U -s ${SERVICE} -a ${origin} -w ${key}\n`).catch(() => {});
+      // `security -i` reports per-command failures on its own output, so read the key back.
+      if (store.readSync(origin) !== key) throw new ConfigError('The key could not be saved in your macOS Keychain. Set AGENTLINKOPS_API_KEY instead.');
+    },
+    async remove(origin) {
+      if (!canonical(origin)) return false;
+      try { exec(SECURITY, ['delete-generic-password', '-s', SERVICE, '-a', origin]); return true; } catch { return false; }
+    },
+  };
+  return store;
+}
+
+function fileStore({ home, uid = process.getuid?.() }) {
+  const dir = join(home, '.agentlinkops', 'keys');
+  const fileFor = origin => join(dir, `${createHash('sha256').update(origin).digest('hex').slice(0, 32)}.json`);
+  const own = info => uid !== undefined && info.uid === uid;
+  const privateDir = info => info.isDirectory() && own(info) && (info.mode & 0o777) === 0o700;
+  const privateFile = info => info.isFile() && info.nlink === 1 && own(info) && (info.mode & 0o777) === 0o600;
+  return {
+    where: '~/.agentlinkops/keys (readable only by you)',
+    readSync(origin) {
+      if (!canonical(origin)) return null;
+      try {
+        if (!privateDir(lstatSync(dir)) || !privateFile(lstatSync(fileFor(origin)))) return null;
+        const record = JSON.parse(readFileSync(fileFor(origin), 'utf8'));
+        return record?.origin === origin && API_KEY_PATTERN.test(record.key) ? record.key : null;
+      } catch { return null; }
+    },
+    async save(origin, key) {
+      if (!canonical(origin) || !API_KEY_PATTERN.test(key)) throw new ConfigError('Only a complete API key for an https origin can be saved.');
+      for (const path of [join(home, '.agentlinkops'), dir]) {
+        try { await fs.mkdir(path, { mode: 0o700 }); } catch (error) { if (error.code !== 'EEXIST') throw error; }
+      }
+      if (!privateDir(await fs.lstat(dir))) throw new ConfigError(`${dir} must be a directory only you can open (mode 700). Fix it, or set AGENTLINKOPS_API_KEY instead.`);
+      const path = fileFor(origin), temporary = `${path}.${randomBytes(8).toString('hex')}.tmp`;
+      try {
+        await fs.writeFile(temporary, `${JSON.stringify({ origin, key })}\n`, { flag: 'wx', mode: 0o600 });
+        await fs.rename(temporary, path);
+      } finally { await fs.unlink(temporary).catch(() => {}); }
+    },
+    async remove(origin) {
+      if (!canonical(origin)) return false;
+      try { await fs.unlink(fileFor(origin)); return true; } catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+    },
+  };
+}
+
+const unsupported = {
+  where: null,
+  readSync: () => null,
+  async save() { throw new ConfigError('This platform has no supported place to save a key yet. Set AGENTLINKOPS_API_KEY instead.'); },
+  async remove() { return false; },
+};
+
+export function createKeyStore({ platform = process.platform, home = homedir(), exec, execInput, uid } = {}) {
+  if (platform === 'darwin') return keychainStore({ exec, execInput });
+  if (platform === 'linux' && typeof home === 'string' && isAbsolute(home)) return fileStore({ home, uid });
+  return unsupported;
+}
+
+/** The environment a command sees, plus a reader for keys saved by `agentlinkops connect`. */
+export function withStoredKeys(env, store) {
+  if (!store) return env;
+  return { ...env, [STORED_KEY]: origin => { const key = store.readSync(origin); return key ? { key, where: store.where } : null; } };
+}

package/cli/ledger.js

@@ -214,6 +214,7 @@ export function toWatchInput(entry) {
   // caller can say so rather than discovering it when a reference comes back short.
   const reference = entry.ref ? `${entry.id} ${entry.ref}` : entry.id;
   return {
+    intent: ({wanted:'prospect',expected:'earned',retired:'retired'})[entry.intent],
     sourceUrl: entry.source, targetUrl: entry.target, targetScope: entry.scope,
     cadenceSeconds: cadenceSeconds(entry.cadence ?? DEFAULT_CADENCE[entry.intent] ?? 'daily'),
     expectedAnchor: entry.expect?.anchor ?? null,

package/cli/local-result.js

@@ -15,11 +15,26 @@ export const LOCAL_RESULT_SCHEMA = 'agentlinkops.local-check.v1';
 
 const timestamp = z.string().refine(value => Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value);
 const strings = z.array(z.string());
+const digest = z.string().regex(/^[a-f0-9]{64}$/u);
+const capturePin = z.string().min(1).max(128).regex(/^[^\x00-\x20\x7f]+$/u);
+const bodyDiagnosticSchema = z.strictObject({ version: z.literal(1), bytes: z.number().int().min(0).max(64 * 1024),
+  complete: z.boolean(), truncated: z.boolean(), sha256: digest, looksLikeHtml: z.boolean() });
+const googlebotSchema = z.strictObject({ productToken: z.literal('Googlebot'), allowed: z.boolean().nullable(),
+  reason: z.string().nullable(), matchedRule: z.string().nullable(), crawlDelaySeconds: z.number().finite().min(0).nullable() });
+const captureSchema = z.strictObject({ version: z.literal(1), representation: z.literal('raw_html'),
+  requestedUrl: z.string(), finalUrl: z.string(), httpStatus: z.number().int().min(100).max(599), acquiredAt: timestamp,
+  body: z.strictObject({ complete: z.literal(true), truncated: z.literal(false), bytes: z.number().int().min(0).max(2 * 1024 * 1024),
+    sha256: digest, decodedSha256: digest, charset: z.string().max(64).nullable().optional() }),
+  transport: z.strictObject({ id: capturePin, version: capturePin, qualified: z.literal(true) }),
+  coverage: z.strictObject({ mainDocument: z.literal(true), iframes: z.literal(false), shadowRoots: z.literal(false) }) });
 const redirectSchema = z.strictObject({ from: z.string(), to: z.string(), status: z.number().int() });
 const robotsSchema = z.strictObject({ allowed: z.boolean().nullable(), reason: z.string().nullable(),
   matchedRule: z.string().nullable(), crawlDelaySeconds: z.number().nullable(), fetched: z.string().nullable(),
   sourceUrl: z.string().optional(), robotsUrl: z.string().optional(), httpStatus: z.number().int().nullable().optional(),
-  productToken: z.string().optional(), redirects: z.array(redirectSchema).max(5).optional(), retryAfterSeconds: z.number().optional() });
+  productToken: z.string().optional(), redirects: z.array(redirectSchema).max(5).optional(), retryAfterSeconds: z.number().finite().min(0).max(86400).optional(),
+  googlebot: googlebotSchema.optional(), decisionReason: z.string().nullable().optional(),
+  policy: z.literal('customer_supplied_monitor').optional(), fetchAuthorized: z.boolean().optional(), overrideUsed: z.literal(false).optional(),
+  bodyDiagnostic: bodyDiagnosticSchema.optional() });
 const readinessSchema = z.strictObject({ requiresRender: z.boolean(), reason: z.string().nullable(), possibleLoginWall: z.boolean(),
   hasVisiblePassword: z.boolean().optional(), targetInScript: z.boolean().optional(), emptyAppRoot: z.boolean().optional(), emptyProfileRoot: z.boolean().optional() });
 const occurrenceSchema = z.strictObject({ href: z.string(), targetUrl: z.string(), anchor: z.string(), rel: strings,
@@ -28,15 +43,18 @@ const observationSchema = z.strictObject({
   state: z.enum(['present','absent','unknown','source_unavailable']), reason: z.string(), sourceUrl: z.string(), finalUrl: z.string(), targetUrl: z.string(),
   targetScope: z.enum(['exact','domain','subdomain','path']), httpStatus: z.number().int().nullable(), checkedAt: timestamp,
   occurrences: z.array(occurrenceSchema).max(1000),
-  directives: z.strictObject({ meta: z.array(z.strictObject({ name: z.string(), content: z.string() })), xRobotsTag: strings, noindex: z.boolean(), nofollow: z.boolean(), indexingStatus: z.string() }),
+  directives: z.strictObject({ meta: z.array(z.strictObject({ name: z.string(), content: z.string() })), xRobotsTag: strings, noindex: z.boolean(), nofollow: z.boolean(), indexingStatus: z.string(),
+    googlebot: z.strictObject({ noindex: z.boolean(), nofollow: z.boolean() }).optional() }),
   redirects: z.array(redirectSchema),
   evidence: z.strictObject({ method: z.string(), checkerVersion: z.string(), complete: z.boolean(), fetchedAt: timestamp.nullable(),
     bytes: z.number().optional(), contentType: z.string().nullable().optional(), etag: z.string().nullable().optional(), lastModified: z.string().nullable().optional(),
-    baseUrl: z.string().optional(), rendered: z.boolean().optional(), sha256: z.string().optional(), parseErrors: strings.optional(),
-    readiness: readinessSchema.optional(), renderEligibility: z.enum(['required', 'comparison']).optional() }),
+    baseUrl: z.string().optional(), rendered: z.literal(false).optional(), sha256: digest.optional(), decodedSha256: digest.optional(),
+    capture: captureSchema.nullable().optional(), parseErrors: strings.optional(),
+    readiness: readinessSchema.optional(), renderEligibility: z.enum(['required', 'comparison']).optional(),
+    renderAttempt: z.strictObject({ attempted: z.literal(false), reason: z.literal('render_not_configured') }).optional() }),
   robots: robotsSchema.optional(), robotsHistory: z.array(robotsSchema).max(6).optional(),
   sourceResponse: z.strictObject({ url: z.string(), httpStatus: z.number().int(), contentType: z.string().max(128).nullable(),
-    retryAfterSeconds: z.number().nullable(), challenge: z.boolean() }).optional(),
+    retryAfterSeconds: z.number().nullable(), challenge: z.boolean(), bodyDiagnostic: bodyDiagnosticSchema.optional() }).optional(),
   expectations: z.strictObject({ expectedAnchor: z.string().nullable(), expectedRel: strings.nullable(), anchorMatches: z.boolean().nullable(), relMatches: z.boolean().nullable(), satisfied: z.boolean() }).optional(),
   linkSignature: z.string().optional(), warnings: strings.optional(), retryAfterSeconds: z.number().optional(),
 });
@@ -88,11 +106,28 @@ export function validateLocalResult(result) {
   const rejectBytes = value => {
     if (!value || typeof value !== 'object') return;
     for (const [key, child] of Object.entries(value)) {
-      if (['html','body','headers'].includes(key.toLowerCase())) throw new Error('portable observations cannot contain raw HTML/body/headers');
+      if (['html','body','headers'].includes(key.toLowerCase())
+        && !(key === 'body' && value === observation.evidence?.capture)) throw new Error('portable observations cannot contain raw HTML/body/headers');
       rejectBytes(child);
     }
   };
   rejectBytes(observation);
+  const capture = observation.evidence.capture;
+  if (capture) {
+    if (capture.requestedUrl !== input.source || capture.finalUrl !== observation.finalUrl
+      || !validatePublicUrl(capture.finalUrl).valid || capture.httpStatus !== observation.httpStatus
+      || capture.acquiredAt !== observation.evidence.fetchedAt
+      || capture.body.bytes !== observation.evidence.bytes || capture.body.sha256 !== observation.evidence.sha256
+      || capture.body.decodedSha256 !== observation.evidence.decodedSha256
+      || observation.evidence.method !== 'http_html') throw new Error('portable capture does not match its observation');
+    if (capture.body.charset != null) {
+      try { new TextDecoder(capture.body.charset, { fatal: true }); }
+      catch { throw new Error('invalid portable capture charset'); }
+    }
+  }
+  if (observation.evidence.renderAttempt && (observation.state !== 'unknown' || observation.evidence.complete !== false
+    || !['possible_render_required', 'navigation_requires_browser'].includes(observation.reason)
+    || observation.evidence.renderEligibility !== 'required')) throw new Error('invalid portable refused-render observation');
   if (observation.occurrences.some(item => !item || typeof item.targetUrl !== 'string' || !Array.isArray(item.rel)
     || !matchesTarget(item.targetUrl, input.target, input.scope))) throw new Error('invalid portable occurrence');
   if (observation.state === 'present' && (!observation.evidence.complete || !observation.occurrences.length)) throw new Error('present requires complete matching occurrences');

package/cli/main.js

@@ -2,6 +2,7 @@ import {projectPlacements} from './placement-projection.js';
 import {chronologyMain} from './chronology.js';
 import { acquireSyncLock } from './sync-lock.js';
 import {lifecycleMain} from './lifecycle.js';
+import {campaignMain,CAMPAIGN_CLI_HELP} from './campaign-bridge.js';
 import {admissionMain} from './admission.js';
 import { commandsMain } from './commands.js';
 import { disavowMain } from './disavow.js';
@@ -23,8 +24,10 @@ import { checkToFile, adoptLocalResult } from './local-result.js';
 import { disagreements, transitions } from './status.js';
 import { readImport, parseMap } from './import.js';
 import { freezeDataset, renderReport, datasetDigest } from './report.js';
-import { createClient, CloudError } from './client.js';
-import { cloudConnection, connectMain, keySetup } from './connection.js';
+import { createClient, CloudError, CLI_VERSION } from './client.js';
+import { cloudConnection, connectKey, connectMain, keySetup } from './connection.js';
+import { createKeyStore, withStoredKeys } from './key-store.js';
+import { askSecret } from './prompt.js';
 import { syncPlan, pushExpectations, pullLifecycleMirrors, pullEvents, cloudObservationRows, watchIndex, pullTargetEvents } from './sync.js';
 import { SUPPLIER_NAMES } from './adapters/suppliers.js';
 import { fleetSummary, renderFleet } from './fleet.js';
@@ -46,6 +49,8 @@ import { citationMain } from './citation.js';
 
 const USAGE = `agentlinkops — a backlink ledger that lives in your repository
 
+  agentlinkops --version              print the installed CLI version
+
   agentlinkops skill [--url|--list [--json]|NAME]  read the agent reference or a named skill
                                             before the first AgentLinkOps call
   agentlinkops init                   create .agentlinkops/ here
@@ -57,8 +62,9 @@ const USAGE = `agentlinkops — a backlink ledger that lives in your repository
   agentlinkops chronology pull --watch-id ID [--limit N] [--cursor TOKEN] [--all] [--out FILE]
   agentlinkops chronology export --pages FILE [--submissions FILE] [--out FILE]
   agentlinkops index pull --watch-id ID [--limit N] [--before ID]
+  agentlinkops campaign plan|apply|reconcile|rollback|pull-plan|pull-apply|pull-rollback|outcomes-plan|outcomes-apply
+                                            preview and reconcile portable campaign records; no sending or automatic checks
   agentlinkops lifecycle get|update|clear|renew|report
-  agentlinkops admission list|add|update|remove|evaluate|reevaluate|receipt --project ID
   agentlinkops disavow list|history|propose|import|export|approve|reject|delete
   agentlinkops index import FILE | export [--out FILE] | csv URLS.csv [--out FILE]
   agentlinkops index submissions-import FILE | submissions-export --project-id ID [--out FILE]
@@ -82,7 +88,9 @@ const USAGE = `agentlinkops — a backlink ledger that lives in your repository
                                             .agentlinkops/citations/; live engines need
                                             engine-specific setup; the mock engine makes no paid calls
   agentlinkops receive --body FILE --headers FILE   signed notification; authenticated pull
-  agentlinkops connect --workspace ID --project-id ID [--origin URL] [--selection FILE] [--oauth --issuer URL --client-id ID [--credential-ref REF]]
+  agentlinkops connect [--project-id ID] [--workspace ID] [--origin URL] [--selection FILE] [--oauth --issuer URL --client-id ID [--credential-ref REF]]
+                                            paste an API key once; it is saved outside the
+                                            repository and the key names its workspace
   agentlinkops tools [TOOLSET] [--json] [--refresh]   cloud commands by toolset (offline snapshot;
                                             --refresh reads the live catalog)
   agentlinkops describe NAME [--examples] [--output-schema] [--json]  one command's exact schema
@@ -91,7 +99,8 @@ const USAGE = `agentlinkops — a backlink ledger that lives in your repository
   agentlinkops agent setup [--client ID ...] [--scope project|user] [--origin URL] [--dry-run]
                                             core connection/reference and the right MCP view;
                                             optional --skill ID ... / --recipe ID ... / --all-skills;
-                                            stores no credential; preserves customer instructions
+                                            stores no credential unless you paste a CLI key
+                                            when asked; preserves customer instructions
   agentlinkops agent status                 what is installed where
   agentlinkops agent remove [--skill ID ...] [--recipe ID ...] [--scope project|user] [--apply] [--json]
   agentlinkops agent recover [--scope project|user] [--apply] [--json]
@@ -126,6 +135,24 @@ evidence · 2 usage, configuration or ledger error. Unknown is nonfailing by def
 Names: \`linktrail\` still runs this CLI, LINKTRAIL_* variables are still read, and an existing
 .linktrail/ directory is still used, each with a one-line notice, until the DP-0029 cutover.`;
 
+// After `agent setup` on a terminal: the CLI half, so the folder's agent can also run
+// `agentlinkops call`. Optional (Enter skips), and setup has already succeeded either way.
+async function connectCliAfterSetup(origin, { env, ask, keyStore, fetchImpl, out }) {
+  let connection = null;
+  try { connection = cloudConnection({ cloud: { origin } }, env); } catch { /* Disagreeing variables: connect reports them. */ }
+  out('');
+  if (connection?.token) { out(`The agentlinkops CLI can use this account too (key in ${connection.tokenSource}).`); return; }
+  try {
+    const key = await connectKey({ origin, ask, keyStore, fetchImpl, out,
+      prompt: `To use the agentlinkops CLI as well, paste an API key from ${origin}/#/access (Create API key), or press Enter to skip: ` });
+    out(key
+      ? `The CLI is connected to ${key.account.workspace.name || 'your workspace'}. Try: agentlinkops call list_tasks`
+      : 'Skipped. Run `npx -y agentlinkops connect` when you want the CLI.');
+  } catch (error) {
+    out(`The CLI wasn't connected: ${error.serverMessage ?? error.message}. Run \`npx -y agentlinkops connect\` to try again.`);
+  }
+}
+
 const parseArgs = argv => parseArguments(argv,["tag", "project", "observations-of", "state-of", "observations", "benchmark", "seed"],{tag:[]});
 
 const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
@@ -139,7 +166,16 @@ function reportProblems(problems, what, out) {
   if (problems.length > 20) out(`  … and ${problems.length - 20} more`);
 }
 
-export async function main(argv = process.argv.slice(2), { cwd = process.cwd(), out = console.log, err = console.error, env = process.env, fetchImpl = globalThis.fetch, afterHistoryPersisted, afterStatePersisted } = {}) {
+export async function main(argv = process.argv.slice(2), options) {
+  // The executables call main() with no options, the one caller that reads the person's saved
+  // key and asks on their terminal. Every other caller passes options and gets neither.
+  const executable = options === undefined;
+  const { cwd = process.cwd(), out = console.log, err = console.error, fetchImpl = globalThis.fetch, localFetchImpl = null, afterHistoryPersisted, afterStatePersisted, signal,
+    keyStore = executable ? createKeyStore() : null,
+    ask = executable && process.stdin.isTTY === true && process.stderr.isTTY === true ? askSecret : null } = options ?? {};
+  if (argv.length === 1 && argv[0] === '--version') { out(CLI_VERSION); return 0; }
+  if (argv[0] === 'campaign' && argv.length===2 && ['--help','help'].includes(argv[1])) { out(CAMPAIGN_CLI_HELP); return 0; }
+  const env = withStoredKeys(options?.env ?? process.env, keyStore);
   if (argv[0] === 'gsc-links') return await gscLinksMain(argv, { cwd, out });
   // Citation watches keep their own files under .agentlinkops/citations/ and never
   // touch the link ledger, so they dispatch before its requirement like context does.
@@ -155,6 +191,7 @@ export async function main(argv = process.argv.slice(2), { cwd = process.cwd(),
   try {
     if (args['recover-cursors'] !== undefined && (command !== 'sync' || args['recover-cursors'] !== true || args['pull-only'] !== true || args['push-only']))
       throw new ConfigError('Cursor recovery requires agentlinkops sync --pull-only --recover-cursors; it performs no remote writes.');
+    if (command === 'campaign') return await campaignMain(args,{cwd,env,fetchImpl,out});
     if (command === 'lifecycle') return await lifecycleMain(args,{cwd,env,fetchImpl,out,err});
     if (command === 'admission') { const config=await loadConfig({cwd}); return await admissionMain(argv.slice(1),{client:createClient({...cloudConnection(config,env),fetchImpl}),out,err}); }
     if (command === 'disavow') return await disavowMain(args,{cwd,env,fetchImpl,out});
@@ -163,17 +200,18 @@ export async function main(argv = process.argv.slice(2), { cwd = process.cwd(),
     if (command === 'setup') return await setupPlanMain(argv, { cwd, out });
     if (command === 'tools' || command === 'describe' || command === 'schema' || command === 'call') return await commandsMain(argv, { cwd, out, err, env, fetchImpl });
     if (command === 'skill') return await skillMain(argv, { out });
-    if (command === 'agent') return await agentMain(argv, { cwd, out, err });
+    if (command === 'agent') return await agentMain(argv, { cwd, out, err, env, connectCli: ask && keyStore ? origin => connectCliAfterSetup(origin, { env, ask, keyStore, fetchImpl, out }) : null });
     if (command === 'connect') {
-      if (args._.length !== 1 || args.tag.length || Object.keys(args).some(key => !['_', 'tag', 'origin', 'workspace', 'project-id', 'selection', 'oauth', 'issuer', 'client-id', 'credential-ref'].includes(key))) throw new ConfigError('connect --workspace ID --project-id ID [--origin URL] [--selection FILE] [--oauth --issuer URL --client-id ID [--credential-ref REF]]');
-      return await connectMain(args, { cwd, out, env, fetchImpl });
+      if (args._.length !== 1 || args.tag.length || Object.keys(args).some(key => !['_', 'tag', 'origin', 'workspace', 'project-id', 'selection', 'oauth', 'issuer', 'client-id', 'credential-ref'].includes(key))) throw new ConfigError('connect [--project-id ID] [--workspace ID] [--origin URL] [--selection FILE] [--oauth --issuer URL --client-id ID [--credential-ref REF]]');
+      return await connectMain(args, { cwd, out, env, fetchImpl, keyStore, ask });
     }
     if (command === 'check' && (args.source !== undefined || args.target !== undefined)) {
       if (typeof args.source !== 'string' || typeof args.target !== 'string') throw new ConfigError('check requires both --source URL and --target URL');
       const allowed = new Set(['_', 'source', 'target', 'scope', 'json', 'out']);
       if (Object.keys(args).some(key => key !== 'tag' && !allowed.has(key)) || args.tag.length || args._.length !== 1) throw new ConfigError('unsupported option for a single local check');
       if (args.out !== undefined && (typeof args.out !== 'string' || !args.out.trim())) throw new ConfigError('--out requires a file path');
-      const result = await checkToFile({ source: args.source, target: args.target, scope: args.scope }, args.out ? resolve(cwd, args.out) : null);
+      const result = await checkToFile({ source: args.source, target: args.target, scope: args.scope }, args.out ? resolve(cwd, args.out) : null,
+        { fetchImpl: localFetchImpl });
       out(args.json ? JSON.stringify(result, null, 2) : `${result.observation.state}  ${result.observation.reason}  ${result.checked_at}${args.out ? `  saved ${args.out}` : ''}`);
       return 0;
     }
@@ -333,7 +371,7 @@ export async function main(argv = process.argv.slice(2), { cwd = process.cwd(),
       // DP-0017's context surface owns its config and files and needs no ledger, so it runs
       // before the ledger check below. contextMain parses its own argv; hand it everything
       // after the command word (found positionally, because flags may precede it).
-      return await contextMain(argv.slice(argv.indexOf(command) + 1), { cwd, out, err });
+      return await contextMain(argv.slice(argv.indexOf(command) + 1), { cwd, out, err,signal });
     }
     if (command === 'doctor') {
       // Doctor must run exactly where the ledger cannot be trusted yet: its job is to name
@@ -341,7 +379,7 @@ export async function main(argv = process.argv.slice(2), { cwd = process.cwd(),
       // file itself. Takes no flags and repairs nothing. Awaited on purpose: a promise returned
       // from inside the try escapes the ConfigError handler below, and a disagreeing pair of
       // token spellings would surface as a stack trace instead of the exit-2 message.
-      return await doctorMain(argv.slice(argv.indexOf(command) + 1), { cwd, out, err });
+      return await doctorMain(argv.slice(argv.indexOf(command) + 1), { cwd, out, err, env });
     }
 
     const config = await loadConfig({ cwd });
@@ -616,6 +654,7 @@ export async function main(argv = process.argv.slice(2), { cwd = process.cwd(),
         concurrency: Number(args.concurrency ?? config.defaults.concurrency ?? DEFAULTS.concurrency),
         timeoutMs: Number(args.timeout ?? config.defaults.timeoutMs ?? DEFAULTS.timeoutMs),
         hostDelayMs: Number(args['host-delay'] ?? config.defaults.hostDelayMs ?? DEFAULTS.hostDelayMs),
+        fetchImpl: localFetchImpl,
       });
       // The mirror records changes; `state.json` records activity. Appending a row that says
       // the same thing as the one above it is 2 KB of git churn per link per run, and the only

package/cli/mcp-client.js

@@ -62,7 +62,7 @@ function retryDelay(error, attempt, now) {
 
 async function sdkClient({url, token, workspaceId, fetchImpl}) {
   const {Client, StreamableHTTPClientTransport} = await import('@modelcontextprotocol/client');
-  const client = new Client({name: 'agentlinkops-cli', version: '0.6.13'});
+  const client = new Client({name: 'agentlinkops-cli', version: '0.6.16'});
   const destination = new URL(url);
   const transport = new StreamableHTTPClientTransport(destination, {
     authProvider: {token: async () => token},
@@ -71,7 +71,7 @@ async function sdkClient({url, token, workspaceId, fetchImpl}) {
       if (target.href !== destination.href) fail('OAUTH_TOKEN_DESTINATION_MISMATCH');
       const headers = new Headers(init.headers ?? (input instanceof Request ? input.headers : undefined));
       if (workspaceId) headers.set('X-Workspace-ID', workspaceId);
-      headers.set('User-Agent', 'agentlinkops-cli/0.6.13');
+      headers.set('User-Agent', 'agentlinkops-cli/0.6.16');
       const response = await fetchImpl(input, {...init, headers, redirect: 'error', signal: AbortSignal.timeout(30000)});
       if (response.redirected || response.status >= 300 && response.status < 400
         || response.url && response.url !== destination.href) fail('OAUTH_TOKEN_DESTINATION_MISMATCH');