@hobocode/thought-layer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hobocode LLC
+
+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

@@ -0,0 +1,80 @@
+# The Thought Layer Kit
+
+Rigor for building. AI made building cheap. It did not make **knowing what to build** cheap, and it did not make a confident, defensible plan cheap. This kit puts that rigor inside the agent you already use, then carries it toward a live thing you own.
+
+The loop it is building toward:
+
+> **validate the idea, grill it into a buildable spec, build it, deploy it.** One agent. Your own key. Nothing phones home.
+
+This is open source and BYOK by design. The point is to help people build real things instead of confident slop, not to sell you a platform.
+
+## What is here
+
+**The rigor, as portable [Agent Skills](https://www.anthropic.com/news/skills)** (work in any agent that reads the format):
+
+- **thought-layer-framework.** The backbone. Walks a founder through the full staged framework in order: validate the idea (what it is, domain knowledge, validation, market selection, the pitch), make the business model real (time, costs, scale, pricing, the model, acquisition, relationships, support), then design (PRD draft, then grill) last. It evaluates each stage at its own altitude, so a one-line idea is never audited for implementation details.
+- **thought-layer-panel.** Pressure-test the answer to one stage with an adversarial panel (red team, domain expert, skeptical investor), at that stage's altitude. Confidence score, letter grade, at most three stage-appropriate fixes; later-stage concerns get parked, not penalized.
+- **thought-layer-prd.** Draft the complete PRD — with a first-cut domain glossary and testable requirements — from the validated idea and business model. The plan the grill then hardens.
+- **thought-layer-grill.** The last design step: grills the draft PRD against the domain one question at a time, sharpening the glossary and hardening the requirements inline until it is build-ready. Runs after the PRD, not instead of the framework.
+- **thought-layer-naming.** Name the thing, with rationale and domain-ready slugs.
+
+**A Pi package** that adds, on top of the skills:
+
+- **Deterministic tools** the agent can call so the math is exact and never re-derived: `tl_score` (confidence to status and grade), `tl_domains` (availability, BYOK), `tl_project` (the numeric business projection).
+- **Slash commands** (prompt templates): `/tl` runs the whole flow, and `/tl-panel`, `/tl-grill`, `/tl-prd`, `/tl-naming` run each stage.
+
+## Install
+
+### Pi
+
+```bash
+pi install npm:@hobocode/thought-layer
+# or, before it is published:
+pi install git:github.com/hobocode-ofc/thought-layer-kit
+```
+
+Installing the package lights up the skills, the `/tl` commands, and the `tl_score` / `tl_domains` / `tl_project` tools. You can also invoke a skill directly with `/skill:thought-layer-panel`.
+
+### Claude Code (or any agent that reads the Agent Skills format)
+
+Copy each skill folder into `~/.claude/skills/`:
+
+```bash
+cp -r skills/* ~/.claude/skills/
+```
+
+The skills work as-is; the Pi-specific tools and slash commands are Pi only. Other agents adopt the `SKILL.md` format with minor adaptation.
+
+## How to use it
+
+Run the whole framework with `/tl`. It walks the stages in order and does not skip ahead:
+
+1. **Validate the idea:** what it is, your domain knowledge, validation (will anyone pay), market selection, the 30-second pitch. The panel judges each at the idea's altitude. It will not pressure-test how the thing is built yet.
+2. **Make the model real:** time, costs, scale, pricing, the business model and its numbers (via `tl_project`), acquisition, relationships, support. This is where unit economics and operational logistics get scrutinized.
+3. **Design it (last):** `/tl-prd` drafts the PRD (with a first-cut glossary and requirements); `/tl-grill` then grills that draft against the domain until it is build-ready. Every "how will it actually work" concern parked during validation gets resolved here.
+
+Each stage clears at confidence 0.85 or when you set it aside (open items carry forward as to-dos). You can also run a single stage directly: `/tl-panel`, `/tl-grill`, `/tl-prd`, `/tl-naming`.
+
+To check domains live, set a RapidAPI key in your environment (`THOUGHT_LAYER_DOMAIN_KEY` or `RAPIDAPI_KEY`). With no key, naming links out to a domain search instead of calling out.
+
+The hosted version of the rigor lives at [weareallproductmanagersnow.com](https://weareallproductmanagersnow.com) if you would rather not install anything.
+
+## Roadmap
+
+- **Done:** the rigor as portable skills, and a Pi package with deterministic tools + slash commands.
+- **Phase 3:** a `build` step that turns the PRD into a deploy-ready artifact, built by your own agent.
+- **Phase 4:** a `deploy` step that publishes it to a live URL you own (Netlify deploy-and-claim by default), closing the loop.
+
+## Notes for contributors
+
+- The deterministic engine in `core/` is TypeScript, with `vitest` tests (`npm test`) and a strict `tsc --noEmit` typecheck. It is the single source of truth for scoring, domain checks, and the projection model.
+- This is a TypeScript-source package: relative imports carry `.ts` extensions so Pi's loader and Vite resolve them directly. It is meant to be consumed by TS-aware tooling, not a plain Node `require`.
+- **Iterating on skills in Pi:** `pi update` syncs files to disk but a running Pi session keeps the skill registry it built at startup — it does not hot-reload. After adding or editing a skill or prompt, **restart Pi** (or run `/reload` if your build supports it) to pick up the change. Symptom of a stale session: a newly added skill is missing from the picker, or a skill shows an outdated description.
+
+## Acknowledgments
+
+The Grill skill's interview technique — relentless, one question at a time, sharpening the domain glossary as it goes — is inspired by Matt Pocock's [`grill-with-docs`](https://github.com/mattpocock/skills/blob/main/skills/engineering/grill-with-docs/SKILL.md) (MIT, © Matt Pocock). His grills an architecture plan against existing domain docs; this kit adapts the technique to grill a draft PRD against the domain, hardening its glossary and requirements inline.
+
+## License
+
+MIT. Copyright Hobocode LLC.

package/core/domains.ts

@@ -0,0 +1,67 @@
+// Domain availability via the Domains API on RapidAPI. The key is the user's
+// own (BYOK); it is sent only to this host. With no key, checkDomains returns
+// null and the caller falls back to a registrar search link, so nothing leaves
+// the machine uninvited. Ported from the web app's src/lib/domains.js.
+
+export const DOMAIN_HOST = "domains-api.p.rapidapi.com";
+export const DOMAIN_TLDS = ["com", "io", "app", "co"] as const;
+
+export interface DomainResult {
+  domain: string;
+  status: string;
+  available: boolean;
+  error?: boolean;
+}
+
+export interface CheckOptions {
+  signal?: AbortSignal;
+  tlds?: readonly string[];
+}
+
+// A slug -> the candidate domains we test for it.
+export function domainsForSlug(slug: string, tlds: readonly string[] = DOMAIN_TLDS): string[] {
+  const base = String(slug || "").toLowerCase().replace(/[^a-z0-9-]/g, "");
+  if (!base) return [];
+  return tlds.map((t) => `${base}.${t}`);
+}
+
+// The API returns availability as "available" | "registered" (and a few others
+// like "reserved"). Only an outright "available" counts as registrable.
+export function isAvailable(availability: string | null | undefined): boolean {
+  return String(availability || "").toLowerCase() === "available";
+}
+
+// Returns null when there is no key (caller shows registrar links instead),
+// otherwise [{ domain, status, available, error? }]. The API takes a single
+// domain per request, so we fan out one request per candidate TLD in parallel.
+// Each lookup is resilient: one TLD failing (some return 500 for certain names)
+// marks just that chip as a failed check, it does not sink the whole batch.
+export async function checkDomains(
+  slug: string,
+  domainKey: string | null | undefined,
+  { signal, tlds }: CheckOptions = {},
+): Promise<DomainResult[] | null> {
+  if (!domainKey) return null;
+  const domains = domainsForSlug(slug, tlds);
+  if (domains.length === 0) return [];
+  return Promise.all(
+    domains.map(async (domain): Promise<DomainResult> => {
+      try {
+        const res = await fetch(`https://${DOMAIN_HOST}/domains/${encodeURIComponent(domain)}`, {
+          signal,
+          headers: { "x-rapidapi-key": domainKey, "x-rapidapi-host": DOMAIN_HOST },
+        });
+        if (!res.ok) return { domain, status: "error", available: false, error: true };
+        const data = (await res.json()) as { availability?: string };
+        return { domain, status: data.availability || "unknown", available: isAvailable(data.availability) };
+      } catch {
+        return { domain, status: "error", available: false, error: true };
+      }
+    }),
+  );
+}
+
+// Outbound search used when no domain key is set (privacy-clean: a click, not a call).
+export function registrarSearchUrl(slug: string): string {
+  return `https://instantdomainsearch.com/?q=${encodeURIComponent(String(slug || "").toLowerCase())}`;
+}

package/core/index.ts

@@ -0,0 +1,12 @@
+// The deterministic core of The Thought Layer: scoring, domain checks, and the
+// numeric projection model. No model calls, no side effects beyond the domain
+// fetch. This is the single source of truth the Pi tools and any other consumer
+// share, so the math is exact and never re-derived by an LLM.
+//
+// Relative imports carry explicit .ts extensions so Pi's jiti loader and Vite
+// resolve them without guesswork. This is a TypeScript-source package consumed
+// by TS-aware tooling (Pi/jiti, Vite), not by a plain Node require.
+
+export * from "./scoring.ts";
+export * from "./domains.ts";
+export * from "./model.ts";

package/core/model.ts

@@ -0,0 +1,196 @@
+// Deterministic monthly projection engine. The AI proposes assumptions; all
+// arithmetic happens here. Ported verbatim-in-behavior from the web app's
+// src/lib/model.js (with explicit types).
+
+export interface Party {
+  id: string;
+  name?: string;
+  role?: string;
+  startingCount?: number | string;
+  monthlyNewBase?: number | string;
+  monthlyNewGrowthPct?: number | string;
+  monthlyChurnPct?: number | string;
+  revenuePerUnitPerMonth?: number | string;
+  variableCostPerUnitPerMonth?: number | string;
+  cacPerUnit?: number | string;
+  notes?: string;
+}
+
+export interface FixedCost {
+  id: string;
+  name?: string;
+  monthlyAmount?: number | string;
+  startMonth?: number | string;
+  notes?: string;
+}
+
+export interface OneTimeCost {
+  id: string;
+  name?: string;
+  amount?: number | string;
+  month?: number | string;
+  notes?: string;
+}
+
+export interface Assumptions {
+  parties: Party[];
+  fixedCosts?: FixedCost[];
+  oneTimeCosts?: OneTimeCost[];
+  horizonMonths?: number;
+  currency?: string;
+  narrative?: string;
+}
+
+export interface PartyRow {
+  count: number;
+  newUnits: number;
+  churned: number;
+  revenue: number;
+  varCost: number;
+  cac: number;
+}
+
+export interface ProjectionRow {
+  month: number;
+  parties: Record<string, PartyRow>;
+  revenue: number;
+  variableCost: number;
+  cacSpend: number;
+  fixedCost: number;
+  oneTimeCost: number;
+  totalCost: number;
+  grossProfit: number;
+  netProfit: number;
+  cumulative: number;
+}
+
+export interface ProjectionSummary {
+  horizon: number;
+  breakEvenMonth: number | null;
+  cumBreakEvenMonth: number | null;
+  year1Revenue: number;
+  year1Net: number;
+  totalRevenue: number;
+  totalNet: number;
+  maxDrawdown: number;
+  endingMRR: number;
+  endingCounts: Record<string, number>;
+}
+
+export interface Projection {
+  rows: ProjectionRow[];
+  summary: ProjectionSummary;
+}
+
+function num(v: unknown, fallback = 0): number {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function sum(arr: number[]): number {
+  return arr.reduce((a, b) => a + b, 0);
+}
+
+export function computeProjection(assumptions: Assumptions | null | undefined): Projection | null {
+  if (!assumptions?.parties?.length) return null;
+  const horizon = Math.min(Math.max(assumptions.horizonMonths || 36, 6), 120);
+  const parties = assumptions.parties;
+  const fixedCosts = assumptions.fixedCosts || [];
+  const oneTimeCosts = assumptions.oneTimeCosts || [];
+
+  const counts: Record<string, number> = {};
+  parties.forEach((p) => {
+    counts[p.id] = num(p.startingCount);
+  });
+
+  const rows: ProjectionRow[] = [];
+  let cumulative = 0;
+  let breakEvenMonth: number | null = null;
+  let cumBreakEvenMonth: number | null = null;
+
+  for (let m = 1; m <= horizon; m++) {
+    const row: ProjectionRow = {
+      month: m, parties: {}, revenue: 0, variableCost: 0, cacSpend: 0, fixedCost: 0, oneTimeCost: 0,
+      totalCost: 0, grossProfit: 0, netProfit: 0, cumulative: 0,
+    };
+
+    for (const p of parties) {
+      const prev = counts[p.id] ?? 0;
+      const newUnits = num(p.monthlyNewBase) * Math.pow(1 + num(p.monthlyNewGrowthPct) / 100, m - 1);
+      const churned = prev * (num(p.monthlyChurnPct) / 100);
+      const count = Math.max(0, prev + newUnits - churned);
+      counts[p.id] = count;
+      const revenue = count * num(p.revenuePerUnitPerMonth);
+      const varCost = count * num(p.variableCostPerUnitPerMonth);
+      const cac = newUnits * num(p.cacPerUnit);
+      row.parties[p.id] = { count, newUnits, churned, revenue, varCost, cac };
+      row.revenue += revenue;
+      row.variableCost += varCost;
+      row.cacSpend += cac;
+    }
+
+    for (const f of fixedCosts) {
+      if (m >= num(f.startMonth, 1)) row.fixedCost += num(f.monthlyAmount);
+    }
+    for (const o of oneTimeCosts) {
+      if (num(o.month, 1) === m) row.oneTimeCost += num(o.amount);
+    }
+
+    row.totalCost = row.variableCost + row.cacSpend + row.fixedCost + row.oneTimeCost;
+    row.grossProfit = row.revenue - row.variableCost;
+    row.netProfit = row.revenue - row.totalCost;
+    cumulative += row.netProfit;
+    row.cumulative = cumulative;
+
+    if (breakEvenMonth === null && row.netProfit > 0) breakEvenMonth = m;
+    if (cumBreakEvenMonth === null && cumulative > 0) cumBreakEvenMonth = m;
+    rows.push(row);
+  }
+
+  const last = rows[rows.length - 1];
+  if (!last) return null;
+  const year1 = rows.slice(0, 12);
+  return {
+    rows,
+    summary: {
+      horizon,
+      breakEvenMonth,
+      cumBreakEvenMonth,
+      year1Revenue: sum(year1.map((r) => r.revenue)),
+      year1Net: sum(year1.map((r) => r.netProfit)),
+      totalRevenue: sum(rows.map((r) => r.revenue)),
+      totalNet: cumulative,
+      maxDrawdown: Math.min(...rows.map((r) => r.cumulative), 0),
+      endingMRR: last.revenue,
+      endingCounts: Object.fromEntries(parties.map((p) => [p.id, last.parties[p.id]?.count || 0])),
+    },
+  };
+}
+
+export function fmtMoney(n: number, currency = "USD"): string {
+  try {
+    return new Intl.NumberFormat("en-US", { style: "currency", currency, maximumFractionDigits: 0 }).format(n);
+  } catch {
+    return `$${Math.round(n).toLocaleString()}`;
+  }
+}
+
+export function fmtNum(n: number): string {
+  return Math.round(n).toLocaleString();
+}
+
+// Apply a benchmark suggestion path like "parties.rider.cacPerUnit" immutably.
+export function applyBenchmarkPath(assumptions: Assumptions, path: string, value: number): Assumptions {
+  const [group, id, field] = path.split(".");
+  const next: Assumptions = structuredClone(assumptions);
+  if (group === "parties" && id && field) {
+    const p = next.parties.find((x) => x.id === id);
+    if (p && field in p) (p as unknown as Record<string, unknown>)[field] = value;
+  } else if (group === "fixedCosts" && id && field) {
+    const f = (next.fixedCosts || []).find((x) => x.id === id);
+    if (f) (f as unknown as Record<string, unknown>)[field] = value;
+  } else if (group === "oneTimeCosts" && id && field) {
+    const o = (next.oneTimeCosts || []).find((x) => x.id === id);
+    if (o) (o as unknown as Record<string, unknown>)[field] = value;
+  }
+  return next;
+}

package/core/scoring.ts

@@ -0,0 +1,56 @@
+// Confidence-driven scoring. The feedback loop's goal is a confidence above
+// CONFIDENCE_GOAL; below that the loop keeps going (no round cap). All the
+// band/grade thresholds live here so every consumer agrees on one source of
+// truth. Ported verbatim-in-behavior from the web app's src/lib/scoring.js.
+
+export type Status = "green" | "yellow" | "red";
+export type Grade = "A" | "B" | "C" | "D" | "F";
+
+export interface FeedbackLike {
+  confidence?: number;
+  status?: Status | string | null;
+}
+
+export const CONFIDENCE_GOAL = 0.85;
+
+// confidence (0..1) -> stoplight status. null in, null out.
+export function statusFromConfidence(c: number | null | undefined): Status | null {
+  if (typeof c !== "number" || Number.isNaN(c)) return null;
+  if (c >= CONFIDENCE_GOAL) return "green";
+  if (c >= 0.6) return "yellow";
+  return "red";
+}
+
+// confidence (0..1) -> letter grade. null when there is nothing to grade.
+export function gradeFromConfidence(c: number | null | undefined): Grade | null {
+  if (typeof c !== "number" || Number.isNaN(c)) return null;
+  if (c >= 0.9) return "A";
+  if (c >= 0.8) return "B";
+  if (c >= 0.7) return "C";
+  if (c >= 0.6) return "D";
+  return "F";
+}
+
+// Mean of the numeric values, ignoring nulls/NaN. null when none are numeric.
+// Used to aggregate the panel's three persona confidences into one number,
+// and to aggregate a section's question confidences.
+export function aggregateConfidence(values: Array<number | null | undefined>): number | null {
+  const nums = (values || []).filter((v): v is number => typeof v === "number" && !Number.isNaN(v));
+  if (nums.length === 0) return null;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+
+// Coarse proxy confidence for a stoplight status, used for items that have a
+// status but no numeric confidence, and for legacy feedback.
+const STATUS_CONFIDENCE: Record<string, number> = { green: 0.9, yellow: 0.7, red: 0.4 };
+export function confidenceFromStatus(status: string | null | undefined): number | null {
+  if (status == null) return null;
+  return STATUS_CONFIDENCE[status] ?? null;
+}
+
+// Pull the effective confidence off a feedback object.
+export function feedbackConfidence(fb: FeedbackLike | null | undefined): number | null {
+  if (!fb) return null;
+  if (typeof fb.confidence === "number") return fb.confidence;
+  return confidenceFromStatus(fb.status);
+}

package/extensions/thought-layer.ts

@@ -0,0 +1,128 @@
+// The Thought Layer Pi extension. It exposes the deterministic core as tools so
+// the agent never has to re-derive the math: confidence scoring, domain
+// availability, and the numeric projection. The methodology itself lives in the
+// skills (thought-layer-panel / grill / prd / naming); this is the engine.
+
+import type { ExtensionAPI, ToolResult } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import {
+  aggregateConfidence, statusFromConfidence, gradeFromConfidence,
+  checkDomains, registrarSearchUrl,
+  computeProjection, fmtMoney,
+  type Assumptions,
+} from "../core/index.ts";
+
+const text = (t: string, details?: Record<string, unknown>): ToolResult => ({
+  content: [{ type: "text", text: t }],
+  details: details ?? {},
+});
+
+export default function (pi: ExtensionAPI) {
+  // tl_score: aggregate persona confidences into a status + letter grade,
+  // using the exact bands from the web app (green >= 0.85, yellow >= 0.6).
+  pi.registerTool({
+    name: "tl_score",
+    label: "Thought Layer: score",
+    description:
+      "Aggregate one or more confidence values (0 to 1) into a stoplight status and a letter grade, using The Thought Layer's exact bands. Use after a panel evaluation to compute the verdict instead of guessing the grade.",
+    parameters: Type.Object({
+      confidences: Type.Array(Type.Number(), {
+        description: "Confidence values 0 to 1 (e.g. one per persona in panel mode).",
+      }),
+    }),
+    async execute(_id, params): Promise<ToolResult> {
+      const { confidences } = params as { confidences: number[] };
+      const confidence = aggregateConfidence(confidences);
+      if (confidence === null) return text("No numeric confidences provided.", { confidence: null });
+      const status = statusFromConfidence(confidence);
+      const grade = gradeFromConfidence(confidence);
+      return text(
+        `Aggregate confidence ${(confidence * 100).toFixed(0)}% -> status ${status}, grade ${grade}. ` +
+          `Goal is 0.85+ (green). ${status === "green" ? "Sufficient to move on." : "Keep refining or set aside with to-dos."}`,
+        { confidence, status, grade },
+      );
+    },
+  });
+
+  // tl_domains: check availability via the user's own RapidAPI key (BYOK, from
+  // env). With no key, return a registrar search link instead of calling out.
+  pi.registerTool({
+    name: "tl_domains",
+    label: "Thought Layer: domains",
+    description:
+      "Check domain availability for a name slug across common TLDs. Reads a RapidAPI key from THOUGHT_LAYER_DOMAIN_KEY or RAPIDAPI_KEY (BYOK). With no key set, returns a registrar search link rather than calling out.",
+    parameters: Type.Object({
+      slug: Type.String({ description: "Domain-ready base, lowercase, no TLD (e.g. 'acmedispatch')." }),
+      tlds: Type.Optional(Type.Array(Type.String(), { description: "TLDs to check; defaults to com, io, app, co." })),
+    }),
+    async execute(_id, params, signal): Promise<ToolResult> {
+      const { slug, tlds } = params as { slug: string; tlds?: string[] };
+      const key = process.env.THOUGHT_LAYER_DOMAIN_KEY || process.env.RAPIDAPI_KEY || "";
+      const results = await checkDomains(slug, key, { signal, tlds });
+      if (results === null) {
+        return text(
+          `No domain key set, so I did not call out. Search manually: ${registrarSearchUrl(slug)}`,
+          { hasKey: false, searchUrl: registrarSearchUrl(slug) },
+        );
+      }
+      const lines = results.map((r) => `${r.available ? "available" : r.error ? "check failed" : "taken"}: ${r.domain}`);
+      return text(`Domain availability for "${slug}":\n${lines.join("\n")}`, { results });
+    },
+  });
+
+  // tl_project: run the deterministic monthly projection from business-model
+  // assumptions and return the headline summary.
+  const PartySchema = Type.Object({
+    id: Type.String(),
+    name: Type.Optional(Type.String()),
+    startingCount: Type.Optional(Type.Number()),
+    monthlyNewBase: Type.Optional(Type.Number()),
+    monthlyNewGrowthPct: Type.Optional(Type.Number()),
+    monthlyChurnPct: Type.Optional(Type.Number()),
+    revenuePerUnitPerMonth: Type.Optional(Type.Number()),
+    variableCostPerUnitPerMonth: Type.Optional(Type.Number()),
+    cacPerUnit: Type.Optional(Type.Number()),
+  });
+  const FixedCostSchema = Type.Object({
+    id: Type.String(),
+    name: Type.Optional(Type.String()),
+    monthlyAmount: Type.Optional(Type.Number()),
+    startMonth: Type.Optional(Type.Number()),
+  });
+  const OneTimeCostSchema = Type.Object({
+    id: Type.String(),
+    name: Type.Optional(Type.String()),
+    amount: Type.Optional(Type.Number()),
+    month: Type.Optional(Type.Number()),
+  });
+  pi.registerTool({
+    name: "tl_project",
+    label: "Thought Layer: project",
+    description:
+      "Run The Thought Layer's deterministic monthly business projection from structured assumptions (parties, fixed costs, one-time costs, horizon). Returns break-even, year-1 revenue and net, max cash drawdown, and ending MRR. Use this instead of estimating the numbers.",
+    parameters: Type.Object({
+      parties: Type.Array(PartySchema),
+      fixedCosts: Type.Optional(Type.Array(FixedCostSchema)),
+      oneTimeCosts: Type.Optional(Type.Array(OneTimeCostSchema)),
+      horizonMonths: Type.Optional(Type.Number()),
+      currency: Type.Optional(Type.String()),
+    }),
+    async execute(_id, params): Promise<ToolResult> {
+      const a = params as Assumptions;
+      const p = computeProjection(a);
+      if (!p) return text("No parties provided, so there is nothing to project.", {});
+      const s = p.summary;
+      const cur = a.currency || "USD";
+      const body = [
+        `Horizon: ${s.horizon} months`,
+        `Monthly break-even: ${s.breakEvenMonth ? `month ${s.breakEvenMonth}` : "beyond horizon"}`,
+        `Cumulative break-even: ${s.cumBreakEvenMonth ? `month ${s.cumBreakEvenMonth}` : "beyond horizon"}`,
+        `Year-1 revenue: ${fmtMoney(s.year1Revenue, cur)}`,
+        `Year-1 net: ${fmtMoney(s.year1Net, cur)}`,
+        `Max cash drawdown: ${fmtMoney(s.maxDrawdown, cur)}`,
+        `Ending MRR: ${fmtMoney(s.endingMRR, cur)}`,
+      ].join("\n");
+      return text(`Projection summary:\n${body}`, { summary: s });
+    },
+  });
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@hobocode/thought-layer",
+  "version": "0.1.0",
+  "description": "The Thought Layer: rigor for building. Validate an idea, grill it into a buildable spec, then build and deploy it, inside the agent you already use. BYOK, no telemetry.",
+  "license": "MIT",
+  "author": "Hobocode LLC <jerm@hobocode.net>",
+  "homepage": "https://weareallproductmanagersnow.com",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "agent-skills",
+    "claude-code",
+    "product-validation",
+    "prd",
+    "domain-driven-design"
+  ],
+  "pi": {
+    "skills": ["./skills"],
+    "extensions": ["./extensions"],
+    "prompts": ["./prompts"]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./core": "./core/index.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "files": [
+    "skills",
+    "extensions",
+    "prompts",
+    "core/index.ts",
+    "core/scoring.ts",
+    "core/domains.ts",
+    "core/model.ts",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/prompts/tl-grill.md

@@ -0,0 +1,5 @@
+Apply the **thought-layer-grill** skill. Grill the draft PRD one sharp question at a time: challenge it against the domain, sharpen the glossary, surface contradictions and missing requirements, and update the PRD inline until it is build-ready. Respect anything marked out of scope.
+
+The Grill is the LAST design step and grills an existing PRD. If there is no PRD yet, say so first and recommend running `/tl` (or `/tl-prd` to draft one) rather than grilling a bare idea — only proceed cold if I tell you to.
+
+Begin the grill on:

package/prompts/tl-naming.md

@@ -0,0 +1,3 @@
+Apply the **thought-layer-naming** skill. Propose name candidates across a range of styles, grounded in this specific business and audience, each with a rationale and a domain-ready slug. Then use the `tl_domains` tool to check availability for the strongest slugs.
+
+Name this:

package/prompts/tl-panel.md

@@ -0,0 +1,3 @@
+Apply the **thought-layer-panel** skill to the answer below, at its stage's altitude. If no stage is given, treat it as the opening idea stage: judge whether the idea is clear, honest, real, and worth pursuing, and park any "how will it be built" concerns (implementation, UX, data, edge cases) for the Grill rather than raising them against the idea. Run all three personas, use the `tl_score` tool for the status and grade, and give the plain verdict plus at most three fixes that belong to this stage. Do not soften it, and do not move the goalposts into a later stage.
+
+Evaluate this:

package/prompts/tl-prd.md

@@ -0,0 +1 @@
+Apply the **thought-layer-prd** skill. Compose a complete first-draft PRD from everything validated so far (the idea and the business model) — including a first-cut domain glossary and testable requirements. This is the pre-grill draft: aim for build-ready, but flag the weakest assumptions and thinnest sections so the grill knows where to push. Keep the ubiquitous language exact. Carry any open to-dos forward. Output only the markdown document.

package/prompts/tl.md

@@ -0,0 +1,10 @@
+Run the full Thought Layer framework on the idea below. Apply the **thought-layer-framework** skill as the backbone:
+
+- Walk every stage in order: first validate the idea (what it is, domain knowledge, validation, market selection, the 30-second pitch), then make the business model real (time, costs, scale, pricing, the model and its numbers, acquisition, relationships, support).
+- Evaluate each stage with the **thought-layer-panel** skill at that stage's altitude, and use the `tl_score` tool for the verdict. Use `tl_project` for the business-model numbers.
+- Do not jump to the design phase. The Grill and the PRD come last, after the validation and model stages. Any "how will it actually be built" concern gets parked until the design phase (the PRD draft, then the grill), not raised against the early idea.
+- When the framework reaches the design phase, run **thought-layer-prd** (draft the spec) then **thought-layer-grill** (grill the draft until it is build-ready). Use **thought-layer-naming** (with `tl_domains`) whenever it needs a name.
+
+Take it one stage at a time, one stage per turn, and wait for the user between stages. If an idea is given below, treat it as the answer to stage 1 (the Concise What) and evaluate it before moving on. If nothing is below, open by asking the user for their idea in one sentence — do not wait to be handed a brief.
+
+The idea (if any):