@clize/clize 0.35.1 → 0.35.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clize/clize",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "mcpName": "ai.clize/clize",
   "description": "The real-world capability layer for AI agents — domains, email, deploy, media, SEO/GEO. CLI + MCP.",
   "keywords": [

package/skills/clize-seo/SKILL.md

@@ -120,9 +120,10 @@ your list. No amount of enumeration produces this. Fold it back into the matrix
 
 ---
 
-## 2. The shape of one analysis
+## 2. The shape of one round
 
-A cold start is a funnel, and the funnel has a known size and a known price.
+A round is a funnel with a known size and a known price — and there is no such thing as an
+"analysis round": every round ends in pages or in a blocker the human must clear (§10).
 
 ```
 30–100 candidates            (§1: competitor teardown + capability matrix)
@@ -235,6 +236,16 @@ will — it cannot measure those. That half of the state exists only here.
   rounds while every session executed "the existing ledger").
 - **Narrative goes underneath as footnotes.** Two or three lines about what the pattern means.
   Not six paragraphs of themes.
+- **Every ledger file counts, and a plan is a queue.** A site may carry more than one ledger
+  (tabledi: `worksheet.md` for en-US and `worksheet-global.md` for the other markets); rows in
+  all of them are the site's rows, and a round that counts only one file will report "nothing
+  to build" beside the cells the other file already verified. A batch plan written under an earlier count rule (`≤5,
+  wait for impressions`) is not re-planned and never "the next batch": each cell is re-gated
+  on its own SERP verdict, and every cell that passes is a `to build` row for step ⓪ of the
+  next session (§10). tabledi's B1–B4 sat under "next batch" through three sessions — and when a
+  session finally counted, only 15 of its cells had a SERP and 6 of those were unbuilt: a plan
+  is not a verified list until each cell has its own verdict; buy the missing ones ($0.02 each)
+  in the same session, never "next time".
 
 **Page batches — the second table in the ledger.** Keyword rows hold bets; the batch table holds
 what the site's composition is doing, and it is what the batch gate and the retire rule (§7.3)
@@ -252,7 +263,7 @@ sitemap — and `unseenTotal` says how much of the site the list is showing you.
 
 ### The pass/fail test
 
-Six ways an analysis fails. The first is about *what you found*, the last two about *what you
+Six ways a round fails. The first is about *what you found*, the last two about *what you
 funded*; the middle three are about *whether you actually ran the analysis you claim to have
 run* — all six have been observed in real runs that read as finished.
 
@@ -281,12 +292,13 @@ run* — all six have been observed in real runs that read as finished.
    the pages they support. Observed in the field (2026-08-31 second run): five funded pages,
    placement nearly invisible in the deliverable.
 6. **Rows without pages — and families without rows.** Buildable rows — a serp verdict that is
-   not a wall, an intent you can serve — left unshipped at session end are stock, not output.
+   not a wall, an intent you can serve — left unshipped at session end, or handed to "next
+   round" without one of the three blockers in §10 ⑤, are stock, not output.
    An opportunity written in prose (a cluster, a family, a locale axis) with no rows behind it
    is test 1 wearing a different coat. The deliverable counts shipped
    URLs, not qualified rows; a ledger of twenty rows and two pages is a session that spent itself
-   on the analysis. Observed on our own tenant zero: eleven weeks of rounds that produced ledgers
-   and no pages. If a page costs a session, the first deliverable is the generator (§7).
+   on the analysis. Observed on kunavo: five rounds, five pages, three of the rounds at zero; and on clize.ai
+   the opposite failure — eleven weeks in which no round ran at all. If a page costs a session, the first deliverable is the generator (§7).
 
 ---
 
@@ -405,10 +417,11 @@ So: a `no_volume` row whose SERP is already full of category roundups is worth a
 A `no_data` row goes to `seo serp` like any other survivor — the SERP does not need a volume
 figure to show who occupies it. Open and servable → buildable, enrolled as `pending`; wall →
 skip row with the reason. What `no_data` never is: a reason to drop the cell. Measured across
-three sites, the rows with the best positions were disproportionately ones the volume table
-could not see (kunavo's payment long-tails at 4.5 and 5.8, clize.ai's German MCP cluster at
-130 impressions), while the priced `attackable` rows sat at 65+ — the table's coverage and the
-incumbents' coverage are the same coverage. On 2026-09-02, 82 of 119 cells left the funnel at
+three sites: the demand the table could not see was real (clize.ai's German MCP cluster,
+`no_data` in the table, 130 impressions in Search Console), and the only page-1 positions any
+of the sites hold are on such cells (kunavo's payment long-tails at 4.5 and 5.8), while the
+priced `attackable` rows sat at 65+ or unseen — the table's coverage and the incumbents'
+coverage are the same coverage. On 2026-09-02, 82 of 119 cells left the funnel at
 the pricing step without a single SERP look; keeping them would have cost $1.64 in serp calls.
 
 ### `--ai` is a different unit
@@ -536,6 +549,29 @@ each after the first. clize.ai went from one page per session to seven in one se
 a family generator existed, and tabledi shipped forty in two days from one. Build the generator
 before the second page of any family, and never machine-translate a family page.
 
+**On a site that already has tools, this round's page count is the locale siblings of the tools
+it has**, and the gate is each cell's own SERP (§7.2). Siblings come in two prices. A *format*
+tool (viewer, merge, split, convert) is one strings entry (tabledi: a `DICT` table in
+`tools/apps.js`; clize.ai: a `strings.<loc>.mjs`) — ten in a session is ordinary. A *text* tool
+(duplicates, compare, clean) carries locale semantics — full-width and half-width forms in
+Japanese, composed and decomposed accents in French — and a sibling that ignores them reports
+"0 duplicates" on a real file, which is gate 3 failed; budget two or three of those per session.
+Count existing tools × verified locale cells before anything else, and buy the SERPs the cells
+lack ($0.02 each) in the same breath — tabledi had 23 tools and 6 markets; when a session
+finally counted, 15 cells had a SERP, 6 were passed and unbuilt, and "next batch" had been
+written beside them three times. New tools are code and tests, one to three per session: the
+next batch's rows, not this batch's excuse.
+
+**Building and publishing a page that passed the gates on the user's own site is never a
+question for the human.** The human's gates are money, changes that alter what the world already
+sees (a redirect, DNS, a canonical), sends, and posts on other people's platforms. Ask for those
+in one line and build while you wait — never bundle the pages into the question. When a
+human-gated change shares a deploy with pages (a redirect map in the same `vercel.json`), split
+the deploy: ship the pages, hold the change. Step ⓪ is done when the pages are *live*, not
+committed — tabledi, 2026-09-02: one session built three things and ended asking about a
+redirect; the next found all three returning 404 in production and ended the same way. Four
+pages built across two sessions, zero live. A session does not end with built, undeployed pages.
+
 ### 7.1 The pipeline — five steps, each with a pass/fail
 
 | step | act | it passed if |
@@ -564,11 +600,17 @@ Judgment calls that matter:
   translates almost for free, and the non-English cells of your matrix are the low-competition
   ones. Each locale page is a real, distinct intent — this is not page-stuffing. Build every
   locale cell whose *own* SERP is not a wall (`seo serp --locale`, $0.02); the English page's
-  impressions are not the gate, because locale SERPs are only loosely coupled — a browser CSV
-  tool holds #1 in German where the English SERP is a tutorial wall, and a Korean payment
-  long-tail ranked where its English sibling never did. What does not multiply: marketing and
-  landing pages. Locale copies of those earned zero on every site measured (72 on clize.ai, 199
-  near-identical on kunavo) and are the composition drag gate 4 exists to prevent.
+  impressions are not the gate, because the same intent draws a different page in each market —
+  kunavo's `claude code pricing`: `official_wall` in de-DE and es-ES, `open` in ja-JP and
+  fr-FR; one keyword, four verdicts. What does not multiply: marketing and landing pages. Read
+  that evidence for what it varied, not for what it sounds like: clize.ai's 72 translated
+  landing pages earn about what their English originals earn — impressions in the tens, zero
+  clicks — so the failure is the *type*, in every language; kunavo's 199 untranslated copies
+  were duplicates, collapsed by canonicalization, and say nothing about locales; the locale
+  pages that do earn on both sites are translated guides and tools (kunavo's Korean pricing
+  guide is its top non-brand page). The bar for adding a locale to a marketing page is local
+  non-brand impressions on the ones that exist — indexing is the floor, not the pass. Locale is
+  not a page-generation primitive; a SERP-backed intent is.
 - **Pick tools with a shelf life.** Protocol- and format-level tools (llms.txt, schema, robots)
   keep earning links for years; trend-chasing tools die with the trend. Ask: will anyone search
   this in a year?
@@ -600,16 +642,23 @@ do the protecting, not experience:
      locale page written in-locale, a host page whose install and config really differ;
    - **the last batch is being indexed** — `gsc.pages.unseen` (§9) shows the previous batch's
      `index`; find the batch by `firstSeen`, and book the counts in the ledger's batch table (§3).
-     Mostly `indexed` → ship the next family. Mostly `Crawled - currently not indexed`
-     → that is Google's own verdict on those pages; the round is indexing and pruning, not
-     shipping.
+     Read the four states apart: `URL is unknown to Google` and `Discovered - currently not
+     indexed` are the queue (a day-old batch sits there; not a verdict); `Crawled - currently
+     not indexed` is Google's verdict on a page it has read — after you rule out your own hand
+     (a canonical pointing elsewhere, hreflang missing or one-way, a stray `noindex`), which
+     produces the same state. Mostly indexed → ship the next family. Mostly crawled-not-indexed
+     on a clean implementation → the round is indexing and pruning, not shipping. This check
+     paces shipping; it does not certify composition — kunavo's 440 locale model pages indexed
+     fine and earned nothing. Composition is the second check and the retire rule.
    Impressions are not the gate for the next batch: at zero authority they arrive five to six
    weeks after shipping and clicks may not arrive in a quarter, so a rule that waits for them
    ships nothing for months — that was the mechanism behind five pages a month. Waiting is for
    *deciding a new page type* (§10), never for the siblings of a type already decided. The
    retire rule is the other half of shipping fast: a page indexed for two windows with no
-   impressions, or refused by the index for two, is noindexed, merged or redirected. The
-   composition stays clean only if dead pages leave.
+   impressions, or refused by the index for two, is retired: `noindex` by default (the page keeps
+   serving users, only its index exposure goes), merge or redirect when another page carries the
+   intent, delete only what nobody visits. The composition stays clean only if dead pages leave
+   the index.
 
 ### 7.4 E-E-A-T floor and locales
 
@@ -790,12 +839,18 @@ which is free (sv/kd are monthly data, SERPs move slowly). The entry read is the
 each round's real question is **where the next unit of work goes** — double down where a signal
 appeared, stop where none did, and keep enumerating cells the ledger has not priced yet.
 
-**A round is five steps: ① read the feedback (`check`, free) → ② allocate (double down / stop
-loss / new bet) → ③ execute (pages, placement, the occasional paid query) → ④ book it (write
-what you put in back into the ledger, §3) → ⑤ report it (two tables, below).** Step ④ is the
-one that gets skipped, and skipping it breaks step ② two weeks later: "flat, no signal" and
-"flat, no signal, *and we already pitched five roundups*" are different rows, and only the
-ledger can tell them apart.
+**A round is a pipeline, and it opens by building.** ⓪ **ship the qualified batch** — every
+`to build` row from the last round and every plan cell with its own SERP verdict (§3), in every
+ledger file — before reading a single number, while the session's budget is whole → ① read the
+feedback (`check`, free) → ② allocate (double down / stop loss / new bet) → ③ execute what is
+cheap now (siblings, retargets, placement drafts) and write the rest as the next session's
+`to build` rows → ④ book it (§3) → ⑤ report it (two tables, below). This round's analysis
+qualifies the *next* round's batch; it does not postpone this one's. Step ⓪ is the step that
+vanished in three consecutive runs: each read, diagnosed, wrote a ledger, named itself an
+"analysis round" and handed the pages to "next time". Step ④ is the other one that gets
+skipped, and skipping it breaks step ② two weeks later: "flat, no signal" and "flat, no signal,
+*and we already pitched five roundups*" are different rows, and only the ledger can tell them
+apart.
 
 ```
 clize seo check            # free — every session on an existing site starts here
@@ -859,8 +914,13 @@ every row the round touched, one line each:
 | open webui api key | en-US | open | /docs/integrations/open-webui | integration doc | to build: generator first |
 | claude code preise | de-DE | official_wall | — | — | skip |
 
-`status` is one of `built` (shipped this round), `to build` (buildable, not shipped — say why),
-`exists` (a page already carries it), `skip` (with the reason). Second, **placement** — target /
+`status` is one of `built` (shipped this round), `to build`, `exists` (a page already carries
+it), `skip` (with the reason). A `to build` row carries a blocker, and only three exist:
+`needs human` (a redirect, a send, money — asked in one line, §7), `needs tool code` (a new
+client-side tool; name the session it ships in), `needs generator` (no family scaffold yet).
+"Analysis round", "next batch", "awaiting go-ahead" and "needs a SERP" are not blockers — a
+SERP is $0.02 inside the fuse and is bought on the spot — and a row wearing one of those means
+the session is not finished: it goes back to step ⓪. Second, **placement** — target /
 page / status (`sent` / `drafted` / `blocked: needs human`). Then at most five lines of
 narrative. A report that is findings and no pages table is test 1 (§3) in its final form: the
 human cannot act on a paragraph. A round with an empty pages table says so *in* the table, with
@@ -893,6 +953,14 @@ So: **promise time series against yourself, never absolute share.** "Our AI refe
 it. Breaking this rule in customer-facing copy is a product-integrity failure, not a rounding
 error.
 
+**The cases in this file are samples of one to three sites, and each varied one thing.** Before
+a case is cited for a rule, say what it varied, how many, and over which window: clize.ai's 72
+locale pages varied *page type* (their English originals earn the same nothing); kunavo's 199
+copies varied *translation* (identical, so Google collapsed them); tabledi's page-1 tools varied
+*age* (three years), not links; tabledi's 36 marketing locales were a day old when first read.
+A rule that survives only because its example was misread is a rule waiting to fail — three
+such misreadings were found in this file on 2026-09-02 and corrected.
+
 ---
 
 ## What this skill will not do