diff --git a/docs/src/content/docs/case-studies/image-alt-text.mdx b/docs/src/content/docs/case-studies/image-alt-text.mdx
index 6c8f3d4ea1..7653d9871b 100644
--- a/docs/src/content/docs/case-studies/image-alt-text.mdx
+++ b/docs/src/content/docs/case-studies/image-alt-text.mdx
@@ -1,18 +1,19 @@
 ---
 title: Image Alt Text
 sidebar:
-  order: 10
+    order: 10
 description: Learn how to automatically generate descriptive alt text for images using OpenAI Vision model to enhance accessibility and SEO.
 keywords: alt text automation, image accessibility, SEO optimization, OpenAI Vision, Astro integration
 ---
-import { Image } from 'astro:assets';
-import { Code } from '@astrojs/starlight/components';
+
+import { Image } from "astro:assets"
+import { Code } from "@astrojs/starlight/components"
 import scriptSrc from "../../../../genaisrc/image-alt-text.genai.js?raw"
-import src from '../../../assets/debugger.png';
+import src from "../../../assets/debugger.png"
 import alt from "../../../assets/debugger.png.txt?raw"
 
-It is a best practice to provide an `alt` attribute for images. 
-This attribute is used to describe the image to users who are unable to see it. 
+It is a best practice to provide an `alt` attribute for images.
+This attribute is used to describe the image to users who are unable to see it.
 It is also used by search engines to understand the content of the image.
 
 ```html "alt"
@@ -30,7 +31,7 @@ However, this task can be tedious and developer are often tempted to skip it, or
 To solve this issue, we created a script that uses the OpenAI Vision model to analyze the documentation
 images and generate a description alt text.
 
-To start, we assume that the script is run on a single image file 
+To start, we assume that the script is run on a single image file
 and we use [defImage](/genaiscript/reference/scripts/images) to add it to the prompt context.
 
 ```js title="image-alt-text.genai.js"
@@ -55,18 +56,16 @@ The GenAIScript documentation uses Astro, which allows to author pages in [MDX](
 The code below shows how the generate alt text, stored in a separate text file, is injected in the final HTML.
 
 ```mdx
-
-import { Image } from 'astro:assets';
-import src from '../../../assets/debugger.png';
+import { Image } from "astro:assets"
+import src from "../../../assets/debugger.png"
 import alt from "../../../assets/debugger.png.txt?raw"
 
-<Image src={src} alt={alt}/>
-
+<Image src={src} alt={alt} />
 ```
 
 The `debugger.png` image shows the screenshot of a debugging session and the generate alt text file contents.
 
-<Image src={src} alt={alt}/>
+<Image src={src} alt={alt} />
 
 <Code code={alt} wrap={true} lang="txt" title="debugger.png.txt" />
 
@@ -76,7 +75,8 @@ Using the [batch](/genaiscript/reference/cli/batch) command, we can apply the sc
 in a single command.
 
 ```sh
-npx --yes genaiscript batch image-alt-text assets/**.png --apply-edits
+for file in assets/**.png; do
+  npx --yes genaiscript run image-alt-text "$file" --apply-edits
 ```
 
 To avoid regenerating the alt text, we also detect if a file exists in the script and cancel accordingly.
diff --git a/docs/src/content/docs/case-studies/seo-frontmatter.mdx b/docs/src/content/docs/case-studies/seo-frontmatter.mdx
index 29709ad4e2..78e4c35ba9 100644
--- a/docs/src/content/docs/case-studies/seo-frontmatter.mdx
+++ b/docs/src/content/docs/case-studies/seo-frontmatter.mdx
@@ -21,11 +21,11 @@ to merge the new front matter with the existing front matter.
 ## Batching over all files
 
 Once the script has been tuned on a few files, you can automate using
-the [CLI](/genaiscript/reference/cli). The CLI has a **batch** mode that applies a LLM generation
-on each file and a **--apply-edits** flag to apply the changes to the file.
+the [CLI](/genaiscript/reference/cli). The CLI has a **--apply-edits** flag to apply the changes to the file.
 
-```bash
-genaiscript batch frontmatter src/**/*.md --apply-edits
+```sh
+for file in src/**/*.md; do
+  npx --yes genaiscript run frontmatter "$file" --apply-edits
 ```
 
 You can run this command in your CI/CD pipeline to keep your SEO front matter up to date.
diff --git a/docs/src/content/docs/faq.md b/docs/src/content/docs/faq.md
index 837dcce635..2e6d7a59ab 100644
--- a/docs/src/content/docs/faq.md
+++ b/docs/src/content/docs/faq.md
@@ -26,9 +26,6 @@ keywords: AI, script generation, performance, best practices, limitations
 -   **Can I use GenAIScript in IDEs other than VS Code?**
     Currently, GenAIScript is integrated with VS Code, but it can be written in any IDE. The VS Code extension, however, provides additional support for creating and debugging scripts.
 
--   **What is a GPSpec and how do I create one?**
-    A GPSpec is an optional markdown file that provides context for a GenAIScript. You can create one by writing a markdown document that lists arguments or includes more complex documentation.
-
 -   **What are foundation models and LLMs in the context of GenAIScript?**
     Foundation models and LLMs (Large Language Models) are AI models that GenAIScript can interact with to perform tasks like generating text or processing information.
 
@@ -60,9 +57,6 @@ keywords: AI, script generation, performance, best practices, limitations
 -   **How can I use GenAIScript to automate document translation?**
     One of our case studies illustrates the use of GenAIScript for translating document fragments between languages: [Translation Case Study](/genaiscript/case-studies/documentation-translations)
 
--   **Is it possible to generate executable code from natural language specifications using GenAIScript?**
-    Yes, you can use a GPSpec to define the task and a GenAIScript to translate the spec into code in a particular programming language.
-
 -   **Can I use GenAIScript to summarize documents or create dialogues from monologues?**
     Yes, LLMs are good at summarizing and can be used within GenAIScript to summarize documents or convert monologues into dialogues.
 
diff --git a/docs/src/content/docs/reference/cli/batch.mdx b/docs/src/content/docs/reference/cli/batch.mdx
deleted file mode 100644
index d8b8e6014a..0000000000
--- a/docs/src/content/docs/reference/cli/batch.mdx
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: Batch
-description: Learn how to use the batch command to process multiple files with GenAIScript, including JSON Lines output and GitHub Actions integration.
-sidebar:
-  order: 4
-keywords: batch processing, JSON Lines, CLI tool, automation, GitHub Actions
----
-import { Steps } from '@astrojs/starlight/components';
-import { Tabs, TabItem } from '@astrojs/starlight/components';
-
-Once you have a script that works in Visual Studio Code, you can use the [command line](/genaiscript/reference/cli/)
-to run the script automatically over many files.
-
-The `batch` command runs the tool over many files in a batch mode (one full LLM iteration per file).
-
-```bash "batch"
-npx genaiscript batch <script> "<files...>"
-```
-
-The script will create various JSON Lines files with the results (JSON Lines is a file format where each line is a valid JSON object, which allows for appending results). You can post-process those results using your favorite script environment.
-
-By default, results will be saved in the `.genaiscript/results` folder, this can be overriden with `--out`. The execution produces various `.jsonl` (JSON Lines) files that provide a convinient way to append runs to the same files.
-
-## Scripting
-
-You can also use the [run](../run) command and your favorite scripting language (_enter favorite language here_) to automate the process.
-
-Let's assume you start with a file `ex1.pdf` you want the output in a new file `ex1.tweet.md`.
-How you do this depends on the shell script you prefer. 
-
-### Bash
-
-```bash wrap frame="none"
-for file in *.pdf; do 
-  newfile="${file%.pdf}.tweet.md"; # foo.pdf -> foo.tweet.md
-  if [ ! -f "$newfile" ]; then # skip if already exists
-    npx genaiscript run gen-tweet $file > $newfile
-  fi
-done
-```
-
-### Powershell
-
-```powershell wrap frame="none"
-Get-ChildItem -Filter *.pdf | ForEach-Object {
-  $newName = $_.BaseName + ".tweet.md"
-  if (-not (Test-Path $newName)) {
-    npx genaiscript run gen-tweet $_.FullName | Set-Content "$newName"  
-  }
-}
-```
-
-### Python
-
-```python wrap frame="none"
-import subprocess, sys, os
-for input_file in sys.argv[1:]:
-    output_file = os.path.splitext(input_file)[0] + '.tweet.md'
-    if not os.path.exists(output_file):
-        with open(output_file, 'w') as outfile:
-            result = subprocess.check_output(
-              ["npx", "genaiscript", "run", "gen-tweet", 
-              input_file], universal_newlines=True)
-            outfile.write(result)
-```
-
-### JavaScript (node.js + google/zx)
-
-```js wrap frame="none"
-#!/usr/bin/env zx
-import "zx/globals"
-
-const files = await glob("*.pdf")
-for(const file of files) {
-  const out = file.replace(/\.pdf$/i, '.tweet.md') // foo.pdf -> foo.tweet.md
-  if (!await fs.exists(out)) // don't regenerate if it already exists
-    await $`npx --yes genaiscript run gen-tweet ${file} > ${out}`
-}
-```
-
-This script requires [zx](https://github.com/google/zx).
-
-```sh
-npm install -g zx
-```
-
-## GitHub Actions
-
-In a GitHub Actions workflow, you can inject a report in the step summary (`GITHUB_STEP_SUMMARY`) using `--out-summary` (`-os`).
-
-```yaml "-os $GITHUB_STEP_SUMMARY"
-- name: Batch genaiscript <script> on <files>
-  run: |
-      npx --yes genaiscript batch <script> <files> -os $GITHUB_STEP_SUMMARY
-- name: Upload GenAIScript results
-  if: always()
-  uses: actions/upload-artifact@v4
-  with:
-      path: |
-          results/**
-```
diff --git a/docs/src/content/docs/reference/transparency-note.md b/docs/src/content/docs/reference/transparency-note.md
index 086abfd2f6..fdda87c4dc 100644
--- a/docs/src/content/docs/reference/transparency-note.md
+++ b/docs/src/content/docs/reference/transparency-note.md
@@ -39,11 +39,6 @@ for the LLM call, allows arbitrary JavaScript code execution, packages
 the prompt input for the LLM, calls the LLM, and unpacks that LLM output
 based on the directions given in the prompt.
 
-**GPSpec** An optional markdown file(s) used to establish the calling
-context for the GenAIScript. A GPSpec can be as simple as a list of
-arguments and as complex as a collection of markdown documents in a
-repository.
-
 **GPVM**: A runtime system that given a GenAIScript and an optional
 GPSpec, executes the GenAIScript, which involves integrating the context
 into a prompt, calling the specified LLM, and extracting content from
diff --git a/packages/cli/src/batch.ts b/packages/cli/src/batch.ts
deleted file mode 100644
index 931255aec3..0000000000
--- a/packages/cli/src/batch.ts
+++ /dev/null
@@ -1,286 +0,0 @@
-import {
-    GenerationResult,
-    host,
-    runTemplate,
-    MarkdownTrace,
-    convertDiagnosticToGitHubActionCommand,
-    convertDiagnosticToAzureDevOpsCommand,
-    dotGenaiscriptPath,
-    assert,
-    normalizeInt,
-    normalizeFloat,
-    GENAI_JS_REGEX,
-    GPSPEC_REGEX,
-    FILES_NOT_FOUND_ERROR_CODE,
-    GENERATION_ERROR_CODE,
-    appendJSONL,
-    writeFileEdits,
-    logVerbose,
-    errorMessage,
-    EMOJI_SUCCESS,
-    EMOJI_FAIL,
-    resolveModelConnectionInfo,
-    logError,
-    CONFIGURATION_ERROR_CODE,
-    parseKeyValuePairs,
-} from "genaiscript-core"
-import { basename, resolve, join, relative, dirname } from "node:path"
-import { appendFile, writeFile } from "node:fs/promises"
-import { emptyDir, ensureDir } from "fs-extra"
-import { buildProject } from "./build"
-import { createProgressSpinner } from "./spinner"
-
-export async function batchScript(
-    tool: string,
-    specs: string[],
-    options: {
-        excludedFiles: string[]
-        excludeGitIgnore: boolean
-        out: string
-        outSummary: string
-        removeOut: boolean
-        retry: string
-        retryDelay: string
-        maxDelay: string
-        label: string
-        temperature: string
-        topP: string
-        seed: string
-        maxTokens: string
-        model: string
-        cache: boolean
-        cacheName: string
-        applyEdits: boolean
-        vars: string[]
-    }
-) {
-    const spinner = createProgressSpinner("preparing tool and files")
-    const fail = (msg: string, exitCode: number) => {
-        if (spinner) spinner.fail(msg)
-        else logVerbose(msg)
-        process.exit(exitCode)
-    }
-
-    const {
-        out = dotGenaiscriptPath("results"),
-        removeOut,
-        cache,
-        cacheName,
-        label,
-        outSummary,
-        applyEdits,
-        excludedFiles,
-        excludeGitIgnore,
-    } = options
-    const outAnnotations = join(out, "annotations.jsonl")
-    const outData = join(out, "data.jsonl")
-    const outFenced = join(out, "fenced.jsonl")
-    const outOutput = join(out, "output.md")
-    const outErrors = join(out, "errors.jsonl")
-    const outFileEdits = join(out, "file-edits.jsonl")
-
-    const retry = normalizeInt(options.retry) || 12
-    const retryDelay = normalizeInt(options.retryDelay) || 15000
-    const maxDelay = normalizeInt(options.maxDelay) || 360000
-    const temperature = normalizeFloat(options.temperature)
-    const topP = normalizeFloat(options.topP)
-    const seed = normalizeFloat(options.seed)
-    const maxTokens = normalizeInt(options.maxTokens)
-
-    const toolFiles: string[] = []
-    if (GENAI_JS_REGEX.test(tool)) toolFiles.push(tool)
-    const specFiles = new Set<string>()
-    for (const arg of specs) {
-        const ffs = await host.findFiles(arg, {
-            applyGitIgnore: excludeGitIgnore,
-        })
-        if (!ffs.length)
-            fail(`no files matching ${arg}`, FILES_NOT_FOUND_ERROR_CODE)
-
-        for (const f of ffs) {
-            if (GPSPEC_REGEX.test(f)) specFiles.add(f)
-            else {
-                const fp = `${f}.gpspec.md`
-                const md = `# Specification
-                
--   [${basename(f)}](./${basename(f)})\n`
-                host.setVirtualFile(fp, md)
-                specFiles.add(fp)
-            }
-        }
-    }
-
-    if (excludedFiles?.length) {
-        for (const arg of excludedFiles) {
-            const ffs = await host.findFiles(arg)
-            for (const f of ffs) specFiles.delete(f)
-        }
-    }
-
-    if (!specFiles.size) fail("no file found", FILES_NOT_FOUND_ERROR_CODE)
-
-    const prj = await buildProject({
-        toolFiles,
-        specFiles: Array.from(specFiles),
-    })
-    const script = prj.templates.find(
-        (t) =>
-            t.id === tool ||
-            (t.filename &&
-                GENAI_JS_REGEX.test(tool) &&
-                resolve(t.filename) === resolve(tool))
-    )
-    if (!script) throw new Error(`tool ${tool} not found`)
-
-    spinner.succeed(
-        `tool: ${script.id} (${script.title}), files: ${specFiles.size}, out: ${resolve(out)}`
-    )
-
-    const vars = parseKeyValuePairs(options.vars)
-
-    let errors = 0
-    let totalTokens = 0
-    if (removeOut) await emptyDir(out)
-    await ensureDir(out)
-    for (let i = 0; i < prj.rootFiles.length; i++) {
-        const specFile = prj.rootFiles[i].filename
-        const file = specFile.replace(GPSPEC_REGEX, "")
-        const meta = { tool, file }
-        try {
-            spinner.start(`${file} (${i + 1}/${specFiles.size})`)
-            const fragment = prj.rootFiles.find(
-                (f) => resolve(f.filename) === resolve(specFile)
-            ).fragments[0]
-            assert(fragment !== undefined, `${specFile} not found`)
-            let tokens = 0
-            const trace = new MarkdownTrace()
-            trace.heading(2, fragment.file.filename)
-            const { info } = await resolveModelConnectionInfo(script, {
-                trace,
-                model: options.model,
-            })
-            if (info.error) {
-                trace.error(undefined, info.error)
-                logError(info.error)
-                process.exit(CONFIGURATION_ERROR_CODE)
-            }
-            const result: GenerationResult = await runTemplate(
-                prj,
-                script,
-                fragment,
-                {
-                    infoCb: () => {},
-                    partialCb: ({ tokensSoFar }) => {
-                        tokens = tokensSoFar
-                        spinner.report({ count: tokens })
-                    },
-                    skipLLM: false,
-                    label,
-                    cache,
-                    cacheName,
-                    temperature,
-                    topP,
-                    seed,
-                    maxTokens,
-                    model: info.model,
-                    retry,
-                    retryDelay,
-                    maxDelay,
-                    vars,
-                    stats: { toolCalls: 0, repairs: 0, turns: 0 },
-                    trace,
-                }
-            )
-
-            const fileEdits = result.fileEdits || {}
-            if (Object.keys(fileEdits).length) {
-                if (applyEdits && result.status === "success")
-                    await writeFileEdits(result)
-                // save results in various files
-                await appendJSONL(
-                    outFileEdits,
-                    [{ fileEdits: result.fileEdits }],
-                    meta
-                )
-            }
-            if (result.error)
-                await appendJSONL(outErrors, [{ error: result.error }], meta)
-            if (result.annotations?.length)
-                await appendJSONL(outAnnotations, result.annotations, meta)
-            if (result.fences?.length)
-                await appendJSONL(outFenced, result.fences, meta)
-            if (result.frames?.length)
-                await appendJSONL(outData, result.frames, meta)
-            // add to summary
-            if (outSummary) {
-                const st = new MarkdownTrace()
-                st.details(file, result.text)
-                await appendFile(outSummary, st.content)
-            }
-            // save results
-            const outText = join(
-                out,
-                `${relative(".", specFile).replace(GPSPEC_REGEX, ".output.md")}`
-            )
-            const outTrace = join(
-                out,
-                `${relative(".", specFile).replace(GPSPEC_REGEX, ".trace.md")}`
-            )
-            const outJSON = join(
-                out,
-                `${relative(".", specFile).replace(GPSPEC_REGEX, ".json")}`
-            )
-            await ensureDir(dirname(outText))
-            await writeFile(outText, result.text, { encoding: "utf8" })
-            await writeFile(outTrace, result.trace, { encoding: "utf8" })
-            await appendFile(
-                outOutput,
-                `- ${result.status === "cancelled" ? "⚠" : result.status === "error" ? EMOJI_FAIL : EMOJI_SUCCESS} [${relative(".", specFile).replace(GPSPEC_REGEX, "")}](${relative(out, outText)}) ([trace](${relative(out, outTrace)}))\n`,
-                { encoding: "utf8" }
-            )
-            await writeFile(outJSON, JSON.stringify(result, null, 2), {
-                encoding: "utf8",
-            })
-
-            if (result.status !== "success") {
-                if (result.status === "cancelled")
-                    spinner.warn(`${spinner.text}, ${result.statusText}`)
-                else {
-                    errors++
-                    spinner.fail(`${spinner.text}, ${result.statusText}`)
-                }
-            } else spinner.succeed()
-
-            totalTokens += tokens
-
-            // if in a CI/GitHub Actions build, print annotations
-            if (
-                result.annotations?.length &&
-                process.env.CI &&
-                process.env.GITHUB_ACTION
-            )
-                result.annotations
-                    .map(convertDiagnosticToGitHubActionCommand)
-                    .forEach((d) => console.log(d))
-            else if (
-                // Azure DevOps
-                result.annotations?.length &&
-                process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI
-            )
-                result.annotations
-                    .map(convertDiagnosticToAzureDevOpsCommand)
-                    .forEach((d) => console.log(d))
-        } catch (e) {
-            errors++
-            await appendJSONL(
-                outErrors,
-                [{ error: errorMessage(e) + "\n" + e.stack }],
-                meta
-            )
-            spinner.fail(`${spinner.text}, ${e.error}`)
-        }
-    }
-
-    spinner.stop()
-    if (errors) process.exit(GENERATION_ERROR_CODE)
-}
diff --git a/packages/cli/src/build.ts b/packages/cli/src/build.ts
index c36966004b..632416073d 100644
--- a/packages/cli/src/build.ts
+++ b/packages/cli/src/build.ts
@@ -1,32 +1,16 @@
-import {
-    GENAI_JS_GLOB,
-    GPSPEC_GLOB,
-    host,
-    parseProject,
-} from "genaiscript-core"
+import { GENAI_JS_GLOB, host, parseProject } from "genaiscript-core"
 
 export async function buildProject(options?: {
     toolFiles?: string[]
-    specFiles?: string[]
     toolsPath?: string
-    specsPath?: string
 }) {
-    const {
-        toolFiles,
-        specFiles,
-        toolsPath = GENAI_JS_GLOB,
-        specsPath = GPSPEC_GLOB,
-    } = options || {}
+    const { toolFiles, toolsPath = GENAI_JS_GLOB } = options || {}
 
-    const gpspecFiles = specFiles?.length
-        ? specFiles
-        : await host.findFiles(specsPath)
     const scriptFiles = toolFiles?.length
         ? toolFiles
         : await host.findFiles(toolsPath)
 
     const newProject = await parseProject({
-        gpspecFiles,
         scriptFiles,
     })
     return newProject
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
index 09f8f412f6..591838859c 100644
--- a/packages/cli/src/cli.ts
+++ b/packages/cli/src/cli.ts
@@ -18,7 +18,6 @@ import { startServer } from "./server"
 import { satisfies as semverSatisfies } from "semver"
 import { NODE_MIN_VERSION, PROMPTFOO_VERSION } from "./version"
 import { runScriptWithExitCode } from "./run"
-import { batchScript } from "./batch"
 import {
     retrievalClear,
     retrievalFuzz,
@@ -155,47 +154,6 @@ export async function cli() {
         )
         .action(runScriptWithExitCode)
 
-    program
-        .command("batch")
-        .description("Run a tool on a batch of specs")
-        .arguments("<script> [files...]")
-        .option("-ef, --excluded-files <string...>", "excluded files")
-        .option(
-            "-egi, --exclude-git-ignore",
-            "exclude files that are ignore through the .gitignore file in the workspace root"
-        )
-        .option(
-            "-o, --out <folder>",
-            "output folder. Extra markdown fields for output and trace will also be generated"
-        )
-        .option("-rmo, --remove-out", "remove output folder if it exists")
-        .option("-os, --out-summary <file>", "append output summary in file")
-        .option("-r, --retry <number>", "number of retries", "8")
-        .option(
-            "-rd, --retry-delay <number>",
-            "minimum delay between retries",
-            "15000"
-        )
-        .option(
-            "-md, --max-delay <number>",
-            "maximum delay between retries",
-            "180000"
-        )
-        .option("-l, --label <string>", "label for the run")
-        .option("-t, --temperature <number>", "temperature for the run")
-        .option("-tp, --top-p <number>", "top-p for the run")
-        .option("-m, --model <string>", "model for the run")
-        .option("-mt, --max-tokens <number>", "maximum tokens for the run")
-        .option("-se, --seed <number>", "seed for the run")
-        .option("--no-cache", "disable LLM result cache")
-        .option("-cn, --cache-name <name>", "custom cache file name")
-        .option("-ae, --apply-edits", "apply file edits")
-        .option(
-            "--vars <string...>",
-            "variables, as name=value, stored in env.vars"
-        )
-        .action(batchScript)
-
     const test = program.command("test")
 
     test.command("run", { isDefault: true })
diff --git a/packages/cli/src/run.ts b/packages/cli/src/run.ts
index 9e58fd7886..7a10449755 100644
--- a/packages/cli/src/run.ts
+++ b/packages/cli/src/run.ts
@@ -11,7 +11,6 @@ import {
     normalizeInt,
     normalizeFloat,
     GENAI_JS_REGEX,
-    GPSPEC_REGEX,
     FILES_NOT_FOUND_ERROR_CODE,
     appendJSONL,
     RUNTIME_ERROR_CODE,
@@ -117,8 +116,7 @@ export async function runScript(
     if (!files?.length) {
         specContent = "\n"
         spec = "stdin.gpspec.md"
-    } else if (files.length === 1 && GPSPEC_REGEX.test(files[0])) {
-        spec = files[0]
+        // TODO
     } else {
         for (const arg of files) {
             if (HTTPS_REGEX.test(arg)) resolvedFiles.add(arg)
@@ -134,11 +132,7 @@ export async function runScript(
                 }
 
                 for (const file of ffs) {
-                    if (GPSPEC_REGEX.test(file)) {
-                        md = (md || "") + (await readText(file)) + "\n"
-                    } else {
-                        resolvedFiles.add(file)
-                    }
+                    resolvedFiles.add(file)
                 }
             }
         }
@@ -163,11 +157,8 @@ ${Array.from(resolvedFiles)
 
     if (!spec) return fail(`genai spec not found`, FILES_NOT_FOUND_ERROR_CODE)
 
-    if (specContent !== undefined) host.setVirtualFile(spec, specContent)
-
     const prj = await buildProject({
         toolFiles,
-        specFiles: [spec],
     })
     const script = prj.templates.find(
         (t) =>
diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts
index 7d1b35225f..83ea958f86 100644
--- a/packages/core/src/constants.ts
+++ b/packages/core/src/constants.ts
@@ -19,14 +19,12 @@ export const GENAI_MJS_EXT = ".genai.mjs"
 export const GENAI_JS_GLOB = "**/*.genai.*js"
 export const GENAI_JS_REGEX = /\.genai\.m?js$/i
 export const MODULE_JS_REGEX = /\.mjs$/i
-export const GPSPEC_REGEX = /\.gpspec\.md$/i
 export const HTTPS_REGEX = /^https:\/\//i
 export const CSV_REGEX = /\.(t|c)sv$/i
 export const XLSX_REGEX = /\.xlsx$/i
 export const DOCX_REGEX = /\.docx$/i
 export const PDF_REGEX = /\.pdf$/i
 export const MDX_REGEX = /\.mdx$/i
-export const GPSPEC_GLOB = "**/*.gpspec.md"
 export const TOOL_NAME = "GenAIScript"
 export const SERVER_PORT = 8003
 export const CLIENT_RECONNECT_DELAY = 2000
diff --git a/packages/vscode/package.json b/packages/vscode/package.json
index 5d6fb2e30f..fab0f6faab 100644
--- a/packages/vscode/package.json
+++ b/packages/vscode/package.json
@@ -41,7 +41,6 @@
         "publish": false
     },
     "activationEvents": [
-        "workspaceContains:**/*.gpspec.md",
         "workspaceContains:**/*.genai.{mjs,js}",
         "onNotebook:genaiscript"
     ],
diff --git a/packages/vscode/src/fragmentcommands.ts b/packages/vscode/src/fragmentcommands.ts
index d90a7b1826..b3f8c399de 100644
--- a/packages/vscode/src/fragmentcommands.ts
+++ b/packages/vscode/src/fragmentcommands.ts
@@ -97,35 +97,24 @@ export function activateFragmentCommands(state: ExtensionState) {
     }
 
     const resolveSpec = async (frag: Fragment | string | vscode.Uri) => {
+        let fragment: Fragment
         // active text editor
         if (frag === undefined && vscode.window.activeTextEditor) {
             const document = vscode.window.activeTextEditor.document
             if (document && document.uri.scheme === "file")
                 frag = document.uri.fsPath
         }
-
         if (frag instanceof vscode.Uri) frag = frag.fsPath
-
-        const { project } = state
-
-        let fragment: Fragment
-        if (typeof frag === "string" && !/\.gpspec\.md(:.*)?$/i.test(frag)) {
+        if (typeof frag === "string") {
             const fragUri = host.toUri(frag)
             if (await checkFileExists(fragUri)) {
-                const prj = await state.parseDocument(fragUri)
-                fragment = prj?.rootFiles?.[0].fragments?.[0]
+                fragment = await state.parseDocument(fragUri)
             } else if (await checkDirectoryExists(fragUri)) {
-                const prj = await state.parseDirectory(fragUri)
-                fragment = prj?.rootFiles?.[0].fragments?.[0]
+                fragment = await state.parseDirectory(fragUri)
             }
-        } else if (typeof frag === "string" && GENAI_JS_REGEX.test(frag)) {
-            const fragUri = host.toUri(frag)
-            const prj = await state.parseDocument(fragUri)
-            fragment = prj?.rootFiles?.[0].fragments?.[0]
         } else {
-            fragment = project.resolveFragment(frag)
+            fragment = frag
         }
-
         return fragment
     }
 
@@ -168,7 +157,6 @@ export function activateFragmentCommands(state: ExtensionState) {
         }
 
         if (!fragment) return
-        fragment = state.project.fragmentByFullId[fragment.fullId] ?? fragment
 
         const parameters = await showPromptParametersQuickPicks(template)
         if (parameters === undefined) return
diff --git a/packages/vscode/src/state.ts b/packages/vscode/src/state.ts
index 20d5b740c8..c841e7bd97 100644
--- a/packages/vscode/src/state.ts
+++ b/packages/vscode/src/state.ts
@@ -29,12 +29,19 @@ import {
     fixPromptDefinitions,
     resolveModelConnectionInfo,
     AI_REQUESTS_CACHE,
+    readText,
 } from "genaiscript-core"
 import { ExtensionContext } from "vscode"
 import { VSCodeHost } from "./vshost"
 import { applyEdits, toRange } from "./edit"
 import { Utils } from "vscode-uri"
-import { findFiles, listFiles, saveAllTextDocuments, writeFile } from "./fs"
+import {
+    findFiles,
+    listFiles,
+    readFileText,
+    saveAllTextDocuments,
+    writeFile,
+} from "./fs"
 import { startLocalAI } from "./localai"
 import { hasOutputOrTraceOpened } from "./markdowndocumentprovider"
 
@@ -494,57 +501,37 @@ temp/
         await this._parseWorkspacePromise
     }
 
-    async parseDirectory(uri: vscode.Uri, token?: vscode.CancellationToken) {
-        const fspath = uri.fsPath        
-        const specn = this.host.path.join(fspath, "dir.gpspec.md")
-        const files = (await listFiles(uri)).filter(
-            (uri) => !uri.fsPath.endsWith(".gpspec.md")
-        )
-        if (token?.isCancellationRequested) return undefined
-
-        const spec = `# Specification
-
-${files
-    .map((uri) => this.host.path.relative(fspath, uri.fsPath))
-    .map((fn) => `-   [${fn}](./${fn})`)
-    .join("\n")}
-`
-        this.host.clearVirtualFiles()
-        this.host.setVirtualFile(specn, spec)
-
-        const gpspecFiles = [specn]
-        const scriptFiles = await this.findScripts()
-        if (token?.isCancellationRequested) return undefined
-
-        const newProject = await parseProject({
-            scriptFiles,
-        })
-        return newProject
+    async parseDirectory(
+        uri: vscode.Uri,
+        token?: vscode.CancellationToken
+    ): Promise<Fragment> {
+        const fspath = uri.fsPath
+        const files = await listFiles(uri)
+
+        return <Fragment>{
+            file: {
+                filename: this.host.path.join(fspath, "dir.gpspec.md"),
+                content: "",
+            },
+            references: files.map((fs) => ({
+                filename: fs.fsPath,
+            })),
+        }
     }
 
     async parseDocument(
         document: vscode.Uri,
         token?: vscode.CancellationToken
-    ) {
+    ): Promise<Fragment> {
         const fspath = document.fsPath
         const fn = Utils.basename(document)
-        const specn = fspath + ".gpspec.md"
-        this.host.clearVirtualFiles()
-        this.host.setVirtualFile(
-            specn,
-            `# Specification
-
-${!GENAI_JS_REGEX.test(fn) ? `-   [${fn}](./${fn})` : ""}
-`
-        )
-        const gpspecFiles = [specn]
-        const scriptFiles = await this.findScripts()
-        if (token?.isCancellationRequested) return undefined
-
-        const newProject = await parseProject({
-            scriptFiles,
-        })
-        return newProject
+        const content = await readFileText(this.host.projectUri, fspath)
+        return <Fragment>{
+            file: {
+                filename: fspath,
+                content,
+            },
+        }
     }
 
     private setDiagnostics() {