@relentlessbuild/decs-mcp 0.2.0

package/README.md

@@ -0,0 +1,54 @@
+# Relentless DECS MCP
+
+DECS (Decision-Embedded Context System) as an MCP server for Codex, Claude Desktop, and other MCP clients.
+
+## Fast Path: Codex Setup
+
+Use one command and follow prompts:
+
+```bash
+npx @relentless/decs-mcp setup codex --repo /path/to/your/repo
+```
+
+Local clone flow:
+
+```bash
+git clone https://github.com/RelentlessToph/relentless-decs.git
+cd relentless-decs
+./install-codex.sh /path/to/your/repo
+```
+
+This local clone flow configures MCP using your local `dist/index.js` path (no npm publish required).
+
+Then in Codex:
+
+```text
+npx @relentless/decs-mcp init <project-node-id> [project-name] --repo /path/to/your/repo
+```
+
+## Command Summary
+
+- `relentless-decs-mcp serve`
+- `relentless-decs-mcp setup codex [--repo <path>] [--yes] [--dry-run] [--no-prompts] [--use-local-server]`
+- `relentless-decs-mcp setup claude-desktop [--platform macos|windows] [--yes] [--dry-run] [--use-local-server]`
+- `relentless-decs-mcp doctor [--repo <path>]`
+- `relentless-decs-mcp init <project-node-id> [project-name] [--repo <path>] [--bootstrap]`
+
+## Docs
+
+- Codex quickstart: `docs/codex-quickstart.md`
+- MCP clients (Codex + Claude Desktop): `docs/mcp-clients.md`
+- Legacy Claude Code hook install: `docs/legacy-claude-code-hooks.md`
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm test
+npm run build
+```
+
+## License
+
+MIT

package/codex/AGENTS.md

@@ -0,0 +1,7 @@
+# Relentless DECS Workflow
+
+1. Before architecture-affecting work, call `decs_get_context`.
+2. Draft decisions with: title, what, why, purpose, constraints.
+3. Ask explicit confirmation before `decs_create` or `decs_update`.
+4. If a key decision is contradicted, explain it and ask whether to supersede.
+5. If `.decs.json` is missing, run DECS init flow first.

package/codex/prompts/decs-context.md

@@ -0,0 +1,5 @@
+Load current architectural decisions.
+
+1. Call `decs_get_context`.
+2. Render markdown context.
+3. Highlight key decisions and contradictions for current task.

package/codex/prompts/decs-init.md

@@ -0,0 +1,9 @@
+Initialize Relentless DECS for this repository.
+
+Arguments: `<project-node-id> [project-name]`
+
+1. Validate project node id.
+2. Call `decs_init_space`.
+3. Ask for confirmation to write `.decs.json`.
+4. Call `decs_write_repo_config`.
+5. Offer bootstrap key decision via `decs_create`.

package/codex/prompts/decs-log.md

@@ -0,0 +1,6 @@
+Log a new architectural decision.
+
+1. Collect: title, what, why, purpose, constraints, isKeyDecision.
+2. Show payload preview.
+3. Ask explicit confirmation.
+4. Call `decs_create`.

package/codex/prompts/decs-update.md

@@ -0,0 +1,7 @@
+Update an existing architectural decision.
+
+1. If id missing, list decisions via `decs_list`.
+2. Collect changed fields.
+3. Show patch preview.
+4. Ask explicit confirmation.
+5. Call `decs_update`.

package/dist/cli/args.js

@@ -0,0 +1,47 @@
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (!token) {
+            continue;
+        }
+        if (!token.startsWith("--")) {
+            positional.push(token);
+            continue;
+        }
+        const [rawKey, rawValue] = token.slice(2).split("=", 2);
+        if (!rawKey) {
+            continue;
+        }
+        if (rawValue !== undefined) {
+            flags[rawKey] = rawValue;
+            continue;
+        }
+        const next = argv[i + 1];
+        if (next && !next.startsWith("--")) {
+            flags[rawKey] = next;
+            i += 1;
+            continue;
+        }
+        flags[rawKey] = true;
+    }
+    return { positional, flags };
+}
+export function flagBoolean(flags, name, defaultValue = false) {
+    const value = flags[name];
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+export function flagString(flags, name) {
+    const value = flags[name];
+    if (typeof value === "string") {
+        return value;
+    }
+    return undefined;
+}

package/dist/cli/output.js

@@ -0,0 +1,12 @@
+export function logStep(message) {
+    process.stdout.write(`${message}\n`);
+}
+export function logWarn(message) {
+    process.stdout.write(`WARN: ${message}\n`);
+}
+export function logError(message) {
+    process.stderr.write(`ERROR: ${message}\n`);
+}
+export function logJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}

package/dist/cli/prompt.js

@@ -0,0 +1,43 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+function maskSecret(value) {
+    if (value.length <= 4) {
+        return "****";
+    }
+    return `${value.slice(0, 4)}***`;
+}
+export async function promptText(label, options) {
+    const rl = createInterface({ input, output });
+    try {
+        const suffix = options?.defaultValue ? ` [${options.defaultValue}]` : "";
+        const raw = await rl.question(`${label}${suffix}: `);
+        const value = raw.trim();
+        if (value.length > 0) {
+            if (options?.secret) {
+                output.write(`Saved ${label}: ${maskSecret(value)}\n`);
+            }
+            return value;
+        }
+        if (options?.defaultValue) {
+            return options.defaultValue;
+        }
+        return "";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptYesNo(label, defaultYes = true) {
+    const rl = createInterface({ input, output });
+    try {
+        const suffix = defaultYes ? " [Y/n]" : " [y/N]";
+        const raw = (await rl.question(`${label}${suffix}: `)).trim().toLowerCase();
+        if (!raw) {
+            return defaultYes;
+        }
+        return raw === "y" || raw === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/doctor.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import TOML from "@iarna/toml";
+import { getConfigPaths, resolveCredentials } from "../config.js";
+import { logStep } from "../cli/output.js";
+import { readRepoDecsConfig } from "../repo-config.js";
+import { getCodexUserConfigPath, resolveClaudeDesktopConfigPath } from "../install/paths.js";
+function printStatus(label, ok, detail) {
+    const status = ok ? "OK" : "MISSING";
+    logStep(`${status.padEnd(7)} ${label} - ${detail}`);
+}
+export function runDoctor(repoPath) {
+    logStep("Relentless DECS doctor");
+    logStep("");
+    const configPaths = getConfigPaths();
+    printStatus("Credentials file (~/.relentless/decs-config.json)", fs.existsSync(configPaths.defaultPath), configPaths.defaultPath);
+    printStatus("Legacy credentials file (~/.claude/decs-config.json)", fs.existsSync(configPaths.legacyPath), configPaths.legacyPath);
+    try {
+        const credentials = resolveCredentials();
+        printStatus("Resolved credentials", true, `URL=${credentials.baseUrl}, Buildspace=${credentials.buildspaceId}`);
+    }
+    catch (error) {
+        printStatus("Resolved credentials", false, error instanceof Error ? error.message : String(error));
+    }
+    const codexConfigPath = getCodexUserConfigPath();
+    if (fs.existsSync(codexConfigPath)) {
+        try {
+            const parsed = TOML.parse(fs.readFileSync(codexConfigPath, "utf8"));
+            const mcpServers = (parsed.mcp_servers ?? {});
+            const hasServer = Object.hasOwn(mcpServers, "relentless_decs");
+            printStatus("Codex MCP config", hasServer, codexConfigPath);
+        }
+        catch (error) {
+            printStatus("Codex MCP config", false, `Invalid TOML: ${codexConfigPath}`);
+        }
+    }
+    else {
+        printStatus("Codex MCP config", false, codexConfigPath);
+    }
+    try {
+        const claudePath = resolveClaudeDesktopConfigPath();
+        printStatus("Claude Desktop MCP config", fs.existsSync(claudePath), claudePath);
+    }
+    catch (error) {
+        printStatus("Claude Desktop MCP config (macOS)", false, "~/Library/Application Support/Claude/claude_desktop_config.json");
+        printStatus("Claude Desktop MCP config (Windows)", false, "%APPDATA%\\Claude\\claude_desktop_config.json");
+    }
+    try {
+        const repo = readRepoDecsConfig(repoPath);
+        printStatus("Repo .decs.json", true, `${repo.path} (space=${repo.config.relentlessSpaceId})`);
+    }
+    catch (error) {
+        printStatus("Repo .decs.json", false, error instanceof Error ? error.message : String(error));
+    }
+    const promptsPath = path.join(os.homedir(), ".codex", "prompts");
+    printStatus("Codex prompts directory", fs.existsSync(promptsPath), promptsPath);
+}

package/dist/commands/init.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { resolveCredentials } from "../config.js";
+import { logStep } from "../cli/output.js";
+import { writeRepoDecsConfig } from "../repo-config.js";
+import { RelentlessApiClient } from "../relentless-api.js";
+export async function runInit(options) {
+    const repoPath = path.resolve(options.repoPath);
+    const projectName = options.projectName ?? path.basename(repoPath);
+    const client = new RelentlessApiClient(resolveCredentials());
+    await client.getNode(options.projectNodeId);
+    const space = await client.createNode({
+        kind: "collection",
+        title: `${projectName} - Decisions`,
+        parentId: options.projectNodeId
+    });
+    const writeResult = writeRepoDecsConfig(space.id, repoPath);
+    logStep(`Created decisions space: ${space.title} (${space.id})`);
+    logStep(`Wrote ${writeResult.path}`);
+    if (options.createBootstrapDecision) {
+        await client.createNode({
+            kind: "decision",
+            title: "Use DECS for architectural decision tracking",
+            parentId: space.id,
+            content: {
+                what: "We adopted Relentless DECS for architectural decision tracking.",
+                why: "AI sessions are stateless and need explicit architectural memory.",
+                purpose: "Maintain architecture consistency and preserve rationale over time.",
+                constraints: "Significant architecture decisions must be captured as DECS entries.",
+                isKeyDecision: true
+            }
+        });
+        logStep("Created bootstrap key decision.");
+    }
+    logStep("Initialization complete.");
+}

package/dist/commands/setup-claude-desktop.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ensureParentDirectory, maybeBackupFile, readTextFileIfExists, writeTextFile } from "../install/fs-utils.js";
+import { resolveClaudeDesktopConfigPath } from "../install/paths.js";
+import { upsertClaudeDesktopServer } from "../install/json-merge.js";
+import { logStep } from "../cli/output.js";
+import { resolveCredentialsForSetup } from "./shared.js";
+const CLAUDE_SERVER_NAME = "relentless-decs";
+export async function runSetupClaudeDesktop(options) {
+    logStep("Configuring Relentless DECS for Claude Desktop...");
+    const { credentials, configPath, wroteConfig } = await resolveCredentialsForSetup({
+        yes: options.yes,
+        dryRun: options.dryRun
+    });
+    if (wroteConfig && configPath) {
+        logStep(`Saved credentials to ${configPath}`);
+    }
+    else {
+        logStep("Using credentials from environment or existing config.");
+    }
+    let command = "npx";
+    let args = ["-y", "@relentless/decs-mcp", "serve"];
+    if (options.useLocalServer) {
+        const localServerPath = path.resolve(process.cwd(), "dist", "index.js");
+        if (!fs.existsSync(localServerPath)) {
+            throw new Error(`Local server mode requested but ${localServerPath} does not exist. Run npm run build first.`);
+        }
+        command = "node";
+        args = [localServerPath, "serve"];
+    }
+    const claudeConfigPath = resolveClaudeDesktopConfigPath(options.platform);
+    const current = readTextFileIfExists(claudeConfigPath);
+    const { nextJson, changed } = upsertClaudeDesktopServer({
+        currentJson: current,
+        serverName: CLAUDE_SERVER_NAME,
+        serverConfig: {
+            command,
+            args,
+            env: {
+                RELENTLESS_API_KEY: credentials.relentlessApiKey,
+                RELENTLESS_URL: credentials.relentlessUrl,
+                RELENTLESS_BUILDSPACE_ID: credentials.buildspaceId
+            }
+        }
+    });
+    if (changed) {
+        if (options.dryRun) {
+            logStep(`[dry-run] Would update ${claudeConfigPath}`);
+        }
+        else {
+            ensureParentDirectory(claudeConfigPath);
+            maybeBackupFile(claudeConfigPath);
+            writeTextFile(claudeConfigPath, nextJson);
+            logStep(`Updated ${claudeConfigPath}`);
+        }
+    }
+    else {
+        logStep(`${claudeConfigPath} already has the DECS MCP server config.`);
+    }
+    logStep("");
+    logStep("Next steps:");
+    logStep("1) Fully restart Claude Desktop.");
+    logStep("2) Open Claude Desktop and verify relentless-decs appears in MCP tools.");
+}

package/dist/commands/setup-codex.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import fs from "node:fs";
+import { ensureParentDirectory, maybeBackupFile, readTextFileIfExists, writeTextFile } from "../install/fs-utils.js";
+import { getCodexPromptDirPath, getCodexUserConfigPath } from "../install/paths.js";
+import { upsertCodexMcpServer } from "../install/toml-merge.js";
+import { installPrompts, mergeAgentsBlock } from "../install/codex-assets.js";
+import { logStep, logWarn } from "../cli/output.js";
+import { resolveCredentialsForSetup } from "./shared.js";
+const CODEX_SERVER_NAME = "relentless_decs";
+export async function runSetupCodex(options) {
+    const repoPath = path.resolve(options.repoPath);
+    logStep("Configuring Relentless DECS for Codex...");
+    const { credentials, configPath, wroteConfig } = await resolveCredentialsForSetup({
+        yes: options.yes,
+        dryRun: options.dryRun
+    });
+    if (wroteConfig && configPath) {
+        logStep(`Saved credentials to ${configPath}`);
+    }
+    else {
+        logStep("Using credentials from environment or existing config.");
+    }
+    let command = "npx";
+    let args = ["-y", "@relentless/decs-mcp", "serve"];
+    if (options.useLocalServer) {
+        const localServerPath = path.resolve(process.cwd(), "dist", "index.js");
+        if (!fs.existsSync(localServerPath)) {
+            throw new Error(`Local server mode requested but ${localServerPath} does not exist. Run npm run build first.`);
+        }
+        command = "node";
+        args = [localServerPath, "serve"];
+    }
+    const codexConfigPath = getCodexUserConfigPath();
+    const currentToml = readTextFileIfExists(codexConfigPath);
+    const { nextToml, changed } = upsertCodexMcpServer({
+        currentToml,
+        serverName: CODEX_SERVER_NAME,
+        serverConfig: {
+            command,
+            args,
+            env: {
+                RELENTLESS_API_KEY: credentials.relentlessApiKey,
+                RELENTLESS_URL: credentials.relentlessUrl,
+                RELENTLESS_BUILDSPACE_ID: credentials.buildspaceId
+            }
+        }
+    });
+    if (changed) {
+        if (options.dryRun) {
+            logStep(`[dry-run] Would update ${codexConfigPath}`);
+        }
+        else {
+            ensureParentDirectory(codexConfigPath);
+            maybeBackupFile(codexConfigPath);
+            writeTextFile(codexConfigPath, nextToml);
+            logStep(`Updated ${codexConfigPath}`);
+        }
+    }
+    else {
+        logStep(`${codexConfigPath} already has the DECS MCP server config.`);
+    }
+    if (!options.noPrompts) {
+        const promptDir = getCodexPromptDirPath();
+        if (options.dryRun) {
+            logStep(`[dry-run] Would install DECS prompts into ${promptDir}`);
+        }
+        else {
+            const installed = installPrompts(promptDir);
+            logStep(`Installed ${installed.files.length} prompt files in ${promptDir}`);
+        }
+    }
+    else {
+        logWarn("Skipped prompt installation (--no-prompts).");
+    }
+    if (options.dryRun) {
+        logStep(`[dry-run] Would merge DECS guidance into ${path.join(repoPath, "AGENTS.md")}`);
+    }
+    else {
+        const agents = mergeAgentsBlock(repoPath);
+        if (agents.changed) {
+            logStep(`Updated ${agents.path}`);
+        }
+        else {
+            logStep(`${agents.path} already contains current DECS guidance.`);
+        }
+    }
+    logStep("");
+    logStep("Next steps:");
+    logStep("1) Restart Codex.");
+    logStep("2) In your repo, run: npx @relentless/decs-mcp init <project-node-id> [project-name] --repo .");
+    logStep("3) Optional in-chat command: /prompts:decs-init <project-node-id> [project-name]");
+}

package/dist/commands/shared.js

@@ -0,0 +1,35 @@
+import { readUserConfigFromDisk, writeUserConfigToDisk } from "../config.js";
+import { promptText } from "../cli/prompt.js";
+function normalizeUrl(url) {
+    return url.replace(/\/+$/, "");
+}
+export async function resolveCredentialsForSetup(options) {
+    const existing = readUserConfigFromDisk();
+    let apiKey = process.env.RELENTLESS_API_KEY ?? existing.relentlessApiKey ?? "";
+    let relentlessUrl = process.env.RELENTLESS_URL ?? existing.relentlessUrl ?? "https://relentless.build";
+    let buildspaceId = process.env.RELENTLESS_BUILDSPACE_ID ?? existing.buildspaceId ?? "";
+    if (!options.yes) {
+        if (!apiKey) {
+            apiKey = await promptText("Relentless API key", { secret: true });
+        }
+        relentlessUrl = await promptText("Relentless URL", {
+            defaultValue: relentlessUrl
+        });
+        if (!buildspaceId) {
+            buildspaceId = await promptText("Relentless buildspace id");
+        }
+    }
+    if (!apiKey || !relentlessUrl || !buildspaceId) {
+        throw new Error("Missing credentials. Provide RELENTLESS_API_KEY, RELENTLESS_URL, RELENTLESS_BUILDSPACE_ID or run setup without --yes for prompts.");
+    }
+    const credentials = {
+        relentlessApiKey: apiKey,
+        relentlessUrl: normalizeUrl(relentlessUrl),
+        buildspaceId
+    };
+    if (options.dryRun) {
+        return { credentials, configPath: null, wroteConfig: false };
+    }
+    const wroteConfigPath = writeUserConfigToDisk(credentials);
+    return { credentials, configPath: wroteConfigPath, wroteConfig: true };
+}

package/dist/config.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { DecsError } from "./errors.js";
+const CONFIG_SCHEMA = z.object({
+    relentlessApiKey: z.string().trim().min(1).optional(),
+    relentlessUrl: z.string().trim().min(1).optional(),
+    buildspaceId: z.string().trim().min(1).optional()
+});
+const REQUIRED_SCHEMA = z.object({
+    relentlessApiKey: z.string().trim().min(1),
+    relentlessUrl: z.string().trim().min(1),
+    buildspaceId: z.string().trim().min(1)
+});
+function resolvePathConfig() {
+    return {
+        defaultPath: path.join(os.homedir(), ".relentless", "decs-config.json"),
+        legacyPath: path.join(os.homedir(), ".claude", "decs-config.json")
+    };
+}
+function readConfigFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new DecsError("CONFIG_ERROR", `Invalid JSON in config file: ${filePath}`, error);
+    }
+    const result = CONFIG_SCHEMA.safeParse(parsed);
+    if (!result.success) {
+        throw new DecsError("CONFIG_ERROR", `Invalid config shape in file: ${filePath}`, result.error.flatten());
+    }
+    return result.data;
+}
+function ensureConfigDirectory(filePath) {
+    const directory = path.dirname(filePath);
+    fs.mkdirSync(directory, { recursive: true });
+}
+function trimTrailingSlash(url) {
+    return url.replace(/\/+$/, "");
+}
+export function resolveCredentials() {
+    const { defaultPath, legacyPath } = resolvePathConfig();
+    const legacyConfig = readConfigFile(legacyPath);
+    const defaultConfig = readConfigFile(defaultPath);
+    const fileConfig = {
+        ...legacyConfig,
+        ...defaultConfig
+    };
+    const mergedConfig = {
+        relentlessApiKey: process.env.RELENTLESS_API_KEY ?? fileConfig.relentlessApiKey,
+        relentlessUrl: process.env.RELENTLESS_URL ?? fileConfig.relentlessUrl,
+        buildspaceId: process.env.RELENTLESS_BUILDSPACE_ID ?? fileConfig.buildspaceId
+    };
+    const parsed = REQUIRED_SCHEMA.safeParse(mergedConfig);
+    if (!parsed.success) {
+        throw new DecsError("CONFIG_ERROR", "Missing Relentless credentials. Set RELENTLESS_API_KEY, RELENTLESS_URL, RELENTLESS_BUILDSPACE_ID or configure ~/.relentless/decs-config.json", parsed.error.flatten());
+    }
+    return {
+        apiKey: parsed.data.relentlessApiKey,
+        baseUrl: trimTrailingSlash(parsed.data.relentlessUrl),
+        buildspaceId: parsed.data.buildspaceId
+    };
+}
+export function getConfigPaths() {
+    return resolvePathConfig();
+}
+export function readUserConfigFromDisk() {
+    const { defaultPath, legacyPath } = resolvePathConfig();
+    const legacyConfig = readConfigFile(legacyPath);
+    const defaultConfig = readConfigFile(defaultPath);
+    return {
+        ...legacyConfig,
+        ...defaultConfig
+    };
+}
+export function writeUserConfigToDisk(config) {
+    const { defaultPath } = resolvePathConfig();
+    ensureConfigDirectory(defaultPath);
+    fs.writeFileSync(defaultPath, `${JSON.stringify({
+        relentlessApiKey: config.relentlessApiKey,
+        relentlessUrl: trimTrailingSlash(config.relentlessUrl),
+        buildspaceId: config.buildspaceId
+    }, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600
+    });
+    return defaultPath;
+}

package/dist/decision-context.js

@@ -0,0 +1,71 @@
+function asString(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return "—";
+}
+function asBoolean(value) {
+    return value === true;
+}
+export function toDecisionSummary(node) {
+    const content = (node.content ?? {});
+    return {
+        id: node.id,
+        title: node.title,
+        updatedAt: node.updatedAt,
+        what: asString(content.what),
+        why: asString(content.why),
+        purpose: asString(content.purpose),
+        constraints: asString(content.constraints),
+        isKeyDecision: asBoolean(content.isKeyDecision)
+    };
+}
+function sortNewestFirst(items) {
+    return [...items].sort((a, b) => {
+        const aTime = a.updatedAt ? Date.parse(a.updatedAt) : 0;
+        const bTime = b.updatedAt ? Date.parse(b.updatedAt) : 0;
+        return bTime - aTime;
+    });
+}
+export function partitionDecisions(decisions, recentLimit = 10) {
+    const sorted = sortNewestFirst(decisions);
+    const keyDecisions = sorted.filter((decision) => decision.isKeyDecision);
+    const recentDecisions = sorted
+        .filter((decision) => !decision.isKeyDecision)
+        .slice(0, recentLimit);
+    return { keyDecisions, recentDecisions };
+}
+function renderDecision(decision) {
+    const updated = decision.updatedAt
+        ? `**Updated:** ${decision.updatedAt.split("T")[0]}`
+        : "**Updated:** —";
+    return [
+        `## ${decision.title}`,
+        updated,
+        "",
+        `**What:** ${decision.what}`,
+        `**Why:** ${decision.why}`,
+        `**Purpose:** ${decision.purpose}`,
+        `**Constraints:** ${decision.constraints}`,
+        "",
+        "---",
+        ""
+    ].join("\n");
+}
+export function renderDecisionContextMarkdown(input) {
+    const sections = ["=== DECS: Prior Architectural Decisions ===", ""];
+    if (input.keyDecisions.length > 0) {
+        sections.push("### Key Decisions (always active)", "");
+        for (const decision of input.keyDecisions) {
+            sections.push(renderDecision(decision));
+        }
+    }
+    if (input.recentDecisions.length > 0) {
+        sections.push("### Recent Decisions", "");
+        for (const decision of input.recentDecisions) {
+            sections.push(renderDecision(decision));
+        }
+    }
+    sections.push("When making architectural decisions, consider how they relate to the above.", "Key decisions marked above are foundational and should only be changed deliberately.");
+    return sections.join("\n");
+}

package/dist/errors.js

@@ -0,0 +1,19 @@
+export class DecsError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "DecsError";
+        this.code = code;
+        this.details = details;
+    }
+}
+export function toDecsError(error) {
+    if (error instanceof DecsError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new DecsError("UPSTREAM_ERROR", error.message);
+    }
+    return new DecsError("UPSTREAM_ERROR", "Unknown error");
+}