@plainconceptsplatform/workflows 0.1.0

package/dist/catalog-installation.d.ts

@@ -0,0 +1,12 @@
+import { repositoryConfigRelativePath } from "./repository-state.js";
+export interface CatalogInstallResult {
+    readonly installed: readonly string[];
+    readonly conflicts: readonly string[];
+}
+export interface CatalogInstallOptions {
+    readonly force?: boolean;
+    readonly sourcePath?: string;
+}
+export declare function catalogSourcePath(): string;
+export declare function installCatalog(repositoryPath: string, options?: CatalogInstallOptions): Promise<CatalogInstallResult>;
+export { repositoryConfigRelativePath };

package/dist/catalog-installation.js

@@ -0,0 +1,81 @@
+import { access, copyFile, mkdir, readFile, readdir } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { repositoryConfigRelativePath } from "./repository-state.js";
+const packageDirectory = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const sourceMappings = [
+    ["actions", ".github/actions"],
+    ["workflows", ".github/workflows"],
+    ["scripts", "scripts"],
+];
+export function catalogSourcePath() {
+    return join(packageDirectory, "loops");
+}
+export async function installCatalog(repositoryPath, options = {}) {
+    const sourcePath = options.sourcePath ?? catalogSourcePath();
+    const files = await catalogFiles(sourcePath);
+    const managedFiles = files.filter((file) => file.managed);
+    const conflicts = (await Promise.all(managedFiles.map(async (file) => {
+        const destination = join(repositoryPath, file.target);
+        return await exists(destination) && !(await filesMatch(file.source, destination)) ? file.target : undefined;
+    }))).filter((file) => file !== undefined);
+    if (conflicts.length > 0 && !options.force)
+        return { installed: [], conflicts };
+    await Promise.all(files.map(async (file) => {
+        const destination = join(repositoryPath, file.target);
+        if (!file.managed && await exists(destination))
+            return;
+        await mkdir(dirname(destination), { recursive: true });
+        await copyFile(file.source, destination);
+    }));
+    return { installed: files.map((file) => file.target), conflicts };
+}
+async function catalogFiles(sourcePath) {
+    const files = [];
+    for (const [sourceDirectory, targetDirectory] of sourceMappings) {
+        for (const file of await filesIn(join(sourcePath, sourceDirectory))) {
+            if (isGeneratedFile(file))
+                continue;
+            files.push({
+                source: join(sourcePath, sourceDirectory, file),
+                target: `${targetDirectory}/${file.replaceAll("\\", "/")}`,
+                managed: true,
+            });
+        }
+    }
+    const repositoryConfigSource = join(sourcePath, "aw", "repo-config.md");
+    if (await exists(repositoryConfigSource)) {
+        files.push({ source: repositoryConfigSource, target: repositoryConfigRelativePath, managed: false });
+    }
+    return files.sort((left, right) => left.target.localeCompare(right.target));
+}
+function isGeneratedFile(file) {
+    const normalized = file.replaceAll("\\", "/");
+    return normalized.endsWith(".lock.yml") || normalized.endsWith("actions-lock.json");
+}
+async function filesIn(path) {
+    const entries = await readdir(path, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.parentPath === undefined ? entry.name : relative(path, join(entry.parentPath, entry.name)));
+}
+async function filesMatch(source, destination) {
+    try {
+        const [sourceContent, destinationContent] = await Promise.all([readFile(source), readFile(destination)]);
+        return sourceContent.equals(destinationContent);
+    }
+    catch {
+        return false;
+    }
+}
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { repositoryConfigRelativePath };

package/dist/catalog-installation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/catalog-installation.test.js

@@ -0,0 +1,85 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { installCatalog, repositoryConfigRelativePath } from "./catalog-installation.js";
+const temporaryDirectories = [];
+afterEach(async () => {
+    await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
+});
+describe("catalog installation", () => {
+    it("installs package-owned loops files and initializes repository config", async () => {
+        const sourcePath = await createDirectory({
+            "actions/check/action.yml": "name: Check\n",
+            "workflows/agent-check.md": "# Check\n",
+            "workflows/shared/defaults.md": "defaults\n",
+            "scripts/compile.mjs": "console.log('compile');\n",
+            "aw/repo-config.md": "# Repository configuration\n",
+            "workflows/agent-check.lock.yml": "generated\n",
+            "actions/actions-lock.json": "generated\n",
+        });
+        const repositoryPath = await createDirectory({});
+        await expect(installCatalog(repositoryPath, { sourcePath })).resolves.toEqual({
+            installed: [
+                ".github/actions/check/action.yml",
+                ".github/workflows/agent-check.md",
+                ".github/workflows/shared/defaults.md",
+                repositoryConfigRelativePath,
+                "scripts/compile.mjs",
+            ],
+            conflicts: [],
+        });
+        await expect(readFile(join(repositoryPath, repositoryConfigRelativePath), "utf8")).resolves.toBe("# Repository configuration\n");
+    });
+    it("does not report identical managed files as conflicts", async () => {
+        const sourcePath = await createDirectory({
+            "actions/check/action.yml": "name: Check\n",
+            "workflows/agent-check.md": "# Check\n",
+            "scripts/compile.mjs": "compile\n",
+        });
+        const repositoryPath = await createDirectory({ ".github/workflows/agent-check.md": "# Check\n" });
+        await expect(installCatalog(repositoryPath, { sourcePath })).resolves.toMatchObject({ conflicts: [] });
+    });
+    it("requires force for different managed files and preserves repository config", async () => {
+        const sourcePath = await createDirectory({
+            "actions/check/action.yml": "package action\n",
+            "workflows/agent-check.md": "package workflow\n",
+            "scripts/compile.mjs": "package script\n",
+            "aw/repo-config.md": "package config\n",
+        });
+        const repositoryPath = await createDirectory({
+            ".github/actions/check/action.yml": "consumer action\n",
+            ".github/workflows/agent-check.md": "consumer workflow\n",
+            "scripts/compile.mjs": "consumer script\n",
+            [repositoryConfigRelativePath]: "consumer config\n",
+        });
+        await expect(installCatalog(repositoryPath, { sourcePath })).resolves.toEqual({
+            installed: [],
+            conflicts: [
+                ".github/actions/check/action.yml",
+                ".github/workflows/agent-check.md",
+                "scripts/compile.mjs",
+            ],
+        });
+        await expect(installCatalog(repositoryPath, { force: true, sourcePath })).resolves.toMatchObject({
+            conflicts: [
+                ".github/actions/check/action.yml",
+                ".github/workflows/agent-check.md",
+                "scripts/compile.mjs",
+            ],
+        });
+        await expect(readFile(join(repositoryPath, ".github/actions/check/action.yml"), "utf8")).resolves.toBe("package action\n");
+        await expect(readFile(join(repositoryPath, repositoryConfigRelativePath), "utf8")).resolves.toBe("consumer config\n");
+    });
+});
+async function createDirectory(files) {
+    const directory = await mkdtemp(join(tmpdir(), "platform-workflows-"));
+    temporaryDirectories.push(directory);
+    await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
+        const path = join(directory, relativePath);
+        const { mkdir } = await import("node:fs/promises");
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, "utf8");
+    }));
+    return directory;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function run(arguments_: readonly string[], repositoryPath?: string): Promise<number>;

package/dist/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { inspectRepository, parseVisibility, resolveVisibility } from "./repository-inspection.js";
+import { installCatalog } from "./catalog-installation.js";
+import { initializeRepository, readManifest, repositoryConfigRelativePath } from "./repository-state.js";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export async function run(arguments_, repositoryPath = process.cwd()) {
+    const [command, ...options] = arguments_;
+    if (command === "--help" || command === "-h" || command === undefined) {
+        console.log("Usage: platform-workflows <init|add|update|status> [--visibility public|private] [--force]");
+        return 0;
+    }
+    if (command === "init") {
+        const visibility = readVisibilityOption(options);
+        if (visibility === "invalid")
+            return fail("--visibility must be public or private.");
+        const inspection = await inspectRepository(repositoryPath);
+        const resolvedVisibility = await resolveVisibility(repositoryPath, visibility);
+        const result = await initializeRepository(inspection, resolvedVisibility);
+        console.log(JSON.stringify({ command, ...result }, null, 2));
+        return 0;
+    }
+    if (command === "status") {
+        const inspection = await inspectRepository(repositoryPath);
+        const manifest = await readManifest(repositoryPath);
+        console.log(JSON.stringify({ command, inspection, manifest, repositoryConfigPath: repositoryConfigRelativePath }, null, 2));
+        return 0;
+    }
+    if (command === "add" || command === "update") {
+        if (options.some((option) => option !== "--force"))
+            return fail(`${command} accepts only --force.`);
+        const result = await installCatalog(repositoryPath, { force: options.includes("--force") });
+        if (result.conflicts.length > 0 && !options.includes("--force")) {
+            console.error(`Catalog conflicts found. Re-run with --force to overwrite package-managed files:\n${result.conflicts.join("\n")}`);
+            return 1;
+        }
+        console.log(JSON.stringify({ command, ...result }, null, 2));
+        return 0;
+    }
+    return fail(`Unknown command: ${command}`);
+}
+function readVisibilityOption(options) {
+    if (options.length === 0)
+        return undefined;
+    if (options.length !== 2 || options[0] !== "--visibility")
+        return "invalid";
+    return parseVisibility(options[1]) ?? "invalid";
+}
+function fail(message) {
+    console.error(message);
+    return 1;
+}
+if (process.argv[1] !== undefined && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    void run(process.argv.slice(2)).then((exitCode) => {
+        process.exitCode = exitCode;
+    });
+}

package/dist/repository-inspection.d.ts

@@ -0,0 +1,23 @@
+export type RepositoryVisibility = "public" | "private";
+export type VisibilitySource = "argument" | "environment" | "github" | "fallback";
+export interface StackHints {
+    readonly packageJson: boolean;
+    readonly pnpmLockfile: boolean;
+    readonly solutionFiles: readonly string[];
+    readonly openSpec: boolean;
+}
+export interface RepositoryInspection {
+    readonly repositoryPath: string;
+    readonly existingAgentWorkflows: readonly string[];
+    readonly stackHints: StackHints;
+}
+export interface VisibilityResolution {
+    readonly value: RepositoryVisibility;
+    readonly source: VisibilitySource;
+}
+export interface CommandRunner {
+    readonly run: (command: string, arguments_: readonly string[], cwd: string) => Promise<string>;
+}
+export declare function inspectRepository(repositoryPath: string): Promise<RepositoryInspection>;
+export declare function resolveVisibility(repositoryPath: string, override: RepositoryVisibility | undefined, environment?: NodeJS.ProcessEnv, commandRunner?: CommandRunner): Promise<VisibilityResolution>;
+export declare function parseVisibility(value: string | undefined): RepositoryVisibility | undefined;

package/dist/repository-inspection.js

@@ -0,0 +1,91 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { access, readdir, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join } from "node:path";
+const execFileAsync = promisify(execFile);
+const defaultCommandRunner = {
+    async run(command, arguments_, cwd) {
+        const { stdout } = await execFileAsync(command, arguments_, { cwd, windowsHide: true });
+        return stdout;
+    },
+};
+export async function inspectRepository(repositoryPath) {
+    const workflowsPath = join(repositoryPath, ".github", "workflows");
+    const workflowEntries = await readDirectoryNames(workflowsPath);
+    const solutionFiles = await findSolutionFiles(repositoryPath);
+    return {
+        repositoryPath,
+        existingAgentWorkflows: workflowEntries.filter((entry) => /^agent-.*\.md$/i.test(entry)).sort(),
+        stackHints: {
+            packageJson: await pathExists(join(repositoryPath, "package.json")),
+            pnpmLockfile: await pathExists(join(repositoryPath, "pnpm-lock.yaml")),
+            solutionFiles,
+            openSpec: await isDirectory(join(repositoryPath, "openspec")),
+        },
+    };
+}
+export async function resolveVisibility(repositoryPath, override, environment = process.env, commandRunner = defaultCommandRunner) {
+    if (override !== undefined)
+        return { value: override, source: "argument" };
+    const environmentOverride = parseVisibility(environment.PLATFORM_WORKFLOWS_VISIBILITY);
+    if (environmentOverride !== undefined)
+        return { value: environmentOverride, source: "environment" };
+    try {
+        const output = await commandRunner.run("gh", ["repo", "view", "--json", "visibility"], repositoryPath);
+        const visibility = parseVisibilityFromGitHub(output);
+        if (visibility !== undefined)
+            return { value: visibility, source: "github" };
+    }
+    catch {
+        // GitHub CLI is optional. Initializing a local repository must still work offline.
+    }
+    return { value: "private", source: "fallback" };
+}
+export function parseVisibility(value) {
+    return value === "public" || value === "private" ? value : undefined;
+}
+async function findSolutionFiles(repositoryPath) {
+    const entries = await readdir(repositoryPath, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".slnx"))
+        .map((entry) => entry.parentPath === undefined ? entry.name : join(entry.parentPath, entry.name))
+        .sort();
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readDirectoryNames(path) {
+    try {
+        return await readdir(path);
+    }
+    catch {
+        return [];
+    }
+}
+function parseVisibilityFromGitHub(output) {
+    try {
+        const parsed = JSON.parse(output);
+        if (typeof parsed !== "object" || parsed === null || !("visibility" in parsed))
+            return undefined;
+        const { visibility } = parsed;
+        return typeof visibility === "string" ? parseVisibility(visibility.toLowerCase()) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/repository-state.d.ts

@@ -0,0 +1,18 @@
+import type { RepositoryInspection, RepositoryVisibility, VisibilityResolution } from "./repository-inspection.js";
+export declare const manifestRelativePath = ".github/workflows/shared/platform-workflows.json";
+export declare const repositoryConfigRelativePath = ".github/workflows/shared/repo-config.md";
+export interface PlatformWorkflowsManifest {
+    readonly schemaVersion: 1;
+    readonly repositoryPath: string;
+    readonly initializedAt: string;
+    readonly visibility: RepositoryVisibility;
+    readonly visibilitySource: VisibilityResolution["source"];
+    readonly existingAgentWorkflows: readonly string[];
+    readonly stackHints: RepositoryInspection["stackHints"];
+}
+export interface InitializationResult {
+    readonly manifest: PlatformWorkflowsManifest;
+    readonly repositoryConfigCreated: boolean;
+}
+export declare function initializeRepository(inspection: RepositoryInspection, visibility: VisibilityResolution, now?: Date): Promise<InitializationResult>;
+export declare function readManifest(repositoryPath: string): Promise<PlatformWorkflowsManifest | undefined>;

package/dist/repository-state.js

@@ -0,0 +1,77 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const manifestRelativePath = ".github/workflows/shared/platform-workflows.json";
+export const repositoryConfigRelativePath = ".github/workflows/shared/repo-config.md";
+export async function initializeRepository(inspection, visibility, now = new Date()) {
+    const configPath = join(inspection.repositoryPath, repositoryConfigRelativePath);
+    const repositoryConfigCreated = await writeRepositoryConfigIfMissing(configPath, inspection, visibility.value);
+    const manifest = {
+        schemaVersion: 1,
+        repositoryPath: inspection.repositoryPath,
+        initializedAt: now.toISOString(),
+        visibility: visibility.value,
+        visibilitySource: visibility.source,
+        existingAgentWorkflows: inspection.existingAgentWorkflows,
+        stackHints: inspection.stackHints,
+    };
+    await writeFile(join(inspection.repositoryPath, manifestRelativePath), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+    return { manifest, repositoryConfigCreated };
+}
+export async function readManifest(repositoryPath) {
+    try {
+        const content = await readFile(join(repositoryPath, manifestRelativePath), "utf8");
+        return parseManifest(JSON.parse(content));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeRepositoryConfigIfMissing(configPath, inspection, visibility) {
+    try {
+        await readFile(configPath, "utf8");
+        return false;
+    }
+    catch {
+        await mkdir(dirname(configPath), { recursive: true });
+        await writeFile(configPath, createRepositoryConfig(inspection, visibility), { encoding: "utf8", flag: "wx" });
+        return true;
+    }
+}
+function createRepositoryConfig(inspection, visibility) {
+    const stack = [
+        inspection.stackHints.packageJson ? "- Node.js (`package.json`)" : undefined,
+        inspection.stackHints.pnpmLockfile ? "- pnpm (`pnpm-lock.yaml`)" : undefined,
+        ...inspection.stackHints.solutionFiles.map((file) => `- .NET solution (${file})`),
+        inspection.stackHints.openSpec ? "- OpenSpec (`openspec/`)" : undefined,
+    ].filter((hint) => hint !== undefined);
+    return [
+        "# Repository workflow configuration",
+        "",
+        `- Visibility: ${visibility}`,
+        "",
+        "## Detected stack",
+        "",
+        ...(stack.length > 0 ? stack : ["- No supported stack markers detected"]),
+        "",
+        "## Verification commands",
+        "",
+        "Add repository-specific verification commands here.",
+        "",
+        "## Repository rules",
+        "",
+        "Add repository-specific workflow rules here.",
+        "",
+    ].join("\n");
+}
+function parseManifest(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const manifest = value;
+    if (manifest.schemaVersion !== 1 || typeof manifest.repositoryPath !== "string" || typeof manifest.initializedAt !== "string")
+        return undefined;
+    if (manifest.visibility !== "public" && manifest.visibility !== "private")
+        return undefined;
+    if (!Array.isArray(manifest.existingAgentWorkflows) || typeof manifest.stackHints !== "object" || manifest.stackHints === null)
+        return undefined;
+    return manifest;
+}

package/dist/repository-state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/repository-state.test.js

@@ -0,0 +1,96 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { inspectRepository, resolveVisibility } from "./repository-inspection.js";
+import { initializeRepository, manifestRelativePath, readManifest, repositoryConfigRelativePath } from "./repository-state.js";
+import { run } from "./index.js";
+const temporaryDirectories = [];
+afterEach(async () => {
+    await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
+});
+describe("repository inspection", () => {
+    it("finds agent workflows and supported stack markers", async () => {
+        const repositoryPath = await createRepository({
+            ".github/workflows/agent-refine.md": "# Refine",
+            ".github/workflows/agent-custom.md": "# Custom",
+            ".github/workflows/other.md": "# Other",
+            "package.json": "{}",
+            "pnpm-lock.yaml": "lockfileVersion: '9.0'",
+            "apps/api/Numa.slnx": "<Solution />",
+            "openspec/changes/.gitkeep": "",
+        });
+        await expect(inspectRepository(repositoryPath)).resolves.toMatchObject({
+            existingAgentWorkflows: ["agent-custom.md", "agent-refine.md"],
+            stackHints: {
+                packageJson: true,
+                pnpmLockfile: true,
+                solutionFiles: [join(repositoryPath, "apps", "api", "Numa.slnx")],
+                openSpec: true,
+            },
+        });
+    });
+    it("uses an explicit visibility before environment or GitHub", async () => {
+        const runner = { run: async () => '{"visibility":"public"}' };
+        await expect(resolveVisibility("repo", "private", { PLATFORM_WORKFLOWS_VISIBILITY: "public" }, runner)).resolves.toEqual({
+            value: "private",
+            source: "argument",
+        });
+    });
+    it("falls back to private when GitHub CLI is unavailable", async () => {
+        const runner = { run: async () => Promise.reject(new Error("missing gh")) };
+        await expect(resolveVisibility("repo", undefined, {}, runner)).resolves.toEqual({ value: "private", source: "fallback" });
+    });
+});
+describe("repository initialization", () => {
+    it("creates config once and updates the managed manifest", async () => {
+        const repositoryPath = await createRepository({ "package.json": "{}" });
+        const inspection = await inspectRepository(repositoryPath);
+        const first = await initializeRepository(inspection, { value: "public", source: "argument" }, new Date("2026-08-12T00:00:00.000Z"));
+        const configPath = join(repositoryPath, repositoryConfigRelativePath);
+        await writeFile(configPath, "consumer settings\n", "utf8");
+        const second = await initializeRepository(inspection, { value: "private", source: "fallback" }, new Date("2026-08-13T00:00:00.000Z"));
+        expect(first.repositoryConfigCreated).toBe(true);
+        expect(second.repositoryConfigCreated).toBe(false);
+        await expect(readFile(configPath, "utf8")).resolves.toBe("consumer settings\n");
+        await expect(readManifest(repositoryPath)).resolves.toMatchObject({
+            initializedAt: "2026-08-13T00:00:00.000Z",
+            visibility: "private",
+            visibilitySource: "fallback",
+        });
+        await expect(readFile(join(repositoryPath, manifestRelativePath), "utf8")).resolves.toContain('"schemaVersion": 1');
+    });
+});
+describe("CLI commands", () => {
+    it("keeps init available", async () => {
+        const repositoryPath = await createRepository({ "package.json": "{}" });
+        const output = captureConsole("log");
+        await expect(run(["init", "--visibility", "public"], repositoryPath)).resolves.toBe(0);
+        expect(output.calls).toHaveLength(1);
+        output.restore();
+    });
+    it("accepts update as an add alias", async () => {
+        const repositoryPath = await createRepository({});
+        const error = captureConsole("error");
+        await expect(run(["update", "--invalid"], repositoryPath)).resolves.toBe(1);
+        expect(error.calls).toEqual(["update accepts only --force."]);
+        error.restore();
+    });
+});
+function captureConsole(method) {
+    const original = console[method];
+    const calls = [];
+    console[method] = (message) => calls.push(message);
+    return { calls, restore: () => { console[method] = original; } };
+}
+async function createRepository(files) {
+    const repositoryPath = await mkdtemp(join(tmpdir(), "platform-workflows-"));
+    temporaryDirectories.push(repositoryPath);
+    await Promise.all(Object.entries(files).map(async ([relativePath, content]) => {
+        const path = join(repositoryPath, relativePath);
+        const { mkdir } = await import("node:fs/promises");
+        await mkdir(join(path, ".."), { recursive: true });
+        await writeFile(path, content, "utf8");
+    }));
+    return repositoryPath;
+}

package/dist/workflow-catalog.d.ts

@@ -0,0 +1,17 @@
+export declare const routeNames: readonly ["refine", "implement", "direct", "apply-review", "merge-gate", "audit", "propose"];
+export type RouteName = (typeof routeNames)[number];
+export interface WorkflowRoute {
+    readonly name: RouteName;
+    readonly worker: string;
+    readonly defaultEnabled: boolean;
+}
+export declare const workflowRoutes: readonly WorkflowRoute[];
+export declare const packageOwnedTargets: readonly [".github/actions", ".github/workflows/agent-*.md", ".github/workflows/shared/platform-defaults.md", ".github/workflows/shared/opencode-ci.md", ".github/workflows/work-router.yml", "scripts/compile-agent-workflows.mjs"];
+export declare const consumerOwnedTargets: readonly [".github/workflows/shared/repo-config.md"];
+export declare const generatedConsumerTargets: readonly [".github/workflows/agent-*.lock.yml", ".github/workflows/agentics-maintenance.yml", ".github/aw/actions-lock.json"];
+export interface RepositoryConfigTemplate {
+    readonly repositoryVisibility: "private" | "public";
+    readonly verificationCommands: readonly string[];
+    readonly repositoryRules: readonly string[];
+}
+export declare const defaultRepositoryConfig: RepositoryConfigTemplate;

package/dist/workflow-catalog.js

@@ -0,0 +1,39 @@
+export const routeNames = [
+    "refine",
+    "implement",
+    "direct",
+    "apply-review",
+    "merge-gate",
+    "audit",
+    "propose",
+];
+export const workflowRoutes = [
+    { name: "refine", worker: "agent-refine.md", defaultEnabled: true },
+    { name: "implement", worker: "agent-implement.md", defaultEnabled: true },
+    { name: "direct", worker: "agent-direct.md", defaultEnabled: true },
+    { name: "apply-review", worker: "agent-apply-review.md", defaultEnabled: true },
+    { name: "merge-gate", worker: "agent-merge-gate.md", defaultEnabled: true },
+    { name: "audit", worker: "agent-audit.md", defaultEnabled: true },
+    { name: "propose", worker: "agent-propose.md", defaultEnabled: false },
+];
+export const packageOwnedTargets = [
+    ".github/actions",
+    ".github/workflows/agent-*.md",
+    ".github/workflows/shared/platform-defaults.md",
+    ".github/workflows/shared/opencode-ci.md",
+    ".github/workflows/work-router.yml",
+    "scripts/compile-agent-workflows.mjs",
+];
+export const consumerOwnedTargets = [
+    ".github/workflows/shared/repo-config.md",
+];
+export const generatedConsumerTargets = [
+    ".github/workflows/agent-*.lock.yml",
+    ".github/workflows/agentics-maintenance.yml",
+    ".github/aw/actions-lock.json",
+];
+export const defaultRepositoryConfig = {
+    repositoryVisibility: "private",
+    verificationCommands: [],
+    repositoryRules: [],
+};

package/dist/workflow-catalog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow-catalog.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { consumerOwnedTargets, generatedConsumerTargets, packageOwnedTargets, routeNames, workflowRoutes, } from "./workflow-catalog.js";
+describe("workflow catalog", () => {
+    it("assigns one worker to each route", () => {
+        expect(workflowRoutes.map((route) => route.name)).toEqual(routeNames);
+        expect(new Set(workflowRoutes.map((route) => route.worker)).size).toBe(workflowRoutes.length);
+    });
+    it("keeps generated and consumer-owned files outside package ownership", () => {
+        const packageTargets = new Set(packageOwnedTargets);
+        for (const target of [...consumerOwnedTargets, ...generatedConsumerTargets]) {
+            expect(packageTargets.has(target)).toBe(false);
+        }
+    });
+});