@skhema/cli 0.4.4 → 0.4.6

package/README.md

@@ -57,6 +57,21 @@ skhema api routes                                # every live route from the Ope
 `--data` takes a JSON literal, `@file`, or `-` (stdin). `--query k=v` repeats. The
 passthrough refuses any host other than the Skhema gateway.
 
+### Strategy document imports
+
+Import a local strategy document or public URL through the same reviewable
+proposal used by the web and MCP surfaces:
+
+```sh
+skhema import start --file ./strategy.pdf --wait
+skhema import get imp_...                       # inspect the mapped proposal
+skhema import decide imp_... --file decisions.json
+skhema import apply imp_... --workspace-name "Imported strategy" --yes
+```
+
+Use `--json` for a stable machine envelope. Applying or discarding requires an
+interactive confirmation, or an explicit `--yes` in scripts and CI.
+
 ## Credential lanes
 
 The CLI accepts **two kinds** of credential and resolves them in a fixed

package/dist/commands/import.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+/** Register the complete proposal-first import session lifecycle. */
+export declare function registerImportCommands(program: Command): void;
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/commands/import.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAkHnC,qEAAqE;AACrE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6L7D"}

package/dist/commands/import.js

@@ -0,0 +1,238 @@
+import chalk from 'chalk';
+import readline from 'readline';
+import { resolveClient } from '../lib/api/client.js';
+import { startFileImport, waitForImport } from '../lib/api/import-transfer.js';
+import { parseJsonFile } from '../lib/api/payload.js';
+import { runCommand, UsageError } from '../lib/api/run-command.js';
+import { getGlobalOptions, log, logHeader, logTable } from '../lib/output.js';
+function printSession(session) {
+    logHeader(session.proposalPayload?.summary.title ?? `Import ${session.id}`);
+    log(`  Id:       ${chalk.cyan(session.id)}`);
+    log(`  Status:   ${session.status}`);
+    const source = session.sourceFilename ?? session.sourceUrl;
+    if (source)
+        log(`  Source:   ${source}`);
+    if (session.progressStage) {
+        const count = session.progressCurrent !== null && session.progressTotal !== null
+            ? ` ${session.progressCurrent}/${session.progressTotal}`
+            : '';
+        log(`  Progress: ${session.progressStage}${count}`);
+    }
+    if (session.error)
+        log(`  Error:    ${session.error}`);
+    if (session.workspaceId)
+        log(`  Workspace: ${session.workspaceId}`);
+    const proposal = session.proposalPayload;
+    if (!proposal)
+        return;
+    log('');
+    log(`${proposal.items.length} mapped item${proposal.items.length === 1 ? '' : 's'}, ` +
+        `${proposal.orphans.length} unmapped.`);
+    if (proposal.items.length > 0) {
+        logTable(['Id', 'Component', 'Type', 'Confidence', 'Content'], proposal.items.map((item) => [
+            item.id,
+            item.componentType,
+            item.elementType,
+            item.confidence,
+            item.proposed.content.length > 60
+                ? `${item.proposed.content.slice(0, 57)}...`
+                : item.proposed.content,
+        ]));
+    }
+}
+function organizationFor(explicit, credential) {
+    const organizationId = explicit ?? credential.organizationId;
+    if (credential.kind === 'oauth' && !organizationId) {
+        throw new UsageError('No organization is available for this OAuth session. Pass --organization <id>.');
+    }
+    return organizationId;
+}
+function interactiveTerminal() {
+    return (Boolean(process.stdin.isTTY && process.stdout.isTTY) &&
+        !getGlobalOptions().json);
+}
+async function confirm(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await new Promise((resolve) => {
+        rl.question(`${question} [y/N]: `, (value) => {
+            rl.close();
+            resolve(value.trim().toLowerCase());
+        });
+    });
+    return answer === 'y' || answer === 'yes';
+}
+async function authorizeMutation(question, yes) {
+    if (yes)
+        return true;
+    if (!interactiveTerminal()) {
+        throw new UsageError('This command requires --yes when run non-interactively.');
+    }
+    return confirm(question);
+}
+function decisionsFrom(source) {
+    const parsed = parseJsonFile(source);
+    const candidate = parsed.decisions &&
+        typeof parsed.decisions === 'object' &&
+        !Array.isArray(parsed.decisions)
+        ? parsed.decisions
+        : parsed;
+    return candidate;
+}
+async function maybeWait(client, response, wait) {
+    if (!wait)
+        return response;
+    return waitForImport({ client, sessionId: response.session.id });
+}
+/** Register the complete proposal-first import session lifecycle. */
+export function registerImportCommands(program) {
+    const imports = program
+        .command('import')
+        .description('Import a strategy document through a reviewable proposal');
+    imports
+        .command('start')
+        .description('Start an import from a local file or public URL')
+        .option('--file <path>', 'Local PDF, DOCX, Markdown, text, CSV, XLSX, or JSON')
+        .option('--url <url>', 'Public http(s) URL to import')
+        .option('--organization <id>', 'Organization id (OAuth user lane)')
+        .option('--wait', 'Poll until the proposal is ready or analysis fails')
+        .action(async (options) => {
+        await runCommand('import start', async () => {
+            if (Boolean(options.file) === Boolean(options.url)) {
+                throw new UsageError('Pass exactly one of --file <path> or --url <url>.');
+            }
+            if (options.url && !/^https?:\/\//i.test(options.url)) {
+                throw new UsageError('--url must be an http(s) URL.');
+            }
+            const { client, credential } = await resolveClient();
+            const organizationId = organizationFor(options.organization, credential);
+            let response = options.file
+                ? await startFileImport({
+                    client,
+                    filePath: options.file,
+                    organizationId,
+                })
+                : await client.imports.create({
+                    sourceType: 'url',
+                    ...(organizationId ? { organizationId } : {}),
+                    url: options.url,
+                });
+            response = await maybeWait(client, response, options.wait);
+            if (!getGlobalOptions().json)
+                printSession(response.session);
+            return response;
+        });
+    });
+    imports
+        .command('list')
+        .description('List recent import sessions')
+        .option('--organization <id>', 'Organization id (OAuth user lane)')
+        .action(async (options) => {
+        await runCommand('import list', async () => {
+            const { client, credential } = await resolveClient();
+            const organizationId = organizationFor(options.organization, credential);
+            const response = await client.imports.list(organizationId);
+            if (!getGlobalOptions().json) {
+                logHeader(`Imports (${response.sessions.length})`);
+                if (response.sessions.length === 0)
+                    log(chalk.dim('  No imports.'));
+                else
+                    logTable(['Status', 'Source', 'Updated', 'Id'], response.sessions.map((session) => [
+                        session.status,
+                        session.sourceFilename ?? session.sourceUrl ?? '—',
+                        session.updatedAt,
+                        session.id,
+                    ]));
+            }
+            return response;
+        });
+    });
+    imports
+        .command('get <session-id>')
+        .description('Inspect an import session and its proposal')
+        .option('--wait', 'Poll until the proposal is ready or analysis fails')
+        .action(async (sessionId, options) => {
+        await runCommand('import get', async () => {
+            const { client } = await resolveClient();
+            let response = await client.imports.get(sessionId);
+            response = await maybeWait(client, response, options.wait);
+            if (!getGlobalOptions().json)
+                printSession(response.session);
+            return response;
+        });
+    });
+    imports
+        .command('decide <session-id>')
+        .description('Replace proposal decisions from a JSON object')
+        .requiredOption('--file <path|->', 'Decisions JSON file, or - for stdin')
+        .action(async (sessionId, options) => {
+        await runCommand('import decide', async () => {
+            const { client } = await resolveClient();
+            const response = await client.imports.updateDecisions(sessionId, decisionsFrom(options.file));
+            if (!getGlobalOptions().json) {
+                log(chalk.green('Import decisions saved.'));
+                printSession(response.session);
+            }
+            return response;
+        });
+    });
+    imports
+        .command('apply <session-id>')
+        .description('Apply a reviewed proposal into a new workspace')
+        .requiredOption('--workspace-name <name>', 'Name for the new workspace')
+        .option('--visibility <visibility>', 'global | restricted', 'global')
+        .option('--yes', 'Confirm without prompting (required when non-interactive)')
+        .action(async (sessionId, options) => {
+        await runCommand('import apply', async () => {
+            if (options.visibility !== 'global' &&
+                options.visibility !== 'restricted') {
+                throw new UsageError('--visibility must be global or restricted.');
+            }
+            const authorized = await authorizeMutation(`Apply import ${sessionId} and create workspace "${options.workspaceName}"?`, options.yes ?? false);
+            if (!authorized)
+                return { cancelled: true, sessionId };
+            const { client } = await resolveClient();
+            const response = await client.imports.apply(sessionId, {
+                workspaceName: options.workspaceName,
+                visibility: options.visibility,
+            });
+            if (!getGlobalOptions().json) {
+                log(chalk.green('Import applied.'));
+                printSession(response.session);
+            }
+            return response;
+        });
+    });
+    imports
+        .command('discard <session-id>')
+        .description('Discard an eligible import session')
+        .option('--yes', 'Confirm without prompting (required when non-interactive)')
+        .action(async (sessionId, options) => {
+        await runCommand('import discard', async () => {
+            const authorized = await authorizeMutation(`Discard import ${sessionId}?`, options.yes ?? false);
+            if (!authorized)
+                return { cancelled: true, sessionId };
+            const { client } = await resolveClient();
+            const response = await client.imports.discard(sessionId);
+            if (!getGlobalOptions().json)
+                log(chalk.green('Import discarded.'));
+            return response;
+        });
+    });
+    imports
+        .command('retry <session-id>')
+        .description('Retry a failed or stale import analysis')
+        .option('--wait', 'Poll until the proposal is ready or analysis fails')
+        .action(async (sessionId, options) => {
+        await runCommand('import retry', async () => {
+            const { client } = await resolveClient();
+            let response = await client.imports.retry(sessionId);
+            response = await maybeWait(client, response, options.wait);
+            if (!getGlobalOptions().json)
+                printSession(response.session);
+            return response;
+        });
+    });
+}

package/dist/lib/api/import-transfer.d.ts

@@ -0,0 +1,22 @@
+import type { ImportSessionResponse, SkhemaClient } from '@skhema/sdk';
+/** Resolve the backend-supported import MIME for a local file. */
+export declare function importMimeFor(filePath: string): string;
+/**
+ * Start a file import, stream the bytes to its signed URL, and confirm upload.
+ * The file is never buffered in memory.
+ */
+export declare function startFileImport(options: {
+    client: SkhemaClient;
+    filePath: string;
+    organizationId?: string;
+    fetchImpl?: typeof fetch;
+}): Promise<ImportSessionResponse>;
+/** Poll the canonical session until it reaches a reviewable or terminal state. */
+export declare function waitForImport(options: {
+    client: SkhemaClient;
+    sessionId: string;
+    intervalMs?: number;
+    maxWaitMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<ImportSessionResponse>;
+//# sourceMappingURL=import-transfer.d.ts.map

package/dist/lib/api/import-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-transfer.d.ts","sourceRoot":"","sources":["../../../src/lib/api/import-transfer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAgBtE,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAStD;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE;IAC7C,MAAM,EAAE,YAAY,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CACzB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA4CjC;AAUD,kFAAkF;AAClF,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAC3C,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAkBjC"}

package/dist/lib/api/import-transfer.js

@@ -0,0 +1,89 @@
+import fs from 'fs';
+import path from 'path';
+import { Readable } from 'stream';
+import { UsageError } from './run-command.js';
+const IMPORT_MIME_BY_EXTENSION = {
+    pdf: 'application/pdf',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    md: 'text/markdown',
+    txt: 'text/plain',
+    csv: 'text/csv',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    json: 'application/json',
+};
+/** Resolve the backend-supported import MIME for a local file. */
+export function importMimeFor(filePath) {
+    const extension = path.extname(filePath).slice(1).toLowerCase();
+    const mime = IMPORT_MIME_BY_EXTENSION[extension];
+    if (!mime) {
+        throw new UsageError('Unsupported import file. Use PDF, DOCX, Markdown, text, CSV, XLSX, or JSON.');
+    }
+    return mime;
+}
+/**
+ * Start a file import, stream the bytes to its signed URL, and confirm upload.
+ * The file is never buffered in memory.
+ */
+export async function startFileImport(options) {
+    let sizeBytes;
+    try {
+        const stat = fs.statSync(options.filePath);
+        if (!stat.isFile())
+            throw new Error('not a file');
+        sizeBytes = stat.size;
+    }
+    catch {
+        throw new UsageError(`Cannot read import file: ${options.filePath}`);
+    }
+    const filename = path.basename(options.filePath);
+    const mime = importMimeFor(filename);
+    const created = await options.client.imports.create({
+        sourceType: 'file',
+        ...(options.organizationId
+            ? { organizationId: options.organizationId }
+            : {}),
+        filename,
+        mime,
+        sizeBytes,
+    });
+    if (!created.uploadUrl) {
+        throw new Error('The import service did not return an upload URL.');
+    }
+    const response = await (options.fetchImpl ?? globalThis.fetch)(created.uploadUrl, {
+        method: 'PUT',
+        headers: {
+            'Content-Type': mime,
+            'Content-Length': String(sizeBytes),
+        },
+        body: Readable.toWeb(fs.createReadStream(options.filePath)),
+        duplex: 'half',
+    });
+    if (!response.ok) {
+        throw new Error(`Uploading import file failed (HTTP ${response.status}).`);
+    }
+    return options.client.imports.confirmUpload(created.session.id);
+}
+const TERMINAL_IMPORT_STATUSES = new Set([
+    'proposed',
+    'applied',
+    'partially_applied',
+    'failed',
+    'discarded',
+]);
+/** Poll the canonical session until it reaches a reviewable or terminal state. */
+export async function waitForImport(options) {
+    const intervalMs = options.intervalMs ?? 2000;
+    const maxWaitMs = options.maxWaitMs ?? 30 * 60000;
+    const sleep = options.sleep ??
+        ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const startedAt = Date.now();
+    while (true) {
+        const response = await options.client.imports.get(options.sessionId);
+        if (TERMINAL_IMPORT_STATUSES.has(response.session.status))
+            return response;
+        if (Date.now() - startedAt >= maxWaitMs) {
+            throw new Error(`Timed out waiting for import ${options.sessionId}; inspect it with "skhema import get ${options.sessionId}".`);
+        }
+        await sleep(intervalMs);
+    }
+}

package/dist/program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAoBnC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAgDrD"}
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAqBnC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiDrD"}

package/dist/program.js

@@ -7,6 +7,7 @@ import { registerContributeCommands } from './commands/contribute.js';
 import { registerDocumentCommands } from './commands/document.js';
 import { registerElementCommands } from './commands/element.js';
 import { registerWorkspaceExportCommand } from './commands/export.js';
+import { registerImportCommands } from './commands/import.js';
 import { registerInitCommand } from './commands/init.js';
 import { registerLinkCommands } from './commands/link.js';
 import { registerResourceCommands } from './commands/resource.js';
@@ -47,6 +48,7 @@ export function buildProgram(version) {
         program.help();
     });
     registerInitCommand(program);
+    registerImportCommands(program);
     registerAuthCommands(program);
     registerWorkspaceCommands(program);
     registerElementCommands(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skhema/cli",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Skhema CLI - Authentication and AI skills management for agent platforms",
   "type": "module",
   "main": "dist/index.js",
@@ -43,14 +43,14 @@
   "dependencies": {
     "@skhema/agent-sdk": "0.1.4",
     "@skhema/method": "0.3.0",
-    "@skhema/sdk": "0.2.2",
+    "@skhema/sdk": "0.2.3",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "ora": "^8.0.0"
   },
   "devDependencies": {
     "@mdx-js/mdx": "3.1.1",
-    "@skhema/linter": "2.2.0",
+    "@skhema/linter": "2.3.0",
     "@skhema/prettier-config": "1.0.0",
     "@types/node": "^22.0.0",
     "eslint": "^9.0.0",

package/skills/.manifest.json

@@ -1,15 +1,13 @@
 {
-  "syncedAt": "2026-07-09T00:27:14.921Z",
+  "syncedAt": "2026-07-09T17:15:20.908Z",
   "source": "/Users/michaellovell/Desktop/GitHub/skhema-skills",
-  "sourceSha": "77561c7dbde8602ca799e5224c65ea18675ee37b",
+  "sourceSha": "2a3abbb24f2fb2539608102eabc90de10fc9984b",
   "skills": [
-    "skhema-challenge-framing",
-    "skhema-coherence-check",
-    "skhema-element-decomposition",
-    "skhema-element-writer",
-    "skhema-judgment-audit",
-    "skhema-semantic-sharpening",
-    "skhema-strategy-advisor",
-    "skhema-workspace-navigator"
+    "skhema-frame",
+    "skhema-compose",
+    "skhema-calibrate",
+    "skhema-pressure-test",
+    "skhema-communicate",
+    "skhema-operate"
   ]
 }

package/skills/skhema-calibrate/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: skhema-calibrate
+description: "Use when you already have a strategy (or a piece of one) written down and need to check it still holds up — spot internal contradictions, claims resting on nothing, words that mean different things to different readers, or judgments the world has since overtaken. A self-check, not an attack; for an adversarial interrogation, use skhema-pressure-test."
+---
+
+# Calibrate
+
+You have something written. A strategy, a plan, a decision memo, a page of it.
+This skill checks whether it is still sound and still current. Not to tear it
+down — to true it up, like checking a level before you build on it.
+
+Calibration is a self-check you run WITH the person on their own work. You read
+what they wrote, you point at specific lines, you ask specific questions. The
+output is a short list of concrete problems, each tied to a place in the text,
+each with a fix or a question that surfaces the fix.
+
+This is not brainstorming and not interrogation. If the person wants their
+strategy attacked from the outside — a devil's-advocate grilling, a pre-mortem —
+that is **skhema-pressure-test**, a different skill. Calibrate stays inside the
+document and asks: does this agree with itself, does it rest on real evidence,
+does it say one clear thing, and is it still true today?
+
+## The four checks
+
+Run whichever the situation calls for. On a full review, run all four in this
+order — each surfaces different faults, and later checks are cleaner once the
+earlier ones are fixed.
+
+| Check | You are hunting for | Route to |
+|---|---|---|
+| Coherence | Two parts that disagree, a tension nobody named, a decision with no follow-through | `references/coherence.md` |
+| Assumptions | Claims stated as fact that are really beliefs; confidence that outruns the evidence | `references/assumptions.md` |
+| Language | Words vague enough that two readers walk away believing different things | `references/language.md` |
+| Freshness | Judgments made under conditions that no longer hold; facts that have gone stale | `references/freshness.md` |
+
+## How to pick
+
+- "Does this hang together?" / "something feels off but I can't say what" /
+  "we decided X here and Y there" → **coherence**.
+- "How sure are we?" / "is this actually true or do we just think so?" /
+  before committing real money or people → **assumptions**.
+- "Everyone read this and nodded but we're doing different things" /
+  "what does 'scale' even mean here" → **language**.
+- "This was written months ago" / "the market moved" / "is this still our
+  situation?" → **freshness**.
+
+If they just say "review this" or "is this any good?", run all four. Announce
+which you're doing as you go so they can follow.
+
+## One habit that runs through all four
+
+Every line in a strategy is doing one of three jobs. Before you judge a line,
+know which:
+
+- **A claim about the world** — something believed true. "Enterprise buyers
+  won't self-serve." These get the assumptions check: what's the evidence?
+- **A command** — something decided to do. "Ship the free tier first." These
+  get the coherence check: does the rest of the plan act on it?
+- **A named thing** — a scope, an outcome, a solution. "The onboarding flow."
+  These get the language check: would two readers point at the same thing?
+
+Most calibration faults are one of these three lines wearing another's clothes:
+a belief written as if it were a decided fact, a hope written as if it were a
+measurable outcome. Naming the job first makes the fault obvious.
+
+## What good output looks like
+
+Not "the strategy has some inconsistencies." Instead: a numbered list where
+each item quotes the exact line, names the fault, and gives the fix or the
+question that gets there. Three sharp findings the person acts on beat twenty
+vague ones they ignore. If a section is clean, say so and move on — do not
+manufacture problems to look thorough.
+
+## Without a live respondent
+
+Run headless, with no one to answer? Don't invent their answers. Make the
+minimal reasonable assumption, mark it in the output as yours ("assumed: …"),
+and list the questions only the owner can settle — what's in scope, what a word
+means, whose dissent to record — at the end instead of papering over them. A
+marked assumption is honest work; a silent one is a guess you built on.
+
+## Sharpen with Skhema
+
+These checks work on any document, in any editor, with nothing installed. If you
+want them automated — every claim typed by its job (world-claim vs command vs
+thing), contradictions flagged as you write, staleness dated — the Skhema method
+gives each strategy element a typed structure the checks run against. Start with
+`npm i @skhema/method` for the vocabulary and validators, or run them in a Skhema
+workspace where the four checks are wired into the element itself. Optional: the
+skill is complete without it.

package/skills/skhema-calibrate/references/assumptions.md

@@ -0,0 +1,77 @@
+# Assumptions
+
+Every strategy rests on things believed true. Some are backed by evidence. Some
+are guesses wearing the clothes of fact. This check separates them, so nobody
+bets real money or people on a sentence that only sounds certain.
+
+The core move: take each claim about the world and ask one blunt question —
+**what is the evidence?** A claim with good evidence is a fact you can lean on. A
+claim with none is an assumption, and it gets labelled as one. That is the whole
+job: type every claim, then look at what you're standing on.
+
+## Find the claims
+
+Walk the strategy and pull every line that states something about the world as
+true. These are the "claims about the world" — the beliefs, not the decisions or
+the named things. Signs of a claim: "customers want", "the market is",
+"competitors can't", "this will grow", "nobody else", "it's too expensive to".
+
+Skip the commands ("ship X") and the labels ("the growth team") — those get
+other checks. You want the load-bearing beliefs, because those are what the
+decisions rest on.
+
+## Type each claim
+
+For every claim, ask for the evidence behind it, then sort it into one bucket:
+
+- **Fact** — direct evidence you can point at. Data, a documented result, a
+  signed contract, a thing you measured. "Churn is 4% monthly" and here's the
+  dashboard.
+- **Assumption** — believed, not shown. No evidence, or only "it stands to
+  reason." "Enterprise buyers won't self-serve." Maybe true. Not demonstrated.
+- **Inference** — reasoned from a fact, but a step removed. "Churn is 4%, so
+  buyers don't see the value." The 4% is a fact; the *why* is a guess dressed as
+  a conclusion. Flag the guess.
+
+The forcing question for each: *if someone asked "how do we know?", what would
+you show them?* If the honest answer is "we don't, we think so" — it's an
+assumption. Label it. There is no shame in an assumption; there is danger in a
+mislabelled one.
+
+## Rate the confidence, and check it earns its weight
+
+Two things matter about each claim, and people conflate them:
+
+- **How sure are we?** High / medium / low, based on evidence quality.
+- **How much rests on it?** If this claim is wrong, how much of the strategy
+  falls?
+
+Plot them against each other. The claims that matter are **load-bearing and
+low-confidence** — high stakes, weak evidence. Those are the ones to name out
+loud and, ideally, turn into something testable before committing. A shaky
+assumption nothing depends on can stay shaky. A shaky assumption the whole plan
+stands on is the real finding of this whole exercise.
+
+Also watch for **confidence that outruns the evidence**: language like
+"obviously", "clearly", "everyone knows", "of course". Certainty in the wording
+is not certainty in the world. The louder the claim, the harder you check it.
+
+## Output
+
+A table or numbered list, one row per claim: the claim quoted, its type (fact /
+assumption / inference), confidence (high / med / low), and how load-bearing it
+is. Then a short verdict that pulls out the two or three load-bearing,
+low-confidence claims and says plainly: *these are what the strategy is really
+betting on; here is what would raise our confidence.*
+
+## Failure modes to avoid
+
+- **Letting "obviously" pass.** The words that most need checking are the ones
+  that sound like they don't.
+- **Rating confidence without asking for evidence.** Confidence is an output of
+  evidence, not a vibe. Always ask "how do we know?" first.
+- **Treating every assumption as a problem.** The goal is to type them, not
+  eliminate them. Strategy runs on assumptions. The point is knowing which ones,
+  and which ones are load-bearing.
+- **Missing the inferences.** These are the sneakiest — a real fact with a guess
+  bolted on, presented as one solid claim. Split them.