project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/lib/source-pack-manifest.js

@@ -19,7 +19,7 @@ export async function buildManifest(params) {
         artifacts: params.artifacts.map((artifact) => artifactReport(artifact)),
         warnings: params.warnings,
         omitted: params.omitted,
-        recommended_upload_sets: params.recommendedUploadSets
+        recommended_upload_sets: params.recommendedUploadSets,
     };
     return `${JSON.stringify(manifest, null, 2)}\n`;
 }
@@ -32,7 +32,7 @@ export function artifactReport(artifact) {
         characters: artifact.content.length,
         source_count: artifact.sourceCount,
         source_line_count: artifact.sourceLineCount,
-        warning_count: artifact.warningCount
+        warning_count: artifact.warningCount,
     };
 }
 export async function writeArtifactSet(projectRoot, outputDir, artifacts) {
@@ -55,13 +55,22 @@ export async function pruneTimestampedExports(projectRoot, keepCount) {
     catch {
         return;
     }
-    const timestampDirs = entries.filter((entry) => /^\d{8}T\d{6}Z$/.test(entry)).sort().reverse();
+    const timestampDirs = entries
+        .filter((entry) => /^\d{8}T\d{6}Z$/.test(entry))
+        .sort()
+        .reverse();
     for (const entry of timestampDirs.slice(keepCount)) {
-        await fs.rm(path.join(exportsRoot, entry), { recursive: true, force: true });
+        await fs.rm(path.join(exportsRoot, entry), {
+            recursive: true,
+            force: true,
+        });
     }
 }
 export function timestampForFile(now) {
-    return now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+    return now
+        .toISOString()
+        .replace(/[-:]/g, "")
+        .replace(/\.\d{3}Z$/, "Z");
 }
 async function writeArtifacts(projectRoot, outputDir, artifacts) {
     for (const artifact of artifacts) {
@@ -78,7 +87,10 @@ async function gitInfo(projectRoot) {
     try {
         const shaResult = await execFileAsync("git", ["-C", projectRoot, "rev-parse", "HEAD"], { encoding: "utf8" });
         const dirtyResult = await execFileAsync("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8" });
-        return { sha: shaResult.stdout.trim() || null, dirty: dirtyResult.stdout.trim().length > 0 };
+        return {
+            sha: shaResult.stdout.trim() || null,
+            dirty: dirtyResult.stdout.trim().length > 0,
+        };
     }
     catch {
         return { sha: null, dirty: false };

package/dist/lib/source-pack-records.js

@@ -4,7 +4,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
 import { listFiles, pathExists, readText } from "./fs.js";
-import { shouldExcludeRelativePath, shouldIncludeCodeFile, toPosix } from "./source-files.js";
+import { shouldExcludeRelativePath, shouldIncludeCodeFile, toPosix, } from "./source-files.js";
 import { classifyCodeFile } from "./source-pack-classify.js";
 import { matchesAny } from "./source-pack-config.js";
 const execFileAsync = promisify(execFile);
@@ -16,10 +16,13 @@ export async function collectCodeRecords(projectRoot, warnings, options = {}) {
     const records = [];
     for (const file of candidates) {
         const relative = repoRelative(projectRoot, file);
-        if (!shouldIncludeCodeFile(relative) || matchesAny(relative, options.exclude ?? [])) {
+        if (!shouldIncludeCodeFile(relative) ||
+            matchesAny(relative, options.exclude ?? [])) {
             continue;
         }
-        if (options.include && options.include.length > 0 && !matchesAny(relative, options.include)) {
+        if (options.include &&
+            options.include.length > 0 &&
+            !matchesAny(relative, options.include)) {
             continue;
         }
         if (!(await isRegularFile(file))) {
@@ -44,26 +47,36 @@ export async function collectCodeRecords(projectRoot, warnings, options = {}) {
             routes: classification.routes,
             score: classification.score,
             bucket: classification.bucket,
-            bundle: "omitted"
+            bundle: "omitted",
         });
     }
     return records.sort((left, right) => left.relative.localeCompare(right.relative));
 }
 export async function collectContextArtifacts(projectRoot, warnings, includePatterns) {
     const files = new Set();
-    for (const relative of ["AGENTS.md", "README.md", "DESIGN.md", "project_context/global.md", "project_context/architecture.md", "project_context/context.toml"]) {
+    for (const relative of [
+        "AGENTS.md",
+        "README.md",
+        "DESIGN.md",
+        "project_context/global.md",
+        "project_context/architecture.md",
+        "project_context/context.toml",
+    ]) {
         await addIfExists(projectRoot, files, warnings, relative, relative.startsWith("project_context/"));
     }
     for (const file of await listFiles(path.join(projectRoot, "project_context"))) {
         const relative = repoRelative(projectRoot, file);
-        if ((relative.endsWith(".md") || relative.endsWith(".toml")) && !shouldExcludeRelativePath(relative)) {
+        if ((relative.endsWith(".md") || relative.endsWith(".toml")) &&
+            !shouldExcludeRelativePath(relative)) {
             files.add(file);
         }
     }
     const artifacts = [];
     for (const file of [...files].sort((a, b) => repoRelative(projectRoot, a).localeCompare(repoRelative(projectRoot, b)))) {
         const relative = repoRelative(projectRoot, file);
-        if (includePatterns && includePatterns.length > 0 && !matchesAny(relative, includePatterns)) {
+        if (includePatterns &&
+            includePatterns.length > 0 &&
+            !matchesAny(relative, includePatterns)) {
             continue;
         }
         const rawContent = await readText(file);
@@ -75,7 +88,7 @@ export async function collectContextArtifacts(projectRoot, warnings, includePatt
             relative,
             content: redacted.content,
             lines: countLines(redacted.content),
-            characters: redacted.content.length
+            characters: redacted.content.length,
         });
     }
     return artifacts;
@@ -103,11 +116,22 @@ async function addIfExists(projectRoot, files, warnings, relative, required) {
 }
 async function listGitCandidateFiles(projectRoot) {
     try {
-        const result = await execFileAsync("git", ["-C", projectRoot, "ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+        const result = await execFileAsync("git", [
+            "-C",
+            projectRoot,
+            "ls-files",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+            "-z",
+        ], {
             encoding: "utf8",
-            maxBuffer: GIT_LS_MAX_BUFFER
+            maxBuffer: GIT_LS_MAX_BUFFER,
         });
-        return result.stdout.split("\0").filter(Boolean).map((relative) => path.join(projectRoot, ...toPosix(relative).split("/")));
+        return result.stdout
+            .split("\0")
+            .filter(Boolean)
+            .map((relative) => path.join(projectRoot, ...toPosix(relative).split("/")));
     }
     catch {
         return undefined;

package/dist/lib/source-pack-render.js

@@ -22,7 +22,7 @@ export function renderFullProjectContextArtifact(contexts, warnings, meta) {
         "## Context Sources",
         "",
         ...contexts.map(renderContextArtifact),
-        ""
+        "",
     ].join("\n");
 }
 export function renderCodeIndexArtifact(records, areas, warnings, meta) {
@@ -52,7 +52,11 @@ export function renderCodeIndexArtifact(records, areas, warnings, meta) {
         "## Context Area Mapping",
         "",
         "Inferred buckets below are export routing only; they are not durable architecture or product ownership facts.",
-        areas.length > 0 ? areas.map((area) => `- ${area.id}: root=${area.root}; context=${area.context}`).join("\n") : "- No Context area mappings found.",
+        areas.length > 0
+            ? areas
+                .map((area) => `- ${area.id}: root=${area.root}; context=${area.context}`)
+                .join("\n")
+            : "- No Context area mappings found.",
         "",
         "## Key Entry Points",
         "",
@@ -68,7 +72,9 @@ export function renderCodeIndexArtifact(records, areas, warnings, meta) {
         "",
         "## CLI / Worker / Script Index",
         "",
-        renderRecordList(records.filter((record) => record.tags.includes("cli") || record.tags.includes("worker")).slice(0, 30)),
+        renderRecordList(records
+            .filter((record) => record.tags.includes("cli") || record.tags.includes("worker"))
+            .slice(0, 30)),
         "",
         "## Test / Verification Index",
         "",
@@ -76,12 +82,14 @@ export function renderCodeIndexArtifact(records, areas, warnings, meta) {
         "",
         "## Oversized Files",
         "",
-        renderRecordList(records.filter((record) => record.tags.includes("oversized")).slice(0, 30)),
+        renderRecordList(records
+            .filter((record) => record.tags.includes("oversized"))
+            .slice(0, 30)),
         "",
         "## Source File Index",
         "",
         renderSourceFileIndex(records),
-        ""
+        "",
     ].join("\n");
 }
 export function renderBundleArtifact(title, records, contexts, omitted, warnings, meta, policy) {
@@ -109,16 +117,21 @@ export function renderBundleArtifact(title, records, contexts, omitted, warnings
         "",
         "## Related Context Paths",
         "",
-        contexts.length > 0 ? contexts.map((context) => `- ${context.relative} (${context.lines} lines)`).join("\n") : "- No related Context files selected.",
+        contexts.length > 0
+            ? contexts
+                .map((context) => `- ${context.relative} (${context.lines} lines)`)
+                .join("\n")
+            : "- No related Context files selected.",
         "",
         "## Source Files",
         "",
-        records.map(renderSourceRecord).join("\n\n") || "- No source files selected for this bundle.",
+        records.map(renderSourceRecord).join("\n\n") ||
+            "- No source files selected for this bundle.",
         "",
         "## Omitted Files Summary",
         "",
         renderOmittedSummary(omitted),
-        ""
+        "",
     ].join("\n");
 }
 export function renderTaskContextArtifact(taskName, contexts, records, verification, omitted, warnings, meta) {
@@ -150,21 +163,31 @@ export function renderTaskContextArtifact(taskName, contexts, records, verificat
         "",
         "## Selected Source Files",
         "",
-        records.map(renderSourceRecord).join("\n\n") || "- No selected source files matched the task filters.",
+        records.map(renderSourceRecord).join("\n\n") ||
+            "- No selected source files matched the task filters.",
         "",
         "## Verification Entry Points",
         "",
-        verification.length > 0 ? verification.map((entry) => `- ${entry}`).join("\n") : "- No profile verification entries selected.",
+        verification.length > 0
+            ? verification.map((entry) => `- ${entry}`).join("\n")
+            : "- No profile verification entries selected.",
         "",
         "## Omitted / Support Notes",
         "",
         renderOmittedSummary(omitted),
-        ""
+        "",
     ].join("\n");
 }
 function renderContextArtifact(context) {
     const fence = fenceFor(context.content);
-    return [`### ${context.relative}`, "", `${fence}markdown`, context.content.trimEnd(), fence, ""].join("\n");
+    return [
+        `### ${context.relative}`,
+        "",
+        `${fence}markdown`,
+        context.content.trimEnd(),
+        fence,
+        "",
+    ].join("\n");
 }
 function renderSourceRecord(record) {
     const fence = fenceFor(record.content);
@@ -183,7 +206,7 @@ function renderSourceRecord(record) {
         "",
         `${fence}${record.language}`,
         record.content.trimEnd(),
-        fence
+        fence,
     ].join("\n");
 }
 function renderSourceFileIndex(records) {
@@ -193,7 +216,7 @@ function renderSourceFileIndex(records) {
     return [
         "| Path | Type | Lines | Characters | SHA256 | Summary | Bundle | Tags |",
         "|---|---:|---:|---:|---|---|---|---|",
-        ...records.map((record) => `| ${escapeTableCell(record.relative)} | ${escapeTableCell(record.language)} | ${record.lines} | ${record.characters} | ${record.sha256.slice(0, 12)} | ${escapeTableCell(record.summary)} | ${record.bundle} | ${escapeTableCell(record.tags.join(", "))} |`)
+        ...records.map((record) => `| ${escapeTableCell(record.relative)} | ${escapeTableCell(record.language)} | ${record.lines} | ${record.characters} | ${record.sha256.slice(0, 12)} | ${escapeTableCell(record.summary)} | ${record.bundle} | ${escapeTableCell(record.tags.join(", "))} |`),
     ].join("\n");
 }
 function renderRepositoryShape(records) {
@@ -202,10 +225,10 @@ function renderRepositoryShape(records) {
         const top = record.relative.split("/")[0] || ".";
         counts.set(top, (counts.get(top) ?? 0) + 1);
     }
-    return [...counts.entries()]
+    return ([...counts.entries()]
         .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
         .map(([name, count]) => `- ${name}: ${count} source file(s)`)
-        .join("\n") || "- No source files matched.";
+        .join("\n") || "- No source files matched.");
 }
 function renderRecordList(records, includeRoutes = false) {
     if (records.length === 0) {
@@ -216,13 +239,19 @@ function renderRecordList(records, includeRoutes = false) {
         .join("\n");
 }
 function renderWarningList(warnings) {
-    return warnings.length > 0 ? warnings.map((warning) => `  - ${warning}`) : ["  - none"];
+    return warnings.length > 0
+        ? warnings.map((warning) => `  - ${warning}`)
+        : ["  - none"];
 }
 function renderOmittedSummary(omitted) {
     const reasons = Object.entries(omitted.reason_counts)
         .sort((left, right) => left[0].localeCompare(right[0]))
         .map(([reason, count]) => `  - ${reason}: ${count}`);
-    return [`- omitted_source_file_count: ${omitted.source_file_count}`, "- reason_counts:", ...(reasons.length > 0 ? reasons : ["  - none: 0"])].join("\n");
+    return [
+        `- omitted_source_file_count: ${omitted.source_file_count}`,
+        "- reason_counts:",
+        ...(reasons.length > 0 ? reasons : ["  - none: 0"]),
+    ].join("\n");
 }
 function fenceFor(content) {
     let fence = "```";

package/dist/lib/stable-json.d.ts

@@ -0,0 +1,2 @@
+export declare function stableJson(value: unknown): string;
+export declare function sha256(value: string): string;

package/dist/lib/stable-json.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+export function stableJson(value) {
+    return JSON.stringify(sortJson(value), null, 2);
+}
+export function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function sortJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJson);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, sortJson(value[key])]));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/lib/strict-codec.d.ts

@@ -0,0 +1,4 @@
+export declare function canonicalJson(value: unknown): string;
+export declare function canonicalValueJson(value: unknown): string;
+export declare function sha256Hex(value: string | Uint8Array): string;
+export declare function parseStrictYaml(content: string): unknown;

package/dist/lib/strict-codec.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import YAML, { isAlias, isMap, isPair, isScalar, isSeq, visit, } from "yaml";
+export function canonicalJson(value) {
+    return `${JSON.stringify(sortCanonical(value), null, 2)}\n`;
+}
+export function canonicalValueJson(value) {
+    return JSON.stringify(sortCanonical(value));
+}
+export function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function parseStrictYaml(content) {
+    if (content.charCodeAt(0) === 0xfeff)
+        throw new Error("YAML byte-order marks are not allowed");
+    if (/^%(?:YAML|TAG)\b/m.test(content))
+        throw new Error("YAML directives are not allowed");
+    const documents = YAML.parseAllDocuments(content, {
+        merge: false,
+        schema: "core",
+        strict: true,
+        stringKeys: true,
+        uniqueKeys: true,
+    });
+    const document = assertSingleDocument(documents);
+    if (document.directives.yaml.explicit ||
+        Object.keys(document.directives.tags).some((handle) => handle !== "!!"))
+        throw new Error("YAML directives are not allowed");
+    visit(document, (_key, node) => inspectNode(node));
+    return document.toJS({ maxAliasCount: 0 });
+}
+function assertSingleDocument(documents) {
+    if (documents.length !== 1)
+        throw new Error("YAML must contain exactly one document");
+    const document = documents[0];
+    const issue = document.errors[0] ?? document.warnings[0];
+    if (issue)
+        throw new Error(`Invalid YAML: ${issue.message}`);
+    return document;
+}
+function inspectNode(node) {
+    if (isAlias(node))
+        throw new Error("YAML aliases are not allowed");
+    const tagged = node;
+    if (tagged.anchor)
+        throw new Error("YAML anchors are not allowed");
+    if (tagged.tag)
+        throw new Error("YAML explicit tags are not allowed");
+    if (isPair(node) && isScalar(node.key) && node.key.value === "<<")
+        throw new Error("YAML merge keys are not allowed");
+    if (isMap(node) || isSeq(node) || isScalar(node) || isPair(node))
+        return;
+    throw new Error("Unsupported YAML node");
+}
+function sortCanonical(value) {
+    if (Array.isArray(value))
+        return value.map(sortCanonical);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [
+            key,
+            sortCanonical(value[key]),
+        ]));
+    return value;
+}

package/dist/lib/sync-engine.js

@@ -2,15 +2,17 @@ import path from "node:path";
 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_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 { copyTree, listFiles, pathExists, readText, writeTextIfChanged, } from "./fs.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 { installLongTaskHooks, uninstallLongTaskHooks, } from "./long-task-hook-install.js";
+import { enabledManagedSkillNames, isProfileEnabled } from "./profiles.js";
 export function emptySyncReport() {
     return {
         changed: [],
         skipped: [],
-        blocked: []
+        blocked: [],
     };
 }
 export async function runSync(projectRoot) {
@@ -23,11 +25,17 @@ export async function runSync(projectRoot) {
         return report;
     }
     for (const managedFile of config.managed_files) {
-        await syncManagedFile(projectRoot, root, managedFile, report);
+        await syncManagedFile(projectRoot, root, managedFile, report, config);
+    }
+    if (isProfileEnabled(config, "long-task")) {
+        await installLongTaskHooks(projectRoot, report);
+    }
+    else {
+        await uninstallLongTaskHooks(projectRoot, report);
     }
     return report;
 }
-async function syncManagedFile(projectRoot, root, managedFile, report) {
+async function syncManagedFile(projectRoot, root, managedFile, report, config) {
     const destination = path.join(projectRoot, managedFile.path);
     if (managedFile.path === "AGENTS.md") {
         await syncAgentsBlock(destination, root, report);
@@ -38,7 +46,7 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         return;
     }
     if (isSkillsManagedPath(managedFile.path, root)) {
-        await syncSkillsTree(packageAssetPath("skills"), path.join(projectRoot, root, "skills"), report);
+        await syncSkillsTree(packageAssetPath("skills"), path.join(projectRoot, root, "skills"), report, enabledManagedSkillNames(config));
         return;
     }
     const managedPath = normalizeManagedPath(managedFile.path);
@@ -47,14 +55,17 @@ async function syncManagedFile(projectRoot, root, managedFile, report) {
         return;
     }
     if (managedPath === harnessPath(root, "ty-context-managed", "context_templates")) {
-        await syncTree(packageAssetPath("context_templates"), destination, report, { prune: true });
+        await syncTree(packageAssetPath("context_templates"), destination, report, {
+            prune: true,
+        });
         return;
     }
     if (managedPath === harnessPath(root, "ty-context-managed", "policies")) {
         await syncTree(packageAssetPath("policies"), destination, report);
         return;
     }
-    if (managedPath === harnessPath(root, "ty-context-managed", "make", "ty-context.mk")) {
+    if (managedPath ===
+        harnessPath(root, "ty-context-managed", "make", "ty-context.mk")) {
         await syncFile(packageAssetPath("make", "ty-context.mk"), destination, report, "skip-if-missing");
         return;
     }
@@ -85,14 +96,16 @@ async function syncAgentsBlock(destination, root, report) {
     }
     const core = renderAgentsCore(await readText(corePath), root);
     const block = `${MANAGED_BLOCK_START}\n${core.trim()}\n${MANAGED_BLOCK_END}`;
-    const existing = (await pathExists(destination)) ? await readText(destination) : "";
+    const existing = (await pathExists(destination))
+        ? await readText(destination)
+        : "";
     const next = mergeManagedBlock({
         existing,
         block,
         markers: AGENTS_BLOCK_MARKERS,
         pathLabel: "AGENTS.md",
         insert: "append",
-        report
+        report,
     });
     if (!next) {
         return;
@@ -108,14 +121,16 @@ function renderAgentsCore(content, root) {
     return content.replaceAll(".agent", root).replaceAll(".codex", root);
 }
 async function syncMakefileInclude(destination, root, report) {
-    const existing = (await pathExists(destination)) ? await readText(destination) : "";
+    const existing = (await pathExists(destination))
+        ? await readText(destination)
+        : "";
     const resetDefaultGoal = shouldResetMakeDefaultGoal(existing);
     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.",
         `-include ${includePath}`,
-        MAKEFILE_BLOCK_END
+        MAKEFILE_BLOCK_END,
     ];
     if (resetDefaultGoal) {
         blockLines.splice(3, 0, ".DEFAULT_GOAL :=");
@@ -127,7 +142,7 @@ async function syncMakefileInclude(destination, root, report) {
         markers: MAKEFILE_BLOCK_MARKERS,
         pathLabel: "Makefile",
         insert: "prepend",
-        report
+        report,
     });
     if (!next) {
         return;
@@ -194,9 +209,14 @@ function findManagedBlock(existing, markersList) {
         matches.push({ markers, startIndex, endIndex });
     }
     if (matches.length > 1) {
-        return { status: "invalid", reason: "conflicting managed block marker namespaces" };
-    }
-    return matches[0] ? { status: "found", ...matches[0] } : { status: "missing" };
+        return {
+            status: "invalid",
+            reason: "conflicting managed block marker namespaces",
+        };
+    }
+    return matches[0]
+        ? { status: "found", ...matches[0] }
+        : { status: "missing" };
 }
 async function syncTree(source, destination, report, options = {}) {
     if (!(await pathExists(source))) {
@@ -224,7 +244,10 @@ async function removeStaleManagedFiles(source, destination) {
         .map((file) => path.relative(source, file).split(path.sep).join("/")));
     const removed = [];
     for (const destinationFile of await listFiles(destination)) {
-        const relative = path.relative(destination, destinationFile).split(path.sep).join("/");
+        const relative = path
+            .relative(destination, destinationFile)
+            .split(path.sep)
+            .join("/");
         if (sourceFiles.has(relative)) {
             continue;
         }
@@ -233,13 +256,18 @@ async function removeStaleManagedFiles(source, destination) {
     }
     return removed;
 }
-async function syncSkillsTree(source, destination, report) {
+async function syncSkillsTree(source, destination, report, enabledSkillNames) {
     if (!(await pathExists(source))) {
         report.skipped.push(path.basename(destination));
         return;
     }
     const files = await listFiles(source);
-    const realFiles = files.filter((file) => !file.endsWith(".gitkeep"));
+    const allManagedSkillNames = new Set(files
+        .map((file) => path.relative(source, file).split(path.sep)[0])
+        .filter(Boolean));
+    const realFiles = files
+        .filter((file) => !file.endsWith(".gitkeep"))
+        .filter((file) => enabledSkillNames.has(path.relative(source, file).split(path.sep)[0]));
     if (realFiles.length === 0) {
         report.skipped.push(path.basename(destination));
         return;
@@ -254,6 +282,21 @@ async function syncSkillsTree(source, destination, report) {
             report.skipped.push(destinationFile);
         }
     }
+    const managedSkillNames = new Set(realFiles
+        .map((file) => path.relative(source, file).split(path.sep)[0])
+        .filter(Boolean));
+    for (const skillName of managedSkillNames) {
+        report.changed.push(...(await removeStaleManagedFiles(path.join(source, skillName), path.join(destination, skillName))));
+    }
+    for (const skillName of allManagedSkillNames) {
+        if (enabledSkillNames.has(skillName))
+            continue;
+        const disabled = path.join(destination, skillName);
+        if (!(await pathExists(disabled)))
+            continue;
+        await fs.rm(disabled, { recursive: true, force: true });
+        report.changed.push(disabled);
+    }
 }
 async function blockDeprecatedSkillOverrides(projectRoot, root, report) {
     for (const overrideRoot of skillOverrideRoots(projectRoot, root)) {
@@ -274,12 +317,18 @@ 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("/")
+            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("/")
-        }
+            relative: path
+                .join(root, "pjsdlc_managed", "override_skills")
+                .split(path.sep)
+                .join("/"),
+        },
     ];
 }
 async function syncFile(source, destination, report, missingMode) {
@@ -320,7 +369,9 @@ async function syncGithubWorkflow(source, destination, relativePath, report) {
         report.blocked.push(`${relativePath}: incomplete managed workflow markers`);
         return;
     }
-    if (markerState === "managed" || normalizeWorkflow(existing) === normalizeWorkflow(stripWorkflowMarkers(sourceContent))) {
+    if (markerState === "managed" ||
+        normalizeWorkflow(existing) ===
+            normalizeWorkflow(stripWorkflowMarkers(sourceContent))) {
         if (await writeTextIfChanged(destination, sourceContent)) {
             report.changed.push(relativePath);
         }
@@ -344,7 +395,8 @@ function workflowMarkerState(content) {
 function stripWorkflowMarkers(content) {
     return content
         .split(/\r?\n/)
-        .filter((line) => line.trim() !== GITHUB_WORKFLOW_BLOCK_START && line.trim() !== GITHUB_WORKFLOW_BLOCK_END)
+        .filter((line) => line.trim() !== GITHUB_WORKFLOW_BLOCK_START &&
+        line.trim() !== GITHUB_WORKFLOW_BLOCK_END)
         .join("\n");
 }
 function normalizeWorkflow(content) {

package/dist/lib/types.d.ts

@@ -3,10 +3,14 @@ export interface HarnessConfig {
         package: string;
         schema_version: string;
     };
+    profiles: {
+        enabled: HarnessProfile[];
+    };
     modularity?: HarnessModularityConfig;
     managed_files: ManagedFile[];
     never_overwrite: string[];
 }
+export type HarnessProfile = "core-portable" | "workflow-default" | "long-task";
 export interface HarnessModularityConfig {
     limit?: number;
     policy?: "scoped_waivers" | "strict_except_generated";
@@ -15,8 +19,11 @@ export interface HarnessModularityConfig {
 export interface ModularityWaiverConfig {
     path?: string;
     category?: string;
+    owner?: string;
+    introduced_at?: string;
     reason?: string;
-    future_split_boundary?: string;
+    tracking_issue?: string;
+    expiry_condition?: string;
 }
 export interface ManagedFile {
     path: string;