costlayers 0.8.1 → 0.8.9

package/README.md

@@ -4,37 +4,65 @@ CostLayers helps teams reduce wasted AI coding-agent spend by creating a compact
 
 ## Install
 
-Preview from the live server:
+One-command setup:
 
 ```bash
-npx -y costlayers start --email you@example.com
+cd your-repo
+npx -y https://costlayers.com/costlayers-0.8.9.tgz start --email you@example.com
 ```
 
-After npm publish, the intended short command is:
+## Usage
+
+Inside a repo:
 
 ```bash
-npx costlayers start --email you@example.com
+costlayers init
+costlayers scan
 ```
 
-## Usage
+Launch Codex with CostLayers context:
 
-Inside a repo:
+```bash
+cd your-repo
+npx -y https://costlayers.com/costlayers-0.8.9.tgz start --email you@example.com -- codex
+```
+
+This gives Codex `.agentspend/repo-pack.md` and `.agentspend/runtime-plan.md`
+so it can avoid repeated broad repo exploration. It also writes
+`~/.codex/costlayers.config.toml` and runs Codex as
+`codex --profile costlayers`, enabling gateway metering and redacted Codex token
+telemetry for ChatGPT-login sessions.
+
+To install only the Codex profile after signup:
 
 ```bash
-agentspend init
-agentspend scan
+npx -y https://costlayers.com/costlayers-0.8.9.tgz codex-profile
+codex --profile costlayers
 ```
 
 With the closed engine enabled:
 
 ```bash
-agentspend signup --email you@example.com
-agentspend gateway start --provider-url https://api.openai.com --mode reduce
-agentspend run -- codex
-agentspend gateway report
-agentspend dashboard
+costlayers signup --email you@example.com
+costlayers gateway start --provider-url https://api.openai.com --mode reduce
+costlayers run -- codex
+costlayers gateway report
+costlayers dashboard
 ```
 
+Metered dashboard savings only increase when model API traffic is routed through
+the CostLayers gateway URL. Codex-metered dashboard savings increase when Codex
+uses the CostLayers profile or emits token telemetry to the CostLayers meter.
+For ChatGPT-login Codex, dollar savings are modeled from observed Codex token
+events because the ChatGPT plan invoice is not an OpenAI Platform API invoice.
+
+The hosted reducer defaults to quality-safe reduction:
+
+- exact cache hits may skip repeated upstream calls
+- certified compaction preserves the current user request
+- prior context is compacted only when there is a safe structural boundary
+- opaque single-message prompts are forwarded unchanged
+
 Output:
 
 - `.agentspend/repo-pack.md`
@@ -54,9 +82,11 @@ The first public version reduces waste by making agents start from a compact rep
 The report estimates:
 
 - baseline broad-read tokens
-- AgentSpend context-pack tokens
+- CostLayers context-pack tokens
 - tokens avoided per repeated task
 - estimated cost avoided per 100 repeated tasks
+- projected weekly and monthly savings at the chosen runs/week assumption
+- before/after token reduction for the first scan
 
 No private internals are included in this package.
 

package/bin/agentspend.js

@@ -6,9 +6,12 @@ const path = require("path");
 const crypto = require("crypto");
 const http = require("http");
 const https = require("https");
+const os = require("os");
 const { spawnSync } = require("child_process");
 
-const VERSION = "0.8.1";
+const VERSION = "0.8.9";
+const DEFAULT_RUNS_PER_WEEK = 20;
+const WEEKS_PER_MONTH = 4.33;
 const DEFAULT_EXCLUDES = new Set([
   ".git",
   ".hg",
@@ -28,6 +31,8 @@ const DEFAULT_EXCLUDES = new Set([
   ".ruff_cache",
   ".turbo",
   ".cache",
+  ".npm-cache",
+  ".pnpm-store",
   ".agentspend"
 ]);
 
@@ -41,26 +46,28 @@ const SOURCE_EXTENSIONS = new Set([
 
 function usage(exitCode = 0) {
   const text = `
-AgentSpend ${VERSION}
+CostLayers ${VERSION}
 
 Usage:
-  agentspend init [--repo <path>]
-  agentspend scan [--repo <path>] [--price-per-1m <usd>] [--tasks <n>]
-  agentspend start [--email <email>] [--provider-url <url>] [--mode measure|reduce] [-- <agent command>]
-  agentspend signup [--email <email>] [--engine-url <url>]
-  agentspend connect --engine-url <url> [--api-key <key>]
-  agentspend gateway start [--provider-url <url>] [--api-key-env <name>] [--mode measure|reduce]
-  agentspend gateway report
-  agentspend gateway stop
-  agentspend dashboard
-  agentspend run [--repo <path>] -- <agent command>
-  agentspend doctor
+  costlayers init [--repo <path>]
+  costlayers scan [--repo <path>] [--price-per-1m <usd>] [--tasks <n>] [--runs-per-week <n>]
+  costlayers start [--email <email>] [--provider-url <url>] [--mode measure|reduce] [--runs-per-week <n>] [-- <agent command>]
+  costlayers signup [--email <email>] [--engine-url <url>]
+  costlayers codex-profile [--repo <path>]
+  costlayers connect --engine-url <url> [--api-key <key>]
+  costlayers gateway start [--provider-url <url>] [--api-key-env <name>] [--mode measure|reduce]
+  costlayers gateway report
+  costlayers gateway stop
+  costlayers dashboard
+  costlayers run [--repo <path>] -- <agent command>
+  costlayers doctor
 
 Commands:
   init    Create .agentspend config and agent instructions.
   scan    Build repo context pack and savings report.
   start   One-command setup, signup, gateway start, and optional agent run.
   signup  Create a self-serve key and save connection settings.
+  codex-profile Write ~/.codex/costlayers.config.toml for metered Codex runs.
   connect Save closed-engine connection settings.
   gateway Manage the closed cost gateway.
   dashboard Print dashboard URL and account status.
@@ -99,6 +106,31 @@ function writeIfMissing(file, content) {
   if (!fs.existsSync(file)) fs.writeFileSync(file, content, "utf8");
 }
 
+function isHomeDirectory(repo) {
+  try {
+    return path.resolve(repo) === path.resolve(os.homedir());
+  } catch {
+    return false;
+  }
+}
+
+function guardRepoRoot(repo, args) {
+  if (!isHomeDirectory(repo) || args["allow-home"]) return;
+  process.stderr.write([
+    "CostLayers is about to use your home directory as the repo.",
+    `Repo detected: ${repo}`,
+    "",
+    "Run it inside a project folder instead:",
+    "  cd path/to/your-repo",
+    "  npx -y https://costlayers.com/costlayers-0.8.9.tgz start --email you@example.com",
+    "",
+    "Or pass --repo path/to/your-repo from anywhere.",
+    "If you really intend to scan your whole home directory, add --allow-home.",
+    ""
+  ].join("\n"));
+  process.exit(2);
+}
+
 function sha256(text) {
   return crypto.createHash("sha256").update(text).digest("hex");
 }
@@ -205,7 +237,7 @@ function summarizeRepo(root) {
 
 function buildRepoPack(repo, summary) {
   const parts = [];
-  parts.push("# AgentSpend Repo Pack");
+  parts.push("# CostLayers Repo Pack");
   parts.push("");
   parts.push("Read this before broad repo exploration. Use it to avoid repeatedly rediscovering project structure.");
   parts.push("");
@@ -241,20 +273,20 @@ function buildRepoPack(repo, summary) {
   parts.push("- Start with this pack before reading many files.");
   parts.push("- Prefer targeted reads of files listed above.");
   parts.push("- If a file hash is unchanged, do not reread it unless the task requires exact code.");
-  parts.push("- Update this pack after major repo changes with `agentspend scan`.");
+  parts.push("- Update this pack after major repo changes with `costlayers scan`.");
   parts.push("");
   return parts.join("\n");
 }
 
 function buildInstructions() {
-  return `# AgentSpend Agent Instructions
+  return `# CostLayers Agent Instructions
 
 Before broad repo exploration:
 
 1. Read .agentspend/repo-pack.md.
 2. Use the listed entry points, route hints, and symbol hints to target file reads.
 3. Avoid rereading unchanged large files unless exact code is required.
-4. After major repo changes, ask the user to run \`agentspend scan\`.
+4. After major repo changes, ask the user to run \`costlayers scan\`.
 
 Goal: reduce repeated context spend while preserving answer quality.
 `;
@@ -263,7 +295,7 @@ Goal: reduce repeated context spend while preserving answer quality.
 function buildAgentsMd() {
   return `# Repository Agent Instructions
 
-This repo uses AgentSpend to reduce repeated AI coding-agent context spend.
+This repo uses CostLayers to reduce repeated AI coding-agent context spend.
 
 Before broad exploration:
 
@@ -271,17 +303,24 @@ Before broad exploration:
 2. Read .agentspend/agent-instructions.md.
 3. Prefer targeted file reads based on the repo pack.
 4. Avoid rereading unchanged large files unless exact code is required.
-5. After major repo changes, run or ask for \`agentspend scan\`.
+5. After major repo changes, run or ask for \`costlayers scan\`.
 
 `;
 }
 
-function buildReport(summary, repoPack, tasks, pricePer1m) {
+function buildReport(summary, repoPack, tasks, pricePer1m, runsPerWeek) {
   const packTokens = estimateTokens(repoPack);
-  const broadReadTokens = summary.topFiles.slice(0, 20).reduce((acc, row) => acc + row.tokens, 0);
+  const broadReadTokens = Math.max(
+    summary.totalTokens,
+    summary.topFiles.slice(0, 20).reduce((acc, row) => acc + row.tokens, 0),
+    packTokens
+  );
   const avoidedPerTask = Math.max(0, broadReadTokens - packTokens);
   const avoidedTotal = avoidedPerTask * tasks;
   const savedUsd = avoidedTotal / 1_000_000 * pricePer1m;
+  const savedPerRunUsd = avoidedPerTask / 1_000_000 * pricePer1m;
+  const projectedWeeklyUsd = savedPerRunUsd * runsPerWeek;
+  const projectedMonthlyUsd = projectedWeeklyUsd * WEEKS_PER_MONTH;
   const reductionPct = broadReadTokens > 0 ? avoidedPerTask / broadReadTokens * 100 : 0;
   return {
     created_utc: new Date().toISOString(),
@@ -294,6 +333,9 @@ function buildReport(summary, repoPack, tasks, pricePer1m) {
     tokens_avoided_total: avoidedTotal,
     price_per_1m_input_tokens_usd: pricePer1m,
     estimated_usd_saved: Number(savedUsd.toFixed(4)),
+    projected_runs_per_week: runsPerWeek,
+    projected_weekly_savings_usd: Number(projectedWeeklyUsd.toFixed(4)),
+    projected_monthly_savings_usd: Number(projectedMonthlyUsd.toFixed(4)),
     estimated_reduction_percent: Number(reductionPct.toFixed(2)),
     largest_files: summary.topFiles.slice(0, 10).map((row) => ({
       path: row.rel,
@@ -307,10 +349,11 @@ function scanToFiles(repo, args) {
   const outDir = path.join(repo, ".agentspend");
   ensureDir(outDir);
   const tasks = Number(args.tasks || 100);
+  const runsPerWeek = Number(args["runs-per-week"] || DEFAULT_RUNS_PER_WEEK);
   const pricePer1m = Number(args["price-per-1m"] || 2.0);
   const summary = summarizeRepo(repo);
   const pack = buildRepoPack(repo, summary);
-  const report = buildReport(summary, pack, tasks, pricePer1m);
+  const report = buildReport(summary, pack, tasks, pricePer1m, runsPerWeek);
   fs.writeFileSync(path.join(outDir, "repo-pack.md"), pack, "utf8");
   fs.writeFileSync(path.join(outDir, "agent-instructions.md"), buildInstructions(), "utf8");
   fs.writeFileSync(path.join(outDir, "savings-report.json"), JSON.stringify(report, null, 2) + "\n", "utf8");
@@ -319,7 +362,7 @@ function scanToFiles(repo, args) {
 }
 
 function reportMarkdown(report) {
-  return `# AgentSpend Savings Report
+  return `# CostLayers Savings Report
 
 Generated: ${report.created_utc}
 
@@ -334,12 +377,15 @@ Generated: ${report.created_utc}
 - Estimated tokens avoided total: ${report.tokens_avoided_total.toLocaleString()}
 - Estimated reduction: ${report.estimated_reduction_percent}%
 - Estimated saved: $${report.estimated_usd_saved}
+- Projected runs/week: ${report.projected_runs_per_week}
+- Projected weekly savings: $${report.projected_weekly_savings_usd}
+- Projected monthly savings: $${report.projected_monthly_savings_usd}
 
 ## How Users Get Value
 
 1. Commit or keep \`.agentspend/repo-pack.md\` locally.
 2. Tell the coding agent to read it before broad repo exploration.
-3. Re-run \`agentspend scan\` after major repo changes.
+3. Re-run \`costlayers scan\` after major repo changes.
 4. Compare provider usage before and after adopting this workflow.
 
 ## Largest Repeated Context Sources
@@ -369,18 +415,18 @@ function init(repo) {
   } else {
     process.stdout.write(`AGENTS.md already exists; snippet saved to ${path.join(outDir, "AGENTS_SNIPPET.md")}\n`);
   }
-  process.stdout.write(`AgentSpend initialized in ${outDir}\n`);
-  process.stdout.write("Next: agentspend scan\n");
+  process.stdout.write(`CostLayers initialized in ${outDir}\n`);
+  process.stdout.write("Next: costlayers scan\n");
 }
 
 function scan(repo, args) {
+  process.stdout.write(`Scanning repo: ${repo}\n`);
   const precomputed = scanToFiles(repo, args);
   const { outDir, report } = precomputed;
-  process.stdout.write(`AgentSpend scan complete\n`);
+  process.stdout.write(`CostLayers scan complete\n`);
   process.stdout.write(`Repo pack: ${path.join(outDir, "repo-pack.md")}\n`);
   process.stdout.write(`Report: ${path.join(outDir, "savings-report.md")}\n`);
-  process.stdout.write(`Estimated tokens avoided per repeated task: ${report.tokens_avoided_per_repeated_task.toLocaleString()}\n`);
-  process.stdout.write(`Estimated saved per ${report.repeated_tasks_modeled} repeated tasks: $${report.estimated_usd_saved}\n`);
+  printSavingsSummary(report);
 }
 
 function connectEngine(repo, args) {
@@ -397,7 +443,7 @@ function connectEngine(repo, args) {
     connected_utc: new Date().toISOString()
   };
   fs.writeFileSync(path.join(outDir, "connection.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
-  process.stdout.write(`Connected AgentSpend engine: ${config.engine_url}\n`);
+  process.stdout.write(`Connected CostLayers engine: ${config.engine_url}\n`);
 }
 
 function loadConnection(repo, args) {
@@ -427,13 +473,122 @@ function defaultPublicGatewayUrl(engineUrl, apiKey) {
   }
 }
 
+function formatUsd(value) {
+  const amount = Number(value || 0);
+  if (amount < 1) return `$${amount.toFixed(4)}`;
+  return `$${amount.toFixed(2)}`;
+}
+
+function formatInt(value) {
+  return Number(value || 0).toLocaleString();
+}
+
+function savingsProjection(report) {
+  const tasks = Math.max(1, Number(report.repeated_tasks_modeled || 0));
+  const runsPerWeek = Math.max(1, Number(report.projected_runs_per_week || DEFAULT_RUNS_PER_WEEK));
+  const savedPerRunUsd = Number(report.estimated_usd_saved || 0) / tasks;
+  const weeklyUsd = savedPerRunUsd * runsPerWeek;
+  const monthlyUsd = weeklyUsd * WEEKS_PER_MONTH;
+  return {
+    tasks,
+    runsPerWeek,
+    savedPerRunUsd,
+    weeklyUsd,
+    monthlyUsd
+  };
+}
+
+function dashboardUrlFromConnection(connection) {
+  return (connection.gateway_url || defaultPublicGatewayUrl(connection.engine_url, connection.api_key)).replace("/gateway/", "/engine/dashboard/");
+}
+
+function printSavingsSummary(report) {
+  const projection = savingsProjection(report);
+  const avoided = Number(report.tokens_avoided_per_repeated_task || 0);
+  process.stdout.write(`\n${avoided > 0 ? "CostLayers found repeated context waste" : "CostLayers built your repo context pack"}\n`);
+  process.stdout.write(`  Tokens avoided per repeated task: ${formatInt(report.tokens_avoided_per_repeated_task)}\n`);
+  if (avoided > 0) {
+    process.stdout.write(`  Before vs after context: ${formatInt(report.baseline_broad_read_tokens)} -> ${formatInt(report.context_pack_tokens)} tokens (${report.estimated_reduction_percent}% less)\n`);
+  } else {
+    process.stdout.write(`  No repeated-context reduction found yet for this small/simple repo.\n`);
+    process.stdout.write(`  Context pack size: ${formatInt(report.context_pack_tokens)} tokens from ${formatInt(report.source_tokens_indexed)} indexed source tokens\n`);
+  }
+  process.stdout.write(`  Modeled savings per ${formatInt(report.repeated_tasks_modeled)} repeated tasks: ${formatUsd(report.estimated_usd_saved)}\n`);
+  process.stdout.write(`  Projected at ${formatInt(projection.runsPerWeek)} agent runs/week: ${formatUsd(projection.weeklyUsd)}/week, ${formatUsd(projection.monthlyUsd)}/month\n`);
+  process.stdout.write(`  Source tokens indexed: ${formatInt(report.source_tokens_indexed)}\n`);
+  process.stdout.write(`  Compact repo pack: ${formatInt(report.context_pack_tokens)} tokens\n`);
+}
+
+function codexHomeDir() {
+  return process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+}
+
+function profileTomlString(connection) {
+  const gateway = String(connection.gateway_url || defaultPublicGatewayUrl(connection.engine_url, connection.api_key)).replace(/\/+$/, "");
+  const baseUrl = `${gateway}/v1`;
+  const engineUrl = String(connection.engine_url || "https://costlayers.com/engine").replace(/\/+$/, "");
+  return [
+    "# Generated by CostLayers. This profile routes Codex through the CostLayers meter.",
+    "# Keep this file private because it contains your keyed CostLayers endpoint.",
+    "",
+    'model_provider = "costlayers"',
+    "",
+    "[model_providers.costlayers]",
+    'name = "CostLayers"',
+    `base_url = ${JSON.stringify(baseUrl)}`,
+    'wire_api = "responses"',
+    "requires_openai_auth = true",
+    "",
+    "[otel]",
+    'environment = "costlayers"',
+    'exporter = "otlp-http"',
+    "log_user_prompt = false",
+    "",
+    '[otel.exporter."otlp-http"]',
+    `endpoint = ${JSON.stringify(`${engineUrl}/v1/codex-meter`)}`,
+    'protocol = "json"',
+    "",
+    '[otel.exporter."otlp-http".headers]',
+    `"x-costlayers-key" = ${JSON.stringify(connection.api_key || "")}`,
+    ""
+  ].join("\n");
+}
+
+function writeCodexProfile(connection) {
+  const dir = codexHomeDir();
+  ensureDir(dir);
+  const file = path.join(dir, "costlayers.config.toml");
+  fs.writeFileSync(file, profileTomlString(connection), "utf8");
+  return file;
+}
+
+function commandName(command) {
+  const first = String(command[0] || "");
+  return path.basename(first).toLowerCase().replace(/\.(cmd|exe|bat|ps1)$/i, "");
+}
+
+function isCodexCommand(command) {
+  return commandName(command) === "codex";
+}
+
+function commandHasProfile(command) {
+  return command.some((item) => item === "--profile" || String(item).startsWith("--profile="));
+}
+
+function withCostLayersCodexProfile(command) {
+  if (!isCodexCommand(command) || commandHasProfile(command)) return command;
+  return [command[0], "--profile", "costlayers", ...command.slice(1)];
+}
+
 async function signupConnection(repo, args) {
   const engineUrl = String(args["engine-url"] || "https://costlayers.com/engine").replace(/\/+$/, "");
+  const savingsReport = readJsonIfExists(path.join(repo, ".agentspend", "savings-report.json"));
   const payload = {
     email: args.email || "",
     label: args.label || path.basename(repo),
     public_host: engineUrl.replace(/\/engine$/, "")
   };
+  if (savingsReport) payload.savings_report = savingsReport;
   const result = await postJson(`${engineUrl}/v1/register`, payload, null);
   if (!result.ok || !result.api_key) {
     process.stderr.write(`Signup failed: ${JSON.stringify(result, null, 2)}\n`);
@@ -460,11 +615,24 @@ async function ensureConnection(repo, args) {
 
 async function signup(repo, args) {
   const connection = await signupConnection(repo, args);
-  process.stdout.write(`AgentSpend self-serve key created\n`);
+  process.stdout.write(`CostLayers self-serve key created\n`);
   process.stdout.write(`Engine: ${connection.engine_url}\n`);
   process.stdout.write(`Gateway: ${connection.gateway_url}\n`);
+  process.stdout.write(`Dashboard: ${dashboardUrlFromConnection(connection)}\n`);
+  process.stdout.write(`Keep this dashboard URL private; it contains your keyed CostLayers path.\n`);
   process.stdout.write(`Plan: free beta\n`);
-  process.stdout.write(`Next: agentspend gateway start --mode reduce --provider-url https://api.openai.com\n`);
+  process.stdout.write(`Next: costlayers gateway start --mode reduce --provider-url https://api.openai.com\n`);
+}
+
+async function codexProfile(repo, args) {
+  const connection = await ensureConnection(repo, args);
+  const profilePath = writeCodexProfile(connection);
+  process.stdout.write(`CostLayers Codex profile installed\n`);
+  process.stdout.write(`Profile: ${profilePath}\n`);
+  process.stdout.write(`Dashboard: ${dashboardUrlFromConnection(connection)}\n`);
+  process.stdout.write(`Keep this dashboard URL private; it contains your keyed CostLayers path.\n`);
+  process.stdout.write(`Run: codex --profile costlayers\n`);
+  process.stdout.write(`Meter endpoint: ${connection.engine_url.replace(/\/+$/, "")}/v1/codex-meter\n`);
 }
 
 function postJson(urlString, payload, apiKey) {
@@ -526,11 +694,25 @@ function buildLocalPlan(report) {
   };
 }
 
+async function fetchEnginePlan(connection, repo, pack, report) {
+  if (!connection || !connection.engine_url) return null;
+  const payload = {
+    version: VERSION,
+    repo_name: path.basename(repo),
+    repo_pack_sha256: sha256(pack),
+    repo_pack_preview: pack.slice(0, 12000),
+    savings_report: report
+  };
+  const plan = await postJson(`${connection.engine_url}/v1/plan`, payload, connection.api_key);
+  plan.mode = plan.mode || "closed-engine";
+  return plan;
+}
+
 function writeRuntimePrompt(outDir, plan) {
   const lines = [];
-  lines.push("# AgentSpend Runtime Plan");
+  lines.push("# CostLayers Runtime Plan");
   lines.push("");
-  lines.push(plan.plan_summary || "Use AgentSpend repo context before broad exploration.");
+  lines.push(plan.plan_summary || "Use CostLayers repo context before broad exploration.");
   lines.push("");
   lines.push("## Instructions");
   for (const item of plan.runtime_instructions || []) lines.push(`- ${item}`);
@@ -555,29 +737,30 @@ async function runAgent(repo, args, argv, options = {}) {
   const connection = readJsonIfExists(path.join(outDir, "connection.json"));
   let plan = buildLocalPlan(report);
   if (connection && connection.engine_url) {
-    const payload = {
-      version: VERSION,
-      repo_name: path.basename(repo),
-      repo_pack_sha256: sha256(pack),
-      repo_pack_preview: pack.slice(0, 12000),
-      savings_report: report
-    };
     try {
-      plan = await postJson(`${connection.engine_url}/v1/plan`, payload, connection.api_key);
-      plan.mode = plan.mode || "closed-engine";
-      process.stdout.write(`Fetched AgentSpend engine plan\n`);
+      plan = await fetchEnginePlan(connection, repo, pack, report);
+      process.stdout.write(`Fetched CostLayers engine plan\n`);
     } catch (err) {
       process.stderr.write(`Engine unavailable; falling back to local plan: ${err.message}\n`);
     }
   }
   writeRuntimePrompt(outDir, plan);
   process.stdout.write(`Runtime plan: ${path.join(outDir, "runtime-plan.md")}\n`);
+  let commandToRun = command;
+  if (connection && connection.engine_url && isCodexCommand(command)) {
+    const profilePath = writeCodexProfile(connection);
+    commandToRun = withCostLayersCodexProfile(command);
+    process.stdout.write(`CostLayers Codex profile: ${profilePath}\n`);
+    process.stdout.write(`Codex metering enabled: ${commandToRun.join(" ")}\n`);
+    process.stdout.write(`Savings dashboard: ${dashboardUrlFromConnection(connection)}\n`);
+    process.stdout.write(`Keep this dashboard URL private; it contains your keyed CostLayers path.\n`);
+  }
   const env = {
     ...process.env,
     AGENTSPEND_REPO_PACK: path.join(outDir, "repo-pack.md"),
     AGENTSPEND_RUNTIME_PLAN: path.join(outDir, "runtime-plan.md")
   };
-  const result = spawnSync(command[0], command.slice(1), {
+  const result = spawnSync(commandToRun[0], commandToRun.slice(1), {
     cwd: repo,
     env,
     stdio: "inherit",
@@ -604,26 +787,28 @@ async function gateway(repo, args) {
       process.stderr.write(`${JSON.stringify(result, null, 2)}\n`);
       process.exit(1);
     }
-    process.stdout.write(`AgentSpend gateway ready: ${result.base_url}\n`);
+    process.stdout.write(`CostLayers gateway ready: ${result.base_url}\n`);
     process.stdout.write(`Set your OpenAI-compatible base URL to: ${result.base_url}\n`);
-    process.stdout.write(`Report: agentspend gateway report\n`);
+    process.stdout.write(`Report: costlayers gateway report\n`);
     return;
   }
   if (action === "report") {
-    const result = await postJson(`${connection.engine_url}/v1/gateway/report`, { port: Number(args.port || 8788) }, connection.api_key);
-    if (!result.ok) {
-      process.stderr.write(`${JSON.stringify(result, null, 2)}\n`);
+    const status = await postJson(`${connection.engine_url}/v1/me`, {}, connection.api_key);
+    if (!status.ok) {
+      process.stderr.write(`${JSON.stringify(status, null, 2)}\n`);
       process.exit(1);
     }
-    const summary = result.summary || {};
-    process.stdout.write(`AgentSpend Gateway Report\n`);
+    const summary = status.gateway_summary || {};
+    process.stdout.write(`CostLayers Gateway Report\n`);
+    process.stdout.write(`scope: current user key\n`);
     process.stdout.write(`requests: ${summary.request_count || 0}\n`);
-    process.stdout.write(`provider_called: ${summary["up" + "stream_called"] || 0}\n`);
-    process.stdout.write(`provider_avoided: ${summary["up" + "stream_avoided"] || 0}\n`);
+    process.stdout.write(`provider_called: ${summary.provider_called || 0}\n`);
+    process.stdout.write(`provider_avoided: ${summary.provider_avoided || 0}\n`);
     process.stdout.write(`baseline_cost_usd: ${summary.baseline_cost_usd || 0}\n`);
     process.stdout.write(`actual_cost_usd: ${summary.actual_cost_usd || 0}\n`);
     process.stdout.write(`saved_cost_usd: ${summary.saved_cost_usd || 0}\n`);
-    process.stdout.write(`report_path: ${result.report_path || ""}\n`);
+    process.stdout.write(`gateway_authenticated_actions: ${status.gateway_request_count || 0}\n`);
+    process.stdout.write(`dashboard: ${dashboardUrlFromConnection(connection)}\n`);
     return;
   }
   if (action === "stop") {
@@ -631,7 +816,7 @@ async function gateway(repo, args) {
     process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
     return;
   }
-  process.stderr.write("Usage: agentspend gateway start|report|stop\n");
+  process.stderr.write("Usage: costlayers gateway start|report|stop\n");
   process.exit(2);
 }
 
@@ -639,11 +824,15 @@ async function dashboard(repo, args) {
   const connection = loadConnection(repo, args);
   const status = await postJson(`${connection.engine_url}/v1/me`, {}, connection.api_key);
   const dashboardUrl = (connection.gateway_url || defaultPublicGatewayUrl(connection.engine_url, connection.api_key)).replace("/gateway/", "/engine/dashboard/");
-  process.stdout.write(`AgentSpend Dashboard\n`);
+  process.stdout.write(`CostLayers Dashboard\n`);
   process.stdout.write(`URL: ${dashboardUrl}\n`);
   process.stdout.write(`status: ${status.status || "unknown"}\n`);
   process.stdout.write(`plan: ${status.free_beta ? "free beta" : "metered"}\n`);
   process.stdout.write(`metered_savings_usd: ${status.metered_savings_usd ?? ""}\n`);
+  process.stdout.write(`codex_metered_savings_usd: ${status.codex_metered_savings_usd ?? ""}\n`);
+  process.stdout.write(`codex_meter_total_tokens: ${status.codex_meter_total_tokens ?? 0}\n`);
+  process.stdout.write(`codex_context_savings_usd: ${status.context_savings_usd ?? ""}\n`);
+  process.stdout.write(`context_tokens_avoided_per_task: ${status.context_tokens_avoided_per_task ?? 0}\n`);
   process.stdout.write(`gateway_requests: ${status.gateway_request_count ?? 0}\n`);
   process.stdout.write(`blocked_requests: ${status.blocked_request_count ?? 0}\n`);
   process.stdout.write(`rate_limit_per_minute: ${status.rate_limit_per_minute ?? ""}\n`);
@@ -653,12 +842,20 @@ async function start(repo, args, argv) {
   const dash = argv.indexOf("--");
   const command = dash >= 0 ? argv.slice(dash + 1) : [];
   init(repo);
+  process.stdout.write(`Scanning repo: ${repo}\n`);
   const precomputed = scanToFiles(repo, args);
-  const { outDir, report } = precomputed;
-  process.stdout.write(`AgentSpend scan complete\n`);
+  const { outDir, pack, report } = precomputed;
+  process.stdout.write(`CostLayers scan complete\n`);
   process.stdout.write(`Report: ${path.join(outDir, "savings-report.md")}\n`);
+  printSavingsSummary(report);
   const connection = await ensureConnection(repo, args);
-  process.stdout.write(`AgentSpend connection ready\n`);
+  try {
+    await fetchEnginePlan(connection, repo, pack, report);
+    process.stdout.write(`Dashboard synced with first-run savings\n`);
+  } catch (err) {
+    process.stderr.write(`Dashboard sync delayed; local report is still available: ${err.message}\n`);
+  }
+  process.stdout.write(`CostLayers connection ready\n`);
   const providerUrl = typeof args["provider-url"] === "string" ? args["provider-url"] : "https://api.openai.com";
   const payload = {
     host: args.host || "127.0.0.1",
@@ -674,22 +871,26 @@ async function start(repo, args, argv) {
     process.stderr.write(`${JSON.stringify(result, null, 2)}\n`);
     process.exit(1);
   }
-  process.stdout.write(`AgentSpend gateway ready: ${result.base_url}\n`);
+  process.stdout.write(`CostLayers gateway ready: ${result.base_url}\n`);
   process.stdout.write(`OpenAI-compatible base URL: ${result.base_url}\n`);
+  process.stdout.write(`Dashboard: ${dashboardUrlFromConnection(connection)}\n`);
+  process.stdout.write(`Keep this dashboard URL private; it contains your keyed CostLayers path.\n`);
   process.stdout.write(`Plan: free beta\n`);
-  process.stdout.write(`Estimated saved per ${report.repeated_tasks_modeled} repeated tasks: $${report.estimated_usd_saved}\n`);
+  const profilePath = writeCodexProfile(connection);
+  process.stdout.write(`CostLayers Codex profile: ${profilePath}\n`);
   if (command.length > 0) {
     return runAgent(repo, args, argv, { skipSetup: true, precomputed });
   }
   process.stdout.write(`\nNext options:\n`);
   process.stdout.write(`  Use gateway URL in your model client: ${result.base_url}\n`);
-  process.stdout.write(`  Or run an agent: npx -y costlayers start -- codex\n`);
-  process.stdout.write(`  View savings: npx -y costlayers gateway report\n`);
-  process.stdout.write(`  Dashboard: npx -y costlayers dashboard\n`);
+  process.stdout.write(`  Run Codex metered: npx -y https://costlayers.com/costlayers-0.8.9.tgz start --email you@example.com -- codex\n`);
+  process.stdout.write(`  Or run Codex directly: codex --profile costlayers\n`);
+  process.stdout.write(`  View savings: npx -y https://costlayers.com/costlayers-0.8.9.tgz gateway report\n`);
+  process.stdout.write(`  Dashboard: npx -y https://costlayers.com/costlayers-0.8.9.tgz dashboard\n`);
 }
 
 function doctor() {
-  process.stdout.write(`AgentSpend ${VERSION}\n`);
+  process.stdout.write(`CostLayers ${VERSION}\n`);
   process.stdout.write(`Node ${process.version}\n`);
   process.stdout.write("Status: ok\n");
 }
@@ -700,11 +901,13 @@ function main() {
   const cmd = args._[0];
   if (!cmd || args.help || args.h) usage(0);
   const repo = path.resolve(String(args.repo || process.cwd()));
+  if (["init", "scan", "start", "run", "codex-profile"].includes(cmd)) guardRepoRoot(repo, args);
   if (cmd === "doctor") return doctor();
   if (cmd === "init") return init(repo);
   if (cmd === "scan") return scan(repo, args);
   if (cmd === "start") return start(repo, args, rawArgv);
   if (cmd === "signup") return signup(repo, args);
+  if (cmd === "codex-profile") return codexProfile(repo, args);
   if (cmd === "connect") return connectEngine(repo, args);
   if (cmd === "gateway") return gateway(repo, args);
   if (cmd === "dashboard") return dashboard(repo, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "costlayers",
-  "version": "0.8.1",
+  "version": "0.8.9",
   "description": "CostLayers cost control for AI coding agents. Build compact repo context packs, gateway reports, and savings dashboards.",
   "bin": {
     "agentspend": "bin/agentspend.js",