@renseiai/agentfactory 0.8.2 → 0.8.4

package/dist/src/config/index.d.ts

@@ -1,3 +1,3 @@
-export { loadRepositoryConfig, RepositoryConfigSchema, getEffectiveAllowedProjects } from './repository-config.js';
-export type { RepositoryConfig } from './repository-config.js';
+export { loadRepositoryConfig, RepositoryConfigSchema, ProjectConfigSchema, ProvidersConfigSchema, getEffectiveAllowedProjects, getProjectConfig, getProjectPath, getProvidersConfig } from './repository-config.js';
+export type { RepositoryConfig, ProjectConfig } from './repository-config.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAA;AAClH,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACpN,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/src/config/index.js

@@ -1 +1 @@
-export { loadRepositoryConfig, RepositoryConfigSchema, getEffectiveAllowedProjects } from './repository-config.js';
+export { loadRepositoryConfig, RepositoryConfigSchema, ProjectConfigSchema, ProvidersConfigSchema, getEffectiveAllowedProjects, getProjectConfig, getProjectPath, getProvidersConfig } from './repository-config.js';

package/dist/src/config/repository-config.d.ts

@@ -7,12 +7,64 @@
  * - Project allowlisting for the orchestrator (allowedProjects field)
  */
 import { z } from 'zod';
+import type { ProvidersConfig } from '../providers/index.js';
+/** Per-project configuration (object form of projectPaths values) */
+export declare const ProjectConfigSchema: z.ZodObject<{
+    path: z.ZodString;
+    packageManager: z.ZodOptional<z.ZodEnum<{
+        pnpm: "pnpm";
+        npm: "npm";
+        yarn: "yarn";
+        bun: "bun";
+        none: "none";
+    }>>;
+    buildCommand: z.ZodOptional<z.ZodString>;
+    testCommand: z.ZodOptional<z.ZodString>;
+    validateCommand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+/** Provider selection configuration */
+export declare const ProvidersConfigSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        amp: "amp";
+        "spring-ai": "spring-ai";
+        a2a: "a2a";
+    }>>;
+    byWorkType: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        amp: "amp";
+        "spring-ai": "spring-ai";
+        a2a: "a2a";
+    }>>>;
+    byProject: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        amp: "amp";
+        "spring-ai": "spring-ai";
+        a2a: "a2a";
+    }>>>;
+}, z.core.$strip>;
 export declare const RepositoryConfigSchema: z.ZodObject<{
     apiVersion: z.ZodString;
     kind: z.ZodLiteral<"RepositoryConfig">;
     repository: z.ZodOptional<z.ZodString>;
     allowedProjects: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    projectPaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    projectPaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        packageManager: z.ZodOptional<z.ZodEnum<{
+            pnpm: "pnpm";
+            npm: "npm";
+            yarn: "yarn";
+            bun: "bun";
+            none: "none";
+        }>>;
+        buildCommand: z.ZodOptional<z.ZodString>;
+        testCommand: z.ZodOptional<z.ZodString>;
+        validateCommand: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
     sharedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     linearCli: z.ZodOptional<z.ZodString>;
     packageManager: z.ZodOptional<z.ZodEnum<{
@@ -25,6 +77,29 @@ export declare const RepositoryConfigSchema: z.ZodObject<{
     buildCommand: z.ZodOptional<z.ZodString>;
     testCommand: z.ZodOptional<z.ZodString>;
     validateCommand: z.ZodOptional<z.ZodString>;
+    providers: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            amp: "amp";
+            "spring-ai": "spring-ai";
+            a2a: "a2a";
+        }>>;
+        byWorkType: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            amp: "amp";
+            "spring-ai": "spring-ai";
+            a2a: "a2a";
+        }>>>;
+        byProject: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            amp: "amp";
+            "spring-ai": "spring-ai";
+            a2a: "a2a";
+        }>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RepositoryConfig = z.infer<typeof RepositoryConfigSchema>;
 /**
@@ -33,6 +108,22 @@ export type RepositoryConfig = z.infer<typeof RepositoryConfigSchema>;
  * Otherwise falls back to `allowedProjects`.
  */
 export declare function getEffectiveAllowedProjects(config: RepositoryConfig): string[] | undefined;
+/**
+ * Returns the normalized ProjectConfig for a given project name.
+ * Handles both string shorthand and object form of projectPaths values.
+ * Per-project overrides take precedence over repo-wide defaults.
+ */
+export declare function getProjectConfig(config: RepositoryConfig, projectName: string): ProjectConfig | null;
+/**
+ * Returns just the path string for a given project name.
+ * Handles both string shorthand and object form.
+ */
+export declare function getProjectPath(config: RepositoryConfig, projectName: string): string | undefined;
+/**
+ * Returns the providers config from a RepositoryConfig, if present.
+ * Convenience helper for passing to ProviderResolutionContext.configProviders.
+ */
+export declare function getProvidersConfig(config: RepositoryConfig): ProvidersConfig | undefined;
 /**
  * Load and validate .agentfactory/config.yaml from the given git root.
  *

package/dist/src/config/repository-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repository-config.d.ts","sourceRoot":"","sources":["../../../src/config/repository-config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBA0ClC,CAAA;AAMD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAMrE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,GAAG,SAAS,CAK1F;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAQ7E"}
+{"version":3,"file":"repository-config.d.ts","sourceRoot":"","sources":["../../../src/config/repository-config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAM5D,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAW9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAW/D,uCAAuC;AACvC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;iBAOhC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDlC,CAAA;AAMD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAMrE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,GAAG,SAAS,CAK1F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAepG;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKhG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAExF;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAQ7E"}

package/dist/src/config/repository-config.js

@@ -13,13 +13,46 @@ import YAML from 'yaml';
 // ---------------------------------------------------------------------------
 // Zod Schema
 // ---------------------------------------------------------------------------
+/** Per-project configuration (object form of projectPaths values) */
+export const ProjectConfigSchema = z.object({
+    /** Root directory for this project within the repo */
+    path: z.string(),
+    /** Package manager override for this project */
+    packageManager: z.enum(['pnpm', 'npm', 'yarn', 'bun', 'none']).optional(),
+    /** Build command override for this project */
+    buildCommand: z.string().optional(),
+    /** Test command override for this project */
+    testCommand: z.string().optional(),
+    /** Validation command override for this project */
+    validateCommand: z.string().optional(),
+});
+/**
+ * projectPaths values can be a string (path shorthand) or a full ProjectConfig object.
+ * String values are normalized to { path: value } by getProjectConfig().
+ */
+const ProjectPathValueSchema = z.union([z.string(), ProjectConfigSchema]);
+/** Valid agent provider names */
+const AgentProviderNameSchema = z.enum(['claude', 'codex', 'amp', 'spring-ai', 'a2a']);
+/** Provider selection configuration */
+export const ProvidersConfigSchema = z.object({
+    /** Default provider for all agents */
+    default: AgentProviderNameSchema.optional(),
+    /** Provider overrides by work type (e.g., { qa: 'codex' }) */
+    byWorkType: z.record(z.string(), AgentProviderNameSchema).optional(),
+    /** Provider overrides by project name (e.g., { Social: 'codex' }) */
+    byProject: z.record(z.string(), AgentProviderNameSchema).optional(),
+});
 export const RepositoryConfigSchema = z.object({
     apiVersion: z.string(),
     kind: z.literal('RepositoryConfig'),
     repository: z.string().optional(),
     allowedProjects: z.array(z.string()).optional(),
-    /** Maps Linear project names to their root directory within the repo (e.g., { Family: 'apps/family' }) */
-    projectPaths: z.record(z.string(), z.string()).optional(),
+    /**
+     * Maps Linear project names to their root directory or full config.
+     * String shorthand: { Family: 'apps/family' }
+     * Object form: { 'Family iOS': { path: 'apps/family-ios', packageManager: 'none', buildCommand: 'make build' } }
+     */
+    projectPaths: z.record(z.string(), ProjectPathValueSchema).optional(),
     /** Shared directories that any project's agent may modify (e.g., ['packages/ui']) */
     sharedPaths: z.array(z.string()).optional(),
     /**
@@ -52,6 +85,11 @@ export const RepositoryConfigSchema = z.object({
      * Injected into workflow templates as {{validateCommand}}.
      */
     validateCommand: z.string().optional(),
+    /**
+     * Provider selection configuration.
+     * Allows routing agents to different providers by work type or project.
+     */
+    providers: ProvidersConfigSchema.optional(),
 }).refine((data) => !(data.allowedProjects && data.projectPaths), { message: 'allowedProjects and projectPaths are mutually exclusive — use one or the other' });
 // ---------------------------------------------------------------------------
 // Helpers
@@ -67,6 +105,46 @@ export function getEffectiveAllowedProjects(config) {
     }
     return config.allowedProjects;
 }
+/**
+ * Returns the normalized ProjectConfig for a given project name.
+ * Handles both string shorthand and object form of projectPaths values.
+ * Per-project overrides take precedence over repo-wide defaults.
+ */
+export function getProjectConfig(config, projectName) {
+    if (!config.projectPaths)
+        return null;
+    const value = config.projectPaths[projectName];
+    if (value === undefined)
+        return null;
+    // Normalize string shorthand to object form
+    const projectConfig = typeof value === 'string' ? { path: value } : value;
+    return {
+        path: projectConfig.path,
+        packageManager: projectConfig.packageManager ?? config.packageManager,
+        buildCommand: projectConfig.buildCommand ?? config.buildCommand,
+        testCommand: projectConfig.testCommand ?? config.testCommand,
+        validateCommand: projectConfig.validateCommand ?? config.validateCommand,
+    };
+}
+/**
+ * Returns just the path string for a given project name.
+ * Handles both string shorthand and object form.
+ */
+export function getProjectPath(config, projectName) {
+    if (!config.projectPaths)
+        return undefined;
+    const value = config.projectPaths[projectName];
+    if (value === undefined)
+        return undefined;
+    return typeof value === 'string' ? value : value.path;
+}
+/**
+ * Returns the providers config from a RepositoryConfig, if present.
+ * Convenience helper for passing to ProviderResolutionContext.configProviders.
+ */
+export function getProvidersConfig(config) {
+    return config.providers;
+}
 // ---------------------------------------------------------------------------
 // Loader
 // ---------------------------------------------------------------------------

package/dist/src/config/repository-config.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { existsSync, readFileSync } from 'fs';
-import { loadRepositoryConfig, RepositoryConfigSchema, getEffectiveAllowedProjects } from './repository-config.js';
+import { loadRepositoryConfig, RepositoryConfigSchema, getEffectiveAllowedProjects, getProjectConfig, getProjectPath, getProvidersConfig, ProvidersConfigSchema } from './repository-config.js';
 vi.mock('fs', () => ({
     existsSync: vi.fn(),
     readFileSync: vi.fn(),
@@ -84,6 +84,38 @@ sharedPaths:
             sharedPaths: ['packages/ui', 'packages/lexical'],
         });
     });
+    it('parses valid YAML with mixed string and object projectPaths', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(`apiVersion: v1
+kind: RepositoryConfig
+repository: github.com/org/monorepo
+projectPaths:
+  Social: apps/social
+  Family iOS:
+    path: apps/family-ios
+    packageManager: none
+    buildCommand: "make build"
+    testCommand: "make test"
+sharedPaths:
+  - packages/ui
+`);
+        const result = loadRepositoryConfig('/some/repo');
+        expect(result).toEqual({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            repository: 'github.com/org/monorepo',
+            projectPaths: {
+                Social: 'apps/social',
+                'Family iOS': {
+                    path: 'apps/family-ios',
+                    packageManager: 'none',
+                    buildCommand: 'make build',
+                    testCommand: 'make test',
+                },
+            },
+            sharedPaths: ['packages/ui'],
+        });
+    });
     it('throws on invalid schema — allowedProjects is not an array', () => {
         mockExistsSync.mockReturnValue(true);
         mockReadFileSync.mockReturnValue(`apiVersion: v1
@@ -122,7 +154,7 @@ describe('RepositoryConfigSchema', () => {
             kind: 'InvalidKind',
         })).toThrow();
     });
-    it('validates config with projectPaths only', () => {
+    it('validates config with projectPaths only (string shorthand)', () => {
         const result = RepositoryConfigSchema.parse({
             apiVersion: 'v1',
             kind: 'RepositoryConfig',
@@ -135,6 +167,44 @@ describe('RepositoryConfigSchema', () => {
         expect(result.projectPaths).toEqual({ Social: 'apps/social', Family: 'apps/family' });
         expect(result.allowedProjects).toBeUndefined();
     });
+    it('validates config with projectPaths object form', () => {
+        const result = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: {
+                Social: 'apps/social',
+                'Family iOS': {
+                    path: 'apps/family-ios',
+                    packageManager: 'none',
+                    buildCommand: 'make build',
+                    testCommand: 'make test',
+                    validateCommand: 'make build',
+                },
+            },
+        });
+        expect(result.projectPaths).toEqual({
+            Social: 'apps/social',
+            'Family iOS': {
+                path: 'apps/family-ios',
+                packageManager: 'none',
+                buildCommand: 'make build',
+                testCommand: 'make test',
+                validateCommand: 'make build',
+            },
+        });
+    });
+    it('validates config with mixed string and object projectPaths', () => {
+        const result = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: {
+                Social: 'apps/social',
+                Family: 'apps/family',
+                'Family iOS': { path: 'apps/family-ios', packageManager: 'none' },
+            },
+        });
+        expect(Object.keys(result.projectPaths)).toEqual(['Social', 'Family', 'Family iOS']);
+    });
     it('validates config with projectPaths and sharedPaths', () => {
         const result = RepositoryConfigSchema.parse({
             apiVersion: 'v1',
@@ -246,4 +316,235 @@ describe('getEffectiveAllowedProjects', () => {
         });
         expect(getEffectiveAllowedProjects(config)).toBeUndefined();
     });
+    it('returns keys from mixed string/object projectPaths', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: {
+                Social: 'apps/social',
+                'Family iOS': { path: 'apps/family-ios', packageManager: 'none' },
+            },
+        });
+        expect(getEffectiveAllowedProjects(config)).toEqual(['Social', 'Family iOS']);
+    });
+});
+describe('getProjectConfig', () => {
+    it('returns null when projectPaths is not set', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+        });
+        expect(getProjectConfig(config, 'Social')).toBeNull();
+    });
+    it('returns null for unknown project', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: { Social: 'apps/social' },
+        });
+        expect(getProjectConfig(config, 'Unknown')).toBeNull();
+    });
+    it('normalizes string shorthand to ProjectConfig', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: { Social: 'apps/social' },
+        });
+        const result = getProjectConfig(config, 'Social');
+        expect(result).toEqual({
+            path: 'apps/social',
+            packageManager: undefined,
+            buildCommand: undefined,
+            testCommand: undefined,
+            validateCommand: undefined,
+        });
+    });
+    it('returns per-project overrides from object form', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: {
+                'Family iOS': {
+                    path: 'apps/family-ios',
+                    packageManager: 'none',
+                    buildCommand: 'make build',
+                    testCommand: 'make test',
+                    validateCommand: 'make build',
+                },
+            },
+        });
+        const result = getProjectConfig(config, 'Family iOS');
+        expect(result).toEqual({
+            path: 'apps/family-ios',
+            packageManager: 'none',
+            buildCommand: 'make build',
+            testCommand: 'make test',
+            validateCommand: 'make build',
+        });
+    });
+    it('falls back to repo-wide defaults when per-project overrides are not set', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            buildCommand: 'pnpm build',
+            testCommand: 'pnpm test',
+            projectPaths: { Social: 'apps/social' },
+        });
+        const result = getProjectConfig(config, 'Social');
+        expect(result).toEqual({
+            path: 'apps/social',
+            packageManager: undefined,
+            buildCommand: 'pnpm build',
+            testCommand: 'pnpm test',
+            validateCommand: undefined,
+        });
+    });
+    it('per-project overrides take precedence over repo-wide defaults', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            buildCommand: 'pnpm build',
+            testCommand: 'pnpm test',
+            packageManager: 'pnpm',
+            projectPaths: {
+                'Family iOS': {
+                    path: 'apps/family-ios',
+                    packageManager: 'none',
+                    buildCommand: 'make build',
+                    testCommand: 'make test',
+                },
+            },
+        });
+        const result = getProjectConfig(config, 'Family iOS');
+        expect(result).toEqual({
+            path: 'apps/family-ios',
+            packageManager: 'none',
+            buildCommand: 'make build',
+            testCommand: 'make test',
+            validateCommand: undefined,
+        });
+    });
+});
+describe('getProjectPath', () => {
+    it('returns path from string shorthand', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: { Social: 'apps/social' },
+        });
+        expect(getProjectPath(config, 'Social')).toBe('apps/social');
+    });
+    it('returns path from object form', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: { 'Family iOS': { path: 'apps/family-ios' } },
+        });
+        expect(getProjectPath(config, 'Family iOS')).toBe('apps/family-ios');
+    });
+    it('returns undefined for unknown project', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            projectPaths: { Social: 'apps/social' },
+        });
+        expect(getProjectPath(config, 'Unknown')).toBeUndefined();
+    });
+    it('returns undefined when projectPaths is not set', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+        });
+        expect(getProjectPath(config, 'Social')).toBeUndefined();
+    });
+});
+describe('ProvidersConfigSchema', () => {
+    it('validates a complete providers config', () => {
+        const result = ProvidersConfigSchema.parse({
+            default: 'codex',
+            byWorkType: { qa: 'amp', development: 'claude' },
+            byProject: { Social: 'codex' },
+        });
+        expect(result.default).toBe('codex');
+        expect(result.byWorkType).toEqual({ qa: 'amp', development: 'claude' });
+        expect(result.byProject).toEqual({ Social: 'codex' });
+    });
+    it('validates an empty object', () => {
+        const result = ProvidersConfigSchema.parse({});
+        expect(result.default).toBeUndefined();
+        expect(result.byWorkType).toBeUndefined();
+        expect(result.byProject).toBeUndefined();
+    });
+    it('rejects invalid provider names', () => {
+        expect(() => ProvidersConfigSchema.parse({ default: 'invalid' })).toThrow();
+    });
+    it('rejects invalid provider names in byWorkType', () => {
+        expect(() => ProvidersConfigSchema.parse({ byWorkType: { qa: 'invalid' } })).toThrow();
+    });
+});
+describe('RepositoryConfigSchema with providers', () => {
+    it('validates config with providers field', () => {
+        const result = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            providers: {
+                default: 'codex',
+                byWorkType: { qa: 'amp' },
+            },
+        });
+        expect(result.providers).toEqual({
+            default: 'codex',
+            byWorkType: { qa: 'amp' },
+        });
+    });
+    it('validates config without providers field', () => {
+        const result = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+        });
+        expect(result.providers).toBeUndefined();
+    });
+});
+describe('loadRepositoryConfig with providers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('parses config with providers section', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(`apiVersion: v1
+kind: RepositoryConfig
+providers:
+  default: codex
+  byWorkType:
+    qa: amp
+  byProject:
+    Social: claude
+`);
+        const result = loadRepositoryConfig('/some/repo');
+        expect(result?.providers).toEqual({
+            default: 'codex',
+            byWorkType: { qa: 'amp' },
+            byProject: { Social: 'claude' },
+        });
+    });
+});
+describe('getProvidersConfig', () => {
+    it('returns providers config when present', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+            providers: { default: 'codex' },
+        });
+        expect(getProvidersConfig(config)).toEqual({ default: 'codex' });
+    });
+    it('returns undefined when providers not set', () => {
+        const config = RepositoryConfigSchema.parse({
+            apiVersion: 'v1',
+            kind: 'RepositoryConfig',
+        });
+        expect(getProvidersConfig(config)).toBeUndefined();
+    });
 });

package/dist/src/orchestrator/detect-work-type.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=detect-work-type.test.d.ts.map

package/dist/src/orchestrator/detect-work-type.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-work-type.test.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/detect-work-type.test.ts"],"names":[],"mappings":""}

package/dist/src/orchestrator/detect-work-type.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { detectWorkType } from './orchestrator.js';
+describe('detectWorkType', () => {
+    describe('leaf issues (isParent=false)', () => {
+        it('maps Backlog status to development', () => {
+            expect(detectWorkType('Backlog', false)).toBe('development');
+        });
+        it('maps Finished status to qa', () => {
+            expect(detectWorkType('Finished', false)).toBe('qa');
+        });
+        it('maps Delivered status to acceptance', () => {
+            expect(detectWorkType('Delivered', false)).toBe('acceptance');
+        });
+        it('maps Rejected status to refinement', () => {
+            expect(detectWorkType('Rejected', false)).toBe('refinement');
+        });
+        it('maps Icebox status to research', () => {
+            expect(detectWorkType('Icebox', false)).toBe('research');
+        });
+        it('maps Started status to inflight', () => {
+            expect(detectWorkType('Started', false)).toBe('inflight');
+        });
+        it('defaults unknown status to development', () => {
+            expect(detectWorkType('SomeUnknownStatus', false)).toBe('development');
+        });
+    });
+    describe('parent issues (isParent=true)', () => {
+        it('upgrades Backlog/development to coordination', () => {
+            expect(detectWorkType('Backlog', true)).toBe('coordination');
+        });
+        it('upgrades Finished/qa to qa-coordination', () => {
+            expect(detectWorkType('Finished', true)).toBe('qa-coordination');
+        });
+        it('upgrades Delivered/acceptance to acceptance-coordination', () => {
+            expect(detectWorkType('Delivered', true)).toBe('acceptance-coordination');
+        });
+        it('upgrades Rejected/refinement to refinement-coordination', () => {
+            expect(detectWorkType('Rejected', true)).toBe('refinement-coordination');
+        });
+        it('does not upgrade research (Icebox) — no coordination variant', () => {
+            expect(detectWorkType('Icebox', true)).toBe('research');
+        });
+        it('does not upgrade inflight (Started) — no coordination variant', () => {
+            expect(detectWorkType('Started', true)).toBe('inflight');
+        });
+        it('upgrades unknown status (defaults to development → coordination)', () => {
+            expect(detectWorkType('SomeUnknownStatus', true)).toBe('coordination');
+        });
+    });
+    describe('post-refinement rework scenario (SUP-1116 bug)', () => {
+        it('parent issue returning to Backlog after refinement gets coordination, not development', () => {
+            // This is the exact scenario that caused SUP-1116 to fail:
+            // After refinement-coordination completed, the parent moved to Backlog.
+            // The orchestrator's run() previously hardcoded 'development', which loaded
+            // the wrong template and the agent asked for human input instead of
+            // autonomously dispatching sub-agents.
+            const workType = detectWorkType('Backlog', true);
+            expect(workType).toBe('coordination');
+            expect(workType).not.toBe('development');
+        });
+    });
+});

package/dist/src/orchestrator/heartbeat-writer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=heartbeat-writer.test.d.ts.map

package/dist/src/orchestrator/heartbeat-writer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat-writer.test.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/heartbeat-writer.test.ts"],"names":[],"mappings":""}