@polymorphism-tech/morph-spec 8.33.0 → 8.35.0

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-cache/cache/triagem.acme.a-saudacao/1/19F631228C6E00BA/contents.data

@@ -0,0 +1,13 @@
+{
+  "messages": [
+    {
+      "role": "assistant",
+      "contents": [
+        {
+          "$type": "text",
+          "text": "Bom dia! Como posso ajudar voce hoje?"
+        }
+      ]
+    }
+  ]
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-cache/cache/triagem.acme.a-saudacao/1/19F631228C6E00BA/entry.json

@@ -0,0 +1,7 @@
+{
+  "scenarioName": "triagem.acme.a-saudacao",
+  "iterationName": "1",
+  "key": "19F631228C6E00BA41892982E6EA1BB23822FA53D6E62C79B6724893618E7E03AE4F70F94332FDEE0DAA960974BA1171",
+  "creation": "2026-09-09T04:54:34.8385364+00:00",
+  "expiration": "2036-09-06T04:54:34.8385364+00:00"
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-cache/cache/triagem.acme.b-escalonamento/1/A24A7C9BDD8239D8/contents.data

@@ -0,0 +1,13 @@
+{
+  "messages": [
+    {
+      "role": "assistant",
+      "contents": [
+        {
+          "$type": "text",
+          "text": "Encaminhando voce para um atendente humano agora."
+        }
+      ]
+    }
+  ]
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-cache/cache/triagem.acme.b-escalonamento/1/A24A7C9BDD8239D8/entry.json

@@ -0,0 +1,7 @@
+{
+  "scenarioName": "triagem.acme.b-escalonamento",
+  "iterationName": "1",
+  "key": "A24A7C9BDD8239D87A60FD05A4BF870DAB4CFBE8BE7A796FF86534B6F37F4517321D3420D76ED6B5EF000C68CB18301F",
+  "creation": "2026-09-09T04:54:34.8448053+00:00",
+  "expiration": "2036-09-06T04:54:34.8448053+00:00"
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-cache/cache/triagem.globex.a-saudacao/1/E38CD37DF003EDB7/contents.data

@@ -0,0 +1,13 @@
+{
+  "messages": [
+    {
+      "role": "assistant",
+      "contents": [
+        {
+          "$type": "text",
+          "text": "Bom dia! Aqui e o atendimento da Globex."
+        }
+      ]
+    }
+  ]
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-cache/cache/triagem.globex.a-saudacao/1/E38CD37DF003EDB7/entry.json

@@ -0,0 +1,7 @@
+{
+  "scenarioName": "triagem.globex.a-saudacao",
+  "iterationName": "1",
+  "key": "E38CD37DF003EDB77815FF1A086F48ACBDD63E743D44DFFDF2A23EEED34731E8D3B6E51A4EBB740CB0BF2720D8AA02ED",
+  "creation": "2026-09-09T04:54:34.846003+00:00",
+  "expiration": "2036-09-06T04:54:34.846003+00:00"
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-datasets/orcamento/acme/a-resposta-estruturada.json

@@ -0,0 +1,24 @@
+{
+  "messages": [
+    {
+      "role": "system",
+      "text": "Responda SOMENTE com um objeto JSON com as chaves valor e prazo."
+    },
+    {
+      "role": "user",
+      "text": "quanto custa a revisao anual?"
+    }
+  ],
+  "assertions": [
+    {
+      "name": "tem-valor",
+      "kind": "json-has-key",
+      "target": "valor"
+    },
+    {
+      "name": "tem-prazo",
+      "kind": "json-has-key",
+      "target": "prazo"
+    }
+  ]
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-datasets/triagem/acme/a-saudacao.json

@@ -0,0 +1,23 @@
+{
+  "messages": [
+    {
+      "role": "system",
+      "text": "Voce e o atendente da Acme. Responda em portugues, em uma frase."
+    },
+    {
+      "role": "user",
+      "text": "bom dia"
+    }
+  ],
+  "assertions": [
+    {
+      "name": "cumprimenta",
+      "kind": "contains",
+      "value": "bom dia"
+    },
+    {
+      "name": "sem-dado-pessoal",
+      "kind": "no-pii"
+    }
+  ]
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-datasets/triagem/acme/b-escalonamento.json

@@ -0,0 +1,24 @@
+{
+  "messages": [
+    {
+      "role": "system",
+      "text": "Voce e o atendente da Acme. Responda em portugues, em uma frase."
+    },
+    {
+      "role": "user",
+      "text": "quero falar com um humano agora"
+    }
+  ],
+  "assertions": [
+    {
+      "name": "confirma-encaminhamento",
+      "kind": "contains",
+      "value": "encaminhando"
+    },
+    {
+      "name": "nao-promete-prazo",
+      "kind": "not-contains",
+      "value": "garantimos"
+    }
+  ]
+}

package/framework/templates/dotnet/ai-kit/tests/Morph.AiKit.Tests/eval-datasets/triagem/globex/a-saudacao.json

@@ -0,0 +1,23 @@
+{
+  "messages": [
+    {
+      "role": "system",
+      "text": "Voce e o atendente da Globex. Responda em portugues, em uma frase."
+    },
+    {
+      "role": "user",
+      "text": "bom dia"
+    }
+  ],
+  "assertions": [
+    {
+      "name": "cumprimenta",
+      "kind": "contains",
+      "value": "Globex"
+    },
+    {
+      "name": "sem-dado-pessoal",
+      "kind": "no-pii"
+    }
+  ]
+}

package/framework/templates/infrastructure/docker/docker-compose.template.yml

@@ -1,17 +1,29 @@
 # Docker Compose for Local Development
 # Next.js + Neon Stack
 #
-# Ports come from variables with sane defaults so `morph-spec e2e up` can hand
-# each feature worktree its own port block (see env-allocator.js). Hardcode
-# "3000:3000" here and two features running side by side collide on the host,
-# no matter what the harness injects — the container names would be distinct
-# and the ports would not.
+# One compose project per worktree. The harness sets
+# COMPOSE_PROJECT_NAME=morph-{feature}, which prefixes every container, network
+# and volume — so two features running side by side never share a resource.
+# Explicit `container_name:` entries are NOT prefixed, which is why this file
+# declares none: a named container is a collision waiting for the second
+# worktree.
 #
-# Healthchecks are what make `up --wait` meaningful: without them Compose
-# reports "started" the moment the process launches, and the e2e node would
-# navigate an application that is not serving yet.
+# Host ports come from the feature's port block (see env-allocator.js):
+#   PORT          block + 0   (web)
+#   API_PORT      block + 1   (api)
+#   POSTGRES_PORT block + 2   (postgres)
+#   REDIS_PORT    block + 3   (redis)
+# Every published port reads one of those variables with a single-stack
+# default. A fixed host port here would defeat the block no matter what the
+# harness injects — `morph-spec e2e up` and the verify e2e node refuse such a
+# compose inside a worktree (`compose-not-isolable`).
 #
-# The harness also exports PLAYWRIGHT_BASE_URL for the same allocated port, so
+# Named volumes are reclaimed by `morph-spec finish` when the feature closes
+# (`--keep-volumes` opts out). Healthchecks are what make `up --wait`
+# meaningful: without them Compose reports "started" the moment the process
+# launches, and the e2e node would navigate an application not serving yet.
+#
+# The harness also exports PLAYWRIGHT_BASE_URL for the allocated port, so
 # `playwright.config.ts` must read it instead of hardcoding a URL:
 #   baseURL: process.env.PLAYWRIGHT_BASE_URL ?? `http://localhost:${process.env.PORT ?? 3000}`
 
@@ -21,12 +33,11 @@ services:
     build:
       context: .
       dockerfile: Dockerfile.dev
-    container_name: {{kebabCase FEATURE_NAME}}-app
     ports:
       - "${PORT:-3000}:3000"
     environment:
       - NODE_ENV=development
-      - DATABASE_URL=${DATABASE_URL}
+      - DATABASE_URL=${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/${POSTGRES_DB:-app}}
     volumes:
       - .:/app
       - /app/node_modules
@@ -46,19 +57,18 @@ services:
   # PostgreSQL Database (Local development)
   postgres:
     image: postgres:15-alpine
-    container_name: {{kebabCase FEATURE_NAME}}-postgres
     restart: unless-stopped
     ports:
       - "${POSTGRES_PORT:-5432}:5432"
     environment:
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: {{snakeCase FEATURE_NAME}}
+      POSTGRES_DB: ${POSTGRES_DB:-app}
     volumes:
       - postgres-data:/var/lib/postgresql/data
       - ./migrations:/docker-entrypoint-initdb.d
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d {{snakeCase FEATURE_NAME}}"]
+      test: ["CMD-SHELL", "pg_isready -U postgres -d ${POSTGRES_DB:-app}"]
       interval: 5s
       timeout: 5s
       retries: 10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "8.33.0",
+  "version": "8.35.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",
@@ -41,8 +41,8 @@
   },
   "scripts": {
     "start": "node bin/morph-spec.js",
-    "generate": "node scripts/generate-refs.js",
-    "generate:check": "node scripts/generate-refs.js --check",
+    "generate": "node scripts/generate-refs.js && node scripts/generate-ai-pin-props.js && node scripts/api-probe/probe.mjs --generate",
+    "generate:check": "node scripts/generate-refs.js --check && node scripts/generate-ai-pin-props.js --check && node scripts/api-probe/probe.mjs --check",
     "generate-standards": "node scripts/generate-standards-registry.js",
     "generate-standards:check": "node scripts/generate-standards-registry.js --check",
     "validate": "node scripts/validate-framework.js && node scripts/check-rubric-parity.js",

package/src/commands/e2e/e2e.js

@@ -7,6 +7,11 @@
  * running still matches the working tree, and `down` releases it — which
  * `morph-spec finish` also does as part of teardown.
  *
+ * Every subcommand acts in the TREE THAT OWNS THE FEATURE: run from the
+ * primary root for a feature that lives in a worktree, the compose file, the
+ * bind mount and the stamp are all the worktree's — the root's copy is a
+ * different checkout of different code.
+ *
  * All the real logic lives in framework/hooks/shared/e2e-check.js, shared with
  * the `verify` e2e node so the two can never drift.
  *
@@ -22,16 +27,21 @@ import {
   bringUpStack,
   composeProjectName,
   computeSourceStamp,
+  decideIsolation,
   defaultExec,
+  deleteStamp,
   getStackStatus,
   isDockerAvailable,
+  lintComposeIsolation,
   prepareAuth,
   readStamp,
   resolveComposeFile,
   resolveSpecCommand,
   tearDownStack,
 } from '../../../framework/hooks/shared/e2e-check.js';
+import { isSecondaryWorktree } from '../../../framework/hooks/shared/git-paths.js';
 import { buildComposeEnv } from '../../lib/e2e/compose-env.js';
+import { findWorktreeForFeature, resolvePrimaryRoot } from '../project/worktree.js';
 
 /** Exit code for a usage error, matching `verify`'s convention. */
 const EXIT_USAGE = 2;
@@ -41,20 +51,26 @@ const EXIT_USAGE = 2;
 // ============================================================================
 
 /**
- * Everything the three subcommands need, resolved once.
- * Returns null (after printing) when the project has no compose file — that is
- * a usage error here, unlike in the verify node where it is a graded skip.
+ * Everything the three subcommands need, resolved once — against the tree
+ * that owns the feature (its live worktree when it has one, the root
+ * otherwise).
+ *
+ * Returns null (after printing) when that tree has no compose file — a usage
+ * error here, unlike in the verify node where it is a graded skip.
  */
 function resolveContext(featureName, { json = false } = {}) {
-  const cwd = process.cwd();
-  const config = readConfig(cwd);
+  const root = resolvePrimaryRoot(process.cwd());
+  const found = findWorktreeForFeature(featureName, root);
+  const cwd = found?.path ?? root;
+
+  const config = readConfig(cwd) ?? readConfig(root);
   const composeFile = resolveComposeFile(cwd, config);
 
   if (!composeFile) {
     const message =
-      'No compose file found (compose.yaml, docker-compose.yml, …). ' +
+      `No compose file found in ${cwd} (compose.yaml, docker-compose.yml, …). ` +
       'Set project.e2e.composeFile in .morph/config/config.json if it lives elsewhere.';
-    if (json) console.log(JSON.stringify({ error: message }, null, 2));
+    if (json) console.log(JSON.stringify({ error: message, tree: cwd }, null, 2));
     else console.error(chalk.red(`\n❌ ${message}\n`));
     return null;
   }
@@ -64,6 +80,9 @@ function resolveContext(featureName, { json = false } = {}) {
 
   return {
     cwd,
+    root,
+    tree: cwd,
+    insideWorktree: isSecondaryWorktree(cwd),
     config,
     composeFile,
     projectName,
@@ -79,39 +98,17 @@ function resolveContext(featureName, { json = false } = {}) {
  * The port block comes from `buildComposeEnv` rather than being assembled here
  * so this command and the `e2e` node inside `verify` agree by construction —
  * isolation that exists only in the command nobody runs is no isolation at all.
- * `COMPOSE_PROJECT_NAME` isolates container NAMES but not host ports; a compose
- * that hardcodes ports instead of reading `${PORT:-3000}` cannot be isolated at
- * all, which is surfaced as a warning rather than silently accepted.
  */
 function buildEnv({ cwd, config, featureName, projectName, gitCommonDir }) {
+  // COMPOSE_PROJECT_NAME is part of the port layout now; the explicit key stays
+  // as the fail-open floor for a repo with no git common dir (no block → no
+  // layout), where the project name is still what isolates the containers.
   return {
     COMPOSE_PROJECT_NAME: projectName,
     ...buildComposeEnv({ cwd, config, featureName, gitCommonDir }),
   };
 }
 
-/**
- * Warn once when the compose file publishes fixed host ports: with a hardcoded
- * `"3000:3000"` the fleet port block cannot take effect, so two features
- * running simultaneously will collide no matter what we inject.
- */
-function warnOnFixedPorts(cwd, composeFile) {
-  try {
-    const raw = readFileSync(join(cwd, composeFile), 'utf8');
-    const publishesFixed = /^\s*-\s*["']?\d+:\d+["']?\s*$/m.test(raw);
-    if (publishesFixed) {
-      console.log(
-        chalk.yellow(
-          '⚠️  Compose publishes fixed host ports. Parallel worktrees will collide — ' +
-            'use ${PORT:-3000}:3000 so the fleet port block applies.'
-        )
-      );
-    }
-  } catch {
-    // Unreadable compose is the caller's problem, not this warning's.
-  }
-}
-
 // ============================================================================
 // up
 // ============================================================================
@@ -119,20 +116,48 @@ function warnOnFixedPorts(cwd, composeFile) {
 /**
  * `morph-spec e2e up <feature> [--fresh]`
  *
- * Exit codes: 0 = stack healthy · 1 = failed to come up (or auth broke) ·
- * 2 = usage (no compose file / no docker).
+ * `--fresh` is destructive on purpose: it tears the previous stack down WITH
+ * its named volumes and forces the auth seed to run again. A rebuild that
+ * preserved the database would hand the next suite the previous run's rows,
+ * and a storageState captured against that database would keep authenticating
+ * a user that no longer exists.
+ *
+ * Exit codes: 0 = stack healthy · 1 = failed to come up (or auth broke, or the
+ * compose cannot be isolated inside a worktree) · 2 = usage (no compose file /
+ * no docker).
  */
 export async function e2eUpCommand(featureName, options = {}) {
   const ctx = resolveContext(featureName, options);
   if (!ctx) process.exit(EXIT_USAGE);
 
+  // Isolation BEFORE the docker check: `COMPOSE_PROJECT_NAME` isolates
+  // container names but not host ports, and a compose that hardcodes them (or
+  // names its containers) collides with the sibling worktree no matter what we
+  // inject. Same rule as the verify node — see decideIsolation().
+  const lint = lintComposeIsolation(readComposeText(ctx.cwd, ctx.composeFile));
+  const isolation = decideIsolation({ findings: lint.findings, insideWorktree: ctx.insideWorktree });
+  if (isolation.status === 'fail') {
+    if (options.json) {
+      console.log(JSON.stringify(
+        { error: 'compose-not-isolable', feature: featureName, tree: ctx.tree, composeFile: ctx.composeFile, reason: isolation.reason, findings: lint.findings },
+        null, 2,
+      ));
+    } else {
+      console.error(chalk.red(`\n❌ ${isolation.reason}`));
+      for (const f of lint.findings) console.error(chalk.gray(`   ${ctx.composeFile}:${f.line}: ${f.text}`));
+      console.error('');
+    }
+    process.exit(1);
+  }
+  if (isolation.status === 'warn' && !options.json) {
+    console.log(chalk.yellow(`⚠️  ${isolation.reason}`));
+  }
+
   if (!isDockerAvailable(ctx.cwd)) {
     console.error(chalk.red('\n❌ Docker is not available in this environment.\n'));
     process.exit(EXIT_USAGE);
   }
 
-  if (!options.json) warnOnFixedPorts(ctx.cwd, ctx.composeFile);
-
   const result = bringUpStack(ctx.cwd, {
     composeFile: ctx.composeFile,
     projectName: ctx.projectName,
@@ -143,18 +168,26 @@ export async function e2eUpCommand(featureName, options = {}) {
 
   const auth =
     result.status === 'pass'
-      ? prepareAuth(ctx.cwd, { config: ctx.config, env: ctx.env })
+      ? prepareAuth(ctx.cwd, { config: ctx.config, env: ctx.env, forceSeed: Boolean(options.fresh) })
       : { status: 'skip', reason: null };
 
+  // Same warnings[] contract as the verify e2e node: a seedCommand that never
+  // runs because `mode` switches it off is reported, never swallowed.
+  const warnings = [];
+  if (isolation.status === 'warn') warnings.push(isolation.reason);
+  if (auth.warning) warnings.push(auth.warning);
+
   const failed = result.status === 'fail' || auth.status === 'fail';
   const payload = {
     feature: featureName,
     project: ctx.projectName,
+    tree: ctx.tree,
     composeFile: ctx.composeFile,
     status: failed ? 'fail' : 'pass',
     reused: result.reused,
     reason: result.reason,
     auth: { status: auth.status, reason: auth.reason },
+    ...(warnings.length ? { warnings } : {}),
   };
 
   if (options.json) {
@@ -165,7 +198,9 @@ export async function e2eUpCommand(featureName, options = {}) {
   } else {
     const how = result.reused ? chalk.gray(`(${result.reason})`) : chalk.gray('(built)');
     console.log(chalk.green(`\n✓ Stack up — ${ctx.projectName} ${how}`));
+    console.log(chalk.gray(`  tree: ${ctx.tree}`));
     if (auth.reason) console.log(chalk.gray(`  auth: ${auth.reason}`));
+    if (auth.warning) console.log(chalk.yellow(`⚠️  ${auth.warning}`));
     console.log('');
   }
 
@@ -217,6 +252,7 @@ export async function e2eStatusCommand(featureName, options = {}) {
   const payload = {
     feature: featureName,
     project: ctx.projectName,
+    tree: ctx.tree,
     composeFile: ctx.composeFile,
     up: status.up,
     healthy: status.healthy,
@@ -236,6 +272,7 @@ export async function e2eStatusCommand(featureName, options = {}) {
   } else {
     console.log('');
     console.log(chalk.bold(`E2E stack — ${ctx.projectName}`));
+    console.log(chalk.gray(`tree:    ${ctx.tree}`));
     console.log(chalk.gray(`compose: ${ctx.composeFile}`));
     console.log(chalk.gray(`url:     ${payload.baseUrl}`));
     console.log('');
@@ -262,7 +299,8 @@ export async function e2eStatusCommand(featureName, options = {}) {
  * `morph-spec e2e down <feature> [--volumes]`
  *
  * Teardown is best-effort by design — a stack that will not come down must
- * never block `finish`.
+ * never block `finish`. The freshness stamp goes regardless: a stamp that
+ * outlives its containers would let the next `up` reuse a stack that is gone.
  */
 export async function e2eDownCommand(featureName, options = {}) {
   const ctx = resolveContext(featureName, options);
@@ -274,11 +312,16 @@ export async function e2eDownCommand(featureName, options = {}) {
     env: ctx.env,
     volumes: Boolean(options.volumes),
   });
+  const stampDeleted = deleteStamp(ctx.gitCommonDir, ctx.projectName);
 
   if (options.json) {
-    console.log(JSON.stringify({ feature: featureName, project: ctx.projectName, status: result.status }, null, 2));
+    console.log(JSON.stringify(
+      { feature: featureName, project: ctx.projectName, tree: ctx.tree, status: result.status, stampDeleted },
+      null, 2,
+    ));
   } else if (result.status === 'pass') {
-    console.log(chalk.green(`\n✓ Stack down — ${ctx.projectName}\n`));
+    console.log(chalk.green(`\n✓ Stack down — ${ctx.projectName}`));
+    console.log(chalk.gray(`  tree: ${ctx.tree}\n`));
   } else {
     console.log(chalk.yellow(`\n⚠️  Teardown reported a problem (not fatal):\n${result.output}\n`));
   }
@@ -300,6 +343,14 @@ function readConfig(cwd) {
   }
 }
 
+function readComposeText(cwd, composeFile) {
+  try {
+    return readFileSync(join(cwd, composeFile), 'utf8');
+  } catch {
+    return '';
+  }
+}
+
 /** Same resolution (and same fail-open) as verify-runner's. */
 function resolveGitCommonDir(cwd) {
   try {