project-tiny-context-harness 0.2.54 → 0.2.55

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/package-json-config.js

@@ -7,7 +7,7 @@ export async function packageHarnessRoot(projectRoot) {
         return undefined;
     }
     const packageJson = parsePackageJson(await readText(packagePath));
-    const config = packageJson.sdlcHarness;
+    const config = packageJson.tyContext;
     if (!config || typeof config !== "object" || Array.isArray(config)) {
         return undefined;
     }
@@ -18,13 +18,13 @@ export async function writePackageHarnessRoot(projectRoot, folderName) {
     const normalized = normalizeHarnessFolderName(folderName);
     const packagePath = path.join(projectRoot, "package.json");
     const packageJson = (await pathExists(packagePath)) ? parsePackageJson(await readText(packagePath)) : {};
-    const existingConfig = packageJson.sdlcHarness;
+    const existingConfig = packageJson.tyContext;
     const nextConfig = existingConfig && typeof existingConfig === "object" && !Array.isArray(existingConfig)
         ? { ...existingConfig, harnessFolderName: normalized }
         : { harnessFolderName: normalized };
     const next = {
         ...packageJson,
-        sdlcHarness: nextConfig
+        tyContext: nextConfig
     };
     return writeTextIfChanged(packagePath, `${JSON.stringify(next, null, 2)}\n`);
 }

package/dist/lib/paths.d.ts

@@ -1,5 +1,5 @@
-export declare const SOURCE_MAPPINGS_PATH = "packages/sdlc-harness/source-mappings.yaml";
+export declare const SOURCE_MAPPINGS_PATH = "packages/ty-context/source-mappings.yaml";
 export declare const DEFAULT_HARNESS_ROOT = ".agent";
-export declare const HARNESS_JSON_CONFIG_PATH = "sdlc-harness.config.json";
+export declare const HARNESS_JSON_CONFIG_PATH = "ty-context.config.json";
 export declare function packageRoot(): string;
 export declare function packageAssetPath(...segments: string[]): string;

package/dist/lib/paths.js

@@ -1,8 +1,8 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-export const SOURCE_MAPPINGS_PATH = "packages/sdlc-harness/source-mappings.yaml";
+export const SOURCE_MAPPINGS_PATH = "packages/ty-context/source-mappings.yaml";
 export const DEFAULT_HARNESS_ROOT = ".agent";
-export const HARNESS_JSON_CONFIG_PATH = "sdlc-harness.config.json";
+export const HARNESS_JSON_CONFIG_PATH = "ty-context.config.json";
 export function packageRoot() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 }

package/dist/lib/sync-engine.js

@@ -3,7 +3,7 @@ import { promises as fs } from "node:fs";
 import { readConfig } from "./config.js";
 import { harnessPath, harnessRoot } from "./harness-root.js";
 import { copyTree, listFiles, pathExists, readText, writeTextIfChanged } from "./fs.js";
-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 { AGENTS_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_END, GITHUB_WORKFLOW_BLOCK_MARKERS, 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";
@@ -50,20 +50,20 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         return;
     }
     const managedPath = normalizeManagedPath(managedFile.path);
-    if (managedPath === harnessPath(root, "pjsdlc_managed", "templates")) {
+    if (managedPath === harnessPath(root, "ty-context-managed", "templates")) {
         await syncTree(packageAssetPath("templates"), destination, report);
         return;
     }
-    if (managedPath === harnessPath(root, "pjsdlc_managed", "context_templates")) {
+    if (managedPath === harnessPath(root, "ty-context-managed", "context_templates")) {
         await syncTree(packageAssetPath("context_templates"), destination, report, { prune: true });
         return;
     }
-    if (managedPath === harnessPath(root, "pjsdlc_managed", "policies")) {
+    if (managedPath === harnessPath(root, "ty-context-managed", "policies")) {
         await syncTree(packageAssetPath("policies"), destination, report);
         return;
     }
-    if (managedPath === harnessPath(root, "pjsdlc_managed", "make", "sdlc-harness.mk")) {
-        await syncFile(packageAssetPath("make", "sdlc-harness.mk"), destination, report, "skip-if-missing");
+    if (managedPath === harnessPath(root, "ty-context-managed", "make", "ty-context.mk")) {
+        await syncFile(packageAssetPath("make", "ty-context.mk"), destination, report, "skip-if-missing");
         return;
     }
     if (managedFile.path === "tools") {
@@ -118,7 +118,7 @@ function renderAgentsCore(content, root) {
 async function syncMakefileInclude(destination, root, report) {
     const existing = (await pathExists(destination)) ? await readText(destination) : "";
     const resetDefaultGoal = shouldResetMakeDefaultGoal(existing);
-    const includePath = `${root.replace(/\\/g, "/")}/pjsdlc_managed/make/sdlc-harness.mk`;
+    const includePath = `${root.replace(/\\/g, "/")}/ty-context-managed/make/ty-context.mk`;
     const blockLines = [
         MAKEFILE_BLOCK_START,
         "# Included before project targets so project recipes win on name conflicts.",
@@ -264,22 +264,31 @@ async function syncSkillsTree(source, destination, report) {
     }
 }
 async function blockDeprecatedSkillOverrides(projectRoot, root, report) {
-    const overrideRoot = skillOverrideRoot(projectRoot, root);
-    if (!(await pathExists(overrideRoot))) {
-        return;
-    }
-    const deprecatedFiles = (await listFiles(overrideRoot))
-        .filter((file) => path.basename(file) !== ".gitkeep")
-        .map((file) => path.relative(overrideRoot, file).split(path.sep).join("/"))
-        .sort();
-    if (deprecatedFiles.length === 0) {
-        return;
+    for (const overrideRoot of skillOverrideRoots(projectRoot, root)) {
+        if (!(await pathExists(overrideRoot.absolute))) {
+            continue;
+        }
+        const deprecatedFiles = (await listFiles(overrideRoot.absolute))
+            .filter((file) => path.basename(file) !== ".gitkeep")
+            .map((file) => path.relative(overrideRoot.absolute, file).split(path.sep).join("/"))
+            .sort();
+        if (deprecatedFiles.length === 0) {
+            continue;
+        }
+        report.blocked.push(`${overrideRoot.relative}: Skill overrides are no longer supported. Move these rules into a separate project-local Skill such as ${root.replace(/\\/g, "/")}/skills/product_plan/SKILL.md, ${root.replace(/\\/g, "/")}/skills/uiux_design/SKILL.md or ${root.replace(/\\/g, "/")}/skills/development_engineer/SKILL.md. Deprecated files: ${deprecatedFiles.join(", ")}`);
     }
-    const relativeRoot = path.join(root, "pjsdlc_managed", "override_skills").split(path.sep).join("/");
-    report.blocked.push(`${relativeRoot}: Skill overrides are no longer supported. Move these rules into a separate project-local Skill such as ${root.replace(/\\/g, "/")}/skills/product_plan/SKILL.md, ${root.replace(/\\/g, "/")}/skills/uiux_design/SKILL.md or ${root.replace(/\\/g, "/")}/skills/development_engineer/SKILL.md. Deprecated files: ${deprecatedFiles.join(", ")}`);
 }
-function skillOverrideRoot(projectRoot, root) {
-    return path.join(projectRoot, root, "pjsdlc_managed", "override_skills");
+function skillOverrideRoots(projectRoot, root) {
+    return [
+        {
+            absolute: path.join(projectRoot, root, "ty-context-managed", "override_skills"),
+            relative: path.join(root, "ty-context-managed", "override_skills").split(path.sep).join("/")
+        },
+        {
+            absolute: path.join(projectRoot, root, "pjsdlc_managed", "override_skills"),
+            relative: path.join(root, "pjsdlc_managed", "override_skills").split(path.sep).join("/")
+        }
+    ];
 }
 async function syncFile(source, destination, report, missingMode) {
     if (!(await pathExists(source))) {
@@ -331,18 +340,11 @@ async function syncGithubWorkflow(source, destination, relativePath, report) {
     report.skipped.push(`${relativePath}: customized`);
 }
 function workflowMarkerState(content) {
-    const startIndex = content.indexOf(GITHUB_WORKFLOW_BLOCK_START);
-    const endIndex = content.indexOf(GITHUB_WORKFLOW_BLOCK_END);
-    const hasStart = startIndex >= 0;
-    const hasEnd = endIndex >= 0;
-    if (!hasStart && !hasEnd) {
+    const found = findManagedBlock(content, GITHUB_WORKFLOW_BLOCK_MARKERS);
+    if (found.status === "missing") {
         return "missing";
     }
-    if (hasStart !== hasEnd || endIndex < startIndex) {
-        return "invalid";
-    }
-    if (content.indexOf(GITHUB_WORKFLOW_BLOCK_START, startIndex + GITHUB_WORKFLOW_BLOCK_START.length) >= 0 ||
-        content.indexOf(GITHUB_WORKFLOW_BLOCK_END, endIndex + GITHUB_WORKFLOW_BLOCK_END.length) >= 0) {
+    if (found.status === "invalid") {
         return "invalid";
     }
     return "managed";

package/dist/lib/validators.js

@@ -160,7 +160,7 @@ async function validateContext(projectRoot) {
         }
     }
     else if (schemaRequiresContextManifest(schemaVersion)) {
-        errors.push("project_context/context.toml is missing; run sdlc-harness upgrade to create the Schema v4 Context graph manifest");
+        errors.push("project_context/context.toml is missing; run ty-context upgrade to create the Schema v4 Context graph manifest");
     }
     const contextFiles = (await listFiles(projectContextRoot))
         .filter((file) => file.endsWith(".md"))
@@ -243,7 +243,7 @@ async function validateContextManifest(projectRoot, manifest, manifestRoles, err
 async function addManifestRole(projectRoot, roles, rawPath, role, source, errors) {
     const relative = normalizeContextPath(rawPath);
     if (looksLikeExportArtifact(relative)) {
-        errors.push(`project_context/context.toml ${source} must not reference temporary export artifact ${rawPath}; export artifacts belong in tmp/sdlc/context-exports/** and must not be registered as Context graph nodes or implementation-index`);
+        errors.push(`project_context/context.toml ${source} must not reference temporary export artifact ${rawPath}; export artifacts belong in tmp/ty-context/context-exports/** and must not be registered as Context graph nodes or implementation-index`);
         return;
     }
     if (!relative.startsWith("project_context/") || !relative.endsWith(".md")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.2.54",
+  "version": "0.2.55",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",
@@ -8,7 +8,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
-    "directory": "packages/sdlc-harness"
+    "directory": "packages/ty-context"
   },
   "bugs": {
     "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
@@ -33,12 +33,12 @@
     "developer-tools",
     "developer-productivity",
     "cli",
-    "sdlc",
+    "ty-context",
     "workflow"
   ],
   "type": "module",
   "bin": {
-    "sdlc-harness": "dist/cli.js"
+    "ty-context": "dist/cli.js"
   },
   "files": [
     "README.md",
@@ -50,7 +50,7 @@
   "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",
+    "test": "npm run build && node --test ../../tests/ty-context/*.test.mjs",
     "prepack": "npm run build"
   },
   "engines": {