@context-os/cli 1.0.0

package/dist/packages/core/src/index.js

@@ -0,0 +1,88 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+/**
+ * Discovers the workspace root by looking for root/soul.md in parent directories.
+ */
+export function findWorkspaceRoot() {
+    let current = process.cwd();
+    const root = path.parse(current).root;
+    while (current !== root) {
+        if (fs.existsSync(path.join(current, "root", "soul.md"))) {
+            return fs.realpathSync(current);
+        }
+        current = path.dirname(current);
+    }
+    return fs.realpathSync(process.cwd()); // Fallback to CWD
+}
+export const workspaceRoot = findWorkspaceRoot();
+/**
+ * Standard ContextOS "Buckets" for security isolation.
+ */
+export const ALLOWED_BUCKETS = [
+    "projects",
+    "knowledge",
+    "schemas",
+    "archive",
+    "log",
+    "orgs",
+    "root"
+];
+/**
+ * Validates that a path is within the workspace root and inside an allowed bucket.
+ */
+export function validatePath(requestedPath) {
+    const resolvedPath = path.resolve(workspaceRoot, requestedPath);
+    let fullPath;
+    try {
+        fullPath = fs.realpathSync(resolvedPath);
+    }
+    catch (e) {
+        fullPath = resolvedPath;
+    }
+    const relativePath = path.relative(workspaceRoot, fullPath);
+    // Security check: must be within the workspace root
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+        throw new Error(`Security violation: Path ${requestedPath} is outside the allowed ContextOS workspace root.`);
+    }
+    // Enterprise check: must be within an allowed bucket
+    const isAllowed = ALLOWED_BUCKETS.some(bucket => {
+        const bucketRoot = path.join(workspaceRoot, bucket);
+        const bucketRelative = path.relative(bucketRoot, fullPath);
+        return !bucketRelative.startsWith("..") && !path.isAbsolute(bucketRelative);
+    });
+    if (!isAllowed) {
+        throw new Error(`Security violation: Path ${requestedPath} is outside the allowed bucket (projects, orgs, knowledge, schemas, etc).`);
+    }
+    return { fullPath, relativePath };
+}
+/**
+ * Checks if a path is in a read-only bucket for agents.
+ */
+export function isReadOnly(filePath) {
+    const { fullPath } = validatePath(filePath);
+    const readOnlyBuckets = ["knowledge", "schemas", "root"];
+    return readOnlyBuckets.some(bucket => {
+        const bucketRoot = path.join(workspaceRoot, bucket);
+        const bucketRelative = path.relative(bucketRoot, fullPath);
+        return !bucketRelative.startsWith("..") && !path.isAbsolute(bucketRelative);
+    });
+}
+/**
+ * Executes an atomic git transaction (Add + Commit).
+ */
+export async function gitCommit(filePath, message) {
+    return new Promise((resolve, reject) => {
+        const add = spawn("git", ["add", filePath], { cwd: workspaceRoot });
+        add.on("close", (code) => {
+            if (code !== 0 && code !== null) {
+                return reject(new Error(`Git add failed with code ${code}`));
+            }
+            const commit = spawn("git", ["commit", "-m", message], { cwd: workspaceRoot });
+            commit.on("close", (code) => {
+                // If code is not 0, it might be "nothing to commit" which is fine for our tools
+                resolve();
+            });
+        });
+    });
+}

package/dist/workspace-cli/src/commands/archive.js

@@ -0,0 +1,51 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { gitCommit } from "../utils.js";
+export function archiveCommand(program) {
+    program
+        .command("archive")
+        .description("Move a completed project to the archive and extract learnings")
+        .argument("<project>", "Project name to archive")
+        .action(async (project) => {
+        const spinner = ora(`Archiving project ${chalk.cyan(project)}...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            const projectDir = path.join(workspaceRoot, "projects", project);
+            const archiveDir = path.join(workspaceRoot, "archive", "projects", project);
+            if (!(await fs.pathExists(projectDir))) {
+                spinner.fail(chalk.red(`Project ${project} not found in projects/`));
+                return;
+            }
+            spinner.text = `Applying #cold tags recursively to ${project}...`;
+            const projectFiles = await fs.readdir(projectDir, { recursive: true });
+            for (const file of projectFiles) {
+                const filePath = path.join(projectDir, file);
+                if ((await fs.stat(filePath)).isFile() && filePath.endsWith(".md")) {
+                    let content = await fs.readFile(filePath, "utf-8");
+                    const activeTags = ["#hot", "#warm"];
+                    let modified = false;
+                    activeTags.forEach(t => {
+                        if (content.includes(t)) {
+                            content = content.replace(new RegExp(`${t}`, 'g'), '#cold');
+                            modified = true;
+                        }
+                    });
+                    if (modified) {
+                        await fs.writeFile(filePath, content, "utf-8");
+                    }
+                }
+            }
+            spinner.text = `Moving ${project} to archive...`;
+            await fs.ensureDir(path.dirname(archiveDir));
+            await fs.move(projectDir, archiveDir, { overwrite: true });
+            await gitCommit(archiveDir, `feat(cli): archive project ${project}`);
+            spinner.succeed(chalk.green(`Project ${project} archived successfully to archive/projects/${project}`));
+            console.log(chalk.yellow(`\n[Intelligence] Archive complete. Next step: 'workspace extract ${project}' to distill learnings.`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Archive failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/context.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function contextCommand(program) {
+    program
+        .command("context")
+        .description("Print agent boot context for a project")
+        .argument("<project>", "Project name")
+        .action(async (project) => {
+        const spinner = ora(`Loading context for ${chalk.cyan(project)}...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            const projectDir = path.join(workspaceRoot, "projects", project);
+            if (!(await fs.pathExists(projectDir))) {
+                spinner.fail(chalk.red(`Project ${project} not found.`));
+                return;
+            }
+            const files = ["CONTEXT.md", "memory.md", "tasks/active.md"];
+            let aggregatedContext = `\n${chalk.bold("--- 🚀 BOOT CONTEXT: " + project + " ---")}\n`;
+            for (const file of files) {
+                const filePath = path.join(projectDir, file);
+                if (await fs.pathExists(filePath)) {
+                    const content = await fs.readFile(filePath, "utf-8");
+                    aggregatedContext += `\n${chalk.yellow("📁 " + file)}\n${content}\n`;
+                }
+            }
+            spinner.succeed(chalk.green(`Loaded context for ${project}`));
+            console.log(aggregatedContext);
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Context failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/decide.js

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { gitCommit } from "../utils.js";
+export function decideCommand(program) {
+    program
+        .command("decide")
+        .description("Log an architectural decision (ADR)")
+        .argument("<project>", "Project name")
+        .argument("<title>", "Decision title")
+        .argument("<context>", "Context of the decision")
+        .argument("<decision>", "The decision made")
+        .argument("<rationale>", "Rationale for the decision")
+        .action(async (project, title, context, decision, rationale) => {
+        const spinner = ora(`Logging decision for ${chalk.cyan(project)}...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            const projectDir = path.join(workspaceRoot, "projects", project);
+            const decisionsFile = path.join(projectDir, "decisions.md");
+            if (!(await fs.pathExists(projectDir))) {
+                spinner.fail(chalk.red(`Project ${project} does not exist.`));
+                return;
+            }
+            const date = new Date().toISOString().split("T")[0];
+            const adrId = `ADR-${Math.floor(Math.random() * 10000).toString().padStart(4, "0")}`;
+            const adrContent = `
+## [${adrId}] ${title}
+
+#hot
+
+- **Date**: ${date}
+- **Status**: Accepted
+- **Context**: ${context}
+- **Decision**: ${decision}
+- **Rationale**: ${rationale}
+\n---\n`;
+            await fs.ensureDir(path.dirname(decisionsFile));
+            await fs.appendFile(decisionsFile, adrContent, "utf-8");
+            await gitCommit(decisionsFile, `feat(cli): log decision ${adrId} for ${project}`);
+            spinner.succeed(chalk.green(`Logged decision ${adrId} in ${project}/decisions.md`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Decide failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/extract.js

@@ -0,0 +1,50 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function extractCommand(program) {
+    program
+        .command("extract")
+        .description("Analyze project context and help distill learnings into the Knowledge Base")
+        .argument("<project>", "Project name to analyze")
+        .action(async (project) => {
+        const spinner = ora(`Analyzing project ${chalk.cyan(project)} for intelligence distillation...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            const projectDir = path.join(workspaceRoot, "projects", project);
+            const archiveDir = path.join(workspaceRoot, "archive", "projects", project);
+            // Check in projects/ or archive/projects/
+            const targetPath = (await fs.pathExists(projectDir)) ? projectDir :
+                (await fs.pathExists(archiveDir)) ? archiveDir : null;
+            if (!targetPath) {
+                spinner.fail(chalk.red(`Project ${project} not found in projects/ or archive/projects/`));
+                return;
+            }
+            const decisionsFile = path.join(targetPath, "decisions.md");
+            const memoryFile = path.join(targetPath, "memory.md");
+            const insights = [];
+            if (await fs.pathExists(decisionsFile)) {
+                const content = await fs.readFile(decisionsFile, "utf-8");
+                const decisionCount = (content.match(/\[ADR-\d+\]/g) || []).length;
+                insights.push(`${chalk.cyan(decisionCount)} architectural decisions found in decisions.md`);
+            }
+            else {
+                insights.push(chalk.yellow(`Warning: No decisions.md found for ADR extraction.`));
+            }
+            if (await fs.pathExists(memoryFile)) {
+                insights.push(`Project memory file found for context distillation.`);
+            }
+            spinner.succeed(chalk.green(`Analysis of ${project} complete.`));
+            console.log(chalk.bold("\n--- Extraction Guide ---"));
+            insights.forEach(insight => console.log(`- ${insight}`));
+            console.log(chalk.cyan("\n[Intelligence Layer] Next steps:"));
+            console.log(`1. Review the ADRs in ${targetPath}/decisions.md`);
+            console.log(`2. Distill reusable patterns into knowledge/domains/`);
+            console.log(`3. Use 'workspace tag <file' to mark files as #warm or #permanent.`);
+            console.log(`4. Archive project if not already done using 'workspace archive ${project}'.`);
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Extraction guide failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/health.js

@@ -0,0 +1,77 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function healthCommand(program) {
+    program
+        .command("health")
+        .description("Perform a workspace integrity audit")
+        .action(async () => {
+        const spinner = ora("Auditing workspace health...").start();
+        try {
+            const workspaceRoot = process.cwd();
+            const projectsDir = path.join(workspaceRoot, "projects");
+            const issuesFound = [];
+            const staleFiles = [];
+            if (!(await fs.pathExists(projectsDir))) {
+                spinner.fail(chalk.red("Projects directory not found."));
+                return;
+            }
+            const projects = await fs.readdir(projectsDir);
+            const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+            const now = Date.now();
+            for (const project of projects) {
+                const projectPath = path.join(projectsDir, project);
+                const stats = await fs.stat(projectPath);
+                if (stats.isDirectory()) {
+                    const memoryFile = path.join(projectPath, "memory.md");
+                    const changelogFile = path.join(projectPath, "changelog.md");
+                    const decisionsFile = path.join(projectPath, "decisions.md");
+                    if (!(await fs.pathExists(memoryFile))) {
+                        issuesFound.push(`[${project}] Missing memory.md`);
+                    }
+                    if (!(await fs.pathExists(changelogFile))) {
+                        issuesFound.push(`[${project}] Missing changelog.md`);
+                    }
+                    if (!(await fs.pathExists(decisionsFile))) {
+                        issuesFound.push(`[${project}] Missing decisions.md`);
+                    }
+                    // Check for stale #hot files
+                    const files = await fs.readdir(projectPath, { recursive: true });
+                    for (const file of files) {
+                        const filePath = path.join(projectPath, file);
+                        const fileStats = await fs.stat(filePath);
+                        if (fileStats.isFile() && filePath.endsWith(".md")) {
+                            const content = await fs.readFile(filePath, "utf-8");
+                            if (content.includes("#hot")) {
+                                const mtime = fileStats.mtimeMs;
+                                if (now - mtime > SEVEN_DAYS_MS) {
+                                    staleFiles.push(`[${project}] ${file} has stale #hot tag (> 7 days since update)`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (issuesFound.length > 0 || staleFiles.length > 0) {
+                spinner.warn(chalk.yellow(`Workspace audit complete: Found ${issuesFound.length} issues and ${staleFiles.length} stale tags.`));
+                if (issuesFound.length > 0) {
+                    console.log(chalk.red("\nCritical Issues:"));
+                    issuesFound.forEach((issue) => console.log(`- ${issue}`));
+                }
+                if (staleFiles.length > 0) {
+                    console.log(chalk.yellow("\nStale Context Warnings:"));
+                    staleFiles.forEach((stale) => console.log(`- ${stale}`));
+                    console.log(chalk.cyan("\nTip: Run 'workspace archive <project>' or 'workspace tag <file> #warm' to update lifecycle state."));
+                }
+            }
+            else {
+                spinner.succeed(chalk.green("Workspace integrity audit complete: 0 issues found."));
+            }
+            console.log(chalk.cyan("\n[Intelligence] Audit complete. Use 'workspace extract' to distill learnings from completed projects."));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Health audit failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/init.js

@@ -0,0 +1,74 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { gitCommit } from "../utils.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function initCommand(program) {
+    program
+        .command("init")
+        .description("Initialize a new ContextOS project or full workspace")
+        .argument("[name]", "Project name (optional for initial workspace setup)")
+        .option("-o, --org <org>", "Organization name", "personal")
+        .action(async (name, options) => {
+        const spinner = ora("Checking workspace status...").start();
+        try {
+            const workspaceRoot = process.cwd();
+            const soulPath = path.join(workspaceRoot, "root", "soul.md");
+            const templatesDir = path.resolve(__dirname, "..", "templates");
+            // 1. Workspace Bootstrapping (Zero-Clone Support)
+            if (!(await fs.pathExists(soulPath))) {
+                spinner.text = chalk.yellow("No ContextOS workspace detected. Bootstrapping new workspace...");
+                const folders = ["root", "schemas", "projects", "knowledge"];
+                for (const folder of folders) {
+                    const src = path.join(templatesDir, folder);
+                    if (await fs.pathExists(src)) {
+                        await fs.copy(src, path.join(workspaceRoot, folder));
+                    }
+                    else {
+                        await fs.ensureDir(path.join(workspaceRoot, folder));
+                    }
+                }
+                // Copy .gitignore
+                const gitignoreSrc = path.join(templatesDir, "dot-gitignore");
+                if (await fs.pathExists(gitignoreSrc)) {
+                    await fs.copy(gitignoreSrc, path.join(workspaceRoot, ".gitignore"));
+                }
+                spinner.info(chalk.green("Workspace structure created."));
+                spinner.start("Initializing project...");
+            }
+            // If no name provided, we just did the workspace setup
+            if (!name) {
+                spinner.succeed(chalk.green("ContextOS workspace initialized successfully."));
+                return;
+            }
+            // 2. Project Initialization
+            const projectDir = path.join(workspaceRoot, "projects", name);
+            if (await fs.pathExists(projectDir)) {
+                spinner.fail(chalk.red(`Project directory already exists at ${projectDir}`));
+                return;
+            }
+            // Create structure
+            await fs.ensureDir(projectDir);
+            await fs.ensureDir(path.join(projectDir, "tasks"));
+            await fs.ensureDir(path.join(projectDir, "decisions"));
+            // Create blanks
+            const templateMap = {
+                "CONTEXT.md": "# Project Context\n\n#hot",
+                "memory.md": "# Project Memory\n\n#hot",
+                "phases.md": "# Project Phases\n\n#hot",
+                "SOUL.md": "# Project Soul\n\n#hot",
+                "HEARTBEAT.md": "# Project Heartbeat\n\n#hot"
+            };
+            for (const [file, content] of Object.entries(templateMap)) {
+                await fs.writeFile(path.join(projectDir, file), content);
+            }
+            await gitCommit(workspaceRoot, `feat(cli): initialize project ${name}`);
+            spinner.succeed(chalk.green(`Project '${name}' initialized successfullly.`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Init failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/prune.js

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function pruneCommand(program) {
+    program
+        .command("prune")
+        .description("Remove stale logs and clean up the workspace")
+        .action(async () => {
+        const spinner = ora("Cleaning up workspace...").start();
+        try {
+            const workspaceRoot = process.cwd();
+            const dailyDir = path.join(workspaceRoot, "daily");
+            const tmpDir = path.join(workspaceRoot, "tmp");
+            let prunedCount = 0;
+            // 1. Clean up tmp/
+            if (await fs.pathExists(tmpDir)) {
+                const files = await fs.readdir(tmpDir);
+                for (const file of files) {
+                    await fs.remove(path.join(tmpDir, file));
+                    prunedCount++;
+                }
+            }
+            // 2. Identify redundant headers or stale session files
+            // (Simplified for now - we'll just check if anything is tagged with #stale)
+            spinner.succeed(chalk.green(`Workspace pruned: ${prunedCount} temporary items removed.`));
+            console.log(chalk.yellow(`\n[Intelligence] Pruning complete. Next step: 'workspace archive' for finished projects.`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Prune failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/search.js

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+import ora from "ora";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export function searchCommand(program) {
+    program
+        .command("search")
+        .description("Search across the workspace")
+        .argument("<query>", "Search query string")
+        .action(async (query) => {
+        const spinner = ora(`Searching for ${chalk.cyan(query)}...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            // Use grep -rnI as a robust default
+            const command = `grep -rnIE "${query}" . | head -n 20`;
+            const { stdout } = await execAsync(command, { cwd: workspaceRoot });
+            if (!stdout) {
+                spinner.info(chalk.yellow("No results found."));
+                return;
+            }
+            spinner.succeed(chalk.green("Search results:"));
+            console.log(`\n${stdout}`);
+        }
+        catch (error) {
+            if (error.code === 1) {
+                spinner.info(chalk.yellow("No results found."));
+                return;
+            }
+            spinner.fail(chalk.red(`Search failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/status.js

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function statusCommand(program) {
+    program
+        .command("status")
+        .description("Show workspace health and project status")
+        .action(async () => {
+        const spinner = ora("Checking workspace status...").start();
+        try {
+            const workspaceRoot = process.cwd();
+            const projectsDir = path.join(workspaceRoot, "projects");
+            if (!(await fs.pathExists(projectsDir))) {
+                spinner.fail(chalk.red("No projects directory found."));
+                return;
+            }
+            const projects = await fs.readdir(projectsDir);
+            spinner.succeed(chalk.green(`Workspace: ${chalk.bold(path.basename(workspaceRoot))}`));
+            console.log(chalk.cyan(`\n📁 Projects [${projects.length}]:`));
+            for (const project of projects) {
+                const projectPath = path.join(projectsDir, project);
+                const stat = await fs.stat(projectPath);
+                if (stat.isDirectory()) {
+                    const memoryPath = path.join(projectPath, "memory.md");
+                    let memoryStatus = chalk.gray("(no memory)");
+                    if (await fs.pathExists(memoryPath)) {
+                        const memoryStat = await fs.stat(memoryPath);
+                        memoryStatus = chalk.dim(`(last modified: ${memoryStat.mtime.toDateString()})`);
+                    }
+                    console.log(`  - ${chalk.bold(project)} ${memoryStatus}`);
+                }
+            }
+            const date = new Date().toISOString().split("T")[0];
+            const dailyFile = path.join(workspaceRoot, "daily", `${date}.md`);
+            console.log(chalk.cyan(`\n📝 Daily Log:`));
+            if (await fs.pathExists(dailyFile)) {
+                console.log(`  - ${chalk.green("ACTIVE")} ${chalk.dim(`(today: ${date}.md)`)}`);
+            }
+            else {
+                console.log(`  - ${chalk.yellow("MISSING")} ${chalk.dim("(run 'workspace today' to initialize)")}`);
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Status failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/summary.js

@@ -0,0 +1,26 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function summaryCommand(program) {
+    program
+        .command("summary")
+        .description("Generate weekly summary")
+        .argument("<type>", "Summary type (e.g., week)")
+        .action(async (type) => {
+        const spinner = ora(`Generating ${type} summary...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            const summaryDir = path.join(workspaceRoot, "docs", "summaries");
+            const date = new Date().toISOString().split("T")[0];
+            const summaryFile = path.join(summaryDir, `${date}-${type}.md`);
+            await fs.ensureDir(summaryDir);
+            const summaryContent = `# ${type.charAt(0).toUpperCase() + type.slice(1)} Summary — ${date}\n\n## 🚀 Highlights\n- \n\n## 📦 Shipped\n- \n\n## 📝 Strategic Context\n- \n`;
+            await fs.writeFile(summaryFile, summaryContent);
+            spinner.succeed(chalk.green(`${type.charAt(0).toUpperCase() + type.slice(1)} summary generated at ${summaryFile}`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Summary failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/sync.js

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+export function syncCommand(program) {
+    program
+        .command("sync")
+        .description("Sync memory, changelog, and daily logs")
+        .argument("[project]", "Project name to sync context for")
+        .action(async (project) => {
+        const spinner = ora("Syncing workspace context...").start();
+        try {
+            const workspaceRoot = process.cwd();
+            const date = new Date().toISOString().split("T")[0];
+            // Simulating sync logic: ensuring memory.md has a "Last Sync" timestamp
+            if (project) {
+                const projectDir = path.join(workspaceRoot, "projects", project);
+                const memoryPath = path.join(projectDir, "memory.md");
+                if (await fs.pathExists(memoryPath)) {
+                    let content = await fs.readFile(memoryPath, "utf-8");
+                    const syncMark = `\n> [!NOTE]\n> Last Sync: ${date} ${new Date().toLocaleTimeString()}\n`;
+                    if (!content.includes("Last Sync:")) {
+                        await fs.appendFile(memoryPath, syncMark);
+                    }
+                    else {
+                        content = content.replace(/> \[!NOTE\]\n> Last Sync: .*/, syncMark.trim());
+                        await fs.writeFile(memoryPath, content);
+                    }
+                    spinner.succeed(chalk.green(`Synced memory for ${project}`));
+                }
+                else {
+                    spinner.fail(chalk.red(`Memory file not found for ${project}`));
+                }
+            }
+            else {
+                spinner.succeed(chalk.green("Global workspace sync complete."));
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Sync failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/tag.js

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { gitCommit } from "../utils.js";
+export function tagCommand(program) {
+    program
+        .command("tag")
+        .description("Update the lifecycle tag of a context file")
+        .argument("<file>", "Path to the file to tag")
+        .argument("<tag>", "The new tag (e.g., #hot, #warm, #cold, #permanent)")
+        .action(async (file, tag) => {
+        const spinner = ora(`Updating tag for ${chalk.cyan(file)} to ${chalk.yellow(tag)}...`).start();
+        try {
+            const workspaceRoot = process.cwd();
+            const filePath = path.join(workspaceRoot, file);
+            if (!(await fs.pathExists(filePath))) {
+                spinner.fail(chalk.red(`File ${file} not found.`));
+                return;
+            }
+            let content = await fs.readFile(filePath, "utf-8");
+            const lifecycleTags = ["#hot", "#warm", "#cold", "#permanent"];
+            // Remove existing lifecycle tags
+            lifecycleTags.forEach(t => {
+                content = content.replace(new RegExp(`${t}(\\s*|\\n*)`, 'g'), '');
+            });
+            // Add new tag at the top (after h1 if exists, else very top)
+            if (content.startsWith("# ")) {
+                const lines = content.split("\n");
+                lines.splice(1, 0, `\n${tag}\n`);
+                content = lines.join("\n");
+            }
+            else {
+                content = `${tag}\n\n${content}`;
+            }
+            await fs.writeFile(filePath, content, "utf-8");
+            await gitCommit(file, `refactor(cli): update lifecycle tag of ${file} to ${tag}`);
+            spinner.succeed(chalk.green(`File ${file} tagged with ${tag} successfully.`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Tagging failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/today.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { gitCommit } from "../utils.js";
+export function todayCommand(program) {
+    program
+        .command("today")
+        .alias("daily")
+        .description("Open or create today's daily log")
+        .action(async () => {
+        const spinner = ora("Setting up today's log...").start();
+        try {
+            const workspaceRoot = process.cwd();
+            const date = new Date().toISOString().split("T")[0];
+            const dailyDir = path.join(workspaceRoot, "daily");
+            const dailyFile = path.join(dailyDir, `${date}.md`);
+            await fs.ensureDir(dailyDir);
+            if (!(await fs.pathExists(dailyFile))) {
+                const templatesDir = path.join(workspaceRoot, "config", "templates");
+                const logTemplatePath = path.join(templatesDir, "daily-log.md");
+                let templateContent = `# Daily Log — ${date}\n\n#hot\n\n## 🎯 Focus\n- \n\n## ✅ Completed\n- \n\n## 📝 Notes\n- \n`;
+                if (await fs.pathExists(logTemplatePath)) {
+                    templateContent = await fs.readFile(logTemplatePath, "utf-8");
+                    templateContent = templateContent.replace("{{date}}", date);
+                }
+                await fs.writeFile(dailyFile, templateContent);
+                await gitCommit(dailyFile, `feat(cli): create daily log for ${date}`);
+                spinner.succeed(chalk.green(`Created today's log at ${dailyFile}`));
+            }
+            else {
+                spinner.info(chalk.blue(`Today's log already exists at ${dailyFile}`));
+            }
+            console.log(chalk.cyan(`\nRun 'workspace sync' after your session to finalize context.`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Today failed: ${error.message}`));
+        }
+    });
+}

package/dist/workspace-cli/src/commands/validate.js

@@ -0,0 +1,136 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import AjvModule from "ajv";
+import addFormatsModule from "ajv-formats";
+import fm from "front-matter";
+const Ajv = AjvModule.default || AjvModule;
+const addFormats = addFormatsModule.default || addFormatsModule;
+const ajv = new Ajv({ allErrors: true });
+addFormats(ajv);
+export function validateCommand(program) {
+    program
+        .command("validate")
+        .description("Validate workspace files against JSON schemas")
+        .action(async () => {
+        const spinner = ora("Validating workspace integrity...").start();
+        try {
+            const findWorkspaceRoot = () => {
+                let current = process.cwd();
+                const root = "/";
+                while (current !== root) {
+                    if (fs.existsSync(path.join(current, "root", "soul.md"))) {
+                        return current;
+                    }
+                    current = path.dirname(current);
+                }
+                return process.cwd();
+            };
+            const workspaceRoot = findWorkspaceRoot();
+            const schemasDir = path.join(workspaceRoot, "schemas");
+            const projectsDir = path.join(workspaceRoot, "projects");
+            const starterDir = path.join(workspaceRoot, "workspace-starter");
+            if (!(await fs.pathExists(schemasDir))) {
+                spinner.fail(chalk.red(`Schemas directory not found at ${schemasDir}`));
+                process.exit(1);
+            }
+            const validFiles = [
+                { name: "SOUL.md", schema: "soul.schema.json", required: true },
+                { name: "CONTEXT.md", schema: "context.schema.json", required: true },
+                { name: "memory.md", schema: "memory.schema.json" },
+                { name: "decisions.md", schema: "decision.schema.json" }
+            ];
+            let totalIssues = 0;
+            // Find all project-like directories (projects/* and workspace-starter)
+            const projectPaths = [];
+            if (await fs.pathExists(projectsDir)) {
+                const projects = await fs.readdir(projectsDir);
+                for (const p of projects) {
+                    const fullPath = path.join(projectsDir, p);
+                    if ((await fs.stat(fullPath)).isDirectory()) {
+                        projectPaths.push(fullPath);
+                    }
+                }
+            }
+            if (await fs.pathExists(starterDir)) {
+                projectPaths.push(starterDir);
+            }
+            for (const projectPath of projectPaths) {
+                const projectName = path.basename(projectPath);
+                const filesInDir = await fs.readdir(projectPath);
+                for (const config of validFiles) {
+                    // Case-insensitive search
+                    const fileName = filesInDir.find(f => f.toLowerCase() === config.name.toLowerCase());
+                    if (!fileName) {
+                        if (config.required) {
+                            totalIssues++;
+                            console.log(chalk.red(`\n❌ Missing required file in ${projectName}: ${config.name}`));
+                        }
+                        continue;
+                    }
+                    const filePath = path.join(projectPath, fileName);
+                    const schemaPath = path.join(schemasDir, config.schema);
+                    const schema = await fs.readJson(schemaPath);
+                    const validate = ajv.compile(schema);
+                    const content = await fs.readFile(filePath, "utf-8");
+                    const data = extractMetadata(content);
+                    const valid = validate(data);
+                    if (!valid) {
+                        totalIssues++;
+                        console.log(chalk.red(`\n❌ Schema error in ${projectName}/${fileName}:`));
+                        validate.errors?.forEach((err) => {
+                            console.log(chalk.yellow(`   - ${err.instancePath || 'root'} ${err.message}`));
+                        });
+                    }
+                }
+            }
+            if (totalIssues === 0) {
+                spinner.succeed(chalk.green("Workspace validation successful! All files conform to schema."));
+            }
+            else {
+                spinner.fail(chalk.red(`Workspace validation failed with ${totalIssues} issues.`));
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Validation error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Robustly extract metadata from a markdown file.
+ * Prioritizes Frontmatter, falls back to Section mapping.
+ */
+function extractMetadata(content) {
+    let data = {};
+    try {
+        const parse = fm.default || fm;
+        if (content.trim().startsWith("---")) {
+            const parsed = parse(content);
+            data = parsed.attributes || {};
+        }
+    }
+    catch (e) {
+        console.error(chalk.yellow(`   ! Frontmatter parse failed, falling back to sections.`));
+    }
+    // SUPPLEMENT with section parsing if frontmatter is missing fields
+    const sections = content.split(/^## /m).slice(1);
+    sections.forEach(s => {
+        const lines = s.split("\n");
+        const title = lines[0].trim();
+        const body = lines.slice(1).join("\n").trim();
+        if (!data[title] || (Array.isArray(data[title]) && data[title].length === 0)) {
+            if (["Core Principles", "Behavioral Rules", "Goals", "Capabilities", "Constraints", "Tags", "Active Tasks", "Backlog"].includes(title)) {
+                data[title] = body.split("\n")
+                    .map(l => l.replace(/^[-*]\s*/, "").trim())
+                    .filter(l => l.length > 0);
+            }
+            else {
+                data[title] = body;
+            }
+        }
+    });
+    return data;
+}

package/dist/workspace-cli/src/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { todayCommand } from "./commands/today.js";
+import { statusCommand } from "./commands/status.js";
+import { decideCommand } from "./commands/decide.js";
+import { syncCommand } from "./commands/sync.js";
+import { summaryCommand } from "./commands/summary.js";
+import { contextCommand } from "./commands/context.js";
+import { searchCommand } from "./commands/search.js";
+import { archiveCommand } from "./commands/archive.js";
+import { pruneCommand } from "./commands/prune.js";
+import { healthCommand } from "./commands/health.js";
+import { extractCommand } from "./commands/extract.js";
+import { tagCommand } from "./commands/tag.js";
+import { validateCommand } from "./commands/validate.js";
+const program = new Command();
+program
+    .name("workspace")
+    .description("ContextOS Developer Interface Layer")
+    .version("1.0.0");
+// Register Commands
+initCommand(program);
+todayCommand(program);
+statusCommand(program);
+decideCommand(program);
+syncCommand(program);
+summaryCommand(program);
+contextCommand(program);
+searchCommand(program);
+archiveCommand(program);
+pruneCommand(program);
+healthCommand(program);
+extractCommand(program);
+tagCommand(program);
+validateCommand(program);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/workspace-cli/src/tests/smoke.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from 'node:url';
+describe("CLI Experience Layer (Smoke Tests)", () => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const cliPath = path.resolve(__dirname, "..", "index.js");
+    it("should display help information", () => {
+        const output = execSync(`node ${cliPath} --help`).toString();
+        assert.ok(output.includes("ContextOS Developer Interface Layer"));
+    });
+    it("should have all core commands registered", () => {
+        const output = execSync(`node ${cliPath} --help`).toString();
+        const expectedCommands = [
+            "init", "today", "status", "decide", "sync",
+            "summary", "context", "search", "archive",
+            "prune", "health", "extract", "tag", "validate"
+        ];
+        expectedCommands.forEach(cmd => {
+            assert.ok(output.includes(cmd));
+        });
+    });
+    it("should report version 1.0.0", () => {
+        const output = execSync(`node ${cliPath} --version`).toString();
+        assert.strictEqual(output.trim(), "1.0.0");
+    });
+});

package/dist/workspace-cli/src/utils.js

@@ -0,0 +1 @@
+export { gitCommit } from "@context-os/core";

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@context-os/cli",
+  "version": "1.0.0",
+  "description": "ContextOS Developer Interface Layer",
+  "keywords": [
+    "context-os",
+    "mcp",
+    "ai-agents",
+    "workspace-intelligence"
+  ],
+  "homepage": "https://github.com/sairam0424/ContextOS",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "bin": {
+    "context-os": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc && node ../scripts/sync-templates.js",
+    "watch": "tsc -w",
+    "start": "node dist/index.js",
+    "test": "npm run build && mocha dist/tests/**/*.test.js"
+  },
+  "dependencies": {
+    "ajv": "^8.18.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.1.0",
+    "execa": "^9.5.2",
+    "front-matter": "^4.0.2",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.0.1",
+    "@context-os/core": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/chai": "^5.2.3",
+    "@types/fs-extra": "^11.0.4",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.13.10",
+    "chai": "^5.2.0",
+    "mocha": "^11.1.0",
+    "typescript": "^5.8.2"
+  }
+}

package/templates/dot-gitignore

@@ -0,0 +1,12 @@
+node_modules/
+.env
+.DS_Store
+*.log
+dist/
+build/
+coverage/
+.vscode/
+.idea/
+
+prompts/
+

package/templates/root/anti-patterns.md

@@ -0,0 +1,19 @@
+# anti-patterns.md
+
+## Engineering Anti-Patterns
+
+- **"Magic" Fixes**: Solving a problem without documenting the mechanism or updating common agent knowledge.
+- **Flat Hierarchies**: Dumping configuration or data into the root without indexing it in the relevant scope ring.
+- **Permission Overstretching**: Attempting to execute commands in restricted directories without verifying access.
+
+## Decision Anti-Patterns
+
+- **Un-indexed ADRs**: Making architectural changes without updating the global `decisions.md`.
+- **Placeholder Dependency**: Relying on "TBD" or generic statements for core configuration.
+- **Context Siloing**: Keeping decisions or logic in memory rather than a persistent file.
+
+## Agent Interaction Anti-Patterns
+
+- **Sycophancy**: Wasting context with polite but useless phrases.
+- **Ambiguous Drafting**: Creating instructions that require more than one clarify-response cycle.
+- **Instruction Skipping**: Skipping sections of a structured prompt or protocol.

package/templates/root/changelog.md

@@ -0,0 +1,15 @@
+# changelog.md
+
+## [2026-03-30] — v0.1.0
+
+### Added
+- Initial **Identity Layer** in the `root/` directory.
+- `soul.md`: Defined core identity and ranked values hierarchy.
+- `personality.md`: Operationalized response and interaction preferences.
+- `preferences.md`: Established standard tech stack and tool defaults.
+- `skills.md`: Created an agent-visible capability inventory.
+- `anti-patterns.md`: Documented negative constraints and architectural debt.
+- `decisions.md`: Reformatted to formal ADR-style records (DEC-001 to DEC-003).
+
+### Notes
+- This version marks the transition from structural scaffolding (Day 1) to a functional, value-driven identity (Day 2).

package/templates/root/decisions.md

@@ -0,0 +1,37 @@
+# decisions.md
+
+---
+
+**ID**: DEC-001  
+**Date**: 2026-03-30  
+**Status**: ACCEPTED  
+**Title**: Initialize Workspace as Localized Context OS  
+
+**Context**: Need a structured, agent-readable workspace context system.  
+**Decision**: Create a file-first architecture with localized roots (`/Users/sairamugge/Desktop/ContextOS/`).  
+**Rationale**: System permissions prevent global directory creation in `~/`.  
+**Consequences**: Portability requires path normalization to the current workspace root.
+
+---
+
+**ID**: DEC-002  
+**Date**: 2026-03-30  
+**Status**: ACCEPTED  
+**Title**: Implement Double-Hook Learning Loop  
+
+**Context**: Agents repeating mistakes across sessions.  
+**Decision**: Enforce a mandatory `AGENTS_LEARNING.md` read/write protocol.  
+**Rationale**: Continuous improvement (Reflexive Learning) is a core value.  
+**Consequences**: Increased context usage at the start of every session.
+
+---
+
+**ID**: DEC-003  
+**Date**: 2026-03-30  
+**Status**: ACCEPTED  
+**Title**: Establish Ranked Identity Layer (Day 2)  
+
+**Context**: Need predictable agent behavior and strategic alignment.  
+**Decision**: Build a multi-file "Identity Layer" in `root/` with a ranked values hierarchy.  
+**Rationale**: Values-based conflict resolution provides a consistent decision model for agents.  
+**Consequences**: High-fidelity operational baseline established for all future tasks.

package/templates/root/personality.md

@@ -0,0 +1,32 @@
+# personality.md
+
+## Response Preferences
+
+- **Length**: Medium; concise, but never at the expense of necessary context.
+- **Format**: Markdown with high reliance on hierarchical structures.
+- **Depth**: Technical and deep; prioritize the "Why" and "Mechanism" over just the "Surface Result."
+
+## Tone Preferences
+
+- **Voice**: Professional Agentic Architect.
+- **Humor**: None preferred; focus on precision.
+- **Technical level**: Expert/Architect.
+
+## Working Patterns
+
+- **Focus style**: Comprehensive execution; build the whole feature, then fix the details.
+- **Context switching**: Minimize switching; complete one scope ring before moving to another.
+- **Review preference**: Detailed analysis of changes before and after implementation.
+
+## Agent Collaboration Rules
+
+- **When stuck**: Analyze `AGENTS_LEARNING.md` for similar patterns. If no resolution: Ask for architectural intent.
+- **Disagreements**: Prioritize `soul.md` values hierarchy.
+- **Updates frequency**: After every completed task.
+
+## Hard Rules
+
+- **No sycophancy**: Do not apologize for system errors; provide a technical root cause and a fix.
+- **No filler language**: Eliminate "Sure," "I can," and "I will." Direct action is expected.
+- **Be direct and useful**: If a task is inefficient, suggest a better way before starting.
+- **The Double-Hook**: Never ignore any past agentic learning.

package/templates/root/preferences.md

@@ -0,0 +1,25 @@
+# preferences.md
+
+## Tech Stack Preferences
+
+- **Frontend**: Not applicable at this stage; prioritizing Markdown for structure.
+- **Backend**: Python for agents; Shell for system-level operations.
+- **Infra**: Workspace root at `/Users/sairamugge/Desktop/ContextOS/`.
+
+## Package Managers
+
+- **JS**: `npm` for standard tooling; `npx` for temporary operations.
+- **Python**: `pip` with `pyproject.toml` or `requirements.txt` for dependencies.
+- **Others**: Git for all version control.
+
+## Coding Preferences
+
+- **Naming**: `kebab-case` for file names; `snake_case` for Python keys; `PascalCase` for classes.
+- **Structure**: Modules must be self-contained; avoid global shared variables without explicit indexing.
+- **Patterns**: First Principles—Solve the problem at the lowest level of the dependency chain first.
+
+## Forbidden / Avoided
+
+- **Placeholder "TBD"**: Forbidden in finalized documents without a pending task reference.
+- **Hardcoded Home Paths**: Use absolute paths tied to the localized workspace root.
+- **Sycophancy**: Forbidden from agent communication.

package/templates/root/skills.md

@@ -0,0 +1,18 @@
+# skills.md
+
+## Core Skills
+
+- **Strategic Systems Architect**: Specialist level; ability to design complex, multi-agent context systems.
+- **Agentic Infrastructure Designer**: Expert level; building the foundational layers of the Context OS.
+- **Cognitive Model Designer**: Specialist level; translating human values into agent-readable structures.
+
+## Advanced Areas
+
+- **Markdown-first Documentation**: High depth; creating structured, indexed documentation.
+- **Git version control**: Standard; branch management for concurrent operational tasks.
+- **Context Routing**: Advanced; implementing complex context loading and inheritance rules.
+
+## Learning Goals
+
+- **Recursive Intelligence Improvement**: Increasing the fidelity and precision of the "Double-Hook" learning loop.
+- **Cross-Agent Handoff Optimization**: Reducing friction during multi-agent session transitions.

package/templates/root/soul.md

@@ -0,0 +1,44 @@
+# soul.md
+
+_Last updated: 2026-03-30 | Version: 0.1.0_
+
+## Identity
+The user is a **Strategic Systems Architect** focused on building high-leverage agentic ecosystems. This workspace is a laboratory for experimenting with "Context OS" principles and operationalizing AI-driven workflows.
+
+## Core Values (Ranked)
+1. **Agentic Autonomy**: Empower systems to act independently with high fidelity.
+2. **Structural Clarity**: Every piece of data must have a clear, indexed location.
+3. **Compound Knowledge**: Learnings must be captured and recycled to prevent regression.
+
+### Conflict Resolution
+When **Agentic Autonomy** conflicts with **Structural Clarity**:
+→ **Structural Clarity** wins. An agent must not act if its actions compromise the integrity of the workspace.
+
+## Decision Framework
+- **Primary method**: Leverage—Prioritize solutions that provide the greatest gain for the least recurring effort.
+- **Secondary filter**: Reversibility—Adopt experimental patterns only if they can be easily rolled back or refactored.
+- **Bias**: Quality over Speed—The foundational layer must be pixel-perfect before scaling.
+
+## Working Philosophy
+- **Optimize for**: Predictability and long-term maintenance.
+- **Avoid**: One-off "magic" fixes that aren't documented as patterns.
+- **Default approach**: File-first configuration.
+
+## Communication Style
+- **Tone**: Precise, technical, and objective.
+- **Structure**: Bulleted, hierarchical, and concise.
+- **Feedback style**: Direct and specific; focus on the "Why."
+- **Pushback rule**: If a request violates a core value, an agent **must** push back and offer an alternative aligned with the system's mission.
+
+## Current Focus
+- **Primary mission**: Building the Identity Layer of the Context OS.
+- **Constraints**: System permissions restriction (must use localized roots).
+
+## Agent Instructions
+- **Always**: Check `AGENTS_LEARNING.md` before execution.
+- **Never**: Create files without a corresponding index update if applicable.
+- **When unsure**: Ask for architectural confirmation before creating new root-level folders.
+
+## Anti-Patterns
+- **The "TBD" Trap**: Creating placeholders without a clear path to resolution.
+- **Context Siloing**: Keeping decisions in conversation memory rather than persistent files.

package/templates/schemas/context.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ContextOS Context Schema",
+  "description": "Schema for project CONTEXT.md files.",
+  "type": "object",
+  "required": ["Overview", "Goals"],
+  "properties": {
+    "Overview": { "type": "string" },
+    "Goals": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1
+    },
+    "Stack": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "Metadata": {
+      "type": "object",
+      "properties": {
+        "Tags": { "type": "array", "items": { "type": "string" } }
+      }
+    }
+  }
+}

package/templates/schemas/decision.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ContextOS Decision Schema",
+  "description": "Schema for project decisions.md files.",
+  "type": "object",
+  "properties": {
+    "Decisions": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["Id", "Title", "Date", "Status", "Context", "Decision", "Rationale"],
+        "properties": {
+          "Id": { "type": "string", "pattern": "^ADR-\\d{4}$" },
+          "Title": { "type": "string" },
+          "Date": { "type": "string", "format": "date" },
+          "Status": { "type": "string", "enum": ["Proposed", "Accepted", "Superseded", "Deprecated"] },
+          "Context": { "type": "string" },
+          "Decision": { "type": "string" },
+          "Rationale": { "type": "string" }
+        }
+      }
+    }
+  }
+}

package/templates/schemas/memory.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ContextOS Memory Schema",
+  "description": "Schema for project memory.md files.",
+  "type": "object",
+  "required": ["Overview"],
+  "properties": {
+    "Overview": { "type": "string" },
+    "Learnings": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "Patterns": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "Metadata": {
+      "type": "object",
+      "properties": {
+        "Tags": { "type": "array", "items": { "type": "string" } }
+      }
+    }
+  }
+}

package/templates/schemas/soul.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ContextOS Soul Schema",
+  "description": "Schema for project SOUL.md files defining identity and values.",
+  "type": "object",
+  "required": ["Identity", "Core Principles", "Behavioral Rules"],
+  "properties": {
+    "Identity": {
+      "type": "string",
+      "description": "High-level description of the project's purpose."
+    },
+    "Core Principles": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1
+    },
+    "Behavioral Rules": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1
+    },
+    "Constraints": {
+      "type": "array",
+      "items": { "type": "string" }
+    }
+  }
+}