@patronage/software-factory 1.0.0-alpha.0 → 1.0.0-alpha.1

package/dist/index.d.ts

@@ -61,8 +61,8 @@ declare const boundaryReviewProofBaseSchema: z.ZodObject<{
   }>;
   producer: z.ZodString;
   rung: z.ZodEnum<{
-    oracle: "oracle";
     "independent-model": "independent-model";
+    oracle: "oracle";
     human: "human";
   }>;
   schemaVersion: z.ZodLiteral<1>;
@@ -105,8 +105,8 @@ declare const boundaryReviewProofSchema: z.ZodObject<{
   }>;
   producer: z.ZodString;
   rung: z.ZodEnum<{
-    oracle: "oracle";
     "independent-model": "independent-model";
+    oracle: "oracle";
     human: "human";
   }>;
   schemaVersion: z.ZodLiteral<1>;
@@ -537,6 +537,7 @@ declare const factoryProjectProfileSchema: z.ZodObject<{
     targets: z.ZodArray<z.ZodObject<{
       importers: z.ZodArray<z.ZodString>;
       name: z.ZodString;
+      paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
   }, z.core.$strict>>;
   proof: z.ZodObject<{
@@ -553,8 +554,8 @@ declare const factoryProjectProfileSchema: z.ZodObject<{
     name: z.ZodString;
     scope: z.ZodOptional<z.ZodObject<{
       classifications: z.ZodArray<z.ZodEnum<{
-        trivial: "trivial";
         "docs/process-only": "docs/process-only";
+        trivial: "trivial";
         "non-trivial": "non-trivial";
       }>>;
     }, z.core.$strict>>;
@@ -1133,8 +1134,8 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
   baseSha: z.ZodString;
   blockingReasons: z.ZodArray<z.ZodString>;
   classification: z.ZodEnum<{
-    trivial: "trivial";
     "docs/process-only": "docs/process-only";
+    trivial: "trivial";
     "non-trivial": "non-trivial";
   }>;
   externalChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1147,8 +1148,8 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodObject<{
       classifications: z.ZodArray<z.ZodEnum<{
-        trivial: "trivial";
         "docs/process-only": "docs/process-only";
+        trivial: "trivial";
         "non-trivial": "non-trivial";
       }>>;
     }, z.core.$strict>>;
@@ -1198,15 +1199,15 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
       unknown: "unknown";
       critical: "critical";
       high: "high";
-      low: "low";
       medium: "medium";
+      low: "low";
     }>>;
     highestOpenSeverity: z.ZodOptional<z.ZodEnum<{
       unknown: "unknown";
       critical: "critical";
       high: "high";
-      low: "low";
       medium: "medium";
+      low: "low";
     }>>;
     maxReviewCycles: z.ZodOptional<z.ZodNumber>;
     nonBlockingFindings: z.ZodNumber;
@@ -1234,8 +1235,8 @@ declare const managedReadinessLedgerSchema: z.ZodObject<{
     }>;
     stage: z.ZodEnum<{
       gate: "gate";
-      interior: "interior";
       "interior-complete": "interior-complete";
+      interior: "interior";
     }>;
   }, z.core.$strip>>;
   reviewRuns: z.ZodOptional<z.ZodArray<z.ZodType<PrReviewResult, unknown, z.core.$ZodTypeInternals<PrReviewResult, unknown>>>>;
@@ -1522,11 +1523,11 @@ declare function runPrReady(args: PrReadyArgs, dependencies?: PrReadyDependencie
  */
 declare const impactStampSchema: z.ZodObject<{
   basis: z.ZodEnum<{
-    "lockfile-scoped": "lockfile-scoped";
+    "target-scoped": "target-scoped";
     conservative: "conservative";
   }>;
   reasons: z.ZodArray<z.ZodString>;
-  stampVersion: z.ZodLiteral<1>;
+  stampVersion: z.ZodLiteral<2>;
   targets: z.ZodArray<z.ZodObject<{
     basis: z.ZodString;
     impact: z.ZodEnum<{
@@ -1560,7 +1561,7 @@ interface ImpactScopeDecision {
  * external proof demand (#542 wave 2), a verification-battery command, or a
  * preview (Alchemy) lifecycle stack (#430 wave 3).
  *
- * The only release path is a `lockfile-scoped` stamp of exactly this build's
+ * The only release path is a `target-scoped` stamp of exactly this build's
  * stamp version whose target entry for exactly this name is provably
  * `not-affected`. Every other input — no trusted stamp, an unknown stamp
  * version, a conservative stamp, a name the stamp does not classify, or an
@@ -1588,8 +1589,8 @@ declare const EVIDENCE_CHECK_TYPES: readonly ["review", "verify"];
 type EvidenceCheckType = (typeof EVIDENCE_CHECK_TYPES)[number];
 declare const requiredCheckScopeSchema: z.ZodObject<{
   classifications: z.ZodArray<z.ZodEnum<{
-    trivial: "trivial";
     "docs/process-only": "docs/process-only";
+    trivial: "trivial";
     "non-trivial": "non-trivial";
   }>>;
 }, z.core.$strict>;
@@ -1646,8 +1647,8 @@ declare const evidenceEnvelopeBaseSchema: z.ZodObject<{
   producer: z.ZodString;
   requestId: z.ZodOptional<z.ZodString>;
   rung: z.ZodOptional<z.ZodEnum<{
-    oracle: "oracle";
     "independent-model": "independent-model";
+    oracle: "oracle";
     human: "human";
   }>>;
   schemaVersion: z.ZodLiteral<1>;
@@ -1673,8 +1674,8 @@ declare const evidenceEnvelopeSchema: z.ZodObject<{
   producer: z.ZodString;
   requestId: z.ZodOptional<z.ZodString>;
   rung: z.ZodOptional<z.ZodEnum<{
-    oracle: "oracle";
     "independent-model": "independent-model";
+    oracle: "oracle";
     human: "human";
   }>>;
   schemaVersion: z.ZodLiteral<1>;
@@ -2294,8 +2295,8 @@ declare const boundaryCheckProofSchema: z.ZodObject<{
     wave: z.ZodString;
   }, z.core.$strip>>;
   demandedRung: z.ZodOptional<z.ZodEnum<{
-    oracle: "oracle";
     "independent-model": "independent-model";
+    oracle: "oracle";
     human: "human";
   }>>;
   epicIssue: z.ZodNumber;
@@ -2310,8 +2311,8 @@ declare const boundaryCheckProofSchema: z.ZodObject<{
     commentUrl: z.ZodOptional<z.ZodString>;
     producer: z.ZodString;
     rung: z.ZodEnum<{
-      oracle: "oracle";
       "independent-model": "independent-model";
+      oracle: "oracle";
       human: "human";
     }>;
     sessionId: z.ZodOptional<z.ZodString>;
@@ -3338,8 +3339,8 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
   slotResolution: z.ZodObject<{
     effort: z.ZodEnum<{
       high: "high";
-      low: "low";
       medium: "medium";
+      low: "low";
       xhigh: "xhigh";
     }>;
     engine: z.ZodString;
@@ -3351,18 +3352,18 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
     }>;
     model: z.ZodString;
     tier: z.ZodEnum<{
+      oracle: "oracle";
       review: "review";
       delegate: "delegate";
-      oracle: "oracle";
       workhorse: "workhorse";
       scout: "scout";
     }>;
   }, z.core.$strict>;
   startedAt: z.ZodString;
   tier: z.ZodEnum<{
+    oracle: "oracle";
     review: "review";
     delegate: "delegate";
-    oracle: "oracle";
     workhorse: "workhorse";
     scout: "scout";
   }>;
@@ -3417,8 +3418,8 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
   slotResolution: z.ZodObject<{
     effort: z.ZodEnum<{
       high: "high";
-      low: "low";
       medium: "medium";
+      low: "low";
       xhigh: "xhigh";
     }>;
     engine: z.ZodString;
@@ -3430,18 +3431,18 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
     }>;
     model: z.ZodString;
     tier: z.ZodEnum<{
+      oracle: "oracle";
       review: "review";
       delegate: "delegate";
-      oracle: "oracle";
       workhorse: "workhorse";
       scout: "scout";
     }>;
   }, z.core.$strict>;
   startedAt: z.ZodString;
   tier: z.ZodEnum<{
+    oracle: "oracle";
     review: "review";
     delegate: "delegate";
-    oracle: "oracle";
     workhorse: "workhorse";
     scout: "scout";
   }>;
@@ -3487,8 +3488,8 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
     slotResolution: z.ZodObject<{
       effort: z.ZodEnum<{
         high: "high";
-        low: "low";
         medium: "medium";
+        low: "low";
         xhigh: "xhigh";
       }>;
       engine: z.ZodString;
@@ -3500,18 +3501,18 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
       }>;
       model: z.ZodString;
       tier: z.ZodEnum<{
+        oracle: "oracle";
         review: "review";
         delegate: "delegate";
-        oracle: "oracle";
         workhorse: "workhorse";
         scout: "scout";
       }>;
     }, z.core.$strict>;
     startedAt: z.ZodString;
     tier: z.ZodEnum<{
+      oracle: "oracle";
       review: "review";
       delegate: "delegate";
-      oracle: "oracle";
       workhorse: "workhorse";
       scout: "scout";
     }>;
@@ -3556,15 +3557,15 @@ declare const FACTORY_TRACE_EVENT_DEFINITIONS: readonly [DefinedTraceEvent<"revi
   observedAt: string;
   purpose: "review" | "code";
   slotResolution: {
-    effort: "high" | "low" | "medium" | "xhigh";
+    effort: "high" | "medium" | "low" | "xhigh";
     engine: string;
     layerSource: "committedDefault" | "operatorSession" | "userConfig";
     model: string;
-    tier: "review" | "delegate" | "oracle" | "workhorse" | "scout";
+    tier: "oracle" | "review" | "delegate" | "workhorse" | "scout";
     fallbackTier?: "delegate" | undefined;
   };
   startedAt: string;
-  tier: "review" | "delegate" | "oracle" | "workhorse" | "scout";
+  tier: "oracle" | "review" | "delegate" | "workhorse" | "scout";
   tokenUsage: {
     source: "cursor-csv" | "codex-json" | "cursor-json" | "claude-json";
     status: "available";
@@ -3923,8 +3924,8 @@ declare const boundaryManifestBaseSchema: z.ZodObject<{
   boundary: z.ZodString;
   closeout: z.ZodOptional<z.ZodObject<{
     review: z.ZodEnum<{
-      oracle: "oracle";
       "independent-model": "independent-model";
+      oracle: "oracle";
       human: "human";
     }>;
   }, z.core.$loose>>;
@@ -3932,8 +3933,8 @@ declare const boundaryManifestBaseSchema: z.ZodObject<{
   prs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   schemaVersion: z.ZodLiteral<1>;
   topology: z.ZodEnum<{
-    flagged: "flagged";
     "each-to-main": "each-to-main";
+    flagged: "flagged";
     stacked: "stacked";
   }>;
   waves: z.ZodArray<z.ZodObject<{
@@ -3941,8 +3942,8 @@ declare const boundaryManifestBaseSchema: z.ZodObject<{
     issues: z.ZodArray<z.ZodNumber>;
     name: z.ZodString;
     review: z.ZodEnum<{
-      oracle: "oracle";
       "independent-model": "independent-model";
+      oracle: "oracle";
       human: "human";
     }>;
   }, z.core.$loose>>;
@@ -3951,8 +3952,8 @@ declare const boundaryManifestSchema: z.ZodObject<{
   boundary: z.ZodString;
   closeout: z.ZodOptional<z.ZodObject<{
     review: z.ZodEnum<{
-      oracle: "oracle";
       "independent-model": "independent-model";
+      oracle: "oracle";
       human: "human";
     }>;
   }, z.core.$loose>>;
@@ -3960,8 +3961,8 @@ declare const boundaryManifestSchema: z.ZodObject<{
   prs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   schemaVersion: z.ZodLiteral<1>;
   topology: z.ZodEnum<{
-    flagged: "flagged";
     "each-to-main": "each-to-main";
+    flagged: "flagged";
     stacked: "stacked";
   }>;
   waves: z.ZodArray<z.ZodObject<{
@@ -3969,8 +3970,8 @@ declare const boundaryManifestSchema: z.ZodObject<{
     issues: z.ZodArray<z.ZodNumber>;
     name: z.ZodString;
     review: z.ZodEnum<{
-      oracle: "oracle";
       "independent-model": "independent-model";
+      oracle: "oracle";
       human: "human";
     }>;
   }, z.core.$loose>>;
@@ -4055,7 +4056,7 @@ declare const evaluateReadiness: (input: EvaluationInput) => {
   ledger: {
     baseSha: string;
     blockingReasons: string[];
-    classification: "trivial" | "docs/process-only" | "non-trivial";
+    classification: "docs/process-only" | "trivial" | "non-trivial";
     github: {
       draft: boolean;
       mergeStateStatus: string;
@@ -4104,7 +4105,7 @@ declare const evaluateReadiness: (input: EvaluationInput) => {
       status: "satisfied" | "unmet" | "out-of-scope";
       reason?: string | undefined;
       scope?: {
-        classifications: ("trivial" | "docs/process-only" | "non-trivial")[];
+        classifications: ("docs/process-only" | "trivial" | "non-trivial")[];
       } | undefined;
     }[] | undefined;
     mergeBaseSha?: string | undefined;
@@ -4120,8 +4121,8 @@ declare const evaluateReadiness: (input: EvaluationInput) => {
       nonBlockingFindings: number;
       openFindings: number;
       windowExhausted: boolean;
-      highestBlockingSeverity?: "unknown" | "critical" | "high" | "low" | "medium" | undefined;
-      highestOpenSeverity?: "unknown" | "critical" | "high" | "low" | "medium" | undefined;
+      highestBlockingSeverity?: "unknown" | "critical" | "high" | "medium" | "low" | undefined;
+      highestOpenSeverity?: "unknown" | "critical" | "high" | "medium" | "low" | undefined;
       maxReviewCycles?: number | undefined;
       reviewCycle?: number | undefined;
       staleRepeatFindings?: number | undefined;
@@ -4132,7 +4133,7 @@ declare const evaluateReadiness: (input: EvaluationInput) => {
         interior: number;
       };
       nextAction: "run-gate-cycle" | "accept-nonblocking-findings" | "escalate-to-triage" | "ready-for-human" | "advance-to-gate" | "run-interior-cycle";
-      stage: "gate" | "interior" | "interior-complete";
+      stage: "gate" | "interior-complete" | "interior";
       forcedTransition?: "gate-cap-exhausted" | "interior-cap-reached" | undefined;
     } | undefined;
     reviewRuns?: PrReviewResult[] | undefined;

package/dist/index.js

@@ -17,7 +17,7 @@ import picomatch from "picomatch";
 import { parse } from "yaml";
 import { promisify } from "node:util";
 //#region package.json
-var version = "1.0.0-alpha.0";
+var version = "1.0.0-alpha.1";
 //#endregion
 //#region src/review-rungs.ts
 const EVIDENCE_REVIEW_RUNGS$1 = [
@@ -894,8 +894,15 @@ function isValidGlob(pattern) {
 		return false;
 	}
 }
+function isRepoRelativePath(value) {
+	const segments = value.split("/");
+	return value.length > 0 && !value.startsWith("/") && !/^[A-Za-z]:\//u.test(value) && !value.includes("\\") && !segments.some((segment) => segment === "" || segment === "." || segment === "..");
+}
+function isValidRepoRelativeGlob(pattern) {
+	return isRepoRelativePath(pattern) && !(pattern.startsWith("!") && !pattern.startsWith("!(")) && isValidGlob(pattern);
+}
 function matchesAnyGlob(patterns, file) {
-	return patterns.length > 0 && picomatch.isMatch(file, patterns);
+	return patterns.length > 0 && picomatch.isMatch(file, [...patterns]);
 }
 //#endregion
 //#region src/diff-classification.ts
@@ -939,8 +946,9 @@ const LEGACY_PROFILE_SCHEMA_VERSIONS = [
 	3,
 	4
 ];
-const PROFILE_JSON_SCHEMA_DESCRIPTION = "Editor validation covers the profile input shape and straightforward cross-field constraints. Zod remains the load-time enforcement authority: verification command names must be distinct and requiredChecks entries must have distinct names; these invariants are enforced at load time, not by this schema.";
+const PROFILE_JSON_SCHEMA_DESCRIPTION = "Editor validation covers the profile input shape and straightforward cross-field constraints. Zod remains the load-time enforcement authority: verification command names must be distinct and requiredChecks entries must have distinct names; these invariants are enforced at load time, not by this schema. Impact target path patterns encode repo-relative safety in JSON Schema, while complete picomatch syntax validity remains a runtime-only refinement.";
 const globSchema = z.string().min(1).refine(isValidGlob, "must be a valid glob");
+const repoRelativeGlobSchema = z.string().min(1).regex(/^(?!(?:\/[\s\S]*|[A-Za-z]:\/[\s\S]*|!(?!\()[\s\S]*|[\s\S]*\\[\s\S]*|[\s\S]*\/\/[\s\S]*|[\s\S]*\/$|\.{1,2}(?:\/|$)[\s\S]*|[\s\S]*\/\.{1,2}(?:\/|$)[\s\S]*)).+$/u, "must be a repo-relative positive glob").refine(isValidRepoRelativeGlob, "must be a valid repo-relative glob");
 const commandSchema = z.object({
 	command: z.string().min(1),
 	description: z.string().min(1),
@@ -972,7 +980,8 @@ const requiredCheckSchema = z.object({
 }).strict();
 const impactTargetSchema = z.object({
 	importers: z.array(z.string().min(1)).min(1),
-	name: z.string().min(1)
+	name: z.string().min(1),
+	paths: z.array(repoRelativeGlobSchema).min(1).optional()
 }).strict();
 const impactConfigSchema = z.object({ targets: z.array(impactTargetSchema).min(1).superRefine((targets, context) => {
 	const names = targets.map((target) => target.name);
@@ -3845,9 +3854,9 @@ const impactStampTargetSchema = z.object({
 * input widened every target to full impact.
 */
 const impactStampSchema = z.object({
-	basis: z.enum(["lockfile-scoped", "conservative"]),
+	basis: z.enum(["target-scoped", "conservative"]),
 	reasons: z.array(z.string()),
-	stampVersion: z.literal(1),
+	stampVersion: z.literal(2),
 	targets: z.array(impactStampTargetSchema).superRefine((targets, context) => {
 		const names = targets.map((target) => target.name);
 		if (new Set(names).size !== names.length) context.addIssue({
@@ -3886,7 +3895,7 @@ const IMPACT_SCOPE_SURFACES = {
 * external proof demand (#542 wave 2), a verification-battery command, or a
 * preview (Alchemy) lifecycle stack (#430 wave 3).
 *
-* The only release path is a `lockfile-scoped` stamp of exactly this build's
+* The only release path is a `target-scoped` stamp of exactly this build's
 * stamp version whose target entry for exactly this name is provably
 * `not-affected`. Every other input — no trusted stamp, an unknown stamp
 * version, a conservative stamp, a name the stamp does not classify, or an
@@ -3905,11 +3914,11 @@ const impactStampScopeDecision = ({ stamp, surface, targetName }) => {
 		reason: `no trusted identity-bound impact stamp covers this candidate; ${floor}`,
 		scoped: false
 	};
-	if (stamp.stampVersion !== 1) return {
-		reason: `impact stamp version ${String(stamp.stampVersion)} is not this build's version 1; ${floor}`,
+	if (stamp.stampVersion !== 2) return {
+		reason: `impact stamp version ${String(stamp.stampVersion)} is not this build's version 2; ${floor}`,
 		scoped: false
 	};
-	if (stamp.basis !== "lockfile-scoped") return {
+	if (stamp.basis !== "target-scoped") return {
 		reason: `impact stamp is conservative (full impact assumed); ${floor}`,
 		scoped: false
 	};
@@ -3951,7 +3960,7 @@ const impactStampDemandRelease = ({ checkName, stamp }) => {
 const conservativeImpactStamp = (targets, reasons) => ({
 	basis: "conservative",
 	reasons,
-	stampVersion: 1,
+	stampVersion: 2,
 	targets: targets.map((target) => ({
 		basis: CONSERVATIVE_TARGET_BASIS,
 		impact: "affected",
@@ -4087,11 +4096,10 @@ const targetImpactForLockfileDelta = (target, delta) => {
 /**
 * Compute the impact stamp for one candidate: every declared target recorded
 * as affected/not-affected with its exact basis. `not-affected` is only ever
-* returned for a provably-scoped pnpm-lock.yaml (v9) delta; every other input
-* — non-lockfile changed files, an empty diff, a missing, unparseable, or
-* structurally malformed lockfile side, an unsupported lockfile version, or a
-* delta outside the importers/packages/snapshots graph sections — widens to
-* full impact.
+* returned only when every changed input is owned by a declared source glob or
+* is an analyzable pnpm-lock.yaml (v9) delta. Source and lockfile reachability
+* are unioned per target. Any invalid, unmatched, unreadable, unsupported, or
+* otherwise doubtful input widens the whole stamp to full impact.
 *
 * Total by contract: this function never throws. Any unexpected failure in
 * reading, parsing, or traversal is itself a doubt path and returns the
@@ -4154,22 +4162,73 @@ const readLockfileSides = (readLockfile) => {
 const assertDeclaredImporterRoots = (targets, sides) => {
 	for (const target of targets) for (const root of target.importers) if (!sides.some((lockfile) => Object.keys(lockfile.importers).some((importerPath) => importerMatchesTarget(importerPath, [root])))) throw new ImpactStampConfigError(`impact target "${target.name}" declares importer root "${root}", but no importer under that root exists in pnpm-lock.yaml on either side of the delta; fix the profile's impact.targets declaration`);
 };
-const computeImpactStampOrThrow = ({ changedFiles, readLockfile }, targets) => {
+const assertDeclaredPathGlobs = (targets) => {
+	for (const target of targets) for (const pattern of target.paths ?? []) if (!isValidRepoRelativeGlob(pattern)) throw new ImpactStampConfigError(`impact target "${target.name}" declares invalid repo-relative path glob "${pattern}"; fix the profile's impact.targets declaration`);
+};
+const analyzeSourcePaths = (sourceFiles, targets, profilePath) => {
+	for (const file of sourceFiles) {
+		if (!isRepoRelativePath(file)) return {
+			kind: "conservative",
+			reason: `changed source path "${file}" is not a valid repo-relative path; fail closed to full impact`
+		};
+		if (file === profilePath) return {
+			kind: "conservative",
+			reason: `changed source path "${file}" is the impact profile being evaluated; fail closed to full impact`
+		};
+		if (!targets.some((target) => matchesAnyGlob(target.paths ?? [], file))) return {
+			kind: "conservative",
+			reason: `changed source path "${file}" has no declared impact target owner; fail closed to full impact`
+		};
+	}
+	return {
+		kind: "ok",
+		targets: targets.map((target) => {
+			const matched = sourceFiles.find((file) => matchesAnyGlob(target.paths ?? [], file));
+			return matched === void 0 ? {
+				basis: "no changed source path matches this target's declared paths",
+				impact: "not-affected",
+				name: target.name
+			} : {
+				basis: `changed source path "${matched}" matches this target's declared paths`,
+				impact: "affected",
+				name: target.name
+			};
+		})
+	};
+};
+const unionTargetImpact = (source, lockfile) => {
+	if (source.impact === "affected") return source;
+	if (lockfile.impact === "affected") return lockfile;
+	return {
+		basis: `${source.basis}; ${lockfile.basis}`,
+		impact: "not-affected",
+		name: source.name
+	};
+};
+const computeImpactStampOrThrow = ({ changedFiles, profilePath = "software-factory.profile.json", readLockfile }, targets) => {
 	if (targets.length === 0) return {
 		basis: "conservative",
 		reasons: ["no impact targets declared in the profile; every surface keeps full demand"],
-		stampVersion: 1,
+		stampVersion: 2,
 		targets: []
 	};
+	assertDeclaredPathGlobs(targets);
 	const sides = readLockfileSides(readLockfile);
 	if (sides.kind === "ok") assertDeclaredImporterRoots(targets, sides.parsed);
 	if (changedFiles.length === 0) return conservativeStamp(targets, ["no changed files detected; full impact assumed"]);
-	const unmodelledFiles = changedFiles.filter((file) => file !== LOCKFILE_PATH);
-	if (unmodelledFiles.length > 0) return conservativeStamp(targets, [`changed files outside the lockfile classifier's model (${unmodelledFiles.toSorted().join(", ")}); full impact assumed`]);
+	const sourceFiles = changedFiles.filter((file) => file !== LOCKFILE_PATH);
+	const source = analyzeSourcePaths(sourceFiles, targets, profilePath);
+	if (source.kind === "conservative") return conservativeStamp(targets, [source.reason]);
 	if (sides.kind === "threw") throw sides.error;
 	if (sides.kind === "unreadable") return conservativeStamp(targets, [`pnpm-lock.yaml is unreadable at the ${sides.side} side; fail closed to full impact`]);
 	if (sides.kind === "unparseable") return conservativeStamp(targets, [`pnpm-lock.yaml is unparseable or structurally malformed at the ${sides.side} side; fail closed to full impact`]);
 	if (sides.kind === "unsupported-version") return conservativeStamp(targets, [`pnpm-lock.yaml is not lockfileVersion ${SUPPORTED_LOCKFILE_VERSION}; only pnpm v9 lockfiles are modelled; fail closed to full impact`]);
+	if (!changedFiles.includes("pnpm-lock.yaml")) return {
+		basis: "target-scoped",
+		reasons: ["all changed source paths have declared target ownership; impact scoped by repo-relative path globs"],
+		stampVersion: 2,
+		targets: source.targets
+	};
 	const [baseLock, headLock] = sides.parsed;
 	if (stableStringify$1(nonGraphSections(baseLock)) !== stableStringify$1(nonGraphSections(headLock))) return conservativeStamp(targets, ["pnpm-lock.yaml delta touches sections outside importers/packages/snapshots (e.g. settings, overrides, patchedDependencies); fail closed to full impact"]);
 	const delta = {
@@ -4178,11 +4237,13 @@ const computeImpactStampOrThrow = ({ changedFiles, readLockfile }, targets) => {
 		changedSnapshots: changedSectionKeys(baseLock.snapshots, headLock.snapshots),
 		sides: [baseLock, headLock]
 	};
+	const lockfileTargets = targets.map((target) => targetImpactForLockfileDelta(target, delta));
+	const mixed = sourceFiles.length > 0;
 	return {
-		basis: "lockfile-scoped",
-		reasons: ["pnpm-lock.yaml is the only changed file; impact scoped by importer/snapshot graph analysis"],
-		stampVersion: 1,
-		targets: targets.map((target) => targetImpactForLockfileDelta(target, delta))
+		basis: "target-scoped",
+		reasons: mixed ? ["all changed source paths have declared target ownership and pnpm-lock.yaml is analyzable; impact is the union of path ownership and importer/snapshot graph analysis"] : ["pnpm-lock.yaml is the only changed file; impact scoped by importer/snapshot graph analysis"],
+		stampVersion: 2,
+		targets: mixed ? source.targets.map((sourceTarget, index) => unionTargetImpact(sourceTarget, lockfileTargets[index])) : lockfileTargets
 	};
 };
 //#endregion
@@ -4361,7 +4422,7 @@ const assertBatteryCompleteness = (proof, context) => {
 * so authorization is bound to the same identities the proof binds. The
 * predicate is the shared {@link impactStampScopeDecision}, not a second
 * reading of the stamp: an entry is authorized exactly when the stamp would
-* have released that target's command in the first place (lockfile-scoped
+* have released that target's command in the first place (target-scoped
 * basis, this build's stamp version, exactly one row for the target,
 * `not-affected`). A conservative stamp, an unknown version, a
 * self-contradictory stamp, an unclassified name, or an `affected` verdict all
@@ -11167,6 +11228,7 @@ function runPrVerify(args, dependencies = {}) {
 		impactStamp = computeImpactStamp({
 			changedFiles: files,
 			profile,
+			profilePath: relativeProfile,
 			readLockfile: (side) => readLockfileAtRef(cwd, side === "base" ? proofMergeBaseSha : headSha, path.resolve(cwd, LOCKFILE_PATH))
 		});
 	} catch (error) {

package/dist/schemas.d.ts

@@ -493,11 +493,11 @@ interface PrReadyProof {
  */
 declare const impactStampSchema: z.ZodObject<{
   basis: z.ZodEnum<{
-    "lockfile-scoped": "lockfile-scoped";
+    "target-scoped": "target-scoped";
     conservative: "conservative";
   }>;
   reasons: z.ZodArray<z.ZodString>;
-  stampVersion: z.ZodLiteral<1>;
+  stampVersion: z.ZodLiteral<2>;
   targets: z.ZodArray<z.ZodObject<{
     basis: z.ZodString;
     impact: z.ZodEnum<{
@@ -1362,11 +1362,11 @@ declare const prVerifyProofSchema: z.ZodObject<{
   headSha: z.ZodString;
   impactStamp: z.ZodOptional<z.ZodObject<{
     basis: z.ZodEnum<{
-      "lockfile-scoped": "lockfile-scoped";
+      "target-scoped": "target-scoped";
       conservative: "conservative";
     }>;
     reasons: z.ZodArray<z.ZodString>;
-    stampVersion: z.ZodLiteral<1>;
+    stampVersion: z.ZodLiteral<2>;
     targets: z.ZodArray<z.ZodObject<{
       basis: z.ZodString;
       impact: z.ZodEnum<{

package/dist/schemas.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import "yaml";
+import "picomatch";
 //#region src/review-rungs.ts
 const EVIDENCE_REVIEW_RUNGS$1 = [
 	"independent-model",
@@ -239,9 +240,9 @@ const impactStampTargetSchema = z.object({
 * input widened every target to full impact.
 */
 const impactStampSchema = z.object({
-	basis: z.enum(["lockfile-scoped", "conservative"]),
+	basis: z.enum(["target-scoped", "conservative"]),
 	reasons: z.array(z.string()),
-	stampVersion: z.literal(1),
+	stampVersion: z.literal(2),
 	targets: z.array(impactStampTargetSchema).superRefine((targets, context) => {
 		const names = targets.map((target) => target.name);
 		if (new Set(names).size !== names.length) context.addIssue({
@@ -267,7 +268,7 @@ const IMPACT_SCOPE_SURFACES = {
 * external proof demand (#542 wave 2), a verification-battery command, or a
 * preview (Alchemy) lifecycle stack (#430 wave 3).
 *
-* The only release path is a `lockfile-scoped` stamp of exactly this build's
+* The only release path is a `target-scoped` stamp of exactly this build's
 * stamp version whose target entry for exactly this name is provably
 * `not-affected`. Every other input — no trusted stamp, an unknown stamp
 * version, a conservative stamp, a name the stamp does not classify, or an
@@ -286,11 +287,11 @@ const impactStampScopeDecision = ({ stamp, surface, targetName }) => {
 		reason: `no trusted identity-bound impact stamp covers this candidate; ${floor}`,
 		scoped: false
 	};
-	if (stamp.stampVersion !== 1) return {
-		reason: `impact stamp version ${String(stamp.stampVersion)} is not this build's version 1; ${floor}`,
+	if (stamp.stampVersion !== 2) return {
+		reason: `impact stamp version ${String(stamp.stampVersion)} is not this build's version 2; ${floor}`,
 		scoped: false
 	};
-	if (stamp.basis !== "lockfile-scoped") return {
+	if (stamp.basis !== "target-scoped") return {
 		reason: `impact stamp is conservative (full impact assumed); ${floor}`,
 		scoped: false
 	};
@@ -435,7 +436,7 @@ const assertBatteryCompleteness = (proof, context) => {
 * so authorization is bound to the same identities the proof binds. The
 * predicate is the shared {@link impactStampScopeDecision}, not a second
 * reading of the stamp: an entry is authorized exactly when the stamp would
-* have released that target's command in the first place (lockfile-scoped
+* have released that target's command in the first place (target-scoped
 * basis, this build's stamp version, exactly one row for the target,
 * `not-affected`). A conservative stamp, an unknown version, a
 * self-contradictory stamp, an unclassified name, or an `affected` verdict all

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patronage/software-factory",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.1",
   "description": "Shared Patronage software factory CLI and project-profile validation tools",
   "license": "MIT",
   "repository": {