ultra-builder-pro-cli 0.25.1 → 0.26.1

package/skills/ultra-tdd/references/templates/testcontainer-postgres.ts

@@ -0,0 +1,73 @@
+/**
+ * Testcontainer-Postgres starter (TypeScript / vitest or jest)
+ *
+ * Why this exists: Real DB in tests catches migration drift, schema bugs, and
+ * concurrency issues that mocked Repositories silently miss. Prefer this to
+ * `jest.fn()` / `vi.fn()` for any Repository or Service that touches data.
+ *
+ * Required deps:
+ *   pnpm add -D @testcontainers/postgresql pg
+ *
+ * Verify:
+ *   pnpm vitest run src/repo/__tests__/userRepo.testcontainer.test.ts
+ *
+ * PHILOSOPHY: enables C2 (Enabling > Defensive) — the cheaper path becomes the
+ * right path, so agents stop reaching for mocks under pressure.
+ */
+
+import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
+import { Pool } from 'pg';
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
+
+let container: StartedPostgreSqlContainer;
+let pool: Pool;
+
+beforeAll(async () => {
+  container = await new PostgreSqlContainer('postgres:16-alpine').start();
+  pool = new Pool({ connectionString: container.getConnectionUri() });
+  // Replace with your migration runner (drizzle/prisma/knex/raw SQL)
+  await pool.query(`
+    CREATE TABLE users (
+      id SERIAL PRIMARY KEY,
+      email TEXT UNIQUE NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    );
+  `);
+}, 60_000); // pulling postgres image can be slow on first run
+
+afterAll(async () => {
+  await pool.end();
+  await container.stop();
+});
+
+beforeEach(async () => {
+  // Reset between tests so each is independent
+  await pool.query('TRUNCATE users RESTART IDENTITY CASCADE');
+});
+
+describe('UserRepo (real Postgres)', () => {
+  test('insert and fetch round-trips', async () => {
+    // Replace with your actual Repository
+    const repo = makeUserRepo(pool);
+    const created = await repo.create({ email: 'a@example.com' });
+    const found = await repo.findById(created.id);
+    expect(found).toEqual(created);
+  });
+});
+
+// Drop your real Repository factory here
+function makeUserRepo(pool: Pool) {
+  return {
+    async create(input: { email: string }) {
+      const { rows } = await pool.query(
+        'INSERT INTO users (email) VALUES ($1) RETURNING *',
+        [input.email],
+      );
+      return rows[0];
+    },
+    async findById(id: number) {
+      const { rows } = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
+      return rows[0] ?? null;
+    },
+  };
+}

package/skills/ultra-tdd/references/templates/vertical-slice.ts

@@ -0,0 +1,66 @@
+/**
+ * Vertical-Slice integration test (TypeScript)
+ *
+ * Why this exists: proves HTTP entry → use case → domain → DB → response works
+ * end-to-end. ONE such test per feature is the difference between "single tasks
+ * pass / project doesn't run" (the failure mode v7 was built to fix) and
+ * actual deliverable software.
+ *
+ * Required deps:
+ *   pnpm add -D supertest @testcontainers/postgresql pg vitest
+ *
+ * Verify:
+ *   pnpm vitest run src/__tests__/auth.vertical-slice.test.ts
+ *
+ * PHILOSOPHY: enables C4 (Incremental Validation) — the `vertical_slice`
+ * dimension in progress.json is satisfied by tests like this.
+ */
+
+import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
+import { Pool } from 'pg';
+import request from 'supertest';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+
+// Replace with your real app/server factory
+import { buildApp } from '../app';
+
+let container: StartedPostgreSqlContainer;
+let pool: Pool;
+let app: ReturnType<typeof buildApp>;
+
+beforeAll(async () => {
+  container = await new PostgreSqlContainer('postgres:16-alpine').start();
+  pool = new Pool({ connectionString: container.getConnectionUri() });
+  // Run migrations
+  await pool.query(`CREATE TABLE users (id SERIAL PRIMARY KEY, email TEXT UNIQUE)`);
+  app = buildApp({ db: pool });
+}, 60_000);
+
+afterAll(async () => {
+  await pool.end();
+  await container.stop();
+});
+
+describe('vertical slice: POST /signup', () => {
+  test('inserts a row, returns 201, body matches input email', async () => {
+    const before = await pool.query('SELECT count(*) FROM users');
+    const beforeCount = parseInt(before.rows[0].count, 10);
+
+    const res = await request(app)
+      .post('/signup')
+      .send({ email: 'vertical@example.com' })
+      .expect(201);
+
+    // 1. response shape
+    expect(res.body.email).toBe('vertical@example.com');
+    expect(res.body.id).toBeGreaterThan(0);
+
+    // 2. real DB write occurred
+    const after = await pool.query('SELECT count(*) FROM users');
+    expect(parseInt(after.rows[0].count, 10)).toBe(beforeCount + 1);
+
+    // 3. data is persistable / queryable
+    const row = await pool.query('SELECT email FROM users WHERE id = $1', [res.body.id]);
+    expect(row.rows[0].email).toBe('vertical@example.com');
+  });
+});

package/skills/ultra-tdd/references/test-execution.md

@@ -0,0 +1,18 @@
+# Test execution evidence
+
+Resolve the canonical command from package scripts, CI configuration, repository
+guidance, or framework files. When two commands prove different contracts, keep the
+distinction visible instead of choosing the easier one.
+
+For every baseline, red, and green run record:
+
+- exact command and working directory;
+- start time, duration, and exit code;
+- runner-reported pass, fail, skip, and coverage counts when available;
+- first useful failure with tight source or test location;
+- whether it reproduces and whether it is product, test, environment, or flaky evidence;
+- raw output path under `.ultra/evidence/<task-id>/` when the output matters.
+
+Do not weaken flags, skip a relevant failure, edit test configuration to obtain green,
+or claim success when the command did not finish with exit zero. A concise evidence
+record may cite the raw log; it must not copy an entire transcript into task context.

package/skills/ultra-test/SKILL.md

@@ -1,42 +1,87 @@
 ---
 name: ultra-test
-description: Independently verify an Ultra task set or Change with an evidence-backed, risk-selected test profile. Use when implementation or current acceptance and recovery evidence needs independent verification.
+description: Audit whole-system integrity after the task ledger is complete by finding anti-patterns, coverage gaps, broken wiring, E2E failures, performance risk, and security risk. Use when preparing delivery or when locally green tasks may not form a working product.
 ---
 
-# Verify current behavior
+# NOT for running unit tests (that's `ultra-dev`). This audits whole-system integrity before delivery.
 
-Testing independently checks the current checkout. Implementation conclusions and
-generated projections are not evidence.
+This is the one end-of-change sensor allowed by PHILOSOPHY C4: an export cannot be
+called orphaned while a later task may still wire it. It is a terminal sensor, never a gate;
+the owner decides what to fix or accept.
 
-## Bind and execute
+## Before you start
 
-1. Call `ultra.context { stage: test, scope: { change_id, task_id? }, detail: full }`.
-2. Import a newer team checkpoint with `ultra.sync`; stop on a real conflict.
-3. Bind exact acceptance, task set, HEAD, worktree, decisions, dev evidence, and public
-   seams.
-4. Select a risk-based profile from acceptance, regression, integration, static
-   analysis, build, performance, security, and recovery. Acceptance is mandatory;
-   explain every material exclusion.
-5. Run repository-native commands and real boundaries. A bug or incident needs one
-   deterministic red-to-green regression signal.
+1. Read `.ultra/tasks.json` and every completed task's `context_file`, especially its
+   Acceptance, Completion and closing `## Resume Note`.
+2. Read `CONTEXT.md` for vocabulary and the relevant `.ultra/decisions/` entries.
+3. Read the active Change intent, the task evidence directories and the current Git
+   `HEAD`; old output is evidence only for the commit it names.
+4. Resolve this loaded Skill's directory and run
+   `node <ultra-test-skill-dir>/scripts/worktree_digest.cjs --project <repository-root>`
+   before and after the audit. Its digest excludes
+   only `.ultra/test-report.json`, avoiding a self-referential report.
 
-When delegated, use the immutable Worker Packet supplied by the parent and echo its
-`packet_digest` in the report. Write an `ultra-test-report-v1` report below the owning
-Change. Bind exact acceptance
-ids, task ids, HEAD, worktree/context digests, commands, seams, failures, recovery,
-profile, timestamp, blockers, and evidence-derived verdict. Register it with
-`ultra.record` using `artifact / bind`.
+## Definition of done
 
-## Checkpoint
+- All six audit areas have an evidence-backed result or an explicit material omission.
+- Wiring lists each changed export and its non-test consumers; zero matches are visible
+  as orphan findings.
+- `.ultra/test-report.json` records `git_commit`, commands, findings, omissions and the
+  owner's disposition without rewriting a finding into a pass.
 
-Call `ultra.checkpoint` once with `stage: test`, exact scope, evidence, and an output
-for the report (`kind: test-report`). The model owns the evidence-derived verdict and
-material exclusions. The checkpoint compiles or reuses checking context, verifies the
-declared report authority and digest, and records that verdict without re-judging it.
+## Audit six areas
 
-If rejected, keep the same draft and repair the structural, digest, path, or
-concurrency fault. Never weaken an assertion, hide a skip, or turn a warning into
-proof.
+1. **Anti-patterns**: find tautological or empty tests and internal collaborators mocked
+   instead of exercising a public seam.
+2. **Coverage gaps**: map changed public behavior to tests and list behavior with no
+   exercising test.
+3. **Wiring Verification**: list changed exported symbols, then search each name in
+   non-test source. `0 matches = orphan` until a framework registration or generated
+   consumer is evidenced. Also trace Component→API, API→DB, Form→Handler and
+   State→Render where those boundaries exist.
+4. **E2E**: run the smallest real primary flow through its deployed or local boundary.
+5. **Performance**: measure the paths whose acceptance or risk makes latency, resource
+   use or scale material; record why anything else was omitted.
+6. **Security**: run the repository's dependency and security checks, then inspect the
+   trust boundaries changed by this Change.
 
-Return the profile, exact results, verified seams, blockers, report digest, and the
-model's recommended next explicit capability. Do not invoke it automatically.
+The six are independent read-only audits and may run in parallel through the host's
+native bounded subagents. Each returns its findings; the parent writes the one report.
+A worker never writes `.ultra/test-report.json` itself — six writers on one canonical
+file is how a report loses findings.
+
+Read `references/export-syntax.md` before collecting exports. The table finds
+candidates; repository conventions and real consumers decide what is public.
+
+## Detect substantive stubs
+
+Report an empty return with no IO, a log-only function, a handler that only prevents
+default, or a component that only renders placeholder text. Pair every finding with
+the smallest real boundary or implementation that would make it observable.
+
+## Write the report
+
+Store the exact `git_commit`, timestamp, run count, commands and exit codes, the six
+area results, findings with paths, verified seams, material omissions, residual risk,
+and `passed` as the model's evidence-derived summary in the one canonical
+`.ultra/test-report.json`. Each command records `command`, `exit_code`, and an
+`evidence_ref`; each area records `status`, `evidence_refs`, and `omissions`. Copy the
+script's `head`, `dirty`, and `diff_digest` into `git_commit` and `worktree`. A stale commit or digest is labelled stale;
+it is never reused as current proof.
+
+Present the findings by consequence and recommend the highest-leverage response. The
+owner may fix all, fix selected findings, accept recorded risk, or reduce scope through
+the normal REDUCTION decision. Recommend the next capability; do not invoke it.
+
+## When the owner decides
+
+The owner decides disposition and risk acceptance. A failed command, orphan or stub is
+an observation, not permission to auto-fix, weaken a test or silently change scope.
+
+## References
+
+- `references/export-syntax.md` — read during Wiring Verification to find exported
+  symbol candidates in TypeScript/JavaScript, Python, Go, Rust and Java.
+- `scripts/worktree_digest.cjs` — deterministic HEAD plus worktree evidence identity.
+- `../ultra-think/references/autonomy-boundary.md` — read when a proposed response
+  would make an existing specification commitment stop holding.

package/skills/ultra-test/references/export-syntax.md

@@ -0,0 +1,18 @@
+# Export syntax lookup
+
+Use this table to collect candidates, then confirm public reachability through the
+repository's build system, framework registration and non-test consumers. Text matches
+are observations, not semantic proof.
+
+| Language | Candidate forms to search |
+|---|---|
+| TypeScript / JavaScript | `export function`, `export class`, `export const`, `export { name }`, `module.exports`, `exports.name` |
+| Python | top-level `def` and `class`, names in `__all__`, public package re-exports; exclude leading-underscore names unless explicitly exported |
+| Go | package-level identifiers beginning with an uppercase letter |
+| Rust | `pub fn`, `pub struct`, `pub enum`, `pub trait`, `pub use`; respect module visibility such as `pub(crate)` |
+| Java | `public` top-level types and public members reachable through the package's exposed API |
+
+For every candidate changed by the current Change, search the exact symbol in non-test
+source. Zero references is an orphan candidate. Before recording it, check declarative
+framework entry points, reflection, dependency injection, generated code and foreign-
+function bindings that may consume the symbol without a textual import.

package/skills/ultra-test/scripts/worktree_digest.cjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+function git(cwd, args, encoding = 'utf8') {
+  return execFileSync('git', args, {
+    cwd,
+    encoding,
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function projectFromArgs(argv) {
+  if (argv.length === 0) return process.cwd();
+  if (argv.length === 2 && argv[0] === '--project' && argv[1]) return path.resolve(argv[1]);
+  throw new Error('usage: worktree_digest.cjs [--project <repository-root>]');
+}
+
+function main(cwd) {
+  const root = fs.realpathSync(git(cwd, ['rev-parse', '--show-toplevel']).trim());
+  const head = git(root, ['rev-parse', 'HEAD']).trim();
+  const diff = git(root, [
+    'diff', '--binary', '--no-ext-diff', 'HEAD', '--', '.',
+    ':(exclude).ultra/test-report.json',
+  ], 'buffer');
+  const untracked = git(root, ['ls-files', '--others', '--exclude-standard', '-z'], 'buffer')
+    .toString('utf8').split('\0').filter(Boolean)
+    .filter((file) => file !== '.ultra/test-report.json')
+    .sort();
+  const hash = crypto.createHash('sha256');
+  hash.update('ultra-worktree-digest-v1\0').update(head).update('\0').update(diff);
+  for (const file of untracked) {
+    hash.update(file).update('\0').update(fs.readFileSync(path.join(root, file))).update('\0');
+  }
+  return {
+    $schema: 'ultra-worktree-digest-v1',
+    head,
+    dirty: diff.length > 0 || untracked.length > 0,
+    diff_digest: hash.digest('hex'),
+    untracked_files: untracked,
+  };
+}
+
+try {
+  process.stdout.write(`${JSON.stringify(main(projectFromArgs(process.argv.slice(2))), null, 2)}\n`);
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+}

package/skills/ultra-think/SKILL.md

@@ -1,39 +1,61 @@
 ---
 name: ultra-think
-description: Resolve a consequential product, architecture, or recovery question through evidence-first reasoning and adaptive user alignment. Use when a material decision cannot be derived safely from accepted intent and current evidence.
+description: Stress-test one consequential product, architecture, recovery, or scope decision and preserve the accepted result when it must outlive the session. Use when another skill needs adversarial reasoning, or when fog of war is too large and unclear to decompose safely.
 ---
 
-# Align without suppressing judgment
+# Turn one consequential uncertainty into an evidence-backed decision
 
-Thinking is optional. Answer self-contained questions directly. Persist only a
-project-bound decision that must survive interruption or control later work.
+Thinking sharpens a decision; it does not perform the implementation that follows.
+Persist only decisions that are hard to reverse, look surprising without context, and
+arose from a real trade-off. All three criteria must hold.
 
-## Reason and interact
+## Before you start
 
-1. Call `ultra.context` for the relevant project or Change scope.
-2. Define the real decision and the constraints that can change its answer.
-3. Inspect source, runtime, tests, accepted artifacts, and primary documentation
-   before asking the owner for facts.
-4. Separate verified fact, evidence-backed inference, accepted intent, delegated
-   implementation judgment, and unresolved owner choice.
-5. Stress-test the leading answer with its strongest failure path and recovery.
+1. Read `.ultra/tasks.json` and the current task's `context_file` and `## Resume Note`.
+2. Read `CONTEXT.md`, relevant `.ultra/decisions/`, the active Change and its evidence.
+3. State the one decision and the assumptions capable of changing its answer.
 
-Read `references/interaction-boundary.md`. Reuse a clear decision already present in the
-request. Decide reversible delegated implementation details yourself. When owner
-authority is necessary, ask one dependent decision through the host-native question
-surface with a recommendation, decisive evidence, and the effect of the answer.
+## Definition of done
 
-## Persist only the normalized result
+- Claims are labelled Fact, Inference or Speculation and cite their evidence.
+- The leading answer survived all four adversarial checks below.
+- The conclusion includes Confidence %, Key Assumptions and What would change my mind.
+- A qualifying durable decision is written once; a local reversible judgment is not.
 
-Use one `ultra.record` batch with `decision / accept` and, when required,
-`artifact / bind` for the owning semantic document. A revised answer carries
-`supersedes_id`; accepted records remain immutable history. Store normalized decisions
-and artifact references, never transcripts or internal reasoning.
+## Run the adversarial protocol
 
-A structural or authority rejection remains a mutable diagnostic. Correct the record;
-do not invent a new decision merely to satisfy a state machine. Semantic disagreement
-belongs in the recommendation and visible decision record, not a kernel error.
+1. **Steel Man**: build the strongest case for the option you expect to reject.
+2. **Pre-Mortem**: assume the choice failed six months later and name the three most
+   plausible causes.
+3. **Sensitivity**: identify the assumption whose failure would reverse the answer.
+4. **Second-Order**: describe the new constraints or failure modes created six to
+   twelve months later.
 
-Return the conclusion, decisive evidence, uncertainty, affected authority, and the
-model's recommended next explicit capability. Thinking never performs unrelated
-implementation or an external effect. Do not invoke the next capability automatically.
+Give the owner one recommendation with the decisive evidence and what changes under
+each viable answer. Reuse an answer already explicit in the request.
+
+## Use decision tickets for fog of war
+
+When the work does not fit one session *and* the path itself remains unclear, map one
+question instead of manufacturing implementation tasks. Write a decision ticket with
+`status: open`; resolve one at a time until no unresolved ticket prevents planning.
+Each answer should make the remaining fog of war smaller.
+
+## Write durable decisions
+
+Use `.ultra/decisions/<id>.md`: question, status, options and real trade-offs, accepted
+decision, owner, date, evidence, consequences, What would change my mind, and
+`supersedes` when applicable. An accepted file is append-only history: overturn it by
+writing a new decision that supersedes it.
+
+## When the owner decides
+
+Only the owner accepts a durable decision or a REDUCTION. Reversible implementation
+details stay with the model. If the host cannot ask, keep `status: open`, record the
+missing answer and stop at that safe point.
+
+## References
+
+- `references/autonomy-boundary.md` — read before changing accepted authority.
+- `references/interaction-boundary.md` — read when the host-facing decision needs one
+  carefully framed question.

package/skills/ultra-think/references/autonomy-boundary.md

@@ -0,0 +1,48 @@
+# The autonomy boundary and the specification-change verdict
+
+Read this when an action is about to cross from "decide freely" into "surface to
+the owner". It is the operational form of PHILOSOPHY C5, Bounded Autonomy; the
+full constitution lives in the package's `docs/PHILOSOPHY.md`.
+
+## Inside the boundary — decide and proceed
+
+Libraries, naming, file layout, internal abstractions, decomposition strategy,
+evidence interpretation, prioritization, final expression.
+
+## Crossing the boundary — surface it
+
+Weakening a test assertion, editing the specification to match the
+implementation, shipping a feature flag that defaults off, replacing real
+persistence with an in-memory stand-in, reducing scope, and any external or
+irreversible effect.
+
+## Classifying a specification change
+
+When the implementation and the specification disagree, classify before touching
+the specification — and classify by one question that can be checked against the
+file, never by intent:
+
+> **Does every commitment the specification already made still hold after this
+> change?**
+
+| Answer | Classification | Action |
+|---|---|---|
+| Yes, and it now commits to more | EXPANSION | write it, log it |
+| Yes, the commitment is unchanged but stated correctly | CORRECTION | write it, log it |
+| **No — at least one prior commitment no longer holds** | **REDUCTION** | **stop and ask the owner** |
+
+The classification follows from the outcome, never from the reason. A
+well-argued rationale does not convert a REDUCTION into a CORRECTION; the
+rationale goes into the question put to the owner.
+
+This matters because it is the exact mechanism by which specifications shrink
+silently. "The specification asked for offline mode, but the architecture makes
+it unreasonable, so the specification was wrong" reads as a CORRECTION and
+removes offline mode without anyone deciding to. Under the question above it is
+a REDUCTION, because a commitment stopped holding.
+
+## Recording it
+
+A boundary crossing produces either an owner question, an entry in the active task
+context's `## Change Log`, or an accepted `.ultra/decisions/<id>.md` when the decision
+outlives that task. Silence and a second drift ledger are not outcomes.

package/skills/ultra-think/references/interaction-boundary.md

@@ -10,47 +10,32 @@ every write.
   acceptance, irreversible actions, external effects, and real-money commitments.
 - The host model investigates facts, recommends a direction, makes reversible
   implementation judgments, and explains uncertainty.
-- Use the host-native question surface declared by the installed interaction contract;
-  prefer its structured form when the host exposes one.
-- `ultra.record` persists only the normalized result and its provenance.
-- MCP validates structure, identity, digests, CAS, leases, paths, and recovery. It does
-  not decide whether a product answer is good.
+- Use the host-native question surface when one exists; prefer its structured form.
+- `.ultra/decisions/*.md` stores only a normalized durable result and bounded
+  provenance. Git supplies history and recovery.
 
 ## Interaction sequence
 
-1. Read `ultra.context` for the relevant scope.
-2. Inspect source, runtime, tests, accepted artifacts, and primary documentation.
+1. Read `.ultra/north-star.md`, `.ultra/tasks.json`, the active task context, relevant
+   specifications, Changes, decisions, and evidence.
+2. Inspect source, runtime, tests, and primary documentation for observable facts.
 3. Reuse an explicit choice already present in the current request or an accepted
-   Decision Record.
+   decision file.
 4. Decide a reversible delegated detail without asking.
 5. When owner authority is still required, ask one unresolved owner choice at a time
-   with:
-   - the recommendation;
-   - the discriminating evidence;
-   - the meaningful cost or failure mode;
-   - what changes when the answer changes.
-6. Normalize the answer into a deterministic Decision Record and persist it with
-   `ultra.record` using `kind: decision`, `action: accept`.
-7. Read `ultra.context` back and verify that the accepted decision is visible before
-   relying on it.
-
-## Decision Record
-
-Persist only:
-
-- normalized question;
-- recommendation and selected answer;
-- effects and non-goals;
-- owner, source, and bounded provenance;
-- applied artifact references;
-- supersession link when revising an earlier answer.
+   with the recommendation, discriminating evidence, meaningful failure mode, and what
+   changes under each viable answer.
+6. Write a qualifying durable result to `.ultra/decisions/<id>.md` with question,
+   status, selected answer, effects, non-goals, owner, date, evidence, consequences,
+   and a supersession link when applicable.
+7. Read that file back before relying on it.
 
 Never persist raw transcripts, hidden reasoning, full prompts, UI receipts, or copied
-memory-provider payloads.
+provider payloads.
 
 ## Revisions and interruptions
 
-Accepted decisions are immutable history. A changed answer creates a new Decision
-Record that supersedes the prior record. A cancelled question writes nothing. If a
-decision cannot be obtained, preserve the unresolved issue as a diagnostic or bounded
-event; do not invent an answer or block unrelated work.
+Accepted decisions are append-only history. A changed answer creates a new file that
+supersedes the prior decision. A cancelled question writes nothing. If the answer
+cannot be obtained, keep the issue open in the active task context and stop only the
+effect that requires that authority; unrelated work remains available.

package/.ultra-template/docs/research/README.md

@@ -1,55 +0,0 @@
-# Research Evidence
-
-Store durable research evidence here only when it is too detailed for the baseline
-specification. Baseline decisions and accepted behavior remain in `.ultra/specs/`.
-
-## Initialization modes
-
-`ultra-init` creates the scaffold and records classification; it never runs research
-or approves a baseline. A later explicit `ultra-research` invocation handles:
-
-- greenfield baseline evidence with adaptive product and architecture coverage;
-- brownfield adoption of observed product, runtime, quality, operations, known
-  failures, and documentation drift;
-- migrated or damaged authority only after backup-first `ultra-doctor` recovery,
-  followed by evidence-backed brownfield adoption.
-
-Blank templates are never baseline evidence. Existing authority is preserved rather
-than replaced by this scaffold.
-
-## Included-area reports
-
-Every included research area that executes, verifies, or reuses evidence writes one
-immutable report at `.ultra/docs/research/<workflow-id>/<step-id>.md`. The accepted
-coverage determines the report set; `full` and `adoption` describe baseline purpose,
-not a requirement to execute all seventeen catalog areas. Omitted areas create no
-report. The shared specifications are updated during research but do not replace these
-per-area evidence records.
-
-This directory is only for baseline establishment and adoption. Active Change research
-writes below
-`.ultra/changes/active/<change-id>/research/<workflow-id>/<step-id>.md`; it updates the
-Change overlay and never edits accepted baseline specifications.
-
-## Report contract
-
-Record:
-
-- a Markdown title and the exact sections `Evidence`, `Specification updates`, and
-  `Decisions and unknowns`;
-- scope and the decision the evidence informs;
-- observed facts with source references and dates;
-- verification commands or runtime evidence;
-- accepted decisions and their owner;
-- unresolved unknowns and whether they block the baseline;
-- links to the product or architecture sections updated from the evidence.
-
-Keep inference distinct from observation. Link to external provider content instead of
-copying memory, code-graph payloads, or large source material into Ultra.
-
-## Completion
-
-Update the affected baseline specification, register the report through typed
-`ultra.record`, reference it from the Research Stage Checkpoint, and record unresolved
-work in the authoritative gap ledger. The final synthesis also binds the baseline
-specifications and research distillate. Do not create a condensed duplicate.

package/.ultra-template/reports/templates/delivery-report.json

@@ -1,17 +0,0 @@
-{
-  "$schema": "ultra-delivery-report-v1",
-  "change_id": null,
-  "archive_status": null,
-  "baseline_id": null,
-  "baseline_status": null,
-  "git_commit": null,
-  "worktree_digest": null,
-  "context_digest": null,
-  "checks": [],
-  "release": {
-    "authorized": false,
-    "performed": false
-  },
-  "rollback": null,
-  "timestamp": null
-}