project-tiny-context-harness 0.2.53 → 0.2.55

package/dist/lib/harness-root.d.ts

@@ -2,7 +2,12 @@ export interface HarnessRootConfig {
     harnessFolderName: string;
     source: string;
 }
+export interface HarnessRootConfigCandidate extends HarnessRootConfig {
+    legacy: boolean;
+}
+export declare const LEGACY_HARNESS_JSON_CONFIG_PATH = "sdlc-harness.config.json";
 export declare function readHarnessRootConfig(projectRoot: string): Promise<HarnessRootConfig>;
+export declare function readHarnessRootConfigCandidates(projectRoot: string): Promise<HarnessRootConfigCandidate[]>;
 export declare function harnessRoot(projectRoot: string): Promise<string>;
 export declare function harnessConfigPath(projectRoot: string): Promise<string>;
 export declare function harnessPath(root: string, ...segments: string[]): string;

package/dist/lib/harness-root.js

@@ -1,19 +1,47 @@
 import path from "node:path";
 import { DEFAULT_HARNESS_ROOT, HARNESS_JSON_CONFIG_PATH } from "./paths.js";
 import { pathExists, readText } from "./fs.js";
+export const LEGACY_HARNESS_JSON_CONFIG_PATH = "sdlc-harness.config.json";
 export async function readHarnessRootConfig(projectRoot) {
+    const candidates = await readHarnessRootConfigCandidates(projectRoot);
+    if (candidates.length > 0) {
+        const candidate = candidates[0];
+        return { harnessFolderName: candidate.harnessFolderName, source: candidate.source };
+    }
+    return { harnessFolderName: DEFAULT_HARNESS_ROOT, source: "default" };
+}
+export async function readHarnessRootConfigCandidates(projectRoot) {
+    const candidates = [];
     const packageJson = await readJsonConfig(path.join(projectRoot, "package.json"));
-    const packageConfig = packageJson && typeof packageJson === "object" ? packageJson.sdlcHarness : undefined;
+    const packageConfig = packageJson && typeof packageJson === "object" ? packageJson.tyContext : undefined;
     const packageValue = folderNameFromObject(packageConfig);
     if (packageValue) {
-        return { harnessFolderName: normalizeHarnessFolderName(packageValue), source: "package.json#sdlcHarness" };
+        candidates.push({ harnessFolderName: normalizeHarnessFolderName(packageValue), source: "package.json#tyContext", legacy: false });
     }
     const explicitConfig = await readJsonConfig(path.join(projectRoot, HARNESS_JSON_CONFIG_PATH));
     const explicitValue = folderNameFromObject(explicitConfig);
     if (explicitValue) {
-        return { harnessFolderName: normalizeHarnessFolderName(explicitValue), source: HARNESS_JSON_CONFIG_PATH };
+        candidates.push({ harnessFolderName: normalizeHarnessFolderName(explicitValue), source: HARNESS_JSON_CONFIG_PATH, legacy: false });
     }
-    return { harnessFolderName: DEFAULT_HARNESS_ROOT, source: "default" };
+    const legacyPackageConfig = packageJson && typeof packageJson === "object" ? packageJson.sdlcHarness : undefined;
+    const legacyPackageValue = folderNameFromObject(legacyPackageConfig);
+    if (legacyPackageValue) {
+        candidates.push({
+            harnessFolderName: normalizeHarnessFolderName(legacyPackageValue),
+            source: "package.json#sdlcHarness",
+            legacy: true
+        });
+    }
+    const legacyExplicitConfig = await readJsonConfig(path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH));
+    const legacyExplicitValue = folderNameFromObject(legacyExplicitConfig);
+    if (legacyExplicitValue) {
+        candidates.push({
+            harnessFolderName: normalizeHarnessFolderName(legacyExplicitValue),
+            source: LEGACY_HARNESS_JSON_CONFIG_PATH,
+            legacy: true
+        });
+    }
+    return candidates;
 }
 export async function harnessRoot(projectRoot) {
     return (await readHarnessRootConfig(projectRoot)).harnessFolderName;

package/dist/lib/legacy-managed-scan.d.ts

@@ -0,0 +1,2 @@
+import type { Migration, UpgradePlanItem } from "./migrations.js";
+export declare function detectLegacyManagedDirectory(projectRoot: string, root: string, migration: Migration): Promise<UpgradePlanItem[]>;

package/dist/lib/legacy-managed-scan.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+import { listFiles, pathExists, readText } from "./fs.js";
+import { packageAssetPath } from "./paths.js";
+const LEGACY_MANAGED_ROOT = "pjsdlc_managed";
+const CURRENT_MANAGED_ROOT = "ty-context-managed";
+const LEGACY_MAKEFILE = "sdlc-harness.mk";
+const CURRENT_MAKEFILE = "ty-context.mk";
+export async function detectLegacyManagedDirectory(projectRoot, root, migration) {
+    const legacyRoot = path.join(projectRoot, root, LEGACY_MANAGED_ROOT);
+    const files = await listFiles(legacyRoot);
+    const items = [];
+    for (const file of files) {
+        if (path.basename(file) === ".gitkeep") {
+            continue;
+        }
+        const relativeToLegacyRoot = path.relative(legacyRoot, file).split(path.sep).join("/");
+        const relativeToProject = path.relative(projectRoot, file).split(path.sep).join("/");
+        const classification = await classifyLegacyManagedFile(relativeToLegacyRoot);
+        if (classification.kind === "override") {
+            items.push(item(migration, "manual_required", relativeToProject, "Legacy skill overrides are no longer supported; move rules into a standalone project-local Skill."));
+            continue;
+        }
+        if (classification.kind === "unknown") {
+            items.push(item(migration, "manual_required", relativeToProject, "Legacy pjsdlc_managed content is not recognized as package-generated; review it manually."));
+            continue;
+        }
+        const target = path.join(projectRoot, root, CURRENT_MANAGED_ROOT, ...classification.targetRelative.split("/"));
+        if (!(await pathExists(target))) {
+            continue;
+        }
+        const assetContent = await readText(classification.assetPath);
+        if ((await readText(target)) !== assetContent) {
+            items.push(item(migration, "blocked", path.relative(projectRoot, target).split(path.sep).join("/"), `Cannot refresh legacy generated file because ${classification.targetRelative} already exists with non-package content.`));
+        }
+    }
+    return items;
+}
+async function classifyLegacyManagedFile(relative) {
+    if (relative.startsWith("override_skills/")) {
+        return { kind: "override" };
+    }
+    const mapped = legacyGeneratedMapping(relative);
+    if (!mapped) {
+        return { kind: "unknown" };
+    }
+    const assetPath = packageAssetPath(...mapped.assetSegments);
+    if (!(await pathExists(assetPath))) {
+        return { kind: "unknown" };
+    }
+    return { kind: "generated", targetRelative: mapped.targetRelative, assetPath };
+}
+function legacyGeneratedMapping(relative) {
+    if (relative === `make/${LEGACY_MAKEFILE}`) {
+        return { targetRelative: `make/${CURRENT_MAKEFILE}`, assetSegments: ["make", CURRENT_MAKEFILE] };
+    }
+    for (const [prefix, assetPrefix] of [
+        ["agents/", "agents"],
+        ["context_templates/", "context_templates"],
+        ["skills/", "skills"],
+        ["minimal_tools/", "tools"]
+    ]) {
+        if (relative.startsWith(prefix)) {
+            const rest = relative.slice(prefix.length);
+            return { targetRelative: `${prefix}${rest}`, assetSegments: [assetPrefix, ...rest.split("/")] };
+        }
+    }
+    return undefined;
+}
+function item(migration, status, pathLabel, message) {
+    return {
+        id: migration.id,
+        introducedIn: migration.introducedIn,
+        description: migration.description,
+        scope: migration.scope,
+        status,
+        path: pathLabel,
+        message
+    };
+}

package/dist/lib/legacy-sdlc-migration.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from "./migrations.js";
+export declare const legacySdlcHarnessMigration: Migration;

package/dist/lib/legacy-sdlc-migration.js

@@ -0,0 +1,189 @@
+import path from "node:path";
+import { LEGACY_HARNESS_JSON_CONFIG_PATH, readHarnessRootConfigCandidates } from "./harness-root.js";
+import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { detectLegacyManagedDirectory } from "./legacy-managed-scan.js";
+import { HARNESS_JSON_CONFIG_PATH } from "./paths.js";
+const LEGACY_MANAGED_ROOT = "pjsdlc_managed";
+const CURRENT_MANAGED_ROOT = "ty-context-managed";
+const LEGACY_MAKEFILE = "sdlc-harness.mk";
+const CURRENT_MAKEFILE = "ty-context.mk";
+export const legacySdlcHarnessMigration = {
+    id: "legacy-sdlc-harness-rename",
+    introducedIn: "0.2.54",
+    description: "Rename legacy sdlc-harness configuration and pjsdlc_managed package-managed paths.",
+    scope: "package.json, sdlc-harness.config.json, <harnessRoot>/config.yaml, old managed markers and pjsdlc_managed/**",
+    risk: "safe",
+    manualMessage: "Resolve legacy sdlc-harness conflicts or move old override rules into standalone project-local Skills.",
+    detect: detectLegacySdlcHarness,
+    apply: migrateLegacySdlcHarness,
+    verify: async () => undefined
+};
+async function detectLegacySdlcHarness(projectRoot, root, migration) {
+    const items = [];
+    const candidates = await readHarnessRootConfigCandidates(projectRoot);
+    const currentCandidates = candidates.filter((candidate) => !candidate.legacy);
+    const legacyCandidates = candidates.filter((candidate) => candidate.legacy);
+    const currentRoot = currentCandidates[0]?.harnessFolderName;
+    const distinctLegacyRoots = Array.from(new Set(legacyCandidates.map((candidate) => candidate.harnessFolderName)));
+    if (currentRoot && distinctLegacyRoots.some((legacyRoot) => legacyRoot !== currentRoot)) {
+        items.push(item(migration, "blocked", rootConflictPath(currentCandidates, legacyCandidates), "Current ty-context and legacy sdlc-harness root configuration disagree; choose the harness root manually before upgrade."));
+    }
+    else if (!currentRoot && distinctLegacyRoots.length > 1) {
+        items.push(item(migration, "blocked", rootConflictPath(currentCandidates, legacyCandidates), "Legacy sdlc-harness root sources disagree; choose one harness root manually before upgrade."));
+    }
+    items.push(...(await detectLegacyManagedDirectory(projectRoot, root, legacySdlcHarnessMigration)));
+    if (items.some((entry) => entry.status === "blocked")) {
+        return items;
+    }
+    if (await needsLegacySafeMigration(projectRoot, root, legacyCandidates.length > 0)) {
+        items.unshift(item(migration, "safe_pending", "legacy sdlc-harness surfaces", "Legacy sdlc-harness naming can be copied to ty-context configuration and refreshed by sync."));
+    }
+    return items;
+}
+async function migrateLegacySdlcHarness(projectRoot, root, report) {
+    await migratePackageJsonConfig(projectRoot, report);
+    await migrateJsonConfig(projectRoot, report);
+    await migrateConfigYamlPaths(projectRoot, root, report);
+}
+async function needsLegacySafeMigration(projectRoot, root, hasLegacyRootConfig) {
+    if (hasLegacyRootConfig && (await legacyPackageConfigNeedsCopy(projectRoot))) {
+        return true;
+    }
+    if (await legacyJsonConfigNeedsCopy(projectRoot)) {
+        return true;
+    }
+    if (await configYamlHasLegacyManagedPaths(projectRoot, root)) {
+        return true;
+    }
+    if (await hasLegacyManagedMarkers(projectRoot)) {
+        return true;
+    }
+    return false;
+}
+async function legacyPackageConfigNeedsCopy(projectRoot) {
+    const packagePath = path.join(projectRoot, "package.json");
+    if (!(await pathExists(packagePath))) {
+        return false;
+    }
+    const packageJson = parseJsonRecord(await readText(packagePath), "package.json");
+    return isJsonRecord(packageJson.sdlcHarness) && !isJsonRecord(packageJson.tyContext);
+}
+async function legacyJsonConfigNeedsCopy(projectRoot) {
+    const legacyPath = path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH);
+    const currentPath = path.join(projectRoot, HARNESS_JSON_CONFIG_PATH);
+    return (await pathExists(legacyPath)) && !(await pathExists(currentPath));
+}
+async function configYamlHasLegacyManagedPaths(projectRoot, root) {
+    const configPath = path.join(projectRoot, root, "config.yaml");
+    if (!(await pathExists(configPath))) {
+        return false;
+    }
+    return hasLegacyManagedPath(await readText(configPath));
+}
+async function hasLegacyManagedMarkers(projectRoot) {
+    for (const relative of ["AGENTS.md", "Makefile", ".github/workflows/harness.yml"]) {
+        const target = path.join(projectRoot, ...relative.split("/"));
+        if ((await pathExists(target)) && hasLegacyMarker(await readText(target))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function migratePackageJsonConfig(projectRoot, report) {
+    const packagePath = path.join(projectRoot, "package.json");
+    if (!(await pathExists(packagePath))) {
+        report.skipped.push("package.json#sdlcHarness");
+        return;
+    }
+    const packageJson = parseJsonRecord(await readText(packagePath), "package.json");
+    if (!isJsonRecord(packageJson.sdlcHarness) || isJsonRecord(packageJson.tyContext)) {
+        report.skipped.push("package.json#sdlcHarness");
+        return;
+    }
+    packageJson.tyContext = { ...packageJson.sdlcHarness };
+    if (await writeTextIfChanged(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`)) {
+        report.changed.push("package.json#tyContext");
+    }
+    else {
+        report.skipped.push("package.json#tyContext");
+    }
+}
+async function migrateJsonConfig(projectRoot, report) {
+    const legacyPath = path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH);
+    const currentPath = path.join(projectRoot, HARNESS_JSON_CONFIG_PATH);
+    if (!(await pathExists(legacyPath))) {
+        report.skipped.push(LEGACY_HARNESS_JSON_CONFIG_PATH);
+        return;
+    }
+    if (await pathExists(currentPath)) {
+        report.skipped.push(HARNESS_JSON_CONFIG_PATH);
+        return;
+    }
+    if (await writeTextIfChanged(currentPath, await readText(legacyPath))) {
+        report.changed.push(HARNESS_JSON_CONFIG_PATH);
+    }
+    else {
+        report.skipped.push(HARNESS_JSON_CONFIG_PATH);
+    }
+}
+async function migrateConfigYamlPaths(projectRoot, root, report) {
+    const relative = `${root}/config.yaml`;
+    const configPath = path.join(projectRoot, root, "config.yaml");
+    if (!(await pathExists(configPath))) {
+        report.skipped.push(relative);
+        return;
+    }
+    const original = await readText(configPath);
+    const next = rewriteLegacyManagedPaths(original);
+    if (next === original) {
+        report.skipped.push(relative);
+        return;
+    }
+    if (await writeTextIfChanged(configPath, next)) {
+        report.changed.push(`${relative}#legacy-managed-paths`);
+    }
+    else {
+        report.skipped.push(`${relative}#legacy-managed-paths`);
+    }
+}
+function rewriteLegacyManagedPaths(content) {
+    return content.replaceAll(LEGACY_MANAGED_ROOT, CURRENT_MANAGED_ROOT).replaceAll(LEGACY_MAKEFILE, CURRENT_MAKEFILE);
+}
+function hasLegacyManagedPath(content) {
+    return content.includes(LEGACY_MANAGED_ROOT) || content.includes(LEGACY_MAKEFILE);
+}
+function hasLegacyMarker(content) {
+    return [
+        "<!-- pjsdlc:sdlc-harness:begin -->",
+        "<!-- sdlc-harness:begin -->",
+        "# pjsdlc:sdlc-harness:make:begin",
+        "# sdlc-harness:make:begin",
+        "# pjsdlc:sdlc-harness:github-workflow:begin"
+    ].some((marker) => content.includes(marker));
+}
+function rootConflictPath(currentCandidates, legacyCandidates) {
+    return [...currentCandidates, ...legacyCandidates]
+        .map((candidate) => `${candidate.source}=${candidate.harnessFolderName}`)
+        .join(", ");
+}
+function item(migrationId, status, pathLabel, message) {
+    return {
+        id: legacySdlcHarnessMigration.id,
+        introducedIn: legacySdlcHarnessMigration.introducedIn,
+        description: legacySdlcHarnessMigration.description,
+        scope: legacySdlcHarnessMigration.scope,
+        status,
+        path: pathLabel,
+        message
+    };
+}
+function parseJsonRecord(content, pathLabel) {
+    const parsed = JSON.parse(content);
+    if (!isJsonRecord(parsed)) {
+        throw new Error(`${pathLabel} must contain a JSON object`);
+    }
+    return parsed;
+}
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/lib/managed-file.d.ts

@@ -2,18 +2,24 @@ export interface ManagedBlockMarkers {
     start: string;
     end: string;
 }
-export declare const MANAGED_BLOCK_START = "<!-- pjsdlc:sdlc-harness:begin -->";
-export declare const MANAGED_BLOCK_END = "<!-- pjsdlc:sdlc-harness:end -->";
-export declare const LEGACY_MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
-export declare const LEGACY_MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
-export declare const MAKEFILE_BLOCK_START = "# pjsdlc:sdlc-harness:make:begin";
-export declare const MAKEFILE_BLOCK_END = "# pjsdlc:sdlc-harness:make:end";
-export declare const LEGACY_MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
-export declare const LEGACY_MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
-export declare const GITHUB_WORKFLOW_BLOCK_START = "# pjsdlc:sdlc-harness:github-workflow:begin";
-export declare const GITHUB_WORKFLOW_BLOCK_END = "# pjsdlc:sdlc-harness:github-workflow:end";
-export declare const MANAGED_METADATA_START = "<!-- pjsdlc:sdlc-harness-managed";
-export declare const LEGACY_MANAGED_METADATA_START = "<!-- sdlc-harness-managed";
+export declare const MANAGED_BLOCK_START = "<!-- ty-context:managed:begin -->";
+export declare const MANAGED_BLOCK_END = "<!-- ty-context:managed:end -->";
+export declare const LEGACY_PJSDLC_MANAGED_BLOCK_START = "<!-- pjsdlc:sdlc-harness:begin -->";
+export declare const LEGACY_PJSDLC_MANAGED_BLOCK_END = "<!-- pjsdlc:sdlc-harness:end -->";
+export declare const LEGACY_SDLC_MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
+export declare const LEGACY_SDLC_MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
+export declare const MAKEFILE_BLOCK_START = "# ty-context:make:begin";
+export declare const MAKEFILE_BLOCK_END = "# ty-context:make:end";
+export declare const LEGACY_PJSDLC_MAKEFILE_BLOCK_START = "# pjsdlc:sdlc-harness:make:begin";
+export declare const LEGACY_PJSDLC_MAKEFILE_BLOCK_END = "# pjsdlc:sdlc-harness:make:end";
+export declare const LEGACY_SDLC_MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
+export declare const LEGACY_SDLC_MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
+export declare const GITHUB_WORKFLOW_BLOCK_START = "# ty-context:github-workflow:begin";
+export declare const GITHUB_WORKFLOW_BLOCK_END = "# ty-context:github-workflow:end";
+export declare const LEGACY_PJSDLC_GITHUB_WORKFLOW_BLOCK_START = "# pjsdlc:sdlc-harness:github-workflow:begin";
+export declare const LEGACY_PJSDLC_GITHUB_WORKFLOW_BLOCK_END = "# pjsdlc:sdlc-harness:github-workflow:end";
+export declare const MANAGED_METADATA_START = "<!-- ty-context-managed";
 export declare const MANAGED_METADATA_END = "-->";
 export declare const AGENTS_BLOCK_MARKERS: ManagedBlockMarkers[];
 export declare const MAKEFILE_BLOCK_MARKERS: ManagedBlockMarkers[];
+export declare const GITHUB_WORKFLOW_BLOCK_MARKERS: ManagedBlockMarkers[];

package/dist/lib/managed-file.js

@@ -1,21 +1,32 @@
-export const MANAGED_BLOCK_START = "<!-- pjsdlc:sdlc-harness:begin -->";
-export const MANAGED_BLOCK_END = "<!-- pjsdlc:sdlc-harness:end -->";
-export const LEGACY_MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
-export const LEGACY_MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
-export const MAKEFILE_BLOCK_START = "# pjsdlc:sdlc-harness:make:begin";
-export const MAKEFILE_BLOCK_END = "# pjsdlc:sdlc-harness:make:end";
-export const LEGACY_MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
-export const LEGACY_MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
-export const GITHUB_WORKFLOW_BLOCK_START = "# pjsdlc:sdlc-harness:github-workflow:begin";
-export const GITHUB_WORKFLOW_BLOCK_END = "# pjsdlc:sdlc-harness:github-workflow:end";
-export const MANAGED_METADATA_START = "<!-- pjsdlc:sdlc-harness-managed";
-export const LEGACY_MANAGED_METADATA_START = "<!-- sdlc-harness-managed";
+export const MANAGED_BLOCK_START = "<!-- ty-context:managed:begin -->";
+export const MANAGED_BLOCK_END = "<!-- ty-context:managed:end -->";
+export const LEGACY_PJSDLC_MANAGED_BLOCK_START = "<!-- pjsdlc:sdlc-harness:begin -->";
+export const LEGACY_PJSDLC_MANAGED_BLOCK_END = "<!-- pjsdlc:sdlc-harness:end -->";
+export const LEGACY_SDLC_MANAGED_BLOCK_START = "<!-- sdlc-harness:begin -->";
+export const LEGACY_SDLC_MANAGED_BLOCK_END = "<!-- sdlc-harness:end -->";
+export const MAKEFILE_BLOCK_START = "# ty-context:make:begin";
+export const MAKEFILE_BLOCK_END = "# ty-context:make:end";
+export const LEGACY_PJSDLC_MAKEFILE_BLOCK_START = "# pjsdlc:sdlc-harness:make:begin";
+export const LEGACY_PJSDLC_MAKEFILE_BLOCK_END = "# pjsdlc:sdlc-harness:make:end";
+export const LEGACY_SDLC_MAKEFILE_BLOCK_START = "# sdlc-harness:make:begin";
+export const LEGACY_SDLC_MAKEFILE_BLOCK_END = "# sdlc-harness:make:end";
+export const GITHUB_WORKFLOW_BLOCK_START = "# ty-context:github-workflow:begin";
+export const GITHUB_WORKFLOW_BLOCK_END = "# ty-context:github-workflow:end";
+export const LEGACY_PJSDLC_GITHUB_WORKFLOW_BLOCK_START = "# pjsdlc:sdlc-harness:github-workflow:begin";
+export const LEGACY_PJSDLC_GITHUB_WORKFLOW_BLOCK_END = "# pjsdlc:sdlc-harness:github-workflow:end";
+export const MANAGED_METADATA_START = "<!-- ty-context-managed";
 export const MANAGED_METADATA_END = "-->";
 export const AGENTS_BLOCK_MARKERS = [
     { start: MANAGED_BLOCK_START, end: MANAGED_BLOCK_END },
-    { start: LEGACY_MANAGED_BLOCK_START, end: LEGACY_MANAGED_BLOCK_END }
+    { start: LEGACY_PJSDLC_MANAGED_BLOCK_START, end: LEGACY_PJSDLC_MANAGED_BLOCK_END },
+    { start: LEGACY_SDLC_MANAGED_BLOCK_START, end: LEGACY_SDLC_MANAGED_BLOCK_END }
 ];
 export const MAKEFILE_BLOCK_MARKERS = [
     { start: MAKEFILE_BLOCK_START, end: MAKEFILE_BLOCK_END },
-    { start: LEGACY_MAKEFILE_BLOCK_START, end: LEGACY_MAKEFILE_BLOCK_END }
+    { start: LEGACY_PJSDLC_MAKEFILE_BLOCK_START, end: LEGACY_PJSDLC_MAKEFILE_BLOCK_END },
+    { start: LEGACY_SDLC_MAKEFILE_BLOCK_START, end: LEGACY_SDLC_MAKEFILE_BLOCK_END }
+];
+export const GITHUB_WORKFLOW_BLOCK_MARKERS = [
+    { start: GITHUB_WORKFLOW_BLOCK_START, end: GITHUB_WORKFLOW_BLOCK_END },
+    { start: LEGACY_PJSDLC_GITHUB_WORKFLOW_BLOCK_START, end: LEGACY_PJSDLC_GITHUB_WORKFLOW_BLOCK_END }
 ];

package/dist/lib/migrations.js

@@ -7,11 +7,13 @@ 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 { legacySdlcHarnessMigration } from "./legacy-sdlc-migration.js";
 import { stringifyYaml } from "./yaml.js";
 async function verifyNoop() {
     return;
 }
 export const migrations = [
+    legacySdlcHarnessMigration,
     {
         id: "schema-v4-config-refresh",
         introducedIn: "0.2.0",
@@ -71,7 +73,7 @@ export const migrations = [
         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/**",
+        scope: "<harnessRoot>/ty-context-managed/override_skills/**",
         risk: "manual",
         manualMessage: "Move override files into standalone project-local Skills before running sync.",
         detect: detectDeprecatedSkillOverrides,
@@ -355,7 +357,7 @@ async function migrateConfig(projectRoot, root, report) {
     }
 }
 async function detectDeprecatedSkillOverrides(projectRoot, root, migration) {
-    const overrideRoot = path.join(projectRoot, root, "pjsdlc_managed", "override_skills");
+    const overrideRoot = path.join(projectRoot, root, "ty-context-managed", "override_skills");
     if (!(await pathExists(overrideRoot))) {
         return [];
     }

package/dist/lib/modularity.d.ts

@@ -8,11 +8,20 @@ export interface ModularityFileReport {
     relativePath: string;
     lines: number;
     overLimit: boolean;
+    waived?: ModularityWaiver;
 }
 export interface ModularityCheckReport {
     limit: number;
     files: ModularityFileReport[];
     warnings: string[];
+    waivedWarnings: string[];
+    errors: string[];
+}
+export interface ModularityWaiver {
+    relativePath: string;
+    category: string;
+    reason: string;
+    futureSplitBoundary: string;
 }
 export declare function runModularityCheck(projectRoot: string, options: ModularityCheckOptions): Promise<ModularityCheckReport>;
 export declare function countPhysicalLines(content: string): number;