agentic-ads-engine 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agentic-ads-engine contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,225 @@
-# Temporary Holding Version
+# agentic-ads-engine
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Offline tools for ad drafts. Node 20 or later. Plain JavaScript ESM with JSDoc, no build step, and zero runtime dependencies.
+
+## Install
+
+```sh
+npm install agentic-ads-engine        # library and CLI in a project
+npm install -g agentic-ads-engine     # the agentic-ads and agentic-ads-mcp commands
+```
+
+## Quick start
+
+```sh
+npx agentic-ads list-templates
+npx agentic-ads hooks
+npx agentic-ads lint --copy 'Browse available listings'
+npx agentic-ads plan --site demo --goal discovery --dry-run
+npx agentic-ads serve --port 8787     # HTTP API, loopback only unless AGENTIC_ADS_TOKEN is set
+npx agentic-ads-mcp                   # MCP server over stdio
+```
+
+From a git checkout, use `node bin/agentic-ads ...` and run `node test/e2e.mjs` for the tests.
+
+CLI output is JSON. Exit codes: `0` for a result, `1` for invalid input, and `2` for blocked copy.
+`lint` requires `--copy`. It accepts `--category housing|none`; the default is `housing`.
+`plan` accepts `--site`, `--goal`, `--template`, `--ratio`, `--copy`, and `--category`.
+Use `--option=value` for values that start with `--`: `node bin/agentic-ads lint --copy=--Sale--`.
+This form preserves `=` inside values. Boolean options accept `=true` or `=false`; plans still require dry-run.
+Site names are lowercase slugs. Ratios are `4:5` and `9:16`.
+
+Plans default to dry-run. `--apply` always fails because this slice has no spending or launch implementation.
+Plans return required slots and policy findings. They do not render an image.
+The five templates cover door reveals, first-person UGC, before/after views, news frames, and help with timing.
+Their slots and story beats differ. The HTML stub uses a shared text layout.
+
+## Library
+
+```js
+import {
+  readScores, writeScores, selectFor, templateProvider, guardCost,
+} from 'agentic-ads-engine';
+
+await writeScores('./scores', 'demo', { help: 8 });
+const scores = await readScores('./scores', 'demo');
+const hook = selectFor({ id: 'demo', scores }, 'discovery');
+
+const preview = templateProvider.run({
+  template: 'door-open-teaser',
+  ratio: '4:5',
+  brand: { name: 'Demo', primary: '#2455cc' },
+  slots: {
+    headline: 'Take a closer look',
+    detail: 'Review the available listing details',
+    cta: 'Browse listings',
+  },
+});
+console.log(hook.id, preview.mime); // help text/html
+```
+
+`selectFor(site, goal)` is pure. Supply `{ id, scores }`; it never reads the store itself.
+Only low-risk hooks qualify. Scores rank matching hooks; catalog order resolves ties.
+No match returns `null`. Scores are finite, nonnegative numbers keyed by known hook IDs.
+The caller defines the score metric. This slice does not measure performance or establish sample confidence.
+CLI and MCP plans use cold-start scores. Load saved scores through the library when selecting hooks.
+
+The file store writes one JSON snapshot per site. Replacement is atomic; callers must use one writer.
+A missing file returns `{}`. Invalid files fail. Store directories must be trusted local directories.
+
+Providers implement `capabilities()`, `estimate(input)`, and `run(input)`.
+The stub returns escaped HTML, dimensions, a content hash, zero cost, and an explicit warning.
+It returns `image: null`. It has no browser, remote asset loading, image generation, or raster conversion.
+Brand colors accept six-digit hex values. The brand name is plain text.
+Use the template descriptor to find required slots before calling the provider.
+Call `lint` on every final slot value before external use. The renderer does not grant policy approval.
+
+`guardCost` accepts `costMinor`, `adSpentMinor`, `monthSpentMinor`, `perAdMinor`, `perMonthMinor`, and `apply`.
+All amounts must be nonnegative safe integers in the same currency.
+Positive cost requires `apply: true`. Equal-to-cap amounts are allowed; excess amounts are blocked.
+The caller supplies totals for the current calendar month, including reserved and uncertain charges.
+This pure guard does not persist reservations, handle concurrency, reset monthly totals, or authorize a paid provider.
+A future paid adapter must check and reserve costs atomically before calling a provider.
+
+## MCP
+
+Start `node bin/agentic-ads-mcp`, or use the installed `agentic-ads-mcp` executable.
+Configure the client to use this command with stdio transport.
+The server uses newline-delimited JSON-RPC and protocol version `2024-11-05`.
+It supports `initialize`, `ping`, `tools/list`, and `tools/call`.
+The original four tools use the same names and arguments as the CLI; `--dry-run` becomes `dryRun`.
+Stdout contains protocol messages only. Frames are limited to 65,536 characters.
+Tool results contain JSON text. Blocked copy sets `isError: true` and retains its findings.
+
+## Honest limits
+
+Lint detects selected English patterns. It cannot prove truth, consent, disclosure quality, or compliance.
+It always returns a human review finding. A `review` status does not mean platform approval.
+Housing is the conservative default. Targeting words, guarantees, superlatives, and below-market percentages are blocked.
+News framing, staging, and urgency also require review. Conservative checks can produce false positives.
+The package does not inspect actual audience settings or implement current platform policy in full.
+
+Keep private data out of inputs. Contact-pattern checks are incomplete; they cannot reliably detect names, addresses, or secrets.
+The CLI prints supplied copy in plans. No telemetry, account integration, or outbound network calls are included.
+No source assets or competitor copy are bundled. Research informs the formats and disclosure needs only.
+
+The E2E script spawns the CLI, MCP server, HTTP server, and a library integration process.
+It records assertions in `test/artifacts/e2e.json`, which Git ignores and npm excludes.
+Run `npm run ci:local` before any future push. Publishing and pushing are separate operator actions.
+
+## Video formats
+
+```sh
+node bin/agentic-ads formats
+node bin/agentic-ads formats --cost-class cheap --risk medium
+node bin/agentic-ads formats show sitcom
+node bin/agentic-ads plan --format sitcom --site demo
+```
+
+Twelve formats cover the eight catalog recipes, lo-fi UGC, sitcom, storytime, and talking objects.
+MCP adds `list_formats({costClass?, risk?})`, `get_format({id})`, and `plan_format({format, site, goal?, dryRun?})`.
+These tools return the same JSON as the commands above.
+The library exports `listFormats`, `getFormat`, and `planFormat` from the package root and `agentic-ads-engine/formats`.
+Filters combine with AND. Unknown formats fail. Format plans require a site slug and default to dry-run.
+Plans return ordered stages, stage estimates, total estimates, policy notes, QA gates, and zero actual spend.
+Apply remains unavailable. QA gates describe required checks; this planner does not run them.
+
+Source paths refer to the supplied `directory/ads-research` archive, reviewed on 2026-11-12.
+Provider `verified` records that source review date. It does not promise current prices or successful renders.
+`unverified: true` marks proposed routes or unresolved quality. Local routes can name tools instead of models.
+Costs exclude labour and compute. Stage notes state asset counts and reuse assumptions.
+The sitcom run cost $2.466; four mouth checks still failed. Its selected speech model preserves that limitation.
+Lo-fi costs reference reused assets: $0.881 for three videos6 ads and $0.165 for three videos5 voice edits.
+Fresh generation estimates differ. The style catalog did not render its recommended local recipes.
+No paid calls, current price checks, media QA, or platform approval occur here.
+
+Run `node test/mutate-formats.mjs` to repeat the three deliberate faults and restore the files.
+It records failures and the restored pass in `test/artifacts/formats-mutations.json`.
+
+### Owner feedback checks
+
+`agentic-ads qa-rules` lists R1 through R26. Use `agentic-ads qa-rules show R5`
+to read one rule. MCP provides `list_qa_rules` and `get_qa_rule` with an `id` argument.
+
+Each format declares `kinds` and `feedbackRules`. A format plan includes
+`reviewChecklist` entries and the six instructions in `costRatchet`.
+Every entry starts as `NOT CHECKED`. This status blocks shipping.
+A reviewer must record PASS or FAIL with a measured value. Voice and sound fit need the owner's ear.
+
+The JavaScript API exports `listRules()`, `getRule(id)`, and `checklistFor(format)`.
+Pass a format descriptor from `getFormat(id)` to `checklistFor`.
+Rules use `blocking` severity. `applies` names format kinds; `all` covers every format.
+Story formats include stickman, POV, before-after, lo-fi, sitcom, and storytime.
+Sitcom has dialogue. Talking-object has visible speech. All current formats have captions.
+
+Run `node test/mutate-qa.mjs` to verify three deliberate faults and restore the files.
+Results go to `test/artifacts/qa-mutations.json` and `test/artifacts/e2e.json`.
+
+## Hook catalog
+
+```sh
+node bin/agentic-ads hooks
+node bin/agentic-ads hooks show shocked-face
+node bin/agentic-ads hooks pick --format pov --emotion curiosity --housing
+```
+
+The catalog contains 42 hooks. Each includes format IDs, emotion, kind, risk, a housing flag, and a short rationale.
+The patterns paraphrase the supplied playbook and style catalog. They include the six requested owner feedback openings.
+No research records, personal data, or account IDs are included.
+
+MCP exposes `list_hooks({format?, emotion?, housing?})`, `get_hook({id})`, and `pick_hooks({format, emotion?, housing?})`.
+CLI and MCP picks return all matching hooks in catalog order, with cold-start scores.
+The original `list-hooks` command and MCP tool still return the whole catalog.
+Format, emotion, and housing filters combine with AND. Invalid filters fail; no matches return an empty list.
+
+The library exports `listHooks`, `getHook`, and `pickHooks(filter, scores = {})`.
+Picks rank matching hooks by descending score. Catalog order resolves ties.
+`selectFor(site, goal, filter = {})` retains its low-risk rule and returns one hook or `null`.
+The original two-argument call still works. Filters apply before score ranking.
+`housing: true` keeps only hooks with `housingSafe: true`. It does not filter by risk level, so medium-risk hooks can still appear.
+
+`housingSafe` means the pattern passes housing lint with generic slot values and contains no eligibility claim, invented number, or testimonial.
+It does not approve arbitrary slot values or rendered media. Fill every slot and lint the final copy before use.
+Every result still requires human review. Personal savings, occupancy, interviews, and broken-trust claims remain outside the housing-safe set.
+
+Run `node test/mutate-hooks.mjs` to verify three single-line faults and restore the catalog.
+Evidence goes to `test/artifacts/hooks-mutations.json`. E2E results go to `test/artifacts/e2e.json`.
+`test/hook-expectations.json` pins every ID and housing flag; review changes to this file explicitly.
+
+## HTTP API for admin sites
+
+Start `node bin/agentic-ads serve`. The defaults are `127.0.0.1:8787`.
+Use `--host H` and `--port N` to change them. Port `0` selects an available port.
+The startup JSON reports the bound port. SIGTERM closes the server and its connections.
+
+```sh
+node bin/agentic-ads serve --port 8787
+curl http://127.0.0.1:8787/health
+curl http://127.0.0.1:8787/v1/formats/sitcom
+curl http://127.0.0.1:8787/v1/qa-rules/R5
+curl -H 'Content-Type: application/json' -d '{"copy":"Browse listings","category":"housing"}' http://127.0.0.1:8787/v1/lint
+curl -H 'Content-Type: application/json' -d '{"format":"sitcom","site":"demo"}' http://127.0.0.1:8787/v1/plan
+```
+
+GET routes: `/health`, `/v1/formats`, `/v1/formats/:id`, `/v1/hooks`, `/v1/templates`,
+`/v1/qa-rules`, and `/v1/qa-rules/:id`. Health returns `{"status":"ok"}`.
+POST routes: `/v1/lint` and `/v1/plan`. Their results match the CLI and MCP tools.
+Blocked lint findings return HTTP 200 with `status: "blocked"`.
+Plans only produce dry-run results. Any `apply` field is refused, including nested fields and query parameters.
+JSON bodies have a 64 KiB limit. Requests have a ten-second timeout.
+Errors return JSON without stacks: 400 invalid input, 401 unauthorized, 403 forbidden host, 404 missing route or item,
+405 wrong method, 408 timeout, 413 oversized body, and 415 unsupported media type.
+
+Set `AGENTIC_ADS_TOKEN` to require `Authorization: Bearer <token>` on every route, including health.
+The token needs 32 or more characters and must not start or end with spaces. Without a token, the server accepts only loopback `Host` values with its own port. This blocks DNS rebinding from a web page.
+A non-loopback host requires this setting. The server never logs bodies or tokens.
+Responses containing the configured token are refused. Use TLS through your admin site's server for remote access.
+
+An admin site's backend can call these routes and keep the token in server-side settings.
+Proxy calls through that backend for browser clients. CORS headers are absent by default.
+`AGENTIC_ADS_CORS_ORIGIN=https://admin.example` allows that exact origin in response headers.
+Unauthenticated browser preflight requests still return 401 when a token is set.
+Direct cross-origin browser calls with bearer headers therefore require the backend proxy.
+
+Run `node test/mutate-api.mjs` to prove authentication, the Host check, the token length rule, body limits, and apply checks detect deliberate faults.
+The script restores the source and writes `test/artifacts/api-mutations.json`.

package/bin/agentic-ads

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { execute, tools } from '../src/index.js';
+try {
+  let [action, ...argv] = process.argv.slice(2);
+  if (action === 'serve') {
+    await (await import('../src/http.js')).serve(argv);
+  } else {
+  const args = {};
+  if (action === 'hooks') {
+    action = argv[0] === 'show' ? 'get_hook' : argv[0] === 'pick' ? 'pick_hooks' : 'list_hooks';
+    if (action === 'get_hook') { argv.shift(); args.id = argv.shift(); }
+    if (action === 'pick_hooks' || argv[0] === 'list') argv.shift();
+  }
+  if (action === 'qa-rules') {
+    action = argv[0] === 'show' ? 'get_qa_rule' : 'list_qa_rules';
+    if (action === 'get_qa_rule') { argv.shift(); args.id = argv.shift(); }
+  }
+  if (action === 'formats') {
+    action = argv[0] === 'show' ? 'get_format' : 'list_formats';
+    if (action === 'get_format') { argv.shift(); args.id = argv.shift(); }
+  }
+  if (action === 'plan' && argv.some(arg => arg === '--format' || arg.startsWith('--format='))) action = 'plan_format';
+  const schema = tools.find(t => t.name === action)?.inputSchema;
+  if (!schema) throw new Error('Use hooks, qa-rules, formats, list-templates, list-hooks, lint, plan, or serve');
+  while (argv.length) {
+    const option = argv.shift(), separator = option.indexOf('=');
+    const flag = separator < 0 ? option : option.slice(0, separator);
+    const value = separator < 0 ? undefined : option.slice(separator + 1);
+    if (!flag.startsWith('--')) throw new Error('Expected an option');
+    const key = flag === '--dry-run' ? 'dryRun' : flag === '--cost-class' ? 'costClass' : flag.slice(2);
+    if (flag === '--apply' && ['plan', 'plan_format'].includes(action)) throw new Error('Apply is unavailable in this offline slice');
+    if (['--costClass', '--dryRun'].includes(flag) || !Object.hasOwn(schema.properties, key) || Object.hasOwn(args, key)) throw new Error('Unknown or repeated option');
+    if (schema.properties[key].type === 'boolean') {
+      if (value !== undefined && !['true', 'false'].includes(value)) throw new Error('Invalid argument');
+      args[key] = value !== 'false';
+    }
+    else if (value !== undefined) args[key] = value;
+    else {
+      if (!argv.length || argv[0].startsWith('--')) throw new Error(`Missing option value (use ${flag}=VALUE for a value that starts with --)`);
+      args[key] = argv.shift();
+    }
+  }
+  const result = execute(action, args);
+  console.log(JSON.stringify(result));
+  if (result.status === 'blocked' || result.policy?.status === 'blocked') process.exitCode = 2;
+  }
+} catch (error) {
+  console.log(JSON.stringify({ error: error.message })); process.exitCode = 1;
+}

package/bin/agentic-ads-mcp

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { execute, tools } from '../src/index.js';
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+// MCP stdio uses one JSON-RPC message per line. stdout is protocol-only.
+const send = message => process.stdout.write(JSON.stringify(message) + '\n');
+const fail = (id, code, message) => send({ jsonrpc: '2.0', id, error: { code, message } });
+let initialized = false;
+function receive(line) {
+  let request;
+  try { request = JSON.parse(line); } catch { fail(null, -32700, 'Parse error'); return; }
+  const validId = request && (typeof request.id === 'string' || (typeof request.id === 'number' && Number.isFinite(request.id)));
+  if (!request || Array.isArray(request) || request.jsonrpc !== '2.0' || typeof request.method !== 'string' ||
+      (Object.hasOwn(request, 'id') && !validId)) { fail(null, -32600, 'Invalid request'); return; }
+  if (!Object.hasOwn(request, 'id')) return;
+  const { id, method, params = {} } = request;
+  if (!params || typeof params !== 'object' || Array.isArray(params)) { fail(id, -32602, 'Invalid params'); return; }
+  let result;
+  if (method === 'initialize') {
+    if (typeof params.protocolVersion !== 'string') { fail(id, -32602, 'Missing protocol version'); return; }
+    initialized = true;
+    result = { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'agentic-ads-engine', version } };
+  } else if (method === 'ping') result = {};
+  else if (!initialized) { fail(id, -32002, 'Initialize first'); return; }
+  else if (method === 'tools/list') result = { tools };
+  else if (method === 'tools/call') {
+    if (typeof params.name !== 'string' || !tools.some(t => t.name === params.name)) { fail(id, -32602, 'Unknown tool'); return; }
+    try {
+      const value = execute(params.name, params.arguments === undefined ? {} : params.arguments);
+      result = { content: [{ type: 'text', text: JSON.stringify(value) }], isError: value.status === 'blocked' || value.policy?.status === 'blocked' };
+    } catch (error) { result = { content: [{ type: 'text', text: error.message }], isError: true }; }
+  } else { fail(id, -32601, 'Method not found'); return; }
+  send({ jsonrpc: '2.0', id, result });
+}
+let buffer = '', dropping = false;
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  // Bound each frame to prevent unbounded buffering from a malformed client.
+  for (const part of chunk.split(/(?<=\n)/)) {
+    if (!dropping) buffer += part;
+    if (buffer.length > 65536) { buffer = ''; dropping = true; fail(null, -32600, 'Frame too large'); }
+    if (part.endsWith('\n')) {
+      if (!dropping && buffer.trim()) receive(buffer);
+      buffer = ''; dropping = false;
+    }
+  }
+});
+process.stdin.on('end', () => { if (buffer.trim() && !dropping) receive(buffer); });

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "agentic-ads-engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Offline ad templates, hook selection, policy lint, and planning tools",
+  "type": "module",
+  "engines": { "node": ">=20" },
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/itsryanarmani/agentic-ads-engine.git" },
+  "homepage": "https://github.com/itsryanarmani/agentic-ads-engine#readme",
+  "bugs": { "url": "https://github.com/itsryanarmani/agentic-ads-engine/issues" },
+  "exports": { ".": "./src/index.js", "./formats": "./src/formats/index.js", "./templates": "./src/templates/index.js", "./hooks": "./src/hooks/index.js", "./policy": "./src/policy/index.js", "./providers": "./src/providers/index.js" },
+  "bin": { "agentic-ads": "./bin/agentic-ads", "agentic-ads-mcp": "./bin/agentic-ads-mcp" },
+  "files": ["src/", "bin/", "README.md", "LICENSE"],
+  "scripts": { "test": "node test/e2e.mjs", "ci:local": "node test/e2e.mjs" },
+  "publishConfig": { "access": "public" }
+}

package/src/formats/index.js

@@ -0,0 +1,36 @@
+import { checklistFor, costRatchet } from '../qa/index.js';
+import { readFileSync } from 'node:fs';
+const library = JSON.parse(readFileSync(new URL('./library.json', import.meta.url), 'utf8'));
+const costs = ['free', 'cheap', 'mid', 'expensive'], risks = ['low', 'medium', 'high'];
+function argumentsFor(value, keys) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(k => !keys.includes(k))) throw new Error('Invalid format arguments');
+}
+/** Return isolated descriptors. Filters combine with AND. No providers run. */
+export function listFormats(filter = {}) {
+  argumentsFor(filter, ['costClass', 'risk']);
+  if (filter.costClass !== undefined && !costs.includes(filter.costClass)) throw new Error('Invalid cost class');
+  if (filter.risk !== undefined && !risks.includes(filter.risk)) throw new Error('Invalid risk');
+  return structuredClone(library.filter(f => (!filter.costClass || f.costClass === filter.costClass) && (!filter.risk || f.policyRisk === filter.risk)));
+}
+export function getFormat(id) {
+  const found = library.find(f => f.id === id);
+  if (!found) throw new Error('Unknown format: ' + String(id));
+  return structuredClone(found);
+}
+/** Costs describe a possible production run, never money spent by this planner. */
+export function planFormat(input = {}) {
+  argumentsFor(input, ['format', 'site', 'goal', 'dryRun', 'apply']);
+  if (input.apply !== undefined && input.apply !== false) throw new Error('Apply is unavailable');
+  if (input.dryRun !== undefined && input.dryRun !== true) throw new Error('Use dry-run; apply is unavailable');
+  const f = getFormat(input.format);
+  if (typeof input.site !== 'string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input.site) || input.site.length > 80) throw new Error('Site must be a lowercase slug');
+  const goal = input.goal ?? 'discovery';
+  if (typeof goal !== 'string' || !goal.trim() || goal.length > 200) throw new Error('Invalid goal');
+  const stages = f.stages.map(id => ({ id, provider: f.providers[id], estimatedCostUsd: f.providers[id].estimatedCostUsd }));
+  const sum = key => Math.round(stages.reduce((n, s) => n + s.estimatedCostUsd[key], 0) * 1000) / 1000;
+  return { format: f.id, site: input.site, goal, dryRun: true, applied: false, spendUsd: 0, stages,
+    reviewChecklist: checklistFor(f), costRatchet,
+    qaGates: f.qaGates, policyRisk: f.policyRisk, riskNotes: f.riskNotes,
+    total: { low: sum('low'), high: sum('high'), note: f.estimatedCostUsd.note },
+    warnings: ['Plan only; no providers or QA checks run.', 'NOT CHECKED blocks shipping. Record PASS or FAIL with a measured value. Voice fit and sound fit need the owner’s ear.', 'Historical source review dates are not current price verification.'] };
+}