project-tiny-context-harness 0.2.49 → 0.2.51

package/dist/commands/upgrade.js

@@ -1,7 +1,62 @@
+import { createUpgradePlan, formatUpgradePlan, hasUpgradePlanWork, updateModeForPlan } from "../lib/migrations.js";
 import { runUpgrade } from "../lib/upgrade.js";
-export async function upgrade() {
+export async function upgrade(args = []) {
+    const options = parseArgs(args);
+    if (options.help) {
+        printHelp();
+        return;
+    }
+    if (options.check) {
+        const plan = await createUpgradePlan(process.cwd());
+        if (options.json) {
+            console.log(JSON.stringify({ mode: updateModeForPlan(plan), ...plan }, null, 2));
+        }
+        else {
+            for (const line of formatUpgradePlan(plan)) {
+                console.log(line);
+            }
+        }
+        if (hasUpgradePlanWork(plan)) {
+            process.exitCode = 1;
+        }
+        return;
+    }
     const report = await runUpgrade(process.cwd());
+    if (options.json) {
+        console.log(JSON.stringify({ lines: report }, null, 2));
+        return;
+    }
     for (const line of report) {
         console.log(line);
     }
 }
+function parseArgs(args) {
+    const options = { check: false, json: false, help: false };
+    for (const arg of args) {
+        if (arg === "--check") {
+            options.check = true;
+        }
+        else if (arg === "--json") {
+            options.json = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            options.help = true;
+        }
+        else {
+            throw new Error(`unknown upgrade argument: ${arg}`);
+        }
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`sdlc-harness upgrade:
+  upgrade              Run safe migrations, sync managed assets and doctor
+  upgrade --check      Print the upgrade plan without writing files
+  upgrade --check --json
+                       Print the upgrade plan as JSON
+
+Update modes:
+  sync-only            No migrations are pending
+  upgrade-required     Safe migrations are pending
+  manual-required      Manual review or blockers are present`);
+}

package/dist/lib/migrations.d.ts

@@ -1,11 +1,39 @@
+export type UpgradePlanItemStatus = "safe_pending" | "manual_required" | "blocked";
+export interface UpgradePlanItem {
+    id: string;
+    introducedIn: string;
+    description: string;
+    scope: string;
+    status: UpgradePlanItemStatus;
+    message: string;
+    path?: string;
+}
+export interface UpgradePlan {
+    safe_pending: UpgradePlanItem[];
+    manual_required: UpgradePlanItem[];
+    blocked: UpgradePlanItem[];
+}
+export type ReleaseUpdateMode = "sync-only" | "upgrade-required" | "manual-required";
 export interface Migration {
-    from: string;
-    to: string;
+    id: string;
+    introducedIn: string;
     description: string;
+    scope: string;
+    risk: "safe" | "manual";
+    manualMessage: string;
+    detect(projectRoot: string, root: string, migrationId: string): Promise<UpgradePlanItem[]>;
+    apply?(projectRoot: string, root: string, report: MigrationReport): Promise<void>;
+    verify(projectRoot: string, root: string): Promise<void>;
 }
-export declare const migrations: Migration[];
 export interface MigrationReport {
     changed: string[];
     skipped: string[];
+    manualRequired: UpgradePlanItem[];
+    blocked: UpgradePlanItem[];
 }
+export declare const migrations: Migration[];
+export declare function createUpgradePlan(projectRoot: string): Promise<UpgradePlan>;
+export declare function hasUpgradePlanWork(plan: UpgradePlan): boolean;
+export declare function updateModeForPlan(plan: UpgradePlan): ReleaseUpdateMode;
+export declare function formatUpgradePlan(plan: UpgradePlan): string[];
 export declare function runMigrations(projectRoot: string): Promise<MigrationReport>;

package/dist/lib/migrations.js

@@ -2,21 +2,135 @@ import path from "node:path";
 import { promises as fs } from "node:fs";
 import { CONTEXT_MANIFEST_PATH, contextManifestFromExistingAreas } from "./context-manifest.js";
 import { architectureContextTemplate, areaContextTemplate, globalContextTemplate, verificationContextTemplate } from "./context-templates.js";
+import { CURRENT_SCHEMA_VERSION } from "./constants.js";
 import { defaultConfig, readConfig } from "./config.js";
 import { createDesignMdIfMissing, DESIGN_MD_PATH } from "./design-md.js";
 import { ensureDir, listFiles, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { harnessConfigPath, harnessRoot } from "./harness-root.js";
 import { stringifyYaml } from "./yaml.js";
-export const migrations = [];
+async function verifyNoop() {
+    return;
+}
+export const migrations = [
+    {
+        id: "schema-v4-config-refresh",
+        introducedIn: "0.2.0",
+        description: "Refresh Harness config core metadata and managed-file list for Schema v4.",
+        scope: "<harnessRoot>/config.yaml",
+        risk: "safe",
+        manualMessage: "Review Harness config manually if custom managed-file paths still drift after upgrade.",
+        detect: detectConfigRefresh,
+        apply: migrateConfig,
+        verify: verifyNoop
+    },
+    {
+        id: "legacy-modules-to-areas",
+        introducedIn: "0.2.0",
+        description: "Move legacy project_context/modules/**/*.md files to project_context/areas/**/*.md.",
+        scope: "project_context/modules/**",
+        risk: "safe",
+        manualMessage: "Resolve target conflicts manually; the Harness will not overwrite existing area Context files.",
+        detect: detectLegacyModulesToAreas,
+        apply: migrateLegacyModulesToAreas,
+        verify: verifyNoop
+    },
+    {
+        id: "context-manifest-baseline",
+        introducedIn: "0.2.0",
+        description: "Create the Schema v4 project_context/context.toml manifest when missing.",
+        scope: "project_context/context.toml and project_context/areas/**",
+        risk: "safe",
+        manualMessage: "Review deep area files without manifest roles and assign explicit context roles when needed.",
+        detect: detectContextManifestBaseline,
+        apply: migrateContextManifest,
+        verify: verifyNoop
+    },
+    {
+        id: "global-context-v4-sections",
+        introducedIn: "0.2.0",
+        description: "Add missing Schema v4 global Context sections and rewrite legacy module links.",
+        scope: "project_context/global.md",
+        risk: "safe",
+        manualMessage: "Review global Context manually if project-specific long-term facts need refinement.",
+        detect: detectGlobalContextSections,
+        apply: migrateGlobalContextSections,
+        verify: verifyNoop
+    },
+    {
+        id: "design-md-baseline",
+        introducedIn: "0.2.0",
+        description: "Create DESIGN.md for existing Harness projects when missing.",
+        scope: "DESIGN.md",
+        risk: "safe",
+        manualMessage: "Review the starter design baseline and replace it with project-specific visual facts when available.",
+        detect: detectDesignMdBaseline,
+        apply: migrateDesignMd,
+        verify: verifyNoop
+    },
+    {
+        id: "deprecated-skill-overrides",
+        introducedIn: "0.2.0",
+        description: "Report deprecated managed skill overrides that must move to standalone project-local Skills.",
+        scope: "<harnessRoot>/pjsdlc_managed/override_skills/**",
+        risk: "manual",
+        manualMessage: "Move override files into standalone project-local Skills before running sync.",
+        detect: detectDeprecatedSkillOverrides,
+        verify: verifyNoop
+    }
+];
+export async function createUpgradePlan(projectRoot) {
+    const root = await harnessRoot(projectRoot);
+    const plan = { safe_pending: [], manual_required: [], blocked: [] };
+    for (const migration of migrations) {
+        for (const item of await migration.detect(projectRoot, root, migration.id)) {
+            plan[item.status].push(item);
+        }
+    }
+    return plan;
+}
+export function hasUpgradePlanWork(plan) {
+    return plan.safe_pending.length > 0 || plan.manual_required.length > 0 || plan.blocked.length > 0;
+}
+export function updateModeForPlan(plan) {
+    if (plan.manual_required.length > 0 || plan.blocked.length > 0) {
+        return "manual-required";
+    }
+    if (plan.safe_pending.length > 0) {
+        return "upgrade-required";
+    }
+    return "sync-only";
+}
+export function formatUpgradePlan(plan) {
+    const lines = [
+        `upgrade plan mode=${updateModeForPlan(plan)} safe_pending=${plan.safe_pending.length} manual_required=${plan.manual_required.length} blocked=${plan.blocked.length}`
+    ];
+    for (const status of ["safe_pending", "manual_required", "blocked"]) {
+        for (const item of plan[status]) {
+            const location = item.path ? ` ${item.path}` : "";
+            lines.push(`${status}: ${item.id}${location} - ${item.message}`);
+        }
+    }
+    return lines;
+}
 export async function runMigrations(projectRoot) {
-    const report = { changed: [], skipped: [] };
+    const report = { changed: [], skipped: [], manualRequired: [], blocked: [] };
     const root = await harnessRoot(projectRoot);
-    await migrateConfig(projectRoot, root, report);
-    await migrateLegacyModulesToAreas(projectRoot, report);
+    const plan = await createUpgradePlan(projectRoot);
+    report.manualRequired.push(...plan.manual_required);
+    report.blocked.push(...plan.blocked);
+    for (const migration of migrations) {
+        if (!migration.apply) {
+            continue;
+        }
+        if (!plan.safe_pending.some((item) => item.id === migration.id)) {
+            report.skipped.push(migration.id);
+            continue;
+        }
+        await migration.apply(projectRoot, root, report);
+        await migration.verify(projectRoot, root);
+    }
     await migrateBaseProjectContext(projectRoot, report);
-    await migrateContextManifest(projectRoot, report);
     await migrateManifestModulePaths(projectRoot, report);
-    await migrateDesignMd(projectRoot, report);
     return report;
 }
 async function migrateBaseProjectContext(projectRoot, report) {
@@ -40,12 +154,30 @@ async function migrateBaseProjectContext(projectRoot, report) {
             report.skipped.push(relative);
         }
     }
-    await migrateGlobalContextSections(projectRoot, report);
 }
-async function migrateGlobalContextSections(projectRoot, report) {
+async function detectGlobalContextSections(projectRoot, _root, migration) {
     const relative = "project_context/global.md";
     const target = path.join(projectRoot, ...relative.split("/"));
     if (!(await pathExists(target))) {
+        return [];
+    }
+    const original = await readText(target);
+    const rewritten = rewriteLegacyModuleReferences(original);
+    const needsSections = !hasHeading(rewritten, "Architecture Context") ||
+        !hasHeading(rewritten, "Context Graph") ||
+        !hasHeading(rewritten, "Context Index");
+    if (!needsSections && rewritten === original) {
+        return [];
+    }
+    return [
+        item(migration, "safe_pending", relative, "Global Context needs Schema v4 sections or legacy module path rewrites.")
+    ];
+}
+async function migrateGlobalContextSections(projectRoot, _root, report) {
+    const relative = "project_context/global.md";
+    const target = path.join(projectRoot, ...relative.split("/"));
+    if (!(await pathExists(target))) {
+        report.skipped.push(relative);
         return;
     }
     const original = await readText(target);
@@ -61,14 +193,31 @@ async function migrateGlobalContextSections(projectRoot, report) {
         additions.push("## Context Index", "", "- See `project_context/context.toml` for the current area and context node list.", "");
     }
     if (additions.length === 0 && rewritten === original) {
+        report.skipped.push(`${relative}#schema-v4-sections`);
         return;
     }
     const next = additions.length === 0 ? rewritten : `${rewritten.replace(/\s*$/, "\n\n")}${additions.join("\n")}`;
     if (await writeTextIfChanged(target, next)) {
         report.changed.push(`${relative}#schema-v4-sections`);
     }
+    else {
+        report.skipped.push(`${relative}#schema-v4-sections`);
+    }
 }
-async function migrateContextManifest(projectRoot, report) {
+async function detectContextManifestBaseline(projectRoot, _root, migration) {
+    const manifestPath = path.join(projectRoot, CONTEXT_MANIFEST_PATH);
+    if (await pathExists(manifestPath)) {
+        return [];
+    }
+    const items = [
+        item(migration, "safe_pending", CONTEXT_MANIFEST_PATH, "Context graph manifest is missing and can be created from existing area files.")
+    ];
+    for (const ambiguous of await ambiguousAreaContextFiles(projectRoot)) {
+        items.push(item(migration, "manual_required", ambiguous, "Deep area Context cannot be safely role-classified by path alone; review context.toml after upgrade."));
+    }
+    return items;
+}
+async function migrateContextManifest(projectRoot, _root, report) {
     const manifestPath = path.join(projectRoot, CONTEXT_MANIFEST_PATH);
     if (await pathExists(manifestPath)) {
         report.skipped.push(CONTEXT_MANIFEST_PATH);
@@ -81,7 +230,26 @@ async function migrateContextManifest(projectRoot, report) {
         report.skipped.push(CONTEXT_MANIFEST_PATH);
     }
 }
-async function migrateLegacyModulesToAreas(projectRoot, report) {
+async function detectLegacyModulesToAreas(projectRoot, _root, migration) {
+    const modulesRoot = path.join(projectRoot, "project_context", "modules");
+    const areasRoot = path.join(projectRoot, "project_context", "areas");
+    const moduleFiles = (await listFiles(modulesRoot)).filter((file) => file.endsWith(".md")).sort();
+    const items = [];
+    for (const source of moduleFiles) {
+        const relativeToModules = path.relative(modulesRoot, source);
+        const sourceRelative = `project_context/modules/${relativeToModules.split(path.sep).join("/")}`;
+        const targetRelative = `project_context/areas/${relativeToModules.split(path.sep).join("/")}`;
+        const target = path.join(areasRoot, relativeToModules);
+        if (await pathExists(target)) {
+            items.push(item(migration, "blocked", sourceRelative, `Cannot move to ${targetRelative} because the target already exists.`));
+        }
+        else {
+            items.push(item(migration, "safe_pending", sourceRelative, `Move to ${targetRelative}.`));
+        }
+    }
+    return items;
+}
+async function migrateLegacyModulesToAreas(projectRoot, _root, report) {
     const modulesRoot = path.join(projectRoot, "project_context", "modules");
     const areasRoot = path.join(projectRoot, "project_context", "areas");
     const moduleFiles = (await listFiles(modulesRoot)).filter((file) => file.endsWith(".md")).sort();
@@ -120,7 +288,12 @@ async function migrateManifestModulePaths(projectRoot, report) {
         report.changed.push(`${CONTEXT_MANIFEST_PATH}#areas-paths`);
     }
 }
-async function migrateDesignMd(projectRoot, report) {
+async function detectDesignMdBaseline(projectRoot, _root, migration) {
+    return (await pathExists(path.join(projectRoot, DESIGN_MD_PATH)))
+        ? []
+        : [item(migration, "safe_pending", DESIGN_MD_PATH, "DESIGN.md is missing and can be created with the package baseline.")];
+}
+async function migrateDesignMd(projectRoot, _root, report) {
     if (await createDesignMdIfMissing(projectRoot)) {
         report.changed.push(DESIGN_MD_PATH);
     }
@@ -128,6 +301,26 @@ async function migrateDesignMd(projectRoot, report) {
         report.skipped.push(DESIGN_MD_PATH);
     }
 }
+async function detectConfigRefresh(projectRoot, root, migration) {
+    const relativeConfigPath = await harnessConfigPath(projectRoot);
+    const configPath = path.join(projectRoot, relativeConfigPath);
+    if (!(await pathExists(configPath))) {
+        return [];
+    }
+    const config = await readConfig(projectRoot);
+    const current = defaultConfig(root);
+    const managedMatches = JSON.stringify(config.managed_files) === JSON.stringify(current.managed_files);
+    const neverOverwriteHasDefaults = current.never_overwrite.every((entry) => config.never_overwrite.includes(entry));
+    if (config.core.package === current.core.package &&
+        config.core.schema_version === CURRENT_SCHEMA_VERSION &&
+        managedMatches &&
+        neverOverwriteHasDefaults) {
+        return [];
+    }
+    return [
+        item(migration, "safe_pending", relativeConfigPath, "Harness config needs current package metadata, schema version or managed-file defaults.")
+    ];
+}
 async function migrateConfig(projectRoot, root, report) {
     const relativeConfigPath = await harnessConfigPath(projectRoot);
     const configPath = path.join(projectRoot, relativeConfigPath);
@@ -147,6 +340,52 @@ async function migrateConfig(projectRoot, root, report) {
         report.skipped.push(relativeConfigPath);
     }
 }
+async function detectDeprecatedSkillOverrides(projectRoot, root, migration) {
+    const overrideRoot = path.join(projectRoot, root, "pjsdlc_managed", "override_skills");
+    if (!(await pathExists(overrideRoot))) {
+        return [];
+    }
+    const deprecatedFiles = (await listFiles(overrideRoot))
+        .filter((file) => path.basename(file) !== ".gitkeep")
+        .map((file) => path.relative(projectRoot, file).split(path.sep).join("/"))
+        .sort();
+    return deprecatedFiles.map((file) => item(migration, "manual_required", file, "Skill overrides are no longer supported; move rules into a standalone project-local Skill before relying on sync."));
+}
+async function ambiguousAreaContextFiles(projectRoot) {
+    const areasRoot = path.join(projectRoot, "project_context", "areas");
+    const areaFiles = (await listFiles(areasRoot)).filter((file) => file.endsWith(".md")).sort();
+    const ambiguous = [];
+    for (const file of areaFiles) {
+        const relativeToAreas = path.relative(areasRoot, file).split(path.sep).join("/");
+        if (!relativeToAreas.includes("/")) {
+            continue;
+        }
+        if (inferredRoleContext(relativeToAreas)) {
+            continue;
+        }
+        const base = path.basename(relativeToAreas, ".md").toLowerCase();
+        if (base === "readme" || base === "index") {
+            continue;
+        }
+        ambiguous.push(`project_context/areas/${relativeToAreas}`);
+    }
+    return ambiguous;
+}
+function item(migrationId, status, pathLabel, message) {
+    const migration = migrations.find((entry) => entry.id === migrationId);
+    if (!migration) {
+        throw new Error(`Unknown migration id: ${migrationId}`);
+    }
+    return {
+        id: migration.id,
+        introducedIn: migration.introducedIn,
+        description: migration.description,
+        scope: migration.scope,
+        status,
+        path: pathLabel,
+        message
+    };
+}
 function hasHeading(content, heading) {
     const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     return new RegExp(`^##\\s+${escaped}\\s*$`, "im").test(content);
@@ -156,6 +395,16 @@ function rewriteLegacyModuleReferences(content) {
         .replace(/project_context\/modules\//g, "project_context/areas/")
         .replace(/\(modules\//g, "(areas/");
 }
+function inferredRoleContext(relativeToAreas) {
+    const normalized = relativeToAreas.toLowerCase();
+    if (normalized.endsWith("/verification.md") || normalized === "verification.md") {
+        return "verification";
+    }
+    if (normalized.endsWith("/deployment.md") || normalized === "deployment.md") {
+        return "deployment";
+    }
+    return undefined;
+}
 function ensureManifestDefaultArea(content) {
     if (/^\s*default\s*=\s*true\s*$/im.test(content)) {
         return content;

package/dist/lib/sync-engine.d.ts

@@ -3,5 +3,8 @@ export interface SyncReport {
     skipped: string[];
     blocked: string[];
 }
+export interface SyncOptions {
+    allowPendingMigrations?: boolean;
+}
 export declare function emptySyncReport(): SyncReport;
-export declare function runSync(projectRoot: string): Promise<SyncReport>;
+export declare function runSync(projectRoot: string, options?: SyncOptions): Promise<SyncReport>;

package/dist/lib/sync-engine.js

@@ -6,6 +6,7 @@ import { copyTree, listFiles, pathExists, readText, writeTextIfChanged } from ".
 import { AGENTS_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_END, GITHUB_WORKFLOW_BLOCK_START, MAKEFILE_BLOCK_END, MAKEFILE_BLOCK_MARKERS, MAKEFILE_BLOCK_START, MANAGED_BLOCK_END, MANAGED_BLOCK_START } from "./managed-file.js";
 import { packageAssetPath } from "./paths.js";
 import { assertSupportedSchema } from "./schema-guard.js";
+import { createUpgradePlan, formatUpgradePlan, hasUpgradePlanWork } from "./migrations.js";
 export function emptySyncReport() {
     return {
         changed: [],
@@ -13,11 +14,18 @@ export function emptySyncReport() {
         blocked: []
     };
 }
-export async function runSync(projectRoot) {
+export async function runSync(projectRoot, options = {}) {
     await assertSupportedSchema(projectRoot, "sync");
     const root = await harnessRoot(projectRoot);
     const config = await readConfig(projectRoot);
     const report = emptySyncReport();
+    if (!options.allowPendingMigrations) {
+        const upgradePlan = await createUpgradePlan(projectRoot);
+        if (hasUpgradePlanWork(upgradePlan)) {
+            report.blocked.push(`upgrade required before sync: ${formatUpgradePlan(upgradePlan).join(" | ")}`);
+            return report;
+        }
+    }
     await blockDeprecatedSkillOverrides(projectRoot, root, report);
     if (report.blocked.length > 0) {
         return report;

package/dist/lib/upgrade.js

@@ -1,20 +1,30 @@
 import { runDoctor } from "./doctor.js";
-import { runMigrations } from "./migrations.js";
+import { formatUpgradePlan, runMigrations } from "./migrations.js";
 import { assertSupportedSchema } from "./schema-guard.js";
 import { runSync } from "./sync-engine.js";
 export async function runUpgrade(projectRoot) {
     const lines = [];
     await assertSupportedSchema(projectRoot, "upgrade");
     const migrationReport = await runMigrations(projectRoot);
-    lines.push(`migrations changed=${migrationReport.changed.length} skipped=${migrationReport.skipped.length}`);
-    const syncReport = await runSync(projectRoot);
+    lines.push(`migrations changed=${migrationReport.changed.length} skipped=${migrationReport.skipped.length} manual_required=${migrationReport.manualRequired.length} blocked=${migrationReport.blocked.length}`);
+    if (migrationReport.manualRequired.length > 0 || migrationReport.blocked.length > 0) {
+        lines.push(...formatUpgradePlan({
+            safe_pending: [],
+            manual_required: migrationReport.manualRequired,
+            blocked: migrationReport.blocked
+        }).slice(1));
+    }
+    const syncReport = await runSync(projectRoot, { allowPendingMigrations: true });
     lines.push(`sync changed=${syncReport.changed.length} skipped=${syncReport.skipped.length} blocked=${syncReport.blocked.length}`);
     for (const skipped of syncReport.skipped.filter((line) => line.includes("customized"))) {
         lines.push(`sync skipped: ${skipped}`);
     }
     const doctor = await runDoctor(projectRoot);
     lines.push(`doctor warnings=${doctor.warnings.length} errors=${doctor.errors.length}`);
-    if (syncReport.blocked.length > 0 || doctor.errors.length > 0) {
+    if (migrationReport.manualRequired.length > 0 ||
+        migrationReport.blocked.length > 0 ||
+        syncReport.blocked.length > 0 ||
+        doctor.errors.length > 0) {
         throw new Error("upgrade completed with blockers");
     }
     return lines;

package/migrations/README.md

@@ -1,3 +1,3 @@
-# Migrations
-
-Schema migrations for `.harness/config.yaml` and managed file layout belong here.
+# Migrations
+
+Schema migrations for `.harness/config.yaml` and managed file layout belong here.

package/package.json

@@ -1,68 +1,68 @@
-{
-  "name": "project-tiny-context-harness",
-  "version": "0.2.49",
-  "description": "Minimal project memory and validation harness for AI coding agents.",
-  "license": "MIT",
-  "author": "Seven128",
-  "homepage": "https://github.com/Seven128/project-tiny-context-harness#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
-    "directory": "packages/sdlc-harness"
-  },
-  "bugs": {
-    "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
-  },
-  "keywords": [
-    "ai-agents",
-    "coding-agent",
-    "codex",
-    "claude-code",
-    "cursor",
-    "gemini-cli",
-    "opencode",
-    "agent-context",
-    "context-engineering",
-    "context-management",
-    "agents-md",
-    "project-memory",
-    "agent-memory",
-    "ai-coding",
-    "multi-agent",
-    "llm",
-    "developer-tools",
-    "developer-productivity",
-    "cli",
-    "sdlc",
-    "workflow"
-  ],
-  "type": "module",
-  "bin": {
-    "sdlc-harness": "dist/cli.js"
-  },
-  "files": [
-    "README.md",
-    "dist",
-    "assets",
-    "migrations",
-    "source-mappings.yaml"
-  ],
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "npm run build && node --test ../../tests/sdlc-harness/*.test.mjs",
-    "prepack": "npm run build"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "@google/design.md": "^0.2.0",
-    "impeccable": "^2.3.2",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/node": "^24.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "project-tiny-context-harness",
+  "version": "0.2.51",
+  "description": "Minimal project memory and validation harness for AI coding agents.",
+  "license": "MIT",
+  "author": "Seven128",
+  "homepage": "https://github.com/Seven128/project-tiny-context-harness#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
+    "directory": "packages/sdlc-harness"
+  },
+  "bugs": {
+    "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "coding-agent",
+    "codex",
+    "claude-code",
+    "cursor",
+    "gemini-cli",
+    "opencode",
+    "agent-context",
+    "context-engineering",
+    "context-management",
+    "agents-md",
+    "project-memory",
+    "agent-memory",
+    "ai-coding",
+    "multi-agent",
+    "llm",
+    "developer-tools",
+    "developer-productivity",
+    "cli",
+    "sdlc",
+    "workflow"
+  ],
+  "type": "module",
+  "bin": {
+    "sdlc-harness": "dist/cli.js"
+  },
+  "files": [
+    "README.md",
+    "dist",
+    "assets",
+    "migrations",
+    "source-mappings.yaml"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test ../../tests/sdlc-harness/*.test.mjs",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@google/design.md": "^0.2.0",
+    "impeccable": "^2.3.2",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.5.0"
+  }
+}