phasegate 0.254.0 → 0.283.0

package/scripts/harness/config-foundation/domain/value-objects/world-config.ts

@@ -0,0 +1,198 @@
+// @unit config-foundation
+// @layer domain
+// @work-item-id WI-300
+
+import { ConfigValidationError } from "../errors/config-validation-error.js";
+
+export interface WorldConfigDocument {
+  readonly enabled: boolean;
+  readonly corpus: {
+    readonly productRoots: readonly string[];
+    readonly inceptionRoots: readonly string[];
+    readonly adrRoots: readonly string[];
+    readonly sourceRoots: readonly string[];
+    readonly include: readonly string[];
+    readonly exclude: readonly string[];
+  };
+  readonly inputs: {
+    readonly matrixPath: string;
+    readonly attestationPath: string;
+    readonly integrityManifestPath: string;
+  };
+  readonly declarations: {
+    readonly constraintsPath: string;
+    readonly baselinePath: string;
+    readonly waiversPath: string;
+    readonly debtsPath: string;
+  };
+  readonly output: {
+    readonly obligationReportPath: string;
+  };
+  readonly sessionStart: {
+    readonly enabled: boolean;
+    readonly maxItems: number;
+    readonly maxChars: number;
+  };
+}
+
+export type WorldConfigSourceDocument = {
+  readonly [K in keyof WorldConfigDocument]?: WorldConfigDocument[K] extends readonly string[]
+    ? readonly string[]
+    : WorldConfigDocument[K] extends object
+      ? Partial<WorldConfigDocument[K]>
+      : WorldConfigDocument[K];
+};
+
+export const WORLD_CONFIG_DEFAULTS: WorldConfigDocument = Object.freeze({
+  enabled: false,
+  corpus: Object.freeze({
+    productRoots: Object.freeze(["docs/product"]),
+    inceptionRoots: Object.freeze(["docs/inception"]),
+    adrRoots: Object.freeze(["docs/ADR"]),
+    sourceRoots: Object.freeze(["scripts/harness"]),
+    include: Object.freeze(["**/*"]),
+    exclude: Object.freeze([]),
+  }),
+  inputs: Object.freeze({
+    matrixPath: ".harness/requirement-test-matrix.json",
+    attestationPath: ".harness/attestation.json",
+    integrityManifestPath: "phasegate.integrity.json",
+  }),
+  declarations: Object.freeze({
+    constraintsPath: "phasegate.world-constraints.json",
+    baselinePath: "phasegate.world-baseline.json",
+    waiversPath: "phasegate.world-waivers.json",
+    debtsPath: "phasegate.world-debts.json",
+  }),
+  output: Object.freeze({
+    obligationReportPath: ".harness/world-obligations.json",
+  }),
+  sessionStart: Object.freeze({ enabled: true, maxItems: 5, maxChars: 2000 }),
+});
+
+const cloneDocument = (document: WorldConfigDocument): WorldConfigDocument =>
+  Object.freeze({
+    enabled: document.enabled,
+    corpus: Object.freeze({
+      productRoots: Object.freeze([...document.corpus.productRoots]),
+      inceptionRoots: Object.freeze([...document.corpus.inceptionRoots]),
+      adrRoots: Object.freeze([...document.corpus.adrRoots]),
+      sourceRoots: Object.freeze([...document.corpus.sourceRoots]),
+      include: Object.freeze([...document.corpus.include]),
+      exclude: Object.freeze([...document.corpus.exclude]),
+    }),
+    inputs: Object.freeze({ ...document.inputs }),
+    declarations: Object.freeze({ ...document.declarations }),
+    output: Object.freeze({ ...document.output }),
+    sessionStart: Object.freeze({ ...document.sessionStart }),
+  });
+
+const assertProjectRelativePosixPath = (value: string): void => {
+  const segments = value.split("/");
+  if (
+    value.length === 0 ||
+    value.startsWith("/") ||
+    value.includes("\\") ||
+    segments.some((segment) => segment === "" || segment === "." || segment === "..")
+  ) {
+    throw new ConfigValidationError(`world path must be a project-relative POSIX path: ${value}`);
+  }
+};
+
+const assertUniqueStrings = (name: string, values: readonly string[], allowEmpty: boolean): void => {
+  if (!allowEmpty && values.length === 0) {
+    throw new ConfigValidationError(`${name} must not be empty`);
+  }
+  if (values.some((value) => value.length === 0) || new Set(values).size !== values.length) {
+    throw new ConfigValidationError(`${name} must contain unique non-empty values`);
+  }
+};
+
+interface CorpusRootEntry {
+  readonly role: string;
+  readonly path: string;
+}
+
+const rootsOverlap = (left: string, right: string): boolean =>
+  left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+
+const assertCorpusRoots = (document: WorldConfigDocument): void => {
+  const entries: readonly CorpusRootEntry[] = [
+    ...document.corpus.productRoots.map((path) => ({ role: "product", path })),
+    ...document.corpus.inceptionRoots.map((path) => ({ role: "inception", path })),
+    ...document.corpus.adrRoots.map((path) => ({ role: "adr", path })),
+    ...document.corpus.sourceRoots.map((path) => ({ role: "source", path })),
+  ];
+
+  for (let leftIndex = 0; leftIndex < entries.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < entries.length; rightIndex += 1) {
+      const left = entries[leftIndex];
+      const right = entries[rightIndex];
+      if (left.path.toLowerCase() === right.path.toLowerCase() && left.path !== right.path) {
+        throw new ConfigValidationError(`world path case-fold collision: ${left.path} / ${right.path}`);
+      }
+      if (left.role !== right.role && rootsOverlap(left.path, right.path)) {
+        throw new ConfigValidationError(`world corpus root role overlap: ${left.path} / ${right.path}`);
+      }
+    }
+  }
+};
+
+const allPaths = (document: WorldConfigDocument): readonly string[] => [
+  ...document.corpus.productRoots,
+  ...document.corpus.inceptionRoots,
+  ...document.corpus.adrRoots,
+  ...document.corpus.sourceRoots,
+  document.inputs.matrixPath,
+  document.inputs.attestationPath,
+  document.inputs.integrityManifestPath,
+  document.declarations.constraintsPath,
+  document.declarations.baselinePath,
+  document.declarations.waiversPath,
+  document.declarations.debtsPath,
+  document.output.obligationReportPath,
+];
+
+const assertNoCaseFoldPathCollisions = (paths: readonly string[]): void => {
+  const byFoldedPath = new Map<string, string>();
+  for (const path of paths) {
+    const folded = path.toLowerCase();
+    const existing = byFoldedPath.get(folded);
+    if (existing !== undefined && existing !== path) {
+      throw new ConfigValidationError(`world path case-fold collision: ${existing} / ${path}`);
+    }
+    byFoldedPath.set(folded, path);
+  }
+};
+
+export class WorldConfig {
+  private constructor(private readonly document: WorldConfigDocument) {}
+
+  static create(document: WorldConfigDocument): WorldConfig {
+    assertUniqueStrings("world.corpus.productRoots", document.corpus.productRoots, false);
+    assertUniqueStrings("world.corpus.inceptionRoots", document.corpus.inceptionRoots, false);
+    assertUniqueStrings("world.corpus.adrRoots", document.corpus.adrRoots, false);
+    assertUniqueStrings("world.corpus.sourceRoots", document.corpus.sourceRoots, false);
+    assertUniqueStrings("world.corpus.include", document.corpus.include, false);
+    assertUniqueStrings("world.corpus.exclude", document.corpus.exclude, true);
+    const paths = allPaths(document);
+    for (const path of paths) assertProjectRelativePosixPath(path);
+    assertNoCaseFoldPathCollisions(paths);
+    assertCorpusRoots(document);
+    if (
+      !Number.isInteger(document.sessionStart.maxItems) ||
+      document.sessionStart.maxItems < 1 ||
+      document.sessionStart.maxItems > 20 ||
+      !Number.isInteger(document.sessionStart.maxChars) ||
+      document.sessionStart.maxChars < 1 ||
+      document.sessionStart.maxChars > 8000
+    ) {
+      throw new ConfigValidationError("world.sessionStart must use maxItems 1..20 and maxChars 1..8000");
+    }
+    return new WorldConfig(cloneDocument(document));
+  }
+
+  toDocument(): WorldConfigDocument {
+    return cloneDocument(this.document);
+  }
+}

package/scripts/harness/config-foundation/index.ts

@@ -1,18 +1,17 @@
 // @unit config-foundation
 // @layer application
+// @work-item-id WI-300
 
-export { createConfigFoundationModule } from './composition-root.js';
-
-export { LoadResolvedConfigUseCase } from './application/usecases/load-resolved-config-use-case.js';
-export { toValidatorSystemConfig } from './application/mappers/validator-system-config-mapper.js';
-
-export type { ResolvedConfigOutput } from './application/dto/resolved-config-output.js';
-export type { FeatureToggleResult } from './application/dto/feature-toggle-result.js';
-export type { AvailableFeatureItem } from './application/dto/available-feature-item.js';
-
-export { EnableFeatureCommandHandler } from './presentation/cli/enable-feature-command-handler.js';
-export { DisableFeatureCommandHandler } from './presentation/cli/disable-feature-command-handler.js';
-
-export type { ConfigRepositoryPort } from './domain/ports/config-repository-port.js';
-export type { ConfigSchemaValidatorPort } from './domain/ports/config-schema-validator-port.js';
-export type { FeatureRegistryPort } from './domain/ports/feature-registry-port.js';
+export type { AvailableFeatureItem } from "./application/dto/available-feature-item.js";
+export type { FeatureToggleResult } from "./application/dto/feature-toggle-result.js";
+export type { ResolvedConfigOutput } from "./application/dto/resolved-config-output.js";
+export { toValidatorSystemConfig } from "./application/mappers/validator-system-config-mapper.js";
+export { toWorldModelConfig } from "./application/mappers/world-model-config-mapper.js";
+export { LoadResolvedConfigUseCase } from "./application/usecases/load-resolved-config-use-case.js";
+export { createConfigFoundationModule } from "./composition-root.js";
+export type { ConfigRepositoryPort } from "./domain/ports/config-repository-port.js";
+export type { ConfigSchemaValidatorPort } from "./domain/ports/config-schema-validator-port.js";
+export type { FeatureRegistryPort } from "./domain/ports/feature-registry-port.js";
+export type { WorldConfigDocument } from "./domain/value-objects/world-config.js";
+export { DisableFeatureCommandHandler } from "./presentation/cli/disable-feature-command-handler.js";
+export { EnableFeatureCommandHandler } from "./presentation/cli/enable-feature-command-handler.js";

package/scripts/harness/config-foundation/infrastructure/presets/minimal.json

@@ -55,5 +55,29 @@
   },
   "preCommit": {
     "implementationExtensions": [".ts"]
+  },
+  "world": {
+    "enabled": false,
+    "corpus": {
+      "productRoots": ["docs/product"],
+      "inceptionRoots": ["docs/inception"],
+      "adrRoots": ["docs/ADR"],
+      "sourceRoots": ["scripts/harness"],
+      "include": ["**/*"],
+      "exclude": []
+    },
+    "inputs": {
+      "matrixPath": ".harness/requirement-test-matrix.json",
+      "attestationPath": ".harness/attestation.json",
+      "integrityManifestPath": "phasegate.integrity.json"
+    },
+    "declarations": {
+      "constraintsPath": "phasegate.world-constraints.json",
+      "baselinePath": "phasegate.world-baseline.json",
+      "waiversPath": "phasegate.world-waivers.json",
+      "debtsPath": "phasegate.world-debts.json"
+    },
+    "output": { "obligationReportPath": ".harness/world-obligations.json" },
+    "sessionStart": { "enabled": true, "maxItems": 5, "maxChars": 2000 }
   }
 }

package/scripts/harness/config-foundation/infrastructure/presets/standard.json

@@ -55,5 +55,29 @@
   },
   "preCommit": {
     "implementationExtensions": [".ts"]
+  },
+  "world": {
+    "enabled": false,
+    "corpus": {
+      "productRoots": ["docs/product"],
+      "inceptionRoots": ["docs/inception"],
+      "adrRoots": ["docs/ADR"],
+      "sourceRoots": ["scripts/harness"],
+      "include": ["**/*"],
+      "exclude": []
+    },
+    "inputs": {
+      "matrixPath": ".harness/requirement-test-matrix.json",
+      "attestationPath": ".harness/attestation.json",
+      "integrityManifestPath": "phasegate.integrity.json"
+    },
+    "declarations": {
+      "constraintsPath": "phasegate.world-constraints.json",
+      "baselinePath": "phasegate.world-baseline.json",
+      "waiversPath": "phasegate.world-waivers.json",
+      "debtsPath": "phasegate.world-debts.json"
+    },
+    "output": { "obligationReportPath": ".harness/world-obligations.json" },
+    "sessionStart": { "enabled": true, "maxItems": 5, "maxChars": 2000 }
   }
 }

package/scripts/harness/config-foundation/infrastructure/presets/strict.json

@@ -55,5 +55,29 @@
   },
   "preCommit": {
     "implementationExtensions": [".ts"]
+  },
+  "world": {
+    "enabled": false,
+    "corpus": {
+      "productRoots": ["docs/product"],
+      "inceptionRoots": ["docs/inception"],
+      "adrRoots": ["docs/ADR"],
+      "sourceRoots": ["scripts/harness"],
+      "include": ["**/*"],
+      "exclude": []
+    },
+    "inputs": {
+      "matrixPath": ".harness/requirement-test-matrix.json",
+      "attestationPath": ".harness/attestation.json",
+      "integrityManifestPath": "phasegate.integrity.json"
+    },
+    "declarations": {
+      "constraintsPath": "phasegate.world-constraints.json",
+      "baselinePath": "phasegate.world-baseline.json",
+      "waiversPath": "phasegate.world-waivers.json",
+      "debtsPath": "phasegate.world-debts.json"
+    },
+    "output": { "obligationReportPath": ".harness/world-obligations.json" },
+    "sessionStart": { "enabled": true, "maxItems": 5, "maxChars": 2000 }
   }
 }

package/scripts/harness/config-foundation/infrastructure/repositories/file-system-config-repository.ts

@@ -2,19 +2,19 @@
  * @layer infrastructure
  * @unit config-foundation
  */
-import * as fs from 'node:fs/promises';
-import path from 'node:path';
-import type { ConfigRepositoryPort } from '../../domain/ports/config-repository-port.js';
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import type { ConfigRepositoryPort } from "../../domain/ports/config-repository-port.js";
 
-const DEFAULT_CONFIG_FILE_NAME = 'phasegate.config.json';
-const PERSONAL_CONFIG_PATH = path.join('.phasegate-local', DEFAULT_CONFIG_FILE_NAME);
+const DEFAULT_CONFIG_FILE_NAME = "phasegate.config.json";
+const PERSONAL_CONFIG_PATH = path.join(".phasegate-local", DEFAULT_CONFIG_FILE_NAME);
 
 export class ConfigNotFoundError extends Error {
   readonly configPath: string;
 
   constructor(configPath: string) {
     super(`Config file not found: ${configPath}`);
-    this.name = 'ConfigNotFoundError';
+    this.name = "ConfigNotFoundError";
     this.configPath = configPath;
     Object.setPrototypeOf(this, new.target.prototype);
   }
@@ -24,15 +24,28 @@ export class ConfigPersistenceError extends Error {
   readonly configPath: string;
   readonly cause?: unknown;
 
-  constructor(configPath: string, cause?: unknown) {
-    super(`Failed to persist config: ${configPath}`);
-    this.name = 'ConfigPersistenceError';
+  constructor(configPath: string, cause?: unknown, message?: string) {
+    super(message ?? `Failed to persist config: ${configPath}`);
+    this.name = "ConfigPersistenceError";
     this.configPath = configPath;
     this.cause = cause;
     Object.setPrototypeOf(this, new.target.prototype);
   }
 }
 
+/**
+ * WI-325: load 経路の JSON パース失敗専用エラー。
+ * ConfigPersistenceError のサブクラスなので、既存の
+ * `instanceof ConfigPersistenceError` fail-open 判定（main.ts / WI-314）は無変更で動く。
+ */
+export class ConfigParseError extends ConfigPersistenceError {
+  constructor(configPath: string, cause?: unknown) {
+    super(configPath, cause, `Failed to parse config JSON: ${configPath}`);
+    this.name = "ConfigParseError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
 async function exists(targetPath: string): Promise<boolean> {
   try {
     await fs.access(targetPath);
@@ -69,14 +82,10 @@ async function findNearestConfig(startDirectory: string): Promise<string | null>
 
 export class FileSystemConfigRepository implements ConfigRepositoryPort {
   async load(configPath?: string): Promise<{ path: string; document: unknown }> {
-    const resolvedPath = configPath
-      ? path.resolve(configPath)
-      : await findNearestConfig(process.cwd());
+    const resolvedPath = configPath ? path.resolve(configPath) : await findNearestConfig(process.cwd());
 
     if (!resolvedPath) {
-      throw new ConfigNotFoundError(
-        path.resolve(process.cwd(), DEFAULT_CONFIG_FILE_NAME),
-      );
+      throw new ConfigNotFoundError(path.resolve(process.cwd(), DEFAULT_CONFIG_FILE_NAME));
     }
 
     if (!(await exists(resolvedPath))) {
@@ -84,7 +93,7 @@ export class FileSystemConfigRepository implements ConfigRepositoryPort {
     }
 
     try {
-      const raw = await fs.readFile(resolvedPath, 'utf8');
+      const raw = await fs.readFile(resolvedPath, "utf8");
 
       return {
         path: resolvedPath,
@@ -92,7 +101,7 @@ export class FileSystemConfigRepository implements ConfigRepositoryPort {
       };
     } catch (error) {
       if (error instanceof SyntaxError) {
-        throw new ConfigPersistenceError(resolvedPath, error);
+        throw new ConfigParseError(resolvedPath, error);
       }
 
       throw error;
@@ -104,7 +113,7 @@ export class FileSystemConfigRepository implements ConfigRepositoryPort {
 
     try {
       const serialized = `${JSON.stringify(document, null, 2)}\n`;
-      await fs.writeFile(resolvedPath, serialized, 'utf8');
+      await fs.writeFile(resolvedPath, serialized, "utf8");
     } catch (error) {
       throw new ConfigPersistenceError(resolvedPath, error);
     }

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v2.schema.json

@@ -3,14 +3,7 @@
   "type": "object",
   "additionalProperties": false,
   "required": [
-    "project",
-    "layers",
-    "quickMode",
-    "phaseDependencies",
-    "planningMode",
-    "harnesses",
-    "paths",
-    "reporting"
+    "project"
   ],
   "properties": {
     "project": {
@@ -477,6 +470,89 @@
         }
       }
     },
+    "world": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "corpus": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "productRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "inceptionRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "adrRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "sourceRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "include": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            },
+            "exclude": {
+              "type": "array",
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            }
+          }
+        },
+        "inputs": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "matrixPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "attestationPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "integrityManifestPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "declarations": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "constraintsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "baselinePath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "waiversPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "debtsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "output": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "obligationReportPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "sessionStart": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "maxItems": { "type": "integer", "minimum": 1, "maximum": 20 },
+            "maxChars": { "type": "integer", "minimum": 1, "maximum": 8000 }
+          }
+        }
+      }
+    },
     "ci": {
       "type": "object",
       "additionalProperties": false,

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v3.schema.json

@@ -3,14 +3,7 @@
   "type": "object",
   "additionalProperties": false,
   "required": [
-    "project",
-    "layers",
-    "quickMode",
-    "phaseDependencies",
-    "planningMode",
-    "harnesses",
-    "paths",
-    "reporting"
+    "project"
   ],
   "$defs": {
     "effectCapability": {
@@ -495,6 +488,89 @@
         }
       }
     },
+    "world": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "corpus": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "productRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "inceptionRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "adrRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "sourceRoots": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+            },
+            "include": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            },
+            "exclude": {
+              "type": "array",
+              "uniqueItems": true,
+              "items": { "type": "string", "minLength": 1 }
+            }
+          }
+        },
+        "inputs": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "matrixPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "attestationPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "integrityManifestPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "declarations": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "constraintsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "baselinePath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "waiversPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" },
+            "debtsPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "output": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "obligationReportPath": { "type": "string", "pattern": "^(?!/)(?!.*\\\\)(?!\\.\\.?(?:/|$))(?!.*\\/\\.\\.?(?:/|$)).+$" }
+          }
+        },
+        "sessionStart": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "maxItems": { "type": "integer", "minimum": 1, "maximum": 20 },
+            "maxChars": { "type": "integer", "minimum": 1, "maximum": 8000 }
+          }
+        }
+      }
+    },
     "ci": {
       "type": "object",
       "additionalProperties": false,

package/scripts/harness/harness-api/domain/ports/config-query-port.ts

@@ -1,10 +1,20 @@
 // @layer domain
 // config-query-port.ts
 
-import type { PresetInfo, ConfigSummary, PhaseGateSummary } from '../value-objects/harness-status-summary.js';
+import type {
+  ConfigSummary,
+  LanguageInfo,
+  PhaseGateSummary,
+  PresetInfo,
+} from "../value-objects/harness-status-summary.js";
 
 export interface ConfigQueryPort {
   getPresetInfo(): Promise<PresetInfo>;
   getConfigSummary(): Promise<ConfigSummary>;
   getPhaseGateSummary(): Promise<PhaseGateSummary>;
+  /**
+   * WI-328: 実効言語リストと出所（declared / detected / fallback）を返す。
+   * 後方互換のため optional — 未実装アダプタでは status に languages を出さない。
+   */
+  getLanguageInfo?(): Promise<LanguageInfo>;
 }