@skhema/cli 0.4.3 → 0.4.5

package/dist/commands/document.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+/**
+ * Document commands — workspace-authored narrative artifacts (board updates,
+ * team briefs, decision briefs, custom docs). All are workspace-scoped via
+ * `--workspace` (falling back to the default set by `skhema workspace use`).
+ * The routes carry the workspace id in the path, so — unlike `workspace list`
+ * — no organizationId is forwarded; the gateway authorizes via workspace access.
+ */
+export declare function registerDocumentCommands(program: Command): void;
+//# sourceMappingURL=document.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../src/commands/document.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAqBnC;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgK/D"}

package/dist/commands/document.js

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import { resolveClient } from '../lib/api/client.js';
+import { asRecord, buildBody, coerceList, readPayloadFile, resolveWorkspaceId, } from '../lib/api/command-helpers.js';
+import { runCommand, UsageError } from '../lib/api/run-command.js';
+import { getGlobalOptions, log, logHeader, logTable } from '../lib/output.js';
+/** Print a single document as a label block (human output only). */
+function printDocument(document) {
+    const d = asRecord(document);
+    logHeader(String(d.title ?? d.id ?? 'Document'));
+    log(`  Id:       ${chalk.cyan(String(d.id ?? '—'))}`);
+    if (d.docType)
+        log(`  Type:     ${String(d.docType)}`);
+    if (d.updatedAt)
+        log(`  Updated:  ${String(d.updatedAt)}`);
+}
+/**
+ * Document commands — workspace-authored narrative artifacts (board updates,
+ * team briefs, decision briefs, custom docs). All are workspace-scoped via
+ * `--workspace` (falling back to the default set by `skhema workspace use`).
+ * The routes carry the workspace id in the path, so — unlike `workspace list`
+ * — no organizationId is forwarded; the gateway authorizes via workspace access.
+ */
+export function registerDocumentCommands(program) {
+    const document = program.command('document').description('Document commands');
+    const withWorkspace = (cmd) => cmd.option('--workspace <id>', 'Workspace id (defaults to `skhema workspace use`)');
+    withWorkspace(document.command('list').description('List documents')).action(async (options) => {
+        await runCommand('document list', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.documents.list(workspaceId);
+            const rows = coerceList(data, 'documents');
+            if (!getGlobalOptions().json) {
+                logHeader(`Documents (${rows.length})`);
+                if (rows.length === 0)
+                    log(chalk.dim('  No documents.'));
+                else
+                    logTable(['Title', 'Type', 'Updated', 'Id'], rows.map((r) => {
+                        const d = asRecord(r);
+                        return [
+                            String(d.title ?? '—'),
+                            String(d.docType ?? '—'),
+                            String(d.updatedAt ?? '—'),
+                            String(d.id ?? '—'),
+                        ];
+                    }));
+            }
+            return data;
+        });
+    });
+    withWorkspace(document.command('get <document-id>').description('Get a document by id')).action(async (documentId, options) => {
+        await runCommand('document get', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.documents.get(workspaceId, documentId);
+            if (!getGlobalOptions().json)
+                printDocument(asRecord(data).document ?? data);
+            return data;
+        });
+    });
+    withWorkspace(document
+        .command('create')
+        .description('Create a document')
+        .option('--title <title>', 'Document title')
+        .option('--doc-type <type>', 'Document type (board_update | team_brief | decision_brief | custom)')
+        .option('--content <content>', 'Document content')
+        .option('--file <path>', 'JSON payload file for the full body ("-" for stdin)')).action(async (options) => {
+        await runCommand('document create', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const body = buildBody(readPayloadFile(options.file), {
+                title: options.title,
+                docType: options.docType,
+                content: options.content,
+            });
+            if (Object.keys(body).length === 0) {
+                throw new UsageError('Nothing to create. Pass document fields as flags or a --file payload.');
+            }
+            const { client } = await resolveClient();
+            const data = await client.documents.create(workspaceId, body);
+            if (!getGlobalOptions().json) {
+                log(chalk.green('Document created.'));
+                printDocument(asRecord(data).document ?? data);
+            }
+            return data;
+        });
+    });
+    withWorkspace(document
+        .command('update <document-id>')
+        .description('Update a document')
+        .option('--title <title>', 'Document title')
+        .option('--doc-type <type>', 'Document type (board_update | team_brief | decision_brief | custom)')
+        .option('--content <content>', 'Document content')
+        .option('--file <path>', 'JSON payload file for the full body ("-" for stdin)')).action(async (documentId, options) => {
+        await runCommand('document update', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const body = buildBody(readPayloadFile(options.file), {
+                title: options.title,
+                docType: options.docType,
+                content: options.content,
+            });
+            if (Object.keys(body).length === 0) {
+                throw new UsageError('Nothing to update. Pass document fields as flags or a --file payload.');
+            }
+            const { client } = await resolveClient();
+            const data = await client.documents.update(workspaceId, documentId, body);
+            if (!getGlobalOptions().json) {
+                log(chalk.green('Document updated.'));
+                printDocument(asRecord(data).document ?? data);
+            }
+            return data;
+        });
+    });
+    withWorkspace(document.command('delete <document-id>').description('Delete a document')).action(async (documentId, options) => {
+        await runCommand('document delete', async () => {
+            const workspaceId = resolveWorkspaceId(options.workspace);
+            const { client } = await resolveClient();
+            const data = await client.documents.delete(workspaceId, documentId);
+            if (!getGlobalOptions().json)
+                log(chalk.green(`Deleted document ${documentId}.`));
+            return data;
+        });
+    });
+}

package/dist/lib/api/command-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/api/command-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAKzC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAQxD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAsB1E;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,WAAW,CAMb;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIhE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAQlE"}
+{"version":3,"file":"command-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/api/command-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAKzC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAQxD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAuB1E;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,WAAW,CAMb;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIhE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE,CAQlE"}

package/dist/lib/api/command-helpers.js

@@ -29,7 +29,8 @@ export function readPayloadFile(filePath) {
         throw new UsageError(`Could not read payload file "${filePath}": ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-        const parsed = JSON.parse(raw);
+        // Strip a leading UTF-8 BOM so a byte-identical-looking file parses.
+        const parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
         if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
             throw new Error('expected a JSON object');
         }

package/dist/lib/api/passthrough.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"passthrough.d.ts","sourceRoot":"","sources":["../../../src/lib/api/passthrough.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAW7C;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQvD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAyBrE;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,EAAE,EAAE;IACF,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACjC,GACA,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CA+B9C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EAAE,GAAG,SAAS,GACxB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CASzB"}
+{"version":3,"file":"passthrough.d.ts","sourceRoot":"","sources":["../../../src/lib/api/passthrough.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAW7C;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQvD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAyBrE;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,EAAE,EAAE;IACF,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACjC,GACA,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CA2C9C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EAAE,GAAG,SAAS,GACxB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CASzB"}

package/dist/lib/api/passthrough.js

@@ -79,10 +79,19 @@ export async function resolveDataBody(raw, io) {
     }
     let parsed;
     try {
-        parsed = JSON.parse(text);
+        // Strip a leading UTF-8 BOM (editors and some `echo`/redirect toolchains
+        // prepend one); JSON.parse chokes on it, which surfaced as the opaque
+        // "--data is not valid JSON" even for a well-formed @file. Mirrors curl.
+        parsed = JSON.parse(text.replace(/^\uFEFF/, ''));
     }
-    catch {
-        throw new UsageError('--data is not valid JSON.');
+    catch (err) {
+        // Name the source so a failed @file is not mistaken for the literal form.
+        const label = raw === '-'
+            ? 'from stdin'
+            : raw.startsWith('@')
+                ? `file "${raw.slice(1)}"`
+                : 'value';
+        throw new UsageError(`--data ${label} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
     }
     if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
         throw new UsageError('--data must be a JSON object.');

package/dist/lib/api/payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/lib/api/payload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAI9C,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAatD;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAczD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,GAAG,WAAW,CAad"}
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/lib/api/payload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAI9C,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAatD;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAezD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,GAAG,WAAW,CAad"}

package/dist/lib/api/payload.js

@@ -22,7 +22,8 @@ export function parseJsonFile(source) {
     const raw = readFileOrStdin(source);
     let parsed;
     try {
-        parsed = JSON.parse(raw);
+        // Strip a leading UTF-8 BOM so a byte-identical-looking file parses.
+        parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
     }
     catch {
         throw new UsageError(`Payload in ${source === '-' ? 'stdin' : source} is not valid JSON.`);

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;AAmBnC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA+CrD"}
+{"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"}

package/dist/program.js

@@ -4,6 +4,7 @@ import { registerApiCommands } from './commands/api.js';
 import { registerAuthCommands } from './commands/auth.js';
 import { registerComponentCommands } from './commands/component.js';
 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 { registerInitCommand } from './commands/init.js';
@@ -53,6 +54,7 @@ export function buildProgram(version) {
     registerWorkspaceExportCommand(program);
     registerComponentCommands(program);
     registerStrategyCommands(program);
+    registerDocumentCommands(program);
     registerResourceCommands(program);
     registerWebhookCommands(program);
     registerAgentCommands(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skhema/cli",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Skhema CLI - Authentication and AI skills management for agent platforms",
   "type": "module",
   "main": "dist/index.js",
@@ -43,7 +43,7 @@
   "dependencies": {
     "@skhema/agent-sdk": "0.1.4",
     "@skhema/method": "0.3.0",
-    "@skhema/sdk": "0.2.1",
+    "@skhema/sdk": "0.2.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "ora": "^8.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.

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

@@ -0,0 +1,95 @@
+# Coherence
+
+Does the strategy agree with itself? You are hunting for three faults:
+**contradictions** (two parts that can't both be acted on), **unnamed tensions**
+(two parts that pull against each other and nobody said so), and **gaps** (a
+decision with no follow-through, or a goal with nothing aimed at it).
+
+Coherence is never automatic. A strategy is written in pieces, over time, by
+people in different moods. The pieces drift. Your job is to lay them side by side
+and find where they stop fitting.
+
+## Before you start
+
+Get the whole thing in front of you. Coherence can only be checked across the
+full set — a single element in isolation always looks fine. If they hand you one
+page, ask what it connects to: what decision it serves, what it depends on.
+
+## The moves
+
+Run these in order. Each pass looks for one fault type.
+
+### 1. List the commitments
+
+Read through and pull out every line that commits to something — a decision, a
+priority, a target, a "we will" or "we won't." Write them as a flat numbered
+list, in the person's own words. This list is your working surface; you check it
+against itself, not the prose.
+
+### 2. Hunt contradictions
+
+Go down the list and, for each commitment, ask: is there another commitment it
+can't coexist with? Watch for:
+
+- **Resource collisions.** "Move fast on A" and "move fast on B" when A and B
+  draw on the same one team. Two top priorities is zero priorities — say so.
+- **Direction collisions.** "Premium positioning" and "win on price." Both may
+  be written proudly, pages apart.
+- **Sequence collisions.** "B depends on A" but the plan does B first.
+
+For each hit, quote both lines and state the collision in one sentence. Do not
+resolve it yourself — that is the person's call. Surface it and ask which gives.
+
+### 3. Name the tensions
+
+A tension is softer than a contradiction: both parts can survive, but they pull
+opposite ways and the strain is unmanaged. "Serve enterprise and stay
+self-serve." Often fine — but only if named, because an unnamed tension gets
+resolved by accident, differently by each person, under pressure.
+
+For each tension: name it, say which two commitments create it, and ask the one
+question that matters — *is this a deliberate balance you're holding, or a
+choice you haven't made yet?* A named tension is a feature. An unnamed one is a
+future argument.
+
+### 4. Find the gaps
+
+Two directions:
+
+- **Decisions with no follow-through.** A commitment that nothing downstream
+  acts on. "We'll win on service" — then no line about staffing, training, or a
+  service metric. The decision is decoration until something carries it.
+- **Goals with nothing aimed at them.** An outcome or target that no initiative,
+  action, or resource points at. Ask: what in this plan actually moves that
+  number?
+
+Gaps hide because absence is invisible. You find them by walking each commitment
+forward ("what happens because of this?") and each goal backward ("what here
+causes this?") and noting where the trail goes cold.
+
+### 5. Spot the off-topic orphan
+
+Sometimes a piece shares no subject with the rest — it's about a different
+market, product, or problem entirely. It can't contradict, support, or gap
+anything, because it isn't part of this argument at all. That's not a coherence
+fault to resolve; it's a sign the element belongs to a *different strategy*.
+Flag it, say what it seems to be about, and recommend it move to its own
+workspace. Never delete it yourself — it may be someone else's live work,
+misfiled here.
+
+## Output
+
+A numbered list. Each item: the fault type (contradiction / tension / gap), the
+exact line(s) quoted, one sentence of what's wrong, and either the fix or the
+question that forces the fix. Group by type. If the set is coherent, say which
+tensions you checked and confirmed are named — that is a real finding too.
+
+## Failure modes to avoid
+
+- **Manufacturing contradictions from vague words.** If two lines only clash
+  because a word is fuzzy, that's a language problem, not a coherence one — route
+  it to `language.md`, don't dress it up as a contradiction.
+- **Resolving it for them.** You flag, they choose. Picking the winner yourself
+  skips the judgment that is theirs to make.
+- **Stopping at the first find.** Walk the whole list. The expensive
+  contradiction is usually not the obvious one.

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

@@ -0,0 +1,81 @@
+# Freshness
+
+A strategy is a set of judgments made at a moment, under conditions that were
+true then. Time passes. The conditions move. Some judgments that were right are
+now stale — not wrong when written, just overtaken. This check finds them before
+you keep building on ground that shifted.
+
+The move: for each judgment, recover the conditions it was made under, then ask
+*do those conditions still hold?* Where they don't, the judgment is up for
+re-decision. You are not attacking the old call. You are checking whether the
+world it assumed is still the world you're in.
+
+## Anchor the date
+
+Find out when the strategy — or the part you're checking — was written or last
+reviewed. If it isn't dated, that is itself a finding: an undated strategy can't
+be kept fresh, because nobody knows how old any judgment is. Establish a rough
+date before you go further, from the person or from context.
+
+## Surface the conditions behind each judgment
+
+Walk the load-bearing decisions and claims. For each, ask: *what had to be true
+about the world for this to be the right call?* Make the hidden conditions
+explicit. Examples:
+
+- "Build our own billing" assumed no good off-the-shelf option existed **then**.
+- "Don't invest in mobile" assumed usage was desktop-first **then**.
+- "Price at $X" assumed a competitor set at $Y and a cost base of $Z **then**.
+- "Win on being AI-native" assumed rivals weren't **then**.
+
+Most conditions are unstated. The judgment records the conclusion, not the world
+it depended on. Your value is reconstructing that world so you can check it.
+
+## Check what moved
+
+For each condition, ask what has changed since the anchor date. Sweep the usual
+sources of drift:
+
+- **Competitors** — new entrants, a rival that closed the gap, someone who
+  exited.
+- **The market** — demand shifted, a segment grew or died, buyer behaviour
+  changed.
+- **Technology** — a capability that was hard or impossible is now cheap and
+  routine (this one dates strategies fastest).
+- **Your own position** — you have people, money, data, or a product you didn't
+  have then. Constraints that shaped the old call may be gone.
+- **Regulation / platform / external rules** — a policy, a fee, a dependency
+  changed under you.
+
+Where a condition held then and doesn't now, flag the judgment that rode on it.
+
+## Rate the staleness
+
+Not every changed condition matters. Sort each flagged judgment:
+
+- **Stale and load-bearing** — the condition moved AND a lot rests on this
+  judgment. Re-decide now. This is the finding that justifies the whole check.
+- **Stale but minor** — overtaken, but little depends on it. Note it, move on.
+- **Still current** — conditions hold. Say so; confirmed-fresh is a real result
+  and stops needless churn.
+
+## Output
+
+A numbered list: the judgment quoted, the condition it rested on, what changed,
+and the verdict (re-decide now / note / still holds). Lead with the stale-and-
+load-bearing ones. If the strategy is undated, say that first — it's the root
+cause that makes everything else guesswork.
+
+## Failure modes to avoid
+
+- **Re-litigating good calls.** A judgment made under conditions that STILL hold
+  is not stale, even if it's old. Age alone is not the fault; a moved condition
+  is. Don't reopen settled decisions for the sake of it.
+- **Only checking the outside world.** The biggest change is often *your own*
+  position — new capability, new resources. A constraint that forced the old
+  call may simply be gone.
+- **Missing the tech shift.** "It was too expensive to build" ages fastest of
+  all. Always ask whether the hard thing got cheap.
+- **Confusing stale with wrong.** Freshness is about conditions changing, not
+  about the original call being a mistake. Frame it as "time overtook this", not
+  "this was bad" — that keeps the person willing to re-decide honestly.