synergyspec-selfevolving 1.1.12 → 1.1.13

package/dist/commands/self-evolution.js

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import fastGlob from 'fast-glob';
-import { aggregateLearnEvolutionHints, applyCandidatePromotion, rollbackCandidatePromotion, shouldAutoPromote, isEvidenceComplete, generateEvolutionHints, persistLearnHints, readCandidateFitness, readHealthBaseline, writeHealthBaseline, readCandidatePackage, resolveTargetLocalFiles, CANONICAL_CANDIDATE_SOURCES, CANONICAL_TARGETS, collectArchiveExperiences, EVOLVABLE_PART_DESCRIPTIONS, EVOLVABLE_PARTS, evaluateTaskDecompositionForChange, evaluateToolEvolutionCandidate, generateCandidateId, generatePromotionReport, groupCandidatesByTarget, rankCandidatesForTarget, makeReplayRunChange, scoreCandidatesByReplay, isEvolutionPartEnabled, findSimilarArchiveExperiences, listCanonicalTargets, lookupCanonicalTarget, runCanonicalProposerAgent, validateCandidateEdits, renderUnifiedDiff, CanonicalProposerNoOp, resolveTargetEvolutionPolicy, isCanonicalTargetEvolvable, parseEvolutionSwitchOptions, readTemplateVariantManifest, renderAlignmentReport, renderArchiveExperienceBlock, renderStaticGateSummary, renderToolEvolutionGuardReport, renderEvolutionSwitches, requireCanonicalTarget, resolveCandidateRepo, runStaticCandidateGate, selectTemplateVariant, shouldTriggerCandidate, validateLearnEvolutionHint, writeCandidatePackage, verifySpecCodeAlignmentForChange, } from '../core/self-evolution/index.js';
+import { aggregateLearnEvolutionHints, applyCandidatePromotion, rollbackCandidatePromotion, shouldAutoPromote, isEvidenceComplete, generateEvolutionHints, persistLearnHints, readCandidateFitness, readHealthBaseline, writeHealthBaseline, readCandidatePackage, resolveTargetLocalFiles, CANONICAL_CANDIDATE_SOURCES, CANONICAL_TARGETS, collectArchiveExperiences, EVOLVABLE_PART_DESCRIPTIONS, EVOLVABLE_PARTS, evaluateTaskDecompositionForChange, evaluateToolEvolutionCandidate, generateCandidateId, generatePromotionReport, groupCandidatesByTarget, rankCandidatesForTarget, makeReplayRunChange, scoreCandidatesByReplay, isEvolutionPartEnabled, findSimilarArchiveExperiences, listCanonicalTargets, lookupCanonicalTarget, runCanonicalProposerAgent, validateCandidateEdits, renderUnifiedDiff, CanonicalProposerNoOp, resolveTargetEvolutionPolicy, resolveKindOnlyPinTarget, detectUnbindableHintObservations, isCanonicalTargetEvolvable, parseEvolutionSwitchOptions, readTemplateVariantManifest, renderAlignmentReport, renderArchiveExperienceBlock, renderStaticGateSummary, renderToolEvolutionGuardReport, renderEvolutionSwitches, requireCanonicalTarget, resolveCandidateRepo, runStaticCandidateGate, selectTemplateVariant, shouldTriggerCandidate, validateLearnEvolutionHint, writeCandidatePackage, verifySpecCodeAlignmentForChange, } from '../core/self-evolution/index.js';
 import { generateLearnReport } from '../core/learn.js';
 import { resolveMetricSource } from '../core/fitness/index.js';
 import { validateChangeExists, validateSchemaExists } from './workflow/shared.js';
@@ -583,9 +583,34 @@ export async function runProposeCanonical(args, opts) {
         }
         return result;
     }
+    // Resolve the per-target evolution policy once (project config + CLI overrides),
+    // BEFORE aggregation so a kind-only hint can be re-pinned to the named
+    // --evolve-target. (issue #4 wired this pin into the learn path only; loading
+    // hints from disk in evolve-from-edits previously skipped it, so a legitimate
+    // kind-only hint could never bind to a concrete --evolve-target — the confusing
+    // "0 surviving hint group" refusal. See ses_15b0.)
+    const targetPolicy = resolveTargetEvolutionPolicy({
+        config: readProjectConfig(opts.repoRoot),
+        evolveTarget: args.evolveTarget,
+        freezeTarget: args.freezeTarget,
+    });
+    // Re-pin ONLY kind-only hints (no affectedTargetId) to the policy-resolved
+    // target, reusing the same pin logic + grouping-key formula as the learn path
+    // (so keys never double the kind prefix). Concrete hints are left UNTOUCHED —
+    // their evolvability is still enforced per-group below (frozen-target skip). A
+    // kind-only hint that cannot be uniquely pinned stays kind-only and surfaces as
+    // an unbindable defect rather than silently misbinding.
+    const scopedHints = hints.map((hint) => {
+        if (hint.affectedTargetId)
+            return hint;
+        const pinId = resolveKindOnlyPinTarget(hint, targetPolicy);
+        return typeof pinId === 'string'
+            ? { ...hint, affectedTargetId: pinId, thresholdKey: `${pinId}:${hint.proposedChangeType}` }
+            : hint;
+    });
     // 4) Aggregate. `aggregationOptions` lets auto-evolve act on a single change
     // (one forward pass = one loss); omitted = conservative cross-change defaults.
-    const allGroups = aggregateLearnEvolutionHints(hints, args.aggregationOptions);
+    const allGroups = aggregateLearnEvolutionHints(scopedHints, args.aggregationOptions);
     // 5) Filter.
     const skipped = [];
     let surviving;
@@ -641,18 +666,27 @@ export async function runProposeCanonical(args, opts) {
     if (path.resolve(layout.baseDir) !== path.resolve(expectedBase)) {
         throw new Error(`Candidate sandbox boundary violated: resolved baseDir=${layout.baseDir} but expected ${expectedBase}`);
     }
-    // Resolve the per-target evolution policy once (project config + CLI overrides).
-    const targetPolicy = resolveTargetEvolutionPolicy({
-        config: readProjectConfig(opts.repoRoot),
-        evolveTarget: args.evolveTarget,
-        freezeTarget: args.freezeTarget,
-    });
     // `--from-edits` carries ONE payload, so it can only map to a single hint
     // group / target. Require the caller to have narrowed to exactly one surviving
     // group (via --target / --threshold-key) so the edits are never misattributed.
     if (args.editsInput && surviving.length !== 1) {
-        stderr(`--from-edits requires exactly one surviving hint group, but ${surviving.length} survived. ` +
-            `Narrow with --target <id> or --threshold-key <key>.`);
+        if (surviving.length === 0) {
+            // Distinguish a BINDING DEFECT (a kind-only hint that could not be pinned to
+            // a concrete target) from a plain over-broad result, so the caller does not
+            // record a binding bug as "the gate correctly refused". See ses_15b0.
+            const unbindable = detectUnbindableHintObservations(scopedHints, targetPolicy);
+            if (unbindable.length > 0) {
+                stderr(unbindable.map((o) => o.summary).join(' '));
+            }
+            else {
+                stderr(`--from-edits requires exactly one surviving hint group, but 0 survived. ` +
+                    `Narrow with --target <id> or --threshold-key <key>.`);
+            }
+        }
+        else {
+            stderr(`--from-edits requires exactly one surviving hint group, but ${surviving.length} survived. ` +
+                `Narrow with --target <id> or --threshold-key <key>.`);
+        }
         return {
             exitCode: 2,
             proposed,

package/dist/core/config.d.ts

@@ -14,4 +14,16 @@ export interface AIToolOption {
     skillsDir?: string;
 }
 export declare const AI_TOOLS: AIToolOption[];
+/**
+ * Skill namespaces an installed project may carry SynergySpec-SelfEvolving
+ * workflow-prompt / skill files under, e.g. `.claude`, `.codex`, `.opencode`.
+ *
+ * Derived from {@link AI_TOOLS} so it can never drift from what the installer
+ * actually writes: the ArtifactSyncEngine writes each skill to
+ * `<skillsDir>/skills/<name>/SKILL.md`. The AGENTS.md option carries no
+ * `skillsDir`, so it is (correctly) excluded. Self-evolution local-target
+ * resolution, the tool-evolution path allowlist, and the skill-instruction
+ * canonical globs all consume this single source of truth.
+ */
+export declare const SKILL_NAMESPACES: readonly string[];
 //# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -29,4 +29,16 @@ export const AI_TOOLS = [
     { name: 'Windsurf', value: 'windsurf', available: true, successLabel: 'Windsurf', skillsDir: '.windsurf' },
     { name: 'AGENTS.md (works with Amp, VS Code, …)', value: 'agents', available: false, successLabel: 'your AGENTS.md-compatible assistant' }
 ];
+/**
+ * Skill namespaces an installed project may carry SynergySpec-SelfEvolving
+ * workflow-prompt / skill files under, e.g. `.claude`, `.codex`, `.opencode`.
+ *
+ * Derived from {@link AI_TOOLS} so it can never drift from what the installer
+ * actually writes: the ArtifactSyncEngine writes each skill to
+ * `<skillsDir>/skills/<name>/SKILL.md`. The AGENTS.md option carries no
+ * `skillsDir`, so it is (correctly) excluded. Self-evolution local-target
+ * resolution, the tool-evolution path allowlist, and the skill-instruction
+ * canonical globs all consume this single source of truth.
+ */
+export const SKILL_NAMESPACES = Object.freeze(Array.from(new Set(AI_TOOLS.map((tool) => tool.skillsDir).filter((dir) => typeof dir === 'string' && dir.length > 0))));
 //# sourceMappingURL=config.js.map

package/dist/core/learn.d.ts

@@ -190,16 +190,6 @@ export declare function structuredMemoryBody(args: {
 }): string;
 export declare function defaultRetrievalQueries(title: string, tags: string[] | undefined): string[];
 export declare function classifyCandidate(candidate: LearnMemoryCandidate): LearnMemoryCandidate;
-/**
- * Find lines in a verification artifact that look like UNRESOLVED failure
- * evidence. The hazard (the same prose-keyword trap as the trajectory runner
- * detector) is mistaking a PASSED negative-path scenario for a failure: a result
- * row `| UC3-E7a | Cleanup failure propagates | PASS | … |`, a table header
- * naming a `Counterexample` / `Regression Test` column, or a list item
- * `- PASS UC1-E1a: Open fails because …` all merely MENTION failure words while
- * reporting success. We therefore decide pass-ness structurally (table outcome
- * cell / PASS-prefixed list item / header row) before keyword-scanning the rest.
- */
 export declare function extractFailureEvidence(file: ArtifactFile): Array<{
     file: string;
     line: string;

package/dist/core/learn.js

@@ -196,9 +196,12 @@ function buildLearnObservations(report) {
     // (a) Candidates carrying a raw template/workflow signal.
     for (const candidate of report.memoryCandidates) {
         const hasTemplateTag = candidate.tags.some((tag) => /^(template|workflow):/i.test(tag));
-        const hasTemplateCode = candidate.sourceConclusionCodes.some((code) => code.startsWith('reuse.artifact-chain') ||
-            code.startsWith('avoid.template-') ||
-            code.startsWith('workflow.'));
+        // Only genuine `workflow.*` defects raise a template/workflow signal. `reuse.*`
+        // / `avoid.*` are COMPLIANCE signals (artifact hygiene), not defects, and must
+        // not emit a vacuous `template-signal` reflection (ses_15b0 category error). The
+        // explicit `template:` / `workflow:` tags (and `template-observation`) below
+        // remain the operator-intended path.
+        const hasTemplateCode = candidate.sourceConclusionCodes.some((code) => code.startsWith('workflow.'));
         if (candidate.tags.includes('template-observation') || hasTemplateTag || hasTemplateCode) {
             const files = candidate.links
                 .map((link) => toPosix(link))
@@ -1446,6 +1449,61 @@ const FAIL_CELL_RE = /^(?:fail(?:ed|s|ing|ure)?|error(?:ed|s)?|blocked|incomplet
  * reporting success. We therefore decide pass-ness structurally (table outcome
  * cell / PASS-prefixed list item / header row) before keyword-scanning the rest.
  */
+// A failure-ish keyword group: matching one of these is NECESSARY but not
+// sufficient to call a prose line failure evidence (see isNegatedSuccessLine).
+const FAILURE_KEYWORD_RE = /\b(fail(?:ed|ing|s|ure)?|errors?|blocked|incomplete|missing|regress(?:ion|ed|ing)?)\b/i;
+// A concrete positive count next to a failure word — "2 tests failed", "3
+// errors", "1 missing requirement". A non-zero integer within a few words of a
+// failure keyword is a GENUINE failure even if a negator appears elsewhere on
+// the line, so such lines are never treated as negated successes.
+const POSITIVE_FAILURE_COUNT_RE = /\b[1-9]\d*\s+(?:\S+\s+){0,3}?(?:fail(?:ed|ing|s|ure)?|errors?|blocked|incomplete|missing|regress(?:ion|ed|ing)?)\b/i;
+// Leading negators that, when they govern a nearby failure word, scope it as a
+// NON-failure ("No tests failed", "no incomplete checkboxes", "0 errors").
+const NEGATOR_TOKEN_RE = /^(?:no|none|zero|0|without|never)$/i;
+/** Every failure keyword in `clause` has a negator within the preceding 4 tokens. */
+function everyFailureWordNegated(clause) {
+    const tokens = clause.split(/\s+/).filter(Boolean);
+    for (let i = 0; i < tokens.length; i++) {
+        if (!FAILURE_KEYWORD_RE.test(tokens[i]))
+            continue;
+        let negated = false;
+        for (let j = Math.max(0, i - 4); j < i; j++) {
+            if (NEGATOR_TOKEN_RE.test(tokens[j])) {
+                negated = true;
+                break;
+            }
+        }
+        if (!negated)
+            return false;
+    }
+    return true;
+}
+/**
+ * True when a line merely MENTIONS failure words while reporting a clean result,
+ * e.g. "No tests failed.", "No missing or incomplete tests remain.", "has no
+ * incomplete checkboxes." Such negated-success prose is common in PASSING
+ * verification reports and must NOT be flagged as failure evidence (ses_1583).
+ *
+ * Rule: split the line into clauses (sentence/clause punctuation, contrast
+ * conjunctions, and dashes) and require that EVERY failure keyword in EVERY
+ * clause is governed by a negator within the preceding few tokens of the SAME
+ * clause. A single un-negated failure word — or a concrete positive failure
+ * count anywhere — means the line is genuine failure evidence. Requiring a
+ * NEAR-LEFT negator per keyword (not just one negator before the first keyword)
+ * is what keeps real prose like "the deploy failed" or "the failing UC4 test"
+ * flagged, where a leading negator scopes a different word.
+ */
+function isNegatedSuccessLine(line) {
+    if (!FAILURE_KEYWORD_RE.test(line))
+        return false;
+    if (POSITIVE_FAILURE_COUNT_RE.test(line))
+        return false;
+    const clauses = line
+        .split(/[.!?;:,]+|\s(?:but|however|though|although|yet|except)\s|\s[-–—]\s/i)
+        .map((clause) => clause.trim())
+        .filter(Boolean);
+    return clauses.every((clause) => everyFailureWordNegated(clause));
+}
 export function extractFailureEvidence(file) {
     const lines = file.content.split(/\r?\n/);
     const nextNonEmpty = (from) => {
@@ -1498,6 +1556,12 @@ export function extractFailureEvidence(file) {
         if (/\bwithout\s+(failures?|failed|errors?)\b/i.test(trimmed)) {
             continue;
         }
+        if (isNegatedSuccessLine(trimmed)) {
+            // A negated SUCCESS statement ("No tests failed.", "no incomplete
+            // checkboxes", "No missing or incomplete tests remain") merely mentions
+            // failure words while reporting a clean result (ses_1583). Not evidence.
+            continue;
+        }
         if (/\bpass(?:ed|es)?\b/i.test(trimmed) && !/\bfail(?:ed|ing|s|ure)?\b/i.test(trimmed)) {
             continue;
         }

package/dist/core/self-evolution/canonical-targets.js

@@ -18,6 +18,7 @@
  * canonical targets: they define the functional-correctness oracle and must
  * not self-evolve. See `docs/decisions/2026-05-30-oracle-freeze.md`.
  */
+import { SKILL_NAMESPACES } from '../config.js';
 const WORKFLOW_PROMPT_NAMES = [
     'apply-change',
     'archive-change',
@@ -37,11 +38,10 @@ const WORKFLOW_PROMPT_NAMES = [
     'verify-spec',
 ];
 const ARTIFACT_TEMPLATE_NAMES = ['proposal', 'spec', 'design', 'tasks'];
-const SKILL_INSTRUCTION_GLOBS = Object.freeze([
-    '.codex/skills/**/SKILL.md',
-    '.agents/skills/**/SKILL.md',
-    '.claude/skills/**/SKILL.md',
-]);
+// Cover every installed host skill namespace (derived from AI_TOOLS via
+// SKILL_NAMESPACES) so the skill-instruction surface is not blind to opencode,
+// cursor, gemini, … the way a hand-curated list was.
+const SKILL_INSTRUCTION_GLOBS = Object.freeze(SKILL_NAMESPACES.map((ns) => `${ns}/skills/**/SKILL.md`));
 const workflowPromptTargets = WORKFLOW_PROMPT_NAMES.map((name) => Object.freeze({
     id: `workflow-prompt:${name}`,
     kind: 'workflow-prompt',
@@ -111,7 +111,7 @@ export const CANONICAL_TARGETS = Object.freeze([
         promotionPolicy: 'human-required',
         rollbackPolicy: 'Regenerate SKILL.md files from previous canonical workflow prompts.',
         versioning: 'file-version',
-        notes: 'Glob entries cover .codex, .agents, and .claude skill namespaces; regenerated from workflow prompts.',
+        notes: 'Glob entries cover every installed skill namespace (derived from AI_TOOLS skillsDir values); regenerated from workflow prompts.',
     }),
 ]);
 /**

package/dist/core/self-evolution/learn-observation-adapter.d.ts

@@ -40,6 +40,13 @@ export declare function resolveTargetLocalFilesReadonly(targetId: string, repoRo
  * `target-evolution.ts` and the `add-per-target-evolution-switch` change.
  */
 export declare function generateEvolutionHints(report: LearnSignals, policy?: TargetEvolutionPolicy): LearnEvolutionHint[];
+/**
+ * Decide the concrete target a kind-only hint should be pinned to under the
+ * policy. Returns the target id to pin to, `undefined` to keep the hint
+ * kind-only (ambiguous — caller leaves it `unspecified`), or `null` to drop the
+ * hint entirely (no evolvable target of its kind exists).
+ */
+export declare function resolveKindOnlyPinTarget(draft: LearnEvolutionHint, policy: TargetEvolutionPolicy): string | undefined | null;
 /**
  * Surface an UNBINDABLE kind-only evolution hint as an actionable DEFECT
  * observation. After {@link scopeHintsByPolicy} runs, a hint that still has no

package/dist/core/self-evolution/learn-observation-adapter.js

@@ -25,12 +25,11 @@ import { findCanonicalTargetsByFile, listCanonicalTargets, lookupCanonicalTarget
 import { isCanonicalTargetEvolvable, explicitTargetIds, } from './target-evolution.js';
 import { detectRepoMode, resolveTargetLocalFiles } from './local-targets.js';
 import { getSchemaDir } from '../artifact-graph/resolver.js';
+import { SKILL_NAMESPACES } from '../config.js';
 import { limitText, } from '../learn.js';
 function toPosix(value) {
     return value.replace(/\\/g, '/');
 }
-/** Skill namespaces an installed project may carry the workflow prompts under. */
-const SKILL_NAMESPACES = ['.codex', '.claude', '.agents'];
 /** The config root the dogfood/user project uses for project-local overrides. */
 const CONFIG_ROOT = 'synergyspec-selfevolving';
 /**
@@ -151,6 +150,13 @@ export function generateEvolutionHints(report, policy) {
     };
     // Heuristic (a): Template/workflow observations recurring in memory candidates.
     for (const candidate of report.memoryCandidates) {
+        // The learn quality gate's verdict also gates evolution: a candidate it
+        // REJECTED (qualityScore below the keep bar) must not drive a canonical
+        // template/prompt edit. (ses_15b0: a reject-disposition `reuse.artifact-chain`
+        // candidate still produced a `confidence: high` hint.) Scoped to (a) only —
+        // Heuristic (b) below intentionally consumes low-quality candidates.
+        if (candidate.disposition === 'reject')
+            continue;
         const observation = inferTemplateObservation(candidate);
         if (!observation)
             continue;
@@ -343,7 +349,7 @@ function scopeHintsByPolicy(drafts, policy) {
  * kind-only (ambiguous — caller leaves it `unspecified`), or `null` to drop the
  * hint entirely (no evolvable target of its kind exists).
  */
-function resolveKindOnlyPinTarget(draft, policy) {
+export function resolveKindOnlyPinTarget(draft, policy) {
     // (1) Authoritative operator intent: a single registered, same-kind target
     // named on the CLI via `--evolve-target` pins the hint even when config leaves
     // other same-kind targets evolvable. `isCanonicalTargetEvolvable` honors
@@ -431,12 +437,13 @@ function inferTemplateObservation(candidate) {
         return { kind: 'artifact-template' };
     }
     for (const code of candidate.sourceConclusionCodes) {
-        if (code.startsWith('reuse.artifact-chain')) {
-            return { kind: 'artifact-template' };
-        }
-        if (code.startsWith('avoid.template-')) {
-            return { kind: 'artifact-template' };
-        }
+        // Only genuine workflow defects (e.g. `workflow.learn-before-archive`) infer a
+        // kind-only target. `reuse.*` / `avoid.*` are COMPLIANCE signals (artifact
+        // hygiene — "this change HAS all its artifacts"), NOT template defects, so they
+        // must not manufacture a template hint. (ses_15b0: a `reuse.artifact-chain`
+        // candidate produced a content-free, unbindable `artifact-template:unspecified`
+        // hint.) The explicit `template:` / `workflow:` / `template-observation` tag
+        // branches above remain the operator-intended path for a concrete template hint.
         if (code.startsWith('workflow.')) {
             return { kind: 'workflow-prompt' };
         }

package/dist/core/self-evolution/local-targets.js

@@ -8,7 +8,8 @@
  * exist only in the SS dev repo. In an installed USER repo the agent actually
  * reads its LOCAL artifacts:
  *   - workflow prompts  → `.codex/skills/synergyspec-selfevolving-<name>/SKILL.md`
- *                         (+ `.claude/…`, `.agents/…`) — already on disk.
+ *                         (+ `.claude/…`, `.opencode/…`, and every other host
+ *                         namespace in SKILL_NAMESPACES) — already on disk.
  *   - artifact templates→ `synergyspec-selfevolving/schemas/<schema>/templates/<name>.md`
  *                         — package-only until MATERIALIZED here (the resolver's
  *                         project-local tier then wins, per getSchemaDir).
@@ -23,8 +24,7 @@ import { existsSync } from 'node:fs';
 import * as path from 'node:path';
 import { lookupCanonicalTarget } from './canonical-targets.js';
 import { getSchemaDir } from '../artifact-graph/resolver.js';
-/** Skill namespaces an installed project may carry the workflow prompts under. */
-const SKILL_NAMESPACES = ['.codex', '.claude', '.agents'];
+import { SKILL_NAMESPACES } from '../config.js';
 /** The config root the dogfood/user project uses for project-local overrides. */
 const CONFIG_ROOT = 'synergyspec-selfevolving';
 /**
@@ -89,8 +89,8 @@ async function resolveUserModeFile(registryFile, repoRoot) {
         return [{ relPath: rel, absPath: abs, content, materialized: true }];
     }
     // Skill-instruction glob, or any other surface that is package-internal:
-    // expand a `.codex/.claude/.agents/skills/**/SKILL.md` glob to present files;
-    // everything else has no user-editable local artifact.
+    // expand a `<ns>/skills/**/SKILL.md` glob to present files (any host namespace
+    // in SKILL_NAMESPACES); everything else has no user-editable local artifact.
     if (/skills\/\*\*\/SKILL\.md$/.test(file)) {
         // Caller (resolveTargetLocalFiles) handles glob targets separately.
         return [];

package/dist/core/self-evolution/tool-evolution.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { clamp01, scoreFromFindings } from './shared.js';
+import { SKILL_NAMESPACES } from '../config.js';
 import { isEvolutionPartEnabled, resolveEvolutionSwitches, } from './evolution-switches.js';
 const ALLOWED_PREFIXES = [
     'schemas/',
@@ -12,9 +13,10 @@ const ALLOWED_PREFIXES = [
     'synergyspec-selfevolving/specs/',
     'synergyspec-selfevolving/changes/',
     'synergyspec-selfevolving/schemas/',
-    '.codex/skills/',
-    '.claude/skills/',
-    '.agents/skills/',
+    // Installed skill prompts across every supported host namespace (derived from
+    // AI_TOOLS so a real consumer's `.opencode/skills/…`, `.cursor/skills/…`, etc.
+    // promote without being rejected as a disallowed path).
+    ...SKILL_NAMESPACES.map((ns) => `${ns}/skills/`),
 ];
 const GENERATED_OR_VENDOR_PREFIXES = [
     'dist/',
@@ -262,7 +264,8 @@ function isSchemaOrTemplate(filePath) {
 /**
  * An artifact-template (`…/templates/<name>.md`), workflow-prompt template
  * (`src/core/templates/workflows/<name>.ts`), or an installed workflow-prompt
- * skill (`.<ns>/skills/<skill>/SKILL.md` for ns in codex/claude/agents). These
+ * skill (`<ns>/skills/<skill>/SKILL.md` for any host namespace in
+ * SKILL_NAMESPACES, e.g. .codex/.claude/.opencode). These
  * canonical-target files ARE the user-facing artifact/prompt contract, so a
  * template-only edit is a complete change and should not warn for "missing
  * companion spec/tests". A machine contract (`schema.yaml`, CLI) is deliberately
@@ -274,13 +277,15 @@ function isArtifactOrPromptTemplate(filePath) {
         isInstalledSkillPrompt(filePath));
 }
 /**
- * An installed workflow-prompt skill file: `.codex|.claude|.agents/skills/<dir>/SKILL.md`.
+ * An installed workflow-prompt skill file: `<ns>/skills/<dir>/SKILL.md`, where
+ * `<ns>` is any supported host namespace (`.codex`, `.claude`, `.opencode`, …).
  * This is the user-facing prompt/contract on a user's local install, so it is
  * treated as a prompt/template contract for scoring and carve-out purposes.
  * Paths are POSIX-normalized (forward slashes) before this is called.
  */
+const INSTALLED_SKILL_PROMPT_RE = new RegExp(`^(?:${SKILL_NAMESPACES.map((ns) => ns.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})/skills/.+/SKILL\\.md$`);
 function isInstalledSkillPrompt(filePath) {
-    return /^\.(codex|claude|agents)\/skills\/.+\/SKILL\.md$/.test(filePath);
+    return INSTALLED_SKILL_PROMPT_RE.test(filePath);
 }
 function isCli(filePath) {
     return /(^|\/)(cli|commands|bin)(\/|$)/.test(filePath) || filePath === 'bin/synergyspec-selfevolving.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synergyspec-selfevolving",
-  "version": "1.1.12",
+  "version": "1.1.13",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "synergyspec-selfevolving",