@orqint/cli 0.1.0

package/AGENTS.md

@@ -0,0 +1,26 @@
+# Agent notes — Orqint
+
+## Cursor-native workflow
+
+- **`orqint think prepare "<intent>"`** writes `orqint/.handoff/think.md`. Run the Agent on that file; write the result as **strict JSON** to e.g. `orqint/.handoff/think.response.json`.
+- **`orqint think apply --file <path>`** merges into `orqint/core/memory.json` and applies confidence rules.
+- **`orqint plan prepare`** / **`orqint plan apply --file <path>`** — same pattern for planning.
+
+## Rules
+
+- Follow the JSON schema embedded in each handoff.
+- Honor `memory.override` from the sliced context.
+- No OpenAI (or other) API keys in the Orqint CLI; intelligence for `think`/`plan` runs here in Cursor.
+
+## Source of truth
+
+- **Canonical:** `orqint/core/memory.json`
+- **Derived:** `orqint-spec/`
+
+## Developing the Orqint CLI (this repository)
+
+- TypeScript: `packages/cli/src/`
+- Prompt templates to edit: `packages/cli/prompts/` (built into `dist/orqint/prompts/`)
+- **npm `version`:** bump per [docs/PRD/PRD.md](docs/PRD/PRD.md) §17 before each publish; see `.cursor/rules/orqint-versioning.mdc`.
+
+See [docs/Repository-layout.md](docs/Repository-layout.md), [docs/PRD/PRD.md](docs/PRD/PRD.md), and `.cursor/rules/orqint-workflow.mdc`.

package/README.md

@@ -0,0 +1,104 @@
+# Orqint
+
+CLI orchestration for Cursor-native `think` / `plan` workflows. See [docs/PRD/PRD.md](docs/PRD/PRD.md).
+
+**Maintainers:** CLI source lives under [`packages/cli/`](packages/cli/README.md). Root folder [`orqint/`](orqint/core/) holds **project state** (`memory.json`, etc.) for this repo only, not TypeScript sources. Full map: [docs/Repository-layout.md](docs/Repository-layout.md).
+
+## Prerequisites
+
+- Node.js (LTS)
+- [pnpm](https://pnpm.io/installation) (for developing this repo)
+- [npm](https://www.npmjs.com/) (ships with Node; used by `npx` and `orqint update`)
+
+## Run with `npx` (no global install)
+
+After the package is **published to npm** (see below):
+
+```bash
+npx --yes @orqint/cli@latest version
+npx --yes @orqint/cli@latest init
+```
+
+Check for updates (queries the registry):
+
+```bash
+npx --yes @orqint/cli@latest update
+```
+
+Run the latest published CLI via npx (recommended when a newer version exists):
+
+```bash
+npx --yes @orqint/cli@latest <command>
+```
+
+`orqint update --install <args>` re-invokes `npx @orqint/cli@latest <args>` for you when a newer version is available.
+
+### Publish (maintainers)
+
+From this repo, with an npm login that can publish to the `@orqint` scope:
+
+```bash
+npm run build
+npm publish
+```
+
+The package is scoped as `@orqint/cli`; `publishConfig.access` is `public` so `npm publish` does not require extra flags.
+
+## Install the `orqint` command (this machine)
+
+From the **root of this repository**:
+
+```bash
+pnpm run cli:install
+```
+
+This installs dependencies, builds `dist/`, and runs `pnpm link --global` so `orqint` is on your PATH.
+
+On Windows (no `bash`), use:
+
+```bash
+pnpm run cli:install:pnpm
+```
+
+If `orqint` is not found, add pnpm’s global bin directory to your PATH (run `pnpm bin -g` to see it).
+
+**Shell alternative (same steps):**
+
+```bash
+bash scripts/setup-cli.sh
+```
+
+## Update after pulling changes
+
+```bash
+pnpm run cli:upgrade
+```
+
+Or:
+
+```bash
+bash scripts/update-cli.sh
+```
+
+`cli:upgrade` runs `git pull --rebase` (when this folder is a git repo), then reinstalls and rebuilds. Your global link keeps pointing at this folder, so you immediately get the new build.
+
+After you `git pull` yourself (or without git), you can run:
+
+```bash
+pnpm run cli:upgrade:pnpm
+```
+
+## Use in a test project
+
+1. Build / install CLI as above.
+2. Open an empty folder in Cursor.
+3. Run `orqint init`, then follow [AGENTS.md](AGENTS.md) and [docs/orqint-cursor-starter.md](docs/orqint-cursor-starter.md).
+
+## Use without global install
+
+```bash
+pnpm run build
+pnpm orqint -- help
+```
+
+Or `node dist/orqint/index.js help` from the repo root.

package/dist/orqint/commands/init.d.ts

@@ -0,0 +1,6 @@
+export type InitOptions = {
+    force?: boolean;
+    brownfield?: boolean;
+    migrateLegacy?: boolean;
+};
+export declare function runInit(cwd: string, opts: InitOptions): Promise<void>;

package/dist/orqint/commands/init.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const paths_1 = require("../engine/paths");
+const memory_1 = require("../utils/memory");
+const logger_1 = require("../utils/logger");
+async function runInit(cwd, opts) {
+    const root = (0, paths_1.orqintRoot)(cwd);
+    const memPath = (0, paths_1.memoryJsonPath)(cwd);
+    const exists = await fs.pathExists(memPath);
+    if (exists && !opts.force) {
+        throw new Error(`memory already exists at ${memPath}. Use --force to re-initialize template.`);
+    }
+    await fs.ensureDir(path.join(root, "core"));
+    await fs.ensureDir(path.join(root, "prompts"));
+    const bundledPrompts = path.join(__dirname, "../prompts");
+    const targetPrompts = path.join(root, "prompts");
+    if (await fs.pathExists(bundledPrompts)) {
+        await fs.copy(bundledPrompts, targetPrompts, { overwrite: false });
+    }
+    await fs.ensureDir(path.join(root, "commands"));
+    await fs.ensureDir(path.join(root, "engine"));
+    await fs.ensureDir(path.join(root, "utils"));
+    await fs.ensureDir(path.join(root, ".handoff"));
+    await fs.ensureDir((0, paths_1.orqintSpecDir)(cwd));
+    await fs.ensureDir((0, paths_1.orqintArchiveDir)(cwd));
+    let memory = (0, memory_1.ensureDefaults)(JSON.parse(JSON.stringify(memory_1.EMPTY_MEMORY)));
+    if (opts.brownfield) {
+        memory = await seedFromRepo(cwd, memory);
+    }
+    if (opts.migrateLegacy) {
+        await migrateLegacyFolder(cwd);
+    }
+    (0, memory_1.validateFoundation)(memory);
+    await (0, memory_1.writeMemory)(cwd, memory);
+    (0, logger_1.log)("info", "init_complete", { cwd, brownfield: !!opts.brownfield });
+}
+async function seedFromRepo(cwd, memory) {
+    const pkgPath = path.join(cwd, "package.json");
+    if (await fs.pathExists(pkgPath)) {
+        try {
+            const pkg = (await fs.readJson(pkgPath));
+            if (pkg.name && !memory.project.name) {
+                memory.project = { ...memory.project, name: pkg.name };
+            }
+            if (!memory.project.type) {
+                memory.project.type = inferProjectType(pkg);
+            }
+            memory.tech_stack = {
+                ...memory.tech_stack,
+                ...(pkg.dependencies ? { dependencies: pkg.dependencies } : {}),
+                ...(pkg.devDependencies
+                    ? { devDependencies: pkg.devDependencies }
+                    : {}),
+            };
+        }
+        catch {
+            (0, logger_1.log)("warn", "init_brownfield_package_read_failed", { path: pkgPath });
+        }
+    }
+    const readme = path.join(cwd, "README.md");
+    if ((await fs.pathExists(readme)) && memory.goals.length === 0) {
+        const snippet = (await fs.readFile(readme, "utf8")).slice(0, 400);
+        if (snippet.trim()) {
+            const line = snippet.split("\n")[0]?.slice(0, 200) ?? "See README.md";
+            memory.goals = [`(from README) ${line}`];
+        }
+    }
+    return (0, memory_1.ensureDefaults)(memory);
+}
+function inferProjectType(pkg) {
+    const all = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    };
+    if (all["next"]) {
+        return "nextjs";
+    }
+    if (all["react"]) {
+        return "react";
+    }
+    if (all["express"]) {
+        return "node";
+    }
+    return "unknown";
+}
+async function migrateLegacyFolder(cwd) {
+    const legacy = path.join(cwd, "legacy");
+    if (!(await fs.pathExists(legacy))) {
+        (0, logger_1.log)("info", "migrate_legacy_skip", { reason: "no ./legacy directory" });
+        return;
+    }
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const dest = path.join((0, paths_1.orqintArchiveDir)(cwd), `legacy-${stamp}`);
+    await fs.ensureDir((0, paths_1.orqintArchiveDir)(cwd));
+    await fs.move(legacy, dest);
+    (0, logger_1.log)("info", "legacy_migrated", { from: legacy, to: dest });
+}

package/dist/orqint/commands/plan.d.ts

@@ -0,0 +1,7 @@
+export declare function planPrepare(cwd: string): Promise<{
+    handoffPath: string;
+}>;
+export declare function planPrepareAllowLowConfidence(cwd: string): Promise<{
+    handoffPath: string;
+}>;
+export declare function planApply(cwd: string, responseFile: string, force: boolean): Promise<void>;

package/dist/orqint/commands/plan.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planPrepare = planPrepare;
+exports.planPrepareAllowLowConfidence = planPrepareAllowLowConfidence;
+exports.planApply = planApply;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const context_1 = require("../engine/context");
+const handoff_1 = require("../engine/handoff");
+const memory_1 = require("../utils/memory");
+const parser_1 = require("../utils/parser");
+const confidence_1 = require("../engine/confidence");
+const paths_1 = require("../engine/paths");
+const logger_1 = require("../utils/logger");
+async function planPrepare(cwd) {
+    const memory = await (0, memory_1.readMemory)(cwd);
+    if (!(0, confidence_1.canStartPlan)(memory.confidence, false)) {
+        throw new Error(`confidence ${memory.confidence} < ${confidence_1.CONFIDENCE_BLOCK}: run think apply first or use plan prepare --force (not recommended)`);
+    }
+    const slice = (0, context_1.sliceForPlan)(memory);
+    const handoffPath = await (0, handoff_1.writePlanHandoff)(cwd, slice);
+    (0, logger_1.log)("info", "plan_prepare_done", { handoffPath });
+    return { handoffPath };
+}
+async function planPrepareAllowLowConfidence(cwd) {
+    const memory = await (0, memory_1.readMemory)(cwd);
+    const slice = (0, context_1.sliceForPlan)(memory);
+    const handoffPath = await (0, handoff_1.writePlanHandoff)(cwd, slice);
+    (0, logger_1.log)("warn", "plan_prepare_forced_low_confidence", {
+        confidence: memory.confidence,
+    });
+    return { handoffPath };
+}
+async function planApply(cwd, responseFile, force) {
+    const memory = await (0, memory_1.readMemory)(cwd);
+    if (!(0, confidence_1.canStartPlan)(memory.confidence, force)) {
+        throw new Error(`confidence ${memory.confidence} < ${confidence_1.CONFIDENCE_BLOCK}: run think apply or pass --force`);
+    }
+    const rawText = await fs.readFile(responseFile, "utf8");
+    const parsed = (0, parser_1.parseJsonFromText)(rawText);
+    const payload = validatePlanPayload(parsed);
+    const next = mergePlanIntoMemory(memory, payload);
+    await (0, memory_1.writeMemory)(cwd, next);
+    await writePlanSpec(cwd, next);
+    (0, logger_1.log)("info", "plan_apply_done", { responseFile });
+}
+function validatePlanPayload(parsed) {
+    for (const key of ["features", "flows", "pages", "states"]) {
+        if (!Array.isArray(parsed[key])) {
+            throw new Error(`plan response: missing array \`${key}\``);
+        }
+    }
+    return parsed;
+}
+function mergePlanIntoMemory(memory, p) {
+    const edge = Array.isArray(p.edge_cases) && p.edge_cases.every((e) => typeof e === "string")
+        ? p.edge_cases
+        : memory.edge_cases;
+    return {
+        ...memory,
+        features: p.features ?? memory.features,
+        flows: p.flows ?? memory.flows,
+        pages: p.pages ?? memory.pages,
+        states: p.states ?? memory.states,
+        edge_cases: edge,
+    };
+}
+async function writePlanSpec(cwd, memory) {
+    const dir = (0, paths_1.orqintSpecDir)(cwd);
+    await fs.ensureDir(dir);
+    const summary = path.join(dir, "plan-summary.md");
+    const body = `# Plan summary (derived — do not treat as source of truth)
+
+Canonical state remains \`orqint/core/memory.json\`.
+
+## Features
+
+\`\`\`json
+${JSON.stringify(memory.features, null, 2)}
+\`\`\`
+
+## Flows
+
+\`\`\`json
+${JSON.stringify(memory.flows, null, 2)}
+\`\`\`
+
+## Pages
+
+\`\`\`json
+${JSON.stringify(memory.pages, null, 2)}
+\`\`\`
+
+## States
+
+\`\`\`json
+${JSON.stringify(memory.states, null, 2)}
+\`\`\`
+
+## Edge cases
+
+${memory.edge_cases.map((e) => `- ${e}`).join("\n") || "(none)"}
+`;
+    await fs.writeFile(summary, body, "utf8");
+}

package/dist/orqint/commands/think.d.ts

@@ -0,0 +1,8 @@
+export declare function thinkPrepare(cwd: string, userIntent: string, overrides: Record<string, boolean | string>): Promise<{
+    handoffPath: string;
+    stdout?: string;
+}>;
+export declare function thinkApply(cwd: string, responseFile: string): Promise<{
+    exitCode: number;
+    messages: string[];
+}>;

package/dist/orqint/commands/think.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thinkPrepare = thinkPrepare;
+exports.thinkApply = thinkApply;
+const fs = __importStar(require("fs-extra"));
+const context_1 = require("../engine/context");
+const handoff_1 = require("../engine/handoff");
+const memory_1 = require("../utils/memory");
+const parser_1 = require("../utils/parser");
+const confidence_1 = require("../engine/confidence");
+const logger_1 = require("../utils/logger");
+async function thinkPrepare(cwd, userIntent, overrides) {
+    let memory = await (0, memory_1.readMemory)(cwd);
+    if (Object.keys(overrides).length > 0) {
+        memory = {
+            ...memory,
+            override: { ...memory.override, ...overrides },
+        };
+        await (0, memory_1.writeMemory)(cwd, memory);
+    }
+    const slice = (0, context_1.sliceForThink)(memory, userIntent);
+    const handoffPath = await (0, handoff_1.writeThinkHandoff)(cwd, userIntent, slice);
+    (0, logger_1.log)("info", "think_prepare_done", { handoffPath });
+    return { handoffPath };
+}
+async function thinkApply(cwd, responseFile) {
+    const rawText = await fs.readFile(responseFile, "utf8");
+    const parsed = (0, parser_1.parseJsonFromText)(rawText);
+    const payload = validateThinkPayload(parsed);
+    let memory = await (0, memory_1.readMemory)(cwd);
+    memory = mergeThinkIntoMemory(memory, payload);
+    await (0, memory_1.writeMemory)(cwd, memory);
+    const outcome = (0, confidence_1.evaluateAfterThink)(payload.confidence);
+    const messages = [
+        `Memory updated from ${responseFile}`,
+        ...outcome.messages,
+    ];
+    if (memory.open_questions.length > 0 && payload.confidence < 0.8) {
+        messages.push("Open questions:\n- " + memory.open_questions.join("\n- "));
+    }
+    (0, logger_1.log)("info", "think_apply_done", {
+        confidence: payload.confidence,
+        exitCode: outcome.exitCode,
+    });
+    return { exitCode: outcome.exitCode, messages };
+}
+function validateThinkPayload(parsed) {
+    if (typeof parsed.confidence !== "number" || Number.isNaN(parsed.confidence)) {
+        throw new Error("think response: missing or invalid numeric `confidence`");
+    }
+    const oq = parsed.open_questions;
+    if (!Array.isArray(oq)) {
+        throw new Error("think response: `open_questions` must be an array");
+    }
+    const questions = oq.filter((x) => typeof x === "string");
+    if (questions.length > 5) {
+        throw new Error("think response: at most 5 open_questions allowed");
+    }
+    return {
+        ...parsed,
+        confidence: parsed.confidence,
+        open_questions: questions,
+    };
+}
+function mergeThinkIntoMemory(memory, p) {
+    const project = { ...memory.project };
+    if (p.project && typeof p.project === "object") {
+        const pr = p.project;
+        if (typeof pr.name === "string") {
+            project.name = pr.name;
+        }
+        if (typeof pr.type === "string") {
+            project.type = pr.type;
+        }
+        if (typeof pr.description === "string") {
+            project.description = pr.description;
+        }
+    }
+    if (typeof p.project_type === "string" && p.project_type.trim()) {
+        if (!project.type) {
+            project.type = p.project_type.trim();
+        }
+    }
+    const goals = Array.isArray(p.goals) && p.goals.every((g) => typeof g === "string")
+        ? p.goals
+        : memory.goals;
+    const open_questions = p.open_questions ?? memory.open_questions;
+    const unknowns = Array.isArray(p.unknowns)
+        ? p.unknowns.filter((u) => typeof u === "string")
+        : memory.unknowns;
+    const requires_input = typeof p.requires_input === "boolean"
+        ? p.requires_input
+        : memory.requires_input;
+    let tech_stack = memory.tech_stack;
+    if (p.tech_stack && typeof p.tech_stack === "object") {
+        tech_stack = (0, memory_1.deepMergeTechStack)(memory.tech_stack, p.tech_stack);
+    }
+    return {
+        ...memory,
+        project,
+        goals,
+        open_questions,
+        confidence: p.confidence,
+        unknowns,
+        requires_input,
+        tech_stack,
+    };
+}

package/dist/orqint/commands/update.d.ts

@@ -0,0 +1,5 @@
+import type { PackageMeta } from "../package-meta";
+/**
+ * Check npm registry for a newer version; optionally re-invoke via npx @latest.
+ */
+export declare function runUpdate(meta: PackageMeta, install: boolean, forwardArgs: string[]): void;

package/dist/orqint/commands/update.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpdate = runUpdate;
+const child_process_1 = require("child_process");
+function compareSemver(a, b) {
+    const pa = a.split(/[.+]/).map((x) => parseInt(x, 10) || 0);
+    const pb = b.split(/[.+]/).map((x) => parseInt(x, 10) || 0);
+    const n = Math.max(pa.length, pb.length);
+    for (let i = 0; i < n; i++) {
+        const da = pa[i] ?? 0;
+        const db = pb[i] ?? 0;
+        if (da < db) {
+            return -1;
+        }
+        if (da > db) {
+            return 1;
+        }
+    }
+    return 0;
+}
+function fetchLatestFromNpm(name) {
+    try {
+        const out = (0, child_process_1.execFileSync)("npm", ["view", name, "version"], {
+            encoding: "utf8",
+            timeout: 20_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check npm registry for a newer version; optionally re-invoke via npx @latest.
+ */
+function runUpdate(meta, install, forwardArgs) {
+    const latest = fetchLatestFromNpm(meta.name);
+    if (!latest) {
+        console.error(`Could not read latest version from npm for "${meta.name}".`);
+        console.error("The package may be unpublished, or npm/registry is unreachable.");
+        console.error(`This CLI build: ${meta.name}@${meta.version}`);
+        if (install) {
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    const newer = compareSemver(latest, meta.version) > 0;
+    if (!newer) {
+        console.error(`orqint is up to date (${meta.version}).`);
+        process.exit(0);
+    }
+    console.error(`Current:  ${meta.version}`);
+    console.error(`Latest:   ${latest}`);
+    console.error("");
+    console.error(`Use a fresh run with npx:`);
+    console.error(`  npx --yes ${meta.name}@latest <command>`);
+    console.error("");
+    if (install) {
+        const r = (0, child_process_1.spawnSync)("npx", ["--yes", `${meta.name}@latest`, ...forwardArgs], { stdio: "inherit", shell: process.platform === "win32" });
+        process.exit(r.status === null ? 1 : r.status);
+    }
+    process.exit(0);
+}

package/dist/orqint/engine/confidence.d.ts

@@ -0,0 +1,10 @@
+/** CGR-005 thresholds (tunable). */
+export declare const CONFIDENCE_BLOCK = 0.6;
+export declare const CONFIDENCE_ASK = 0.8;
+export declare const CONFIDENCE_PROCEED = 0.9;
+export type ConfidenceOutcome = {
+    exitCode: number;
+    messages: string[];
+};
+export declare function evaluateAfterThink(confidence: number): ConfidenceOutcome;
+export declare function canStartPlan(confidence: number, force: boolean): boolean;

package/dist/orqint/engine/confidence.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIDENCE_PROCEED = exports.CONFIDENCE_ASK = exports.CONFIDENCE_BLOCK = void 0;
+exports.evaluateAfterThink = evaluateAfterThink;
+exports.canStartPlan = canStartPlan;
+/** CGR-005 thresholds (tunable). */
+exports.CONFIDENCE_BLOCK = 0.6;
+exports.CONFIDENCE_ASK = 0.8;
+exports.CONFIDENCE_PROCEED = 0.9;
+function evaluateAfterThink(confidence) {
+    const messages = [];
+    if (confidence < exports.CONFIDENCE_BLOCK) {
+        messages.push(`[CGR-005] confidence ${confidence} < ${exports.CONFIDENCE_BLOCK}: blocked for planning until you raise confidence (answer open_questions and re-run think apply).`);
+        return { exitCode: 2, messages };
+    }
+    if (confidence < exports.CONFIDENCE_ASK) {
+        messages.push(`[CGR-005] confidence ${confidence} < ${exports.CONFIDENCE_ASK}: review open_questions before planning.`);
+    }
+    if (confidence >= exports.CONFIDENCE_PROCEED) {
+        messages.push(`[CGR-005] confidence ${confidence} >= ${exports.CONFIDENCE_PROCEED}: ready to run plan prepare.`);
+    }
+    return { exitCode: 0, messages };
+}
+function canStartPlan(confidence, force) {
+    if (force) {
+        return true;
+    }
+    return confidence >= exports.CONFIDENCE_BLOCK;
+}