@fission-ai/openspec 1.14.1 → 1.14.3

package/README.md

@@ -33,11 +33,6 @@ Our philosophy:
 → scalable from personal projects to enterprises
 ```
 
-> [!TIP]
-> **New workflow now available!** We've rebuilt OpenSpec with a new artifact-guided workflow.
->
-> Run `/opsx:propose "your idea"` to get started. → [Learn more here](docs/opsx.md)
-
 <p align="center">
   Follow <a href="https://x.com/0xTab">@0xTab on X</a> for updates · Join the <a href="https://discord.gg/YctCnvvshC">OpenSpec Discord</a> for help and questions.
 </p>
@@ -112,13 +107,13 @@ OpenSpec is built with OpenSpec — browse this repo's live [specs](openspec/spe
 
 Solo, OpenSpec keeps you and your AI honest on a single repo. On a team, the hard part moves: a feature spans the API server, the web app, and a shared library; requirements are owned by one team and consumed by others; planning starts before any code exists.
 
-**[Stores](docs/stores-beta/user-guide.md)** are the answer — planning in a repo of its own. The same `openspec/` shape you already know (specs and changes), shared by `git push` like anything else. One source of truth your whole team and every coding agent can read, across every repo.
+**[Stores](https://openspec.dev/docs/stores)** are the answer — planning in a repo of its own. The same `openspec/` shape you already know (specs and changes), shared by `git push` like anything else. One source of truth your whole team and every coding agent can read, across every repo.
 
 - **Cross-repo features** — one change, one plan, even when the code lands in three repos.
 - **Shared requirements** — a platform team owns the specs; product teams reference them read-only, right where their coding agent can read them. No drifting wiki.
 - **Plan before code** — capture the plan in the store now; the code repos catch up later.
 
-> Stores are in **beta**. Start with the [Stores User Guide](docs/stores-beta/user-guide.md).
+> Stores are in **beta**. Start with the [Stores guide](https://openspec.dev/docs/stores).
 
 ## Quick Start
 
@@ -143,44 +138,33 @@ cd your-project
 openspec init
 ```
 
-> **Want your AI to do it?** Paste the [setup prompt](docs-lab/start/installation.md#install-with-your-ai-assistant) into your coding assistant — it installs the CLI, runs `openspec init`, and verifies the result.
+> **Want your AI to do it?** Paste the [setup prompt](https://openspec.dev/docs/installation#install-with-your-ai-assistant) into your coding assistant — it installs the CLI, runs `openspec init`, and verifies the result.
 
 Now talk to your AI:
 
-- **Not sure what to build yet?** Start with `/opsx:explore`, a no-stakes thinking partner that reads your code, weighs options, and shapes a plan before any code gets written. ([Explore guide](docs/explore.md))
+- **Not sure what to build yet?** Start with `/opsx:explore`, a no-stakes thinking partner that reads your code, weighs options, and shapes a plan before any code gets written. ([Quickstart](https://openspec.dev/docs/quickstart))
 - **Already know what you want?** Go straight to `/opsx:propose <what-you-want-to-build>`.
 
 Both are in the default profile. If you want the expanded workflow (`/opsx:new`, `/opsx:continue`, `/opsx:ff`, `/opsx:verify`, `/opsx:bulk-archive`, `/opsx:onboard`), select it with `openspec config profile` and apply with `openspec update`.
 
-`/opsx:propose` is the canonical name; your tool may spell it `/opsx-propose` (Cursor, GitHub Copilot), `@opsx-propose` (Amazon Q) or `$openspec-propose` (Codex). `openspec init` prints the right form for the tools you picked — see [How To Invoke](docs/supported-tools.md#how-to-invoke).
+`/opsx:propose` is the canonical name; your tool may spell it `/opsx-propose` (Cursor, GitHub Copilot), `@opsx-propose` (Amazon Q) or `$openspec-propose` (Codex). `openspec init` prints the right form for the tools you picked — see [Supported Tools](https://openspec.dev/docs/supported-tools).
 
 > [!NOTE]
-> Not sure if your tool is supported? [View the full list](docs/supported-tools.md) – we support 30+ tools and growing.
+> Not sure if your tool is supported? [View the full list](https://openspec.dev/docs/supported-tools) – we support 30+ tools and growing.
 >
-> Also works with Homebrew, pnpm, yarn, bun, and Nix. [See installation options](docs-lab/start/installation.md).
+> Also works with Homebrew, pnpm, yarn, bun, and Nix. [See installation options](https://openspec.dev/docs/installation).
 
 ## Docs
 
-**Start here:** the **[Documentation Home](docs/README.md)** maps everything. New to OpenSpec? Read [Getting Started](docs/getting-started.md), then [How Commands Work](docs/how-commands-work.md) (where you actually type `/opsx:propose`).
-
-→ **[Getting Started](docs/getting-started.md)**: first steps<br>
-→ **[Explore First](docs/explore.md)**: think it through with `/opsx:explore` before you commit<br>
-→ **[How Commands Work](docs/how-commands-work.md)**: where slash commands run vs the CLI<br>
-→ **[Core Concepts at a Glance](docs/overview.md)**: the whole mental model, one page<br>
-→ **[Examples & Recipes](docs/examples.md)**: real changes, start to finish<br>
-→ **[Workflows](docs/workflows.md)**: combos and patterns<br>
-→ **[Existing Projects](docs/existing-projects.md)**: adopt OpenSpec on a brownfield codebase<br>
-→ **[Editing a Change](docs/editing-changes.md)**: update artifacts, go back, reconcile manual edits<br>
-→ **[Commands](docs/commands.md)**: slash commands & skills<br>
-→ **[CLI](docs/cli.md)**: terminal reference<br>
-→ **[Stores](docs/stores-beta/user-guide.md)**: plan in a separate repo, shared across your team (beta)<br>
-→ **[Supported Tools](docs/supported-tools.md)**: tool integrations & install paths<br>
-→ **[Concepts](docs/concepts.md)**: how it all fits<br>
-→ **[Multi-Language](docs/multi-language.md)**: multi-language support<br>
-→ **[Customization](docs/customization.md)**: make it yours<br>
-→ **[Community Showcase](docs/community.md)**: projects and resources built with and for OpenSpec<br>
-→ **[FAQ](docs/faq.md)** · **[Troubleshooting](docs/troubleshooting.md)** · **[Glossary](docs/glossary.md)**: quick help
+Full documentation lives at **[openspec.dev/docs](https://openspec.dev/docs)**.
 
+→ **[Quickstart](https://openspec.dev/docs/quickstart)**: your first change, start to finish<br>
+→ **[Set up your project](https://openspec.dev/docs/setup)**: what `openspec init` installs<br>
+→ **[CLI](https://openspec.dev/docs/cli)**: terminal reference<br>
+→ **[Supported Tools](https://openspec.dev/docs/supported-tools)**: tool integrations & install paths<br>
+→ **[Customize](https://openspec.dev/docs/customize)**: profiles, project config, and schemas<br>
+→ **[Stores](https://openspec.dev/docs/stores)**: plan in a separate repo, shared across your team (beta)<br>
+→ **[Community Showcase](docs/community.md)**: projects and resources built with and for OpenSpec
 
 ## Community schemas
 

package/dist/cli/index.d.ts

@@ -27,6 +27,11 @@ export declare function isJsonRun(command: Command): boolean;
  * completions is noise, and `__complete` would burn the one-shot tip invisibly.
  */
 export declare function isCompletionRun(commandPath: string): boolean;
+/**
+ * True for the hidden `__complete` resolver alone. It runs on every Tab press,
+ * so the hooks skip telemetry and the completion tip for it entirely.
+ */
+export declare function isTabCompletionRun(commandPath: string): boolean;
 /**
  * True when the first-run completions tip must be deferred rather than shown.
  *

package/dist/cli/index.js

@@ -90,6 +90,13 @@ export function isJsonRun(command) {
 export function isCompletionRun(commandPath) {
     return commandPath.split(':')[0] === 'completion' || commandPath === '__complete';
 }
+/**
+ * True for the hidden `__complete` resolver alone. It runs on every Tab press,
+ * so the hooks skip telemetry and the completion tip for it entirely.
+ */
+export function isTabCompletionRun(commandPath) {
+    return commandPath === '__complete';
+}
 /**
  * True when the first-run completions tip must be deferred rather than shown.
  *
@@ -149,6 +156,12 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
     if (opts.color === false) {
         process.env.NO_COLOR = '1';
     }
+    // `__complete` runs on every Tab press, with stderr sent to /dev/null by the
+    // generated scripts. Tracking it would hold each press open for the request,
+    // and the first-run notice would be marked seen without anyone reading it.
+    if (isTabCompletionRun(getCommandPath(actionCommand))) {
+        return;
+    }
     // Show first-run telemetry notice (if not seen). It's written to stderr, so it
     // never pollutes stdout — but --json runs still defer it (see isJsonRun) so the
     // very first invocation stays free of any incidental output on either stream.
@@ -160,6 +173,11 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
 });
 // Shutdown telemetry after command completes
 program.hook('postAction', async (_thisCommand, actionCommand) => {
+    // Nothing to flush (preAction tracked nothing), and the tip is always
+    // deferred for completion runs, so skip loading either module.
+    if (isTabCompletionRun(getCommandPath(actionCommand))) {
+        return;
+    }
     // Show the first-run shell-completions tip (on stderr, so piped stdout stays
     // clean). postAction, not preAction: the tip trails the command's own output
     // instead of pushing an error message or `init`'s setup summary down the

package/dist/commands/change.js

@@ -10,6 +10,7 @@ import { getActiveChangeIds } from '../utils/item-discovery.js';
 import { describeNestedChange, findNestedChangesIn, } from '../utils/nested-change.js';
 import { getTaskProgressForChange } from '../utils/task-progress.js';
 import { FileSystemUtils } from '../utils/file-system.js';
+import { assertDiscoveredSpecFile } from '../utils/spec-path-containment.js';
 import { discoverSpecFiles } from '../utils/spec-discovery.js';
 import { foldRequirementName, parseDeltaSpec, } from '../core/parsers/requirement-blocks.js';
 import { extractRequirementBlock, diffRequirementBlock, buildRenameMap, } from '../utils/requirement-diff.js';
@@ -168,7 +169,7 @@ export class ChangeCommand {
             const mainSpecPath = path.join(mainSpecsDir, ...capability.split('/'), 'spec.md');
             let mainContent = null;
             try {
-                FileSystemUtils.assertPathWithin(mainSpecsDir, mainSpecPath);
+                assertDiscoveredSpecFile(mainSpecsDir, mainSpecPath);
                 mainContent = await fs.readFile(mainSpecPath, 'utf-8');
             }
             catch (error) {

package/dist/commands/completion.js

@@ -1,4 +1,3 @@
-import ora from 'ora';
 import { CompletionFactory } from '../core/completions/factory.js';
 import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
 import { detectShell } from '../utils/shell-detection.js';
@@ -93,6 +92,9 @@ export class CompletionCommand {
     async installForShell(shell, verbose) {
         const generator = CompletionFactory.createGenerator(shell);
         const installer = CompletionFactory.createInstaller(shell);
+        // Loaded here, not at the top: `__complete` shares this module and runs on
+        // every Tab press, so it must not pay for the spinner.
+        const { default: ora } = await import('ora');
         const spinner = ora(`Installing ${shell} completion script...`).start();
         try {
             // Generate the completion script
@@ -187,6 +189,7 @@ export class CompletionCommand {
                 return;
             }
         }
+        const { default: ora } = await import('ora');
         const spinner = ora(`Uninstalling ${shell} completion script...`).start();
         try {
             const result = await installer.uninstall();

package/dist/commands/spec.js

@@ -5,7 +5,7 @@ import { Validator } from '../core/validation/validator.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
 import { discoverSpecFiles } from '../utils/spec-discovery.js';
-import { FileSystemUtils } from '../utils/file-system.js';
+import { assertDiscoveredSpecFile } from '../utils/spec-path-containment.js';
 const SPECS_DIR = 'openspec/specs';
 function assertSpecPath(specsDir, specPath) {
     const relativePath = path.relative(path.resolve(specsDir), path.resolve(specPath));
@@ -14,15 +14,7 @@ function assertSpecPath(specsDir, specPath) {
         path.isAbsolute(relativePath)) {
         throw new Error(`Path is outside the allowed directory: ${specPath}`);
     }
-    try {
-        // Preserve confined spec.md links, including links to a sibling capability.
-        FileSystemUtils.assertPathWithin(specsDir, specPath);
-    }
-    catch {
-        // A capability directory may intentionally be a monorepo symlink. Treat it
-        // as the trust root while still rejecting a link outside that capability.
-        FileSystemUtils.assertPathWithin(path.dirname(specPath), specPath);
-    }
+    assertDiscoveredSpecFile(specsDir, specPath);
 }
 function parseSpecFromFile(specsDir, specPath, specId) {
     assertSpecPath(specsDir, specPath);

package/dist/commands/validate.js

@@ -4,7 +4,7 @@ import { describeNestedChange, findNestedChangesIn, NESTED_CHANGE_ISSUE_MARKER,
 import { Validator } from '../core/validation/validator.js';
 import { VALIDATION_MESSAGES } from '../core/validation/constants.js';
 import { resolveRootForCommand, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../core/root-selection.js';
-import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
+import { canRenderSpinner, isInteractive, resolveNoInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
 import { getAvailableChanges } from './workflow/shared.js';
 import { nearestMatches } from '../utils/match.js';
@@ -356,7 +356,7 @@ export class ValidateCommand {
         }
     }
     async runBulkValidation(root, scope, opts) {
-        const spinner = !opts.json && !opts.noInteractive ? ora('Validating...').start() : undefined;
+        const spinner = !opts.json && isInteractive(opts) && canRenderSpinner() ? ora('Validating...').start() : undefined;
         const [changeIds, specIds] = await Promise.all([
             scope.changes ? this.listChangeIds(root) : Promise.resolve([]),
             scope.specs ? getSpecIds(root.path) : Promise.resolve([]),
@@ -527,7 +527,7 @@ export class ValidateCommand {
         // List first (may throw on a real archive-read failure), then start the
         // spinner so a thrown error never leaves a spinner spinning.
         const ids = await this.listArchivedChangeIds(root);
-        const spinner = !opts.json && !opts.noInteractive ? ora('Validating archived changes...').start() : undefined;
+        const spinner = !opts.json && isInteractive(opts) && canRenderSpinner() ? ora('Validating archived changes...').start() : undefined;
         // The archive is append-only and can hold thousands of changes; a single
         // run resolves them all under one constant projectRoot (root.path), so
         // memoize the schema→glob lookup to avoid re-parsing the same schema.yaml

package/dist/core/archive.js

@@ -1078,13 +1078,22 @@ export class ArchiveCommand {
         const changesDir = root.changesDir;
         const archiveDir = root.archiveDir;
         const mainSpecsDir = root.specsDir;
-        for (const [allowedDirectory, managedDir] of [
-            [root.path, changesDir],
-            [changesDir, archiveDir],
-            [root.path, mainSpecsDir],
+        const openspecDir = path.dirname(changesDir);
+        // openspec/, changes/ and specs/ may be project-owned symlinks to another
+        // directory; archive/ may not leave the changes directory it lives in.
+        for (const [allowedDirectory, managedDir, allowLinkedLeaf] of [
+            [root.path, openspecDir, true],
+            [openspecDir, changesDir, true],
+            [changesDir, archiveDir, false],
+            [openspecDir, mainSpecsDir, true],
         ]) {
             try {
-                FileSystemUtils.assertPathWithin(allowedDirectory, managedDir);
+                if (allowLinkedLeaf) {
+                    FileSystemUtils.assertPathWithinAllowingLinkedLeaf(allowedDirectory, managedDir);
+                }
+                else {
+                    FileSystemUtils.assertPathWithin(allowedDirectory, managedDir);
+                }
             }
             catch {
                 throw new ArchiveBlockedError('archive_path_outside_root', `Refusing to archive through a path outside the OpenSpec root: ${managedDir}`);
@@ -1744,6 +1753,9 @@ export class ArchiveCommand {
                             if (hasRetirements) {
                                 await assertRetirementAuthorization(changeDir, retirementAuthorizationFingerprint);
                             }
+                            // update.source is canonical (symlinks resolved), so measure it from
+                            // the canonical change directory; changes/ may itself be a symlink.
+                            const canonicalChangeDir = FileSystemUtils.canonicalizeExistingPath(changeDir);
                             const verifyArchivedDeltas = async (stagedSource) => {
                                 if (hasRetirements) {
                                     await assertRetirementAuthorization(archivePath, retirementAuthorizationFingerprint, 
@@ -1757,13 +1769,13 @@ export class ArchiveCommand {
                                     }
                                 }
                                 for (const proposed of prepared) {
-                                    const archivedSource = path.join(archivePath, path.relative(changeDir, proposed.update.source));
+                                    const archivedSource = path.join(archivePath, path.relative(canonicalChangeDir, proposed.update.source));
                                     if ((await fingerprintPortableContent(archivedSource)) !==
                                         proposed.sourceContentFingerprint) {
                                         throw new Error(`The archived delta for '${proposed.update.id}' changed during the final move.`);
                                     }
                                     if (stagedSource) {
-                                        const stagedDelta = path.join(stagedSource, path.relative(changeDir, proposed.update.source));
+                                        const stagedDelta = path.join(stagedSource, path.relative(canonicalChangeDir, proposed.update.source));
                                         if ((await fingerprintPortableContent(stagedDelta)) !==
                                             proposed.sourceContentFingerprint) {
                                             throw new Error(`The active delta for '${proposed.update.id}' changed during the fallback copy.`);

package/dist/core/artifact-graph/outputs.js

@@ -1,9 +1,221 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import fg from 'fast-glob';
+import { expand } from 'brace-expansion';
+import picomatch from 'picomatch';
+import * as globby from 'tinyglobby';
 import { FileSystemUtils } from '../../utils/file-system.js';
 const EXTGLOB_RE = /[!*+?@]\([^(]*\)/u;
 const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./u;
+const DUPLICATE_SLASH_RE = /(?!^)\/{2,}/gu;
+// Deeply nested braces can overflow a recursive expander. Reject nesting no real
+// artifact pattern needs before brace-expansion or tinyglobby see the pattern.
+const MAX_BRACE_NESTING = 16;
+// Nesting depth alone does not bound the work: `{a,b}` repeated 20 times is
+// only one level deep and expands to 1,048,576 patterns, which exhausts the
+// heap. fast-glob never expanded that far because micromatch compiled the
+// braces to a regex. No real artifact pattern needs more than a few hundred.
+const MAX_BRACE_EXPANSIONS = 1024;
+const ARTIFACT_GLOB_OPTIONS = {
+    absolute: true,
+    // Braces are expanded first so `{draft}` left behind stays a literal name.
+    braceExpansion: false,
+    // fast-glob migration: directory patterns must not grow a trailing `/**`.
+    expandDirectories: false,
+    followSymbolicLinks: true,
+    onlyFiles: true,
+};
+function assertBraceNesting(pattern) {
+    // Mirror the braces parser: `[...]` and quoted runs are literal, `(` nests like
+    // `{`, and a closer only closes the innermost group of its own kind.
+    const open = [];
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === '[') {
+            for (let brackets = 1; brackets > 0 && index + 1 < pattern.length;) {
+                index += 1;
+                if (pattern[index] === '[')
+                    brackets += 1;
+                else if (pattern[index] === ']')
+                    brackets -= 1;
+            }
+        }
+        else if (char === '"' || char === "'" || char === '`') {
+            const end = pattern.indexOf(char, index + 1);
+            index = end === -1 ? pattern.length : end;
+        }
+        else if (char === '{' || char === '(') {
+            open.push(char);
+            if (open.length > MAX_BRACE_NESTING) {
+                // A pattern this deep can run to thousands of characters; quote only its start.
+                const shown = pattern.length > 80 ? `${pattern.slice(0, 80)}...` : pattern;
+                throw new Error(`Artifact output pattern nests braces more than ${MAX_BRACE_NESTING} levels deep: ${shown}`);
+            }
+        }
+        else if ((char === '}' && open.at(-1) === '{') || (char === ')' && open.at(-1) === '(')) {
+            open.pop();
+        }
+    }
+}
+function isDynamicSegment(segment) {
+    return segment.includes('*') || segment.includes('?') || segment.includes('[')
+        || EXTGLOB_RE.test(segment);
+}
+/**
+ * Static directory prefix of an expanded pattern, equivalent to the `base`
+ * fast-glob's generateTasks used to reject `../` before walking.
+ */
+function globBase(pattern) {
+    const segments = pattern.split('/');
+    if (segments.length <= 1)
+        return '.';
+    const base = [];
+    for (const segment of segments.slice(0, -1)) {
+        if (segment === '')
+            continue;
+        if (isDynamicSegment(segment))
+            break;
+        base.push(segment);
+    }
+    // An absolute pattern must stay absolute, or `path.resolve(changeDir, base)`
+    // rebases `/etc/*` inside the change directory and the containment check
+    // passes for a pattern that globs the filesystem root.
+    if (pattern.startsWith('/'))
+        return `/${base.join('/')}`;
+    return base.length > 0 ? base.join('/') : '.';
+}
+// brace-expansion 5 leaves the rest of a pattern literal when a non-expanding
+// group such as `{draft}` comes before a range. Expand one real group at a time.
+// NUL-prefixed so no `generates` value can forge them: `resolveArtifactOutputPath`
+// runs `path.join` first, which rejects a NUL byte. A single-character sentinel
+// such as U+0001 is a legal filename character, and a pattern containing one
+// would come back out of the expander as a brace.
+const LITERAL_BRACE_OPEN = '\u0000<';
+const LITERAL_BRACE_CLOSE = '\u0000>';
+function hasTopLevelExpansion(body) {
+    let depth = 0;
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (char === '{')
+            depth += 1;
+        else if (char === '}')
+            depth = Math.max(0, depth - 1);
+        else if (depth === 0) {
+            if (char === ',')
+                return true;
+            if (char === '.' && body[index + 1] === '.')
+                return true;
+        }
+    }
+    return false;
+}
+function findTopLevelExpansion(pattern) {
+    const stack = [];
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === '{') {
+            stack.push(index);
+        }
+        else if (char === '}' && stack.length > 0) {
+            const open = stack.pop();
+            if (open === undefined)
+                continue;
+            // Only the outermost group that actually expands. brace-expansion expands
+            // its nested groups in one linear pass. Peeling the innermost `{a,b}` first
+            // turns `{a,{a,{a,b}}}` into a binary tree, so a 16-deep pattern does not
+            // finish before the test timeout.
+            if (stack.length > 0)
+                continue;
+            const body = pattern.slice(open + 1, index);
+            if (!hasTopLevelExpansion(body)) {
+                // `{prefix{a,b}}` has no separator of its own, so the outer braces stay
+                // literal. Keep scanning inside them; a nested group may still expand.
+                const nested = findTopLevelExpansion(body);
+                if (!nested)
+                    continue;
+                return {
+                    pre: `${pattern.slice(0, open + 1)}${nested.pre}`,
+                    body: nested.body,
+                    post: `${nested.post}${pattern.slice(index)}`,
+                };
+            }
+            return { pre: pattern.slice(0, open), body, post: pattern.slice(index + 1) };
+        }
+    }
+    return null;
+}
+function assertExpansionBudget(pattern, count) {
+    if (count <= MAX_BRACE_EXPANSIONS)
+        return;
+    // A pattern this wide can run to thousands of characters; quote only its start.
+    const shown = pattern.length > 80 ? `${pattern.slice(0, 80)}...` : pattern;
+    throw new Error(`Artifact output pattern expands to more than ${MAX_BRACE_EXPANSIONS} patterns: ${shown}`);
+}
+function expandArtifactBraces(pattern) {
+    if (pattern.includes('\u0000')) {
+        throw new Error('Artifact output pattern contains a NUL byte');
+    }
+    const pending = [pattern];
+    const finished = [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        const group = findTopLevelExpansion(current);
+        if (!group) {
+            finished.push(current.replaceAll(LITERAL_BRACE_OPEN, '{').replaceAll(LITERAL_BRACE_CLOSE, '}'));
+            continue;
+        }
+        const wrapped = `{${group.body}}`;
+        // `max` makes this budget the binding one. Without it `{1..1000000000}`
+        // allocates brace-expansion's own 100,000-result default before the check
+        // below rejects it. `max` truncates silently, so ask for one result more
+        // than the budget allows: a result that long means the pattern is over
+        // budget rather than fully expanded. A truncated group never looks literal,
+        // because its first alternative is not the group itself.
+        const remaining = Math.max(MAX_BRACE_EXPANSIONS - (pending.length + finished.length), 0);
+        const alternatives = expand(wrapped, { max: remaining + 1 });
+        if (alternatives.length === 1 && alternatives[0] === wrapped) {
+            pending.push(`${group.pre}${LITERAL_BRACE_OPEN}${group.body}${LITERAL_BRACE_CLOSE}${group.post}`);
+            continue;
+        }
+        // Checked before the push so the budget bounds memory, not just the result.
+        assertExpansionBudget(pattern, pending.length + finished.length + alternatives.length);
+        for (const alternative of alternatives) {
+            pending.push(`${group.pre}${alternative}${group.post}`);
+        }
+    }
+    const normalized = finished
+        .map((value) => value.replace(DUPLICATE_SLASH_RE, '/'))
+        .filter((value) => value.length > 0);
+    return normalized.length > 0 ? normalized : [pattern];
+}
+/**
+ * One directory level. picomatch matches the segment; readdir keeps symlink
+ * entries tinyglobby would drop when followSymbolicLinks is false.
+ */
+function listDirectoryMatches(directory, segment) {
+    let entries;
+    try {
+        entries = fs.readdirSync(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const isMatch = picomatch(segment, {
+        dot: false,
+        nobrace: true,
+        noglobstar: true,
+        posix: true,
+    });
+    const names = [];
+    for (const entry of entries) {
+        if (isMatch(entry.name))
+            names.push(entry.name);
+    }
+    return names;
+}
 function hasBraceExpansion(pattern) {
     const openings = [];
     for (let index = 0; index < pattern.length; index += 1) {
@@ -59,12 +271,16 @@ function assertGlobDirectoryTraversal(changeDir, currentDir, directorySegments,
             // `**` may consume no directory at all.
             assertGlobDirectoryTraversal(changeDir, canonicalDir, directorySegments, segmentIndex + 1, visited, canonicalChangeDir, ancestors);
         }
-        const matches = fg.sync(segment === '**' ? '*' : segment, {
-            cwd: canonicalDir,
-            onlyFiles: false,
-            followSymbolicLinks: false,
-            deep: 1,
-        });
+        // `.` and `..` are not directory entries. Resolve them directly so a
+        // `**/../` pattern is confined before any glob runs.
+        if (segment === '' || segment === '.' || segment === '..') {
+            const candidate = path.resolve(canonicalDir, segment === '' ? '.' : segment);
+            const canonicalCandidate = FileSystemUtils.canonicalizeExistingPath(candidate);
+            FileSystemUtils.assertPathWithin(canonicalChangeDir, canonicalCandidate);
+            assertGlobDirectoryTraversal(changeDir, canonicalCandidate, directorySegments, segmentIndex + 1, visited, canonicalChangeDir, ancestors);
+            return;
+        }
+        const matches = listDirectoryMatches(canonicalDir, segment === '**' ? '*' : segment);
         for (const match of matches) {
             const candidate = path.join(canonicalDir, match);
             try {
@@ -90,8 +306,11 @@ function assertGlobDirectoryTraversal(changeDir, currentDir, directorySegments,
  * Returns absolute file paths. Glob matches are sorted for deterministic output.
  */
 export function resolveArtifactOutputs(changeDir, generates) {
+    const isGlob = isGlobPattern(generates);
+    if (isGlob)
+        assertBraceNesting(FileSystemUtils.toPosixPath(generates));
     const outputPath = resolveArtifactOutputPath(changeDir, generates);
-    if (!isGlobPattern(generates)) {
+    if (!isGlob) {
         try {
             return fs.statSync(outputPath).isFile()
                 ? [FileSystemUtils.canonicalizeExistingPath(outputPath)]
@@ -101,27 +320,21 @@ export function resolveArtifactOutputs(changeDir, generates) {
             return [];
         }
     }
-    const normalizedPattern = FileSystemUtils.toPosixPath(generates);
-    const globOptions = {
+    const normalizedPattern = FileSystemUtils.toPosixPath(generates).replace(DUPLICATE_SLASH_RE, '/');
+    // Expand braces before any filesystem access. tinyglobby has no generateTasks,
+    // and a `../` alternative is invisible until the braces are expanded.
+    const patterns = expandArtifactBraces(normalizedPattern);
+    for (const pattern of patterns) {
+        FileSystemUtils.assertPathWithin(changeDir, path.resolve(changeDir, globBase(pattern)));
+    }
+    for (const pattern of patterns) {
+        assertGlobDirectoryTraversal(changeDir, changeDir, pattern.split('/').slice(0, -1));
+    }
+    const matches = globby
+        .globSync(patterns, {
         cwd: changeDir,
-        onlyFiles: true,
-        absolute: true,
-        // Preserve linked artifact directories; confine traversal and concrete matches.
-        followSymbolicLinks: true,
-    };
-    // Task generation expands braces without accessing the filesystem. Validate
-    // every task base before globbing, including paths introduced by expansion.
-    const tasks = fg.generateTasks(normalizedPattern, globOptions);
-    for (const task of tasks) {
-        FileSystemUtils.assertPathWithin(changeDir, path.resolve(changeDir, task.base));
-    }
-    for (const task of tasks) {
-        for (const positivePattern of task.positive) {
-            assertGlobDirectoryTraversal(changeDir, changeDir, positivePattern.split('/').slice(0, -1));
-        }
-    }
-    const matches = fg
-        .sync(normalizedPattern, globOptions)
+        ...ARTIFACT_GLOB_OPTIONS,
+    })
         .map((match) => {
         const normalizedMatch = path.normalize(match);
         FileSystemUtils.assertPathWithin(changeDir, normalizedMatch);

package/dist/core/completions/completion-provider.js

@@ -1,5 +1,4 @@
 import { getActiveChangeIds, getSpecIds } from '../../utils/item-discovery.js';
-import { listSchemas } from '../artifact-graph/index.js';
 /**
  * Provides dynamic completion suggestions for OpenSpec items (changes and specs).
  * Implements a 2-second cache to avoid excessive file system operations during
@@ -74,7 +73,10 @@ export class CompletionProvider {
         if (this.schemaCache && now - this.schemaCache.timestamp < this.cacheTTL) {
             return this.schemaCache.data;
         }
-        // Fetch fresh data
+        // Fetch fresh data. The resolver (and the yaml and zod it parses schemas
+        // with) loads only here: completing changes or specs never needs it, and
+        // the artifact-graph barrel would also pull in tinyglobby.
+        const { listSchemas } = await import('../artifact-graph/resolver.js');
         const schemaNames = listSchemas(this.projectRoot);
         // Update cache
         this.schemaCache = {

package/dist/core/parsers/requirement-blocks.d.ts

@@ -70,6 +70,15 @@ export interface OrphanedRequirement {
     section: string | null;
     line: number;
 }
+/**
+ * Authored text archive does not carry into the main spec: a non-delta `## `
+ * section, text above the first `## `, or prose before the first requirement
+ * in ADDED/MODIFIED. `section` is null for text above the first `## `.
+ */
+export interface UnappliedContent {
+    section: string | null;
+    line: number;
+}
 export interface DeltaPlan {
     added: RequirementBlock[];
     modified: RequirementBlock[];
@@ -83,6 +92,7 @@ export interface DeltaPlan {
     unpairedRenames: UnpairedRename[];
     /** Canonical requirement blocks written outside every delta section. */
     orphanedRequirements: OrphanedRequirement[];
+    unappliedContent: UnappliedContent[];
     skippedHeaders: SkippedHeader[];
     sectionPresence: {
         added: boolean;
@@ -95,6 +105,7 @@ export interface DeltaPlan {
  * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
  */
 export declare function parseDeltaSpec(content: string): DeltaPlan;
+export declare function describeUnappliedContent(content: UnappliedContent, sentenceStart?: boolean): string;
 /** Both directions of the scenario-name comparison, plus the two totals. */
 export interface ScenarioNameDiff {
     /** Names the current block has that the incoming block does not cover. */