lsd-pi 1.0.0 → 1.1.0

package/dist/resources/extensions/gsd/prompt-cache-optimizer.js

@@ -1,150 +0,0 @@
-/**
- * Prompt Cache Optimizer — separates prompt content into cacheable static
- * prefixes and dynamic per-task suffixes to maximize provider cache hit rates.
- *
- * Anthropic caches by prefix match (up to 4 breakpoints, 90% savings).
- * OpenAI auto-caches prompts with 1024+ stable prefix tokens (50% savings).
- * Both benefit from placing static content first and dynamic content last.
- */
-// ─── Label classification maps ───────────────────────────────────────────────
-/** Labels that never change within a session */
-const STATIC_LABELS = new Set([
-    "system-prompt",
-    "base-instructions",
-    "executor-constraints",
-]);
-/** Prefix patterns for static labels (e.g. "template-*") */
-const STATIC_PREFIXES = ["template-"];
-/** Labels that change per-slice but not per-task */
-const SEMI_STATIC_LABELS = new Set([
-    "slice-plan",
-    "decisions",
-    "requirements",
-    "roadmap",
-    "prior-summaries",
-    "project-context",
-    "overrides",
-]);
-/** Labels that change per-task */
-const DYNAMIC_LABELS = new Set([
-    "task-plan",
-    "task-instructions",
-    "task-context",
-    "file-contents",
-    "diff-context",
-    "verification-commands",
-]);
-// ─── Public API ──────────────────────────────────────────────────────────────
-/**
- * Classify common GSD prompt sections by their caching potential.
- * Returns the appropriate ContentRole for a section label.
- */
-export function classifySection(label) {
-    if (STATIC_LABELS.has(label))
-        return "static";
-    if (STATIC_PREFIXES.some((p) => label.startsWith(p)))
-        return "static";
-    if (SEMI_STATIC_LABELS.has(label))
-        return "semi-static";
-    if (DYNAMIC_LABELS.has(label))
-        return "dynamic";
-    // Conservative default: unknown labels are treated as dynamic
-    return "dynamic";
-}
-/**
- * Build a PromptSection from content with automatic role classification.
- *
- * @param label Section label (e.g., "slice-plan", "task-instructions")
- * @param content The section content
- * @param role Optional explicit role override
- */
-export function section(label, content, role) {
-    return {
-        label,
-        content,
-        role: role ?? classifySection(label),
-    };
-}
-/**
- * Optimize prompt sections for maximum cache hit rates.
- * Reorders sections: static first, then semi-static, then dynamic.
- * Preserves relative order within each role group.
- *
- * @param sections Array of labeled prompt sections
- * @returns Cache-optimized prompt with statistics
- */
-export function optimizeForCaching(sections) {
-    const groups = {
-        static: [],
-        "semi-static": [],
-        dynamic: [],
-    };
-    for (const s of sections) {
-        groups[s.role].push(s);
-    }
-    const ordered = [
-        ...groups["static"],
-        ...groups["semi-static"],
-        ...groups["dynamic"],
-    ];
-    const prompt = ordered.map((s) => s.content).join("\n\n");
-    const staticChars = groups["static"].reduce((sum, s) => sum + s.content.length, 0);
-    const semiStaticChars = groups["semi-static"].reduce((sum, s) => sum + s.content.length, 0);
-    // Account for separator characters between sections in the cacheable prefix
-    const staticSeparators = groups["static"].length > 0
-        ? (groups["static"].length - 1) * 2 // "\n\n" between static sections
-        : 0;
-    const semiStaticSeparators = groups["semi-static"].length > 0
-        ? (groups["semi-static"].length - 1) * 2
-        : 0;
-    // Separator between static and semi-static groups
-    const groupSeparator = groups["static"].length > 0 && groups["semi-static"].length > 0 ? 2 : 0;
-    const cacheablePrefixChars = staticChars +
-        semiStaticChars +
-        staticSeparators +
-        semiStaticSeparators +
-        groupSeparator;
-    const totalChars = prompt.length;
-    const cacheEfficiency = totalChars > 0 ? cacheablePrefixChars / totalChars : 0;
-    return {
-        prompt,
-        cacheablePrefixChars,
-        totalChars,
-        cacheEfficiency,
-        sectionCounts: {
-            static: groups["static"].length,
-            "semi-static": groups["semi-static"].length,
-            dynamic: groups["dynamic"].length,
-        },
-    };
-}
-/**
- * Estimate the cache savings for a given optimization result.
- * Based on provider pricing:
- * - Anthropic: 90% savings on cached tokens
- * - OpenAI: 50% savings on cached tokens
- *
- * @param result The cache-optimized prompt
- * @param provider Provider name for savings calculation
- * @returns Estimated savings as a decimal (0.0-1.0)
- */
-export function estimateCacheSavings(result, provider) {
-    switch (provider) {
-        case "anthropic":
-            return result.cacheEfficiency * 0.9;
-        case "openai":
-            return result.cacheEfficiency * 0.5;
-        case "other":
-            return 0;
-    }
-}
-/**
- * Compute cache hit rate from token usage metrics.
- * Returns a percentage 0-100.
- */
-export function computeCacheHitRate(usage) {
-    const denominator = usage.cacheRead + usage.input;
-    if (denominator === 0)
-        return 0;
-    return (usage.cacheRead / denominator) * 100;
-}

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -1,156 +0,0 @@
-/**
- * GSD Prompt Loader
- *
- * Reads .md prompt templates from the prompts/ directory and substitutes
- * {{variable}} placeholders with provided values.
- *
- * Templates live at prompts/ relative to this module's directory.
- * They use {{variableName}} syntax for substitution.
- *
- * All templates are eagerly loaded into cache at module init via warmCache().
- * This prevents a running session from being invalidated when another `gsd`
- * launch overwrites ~/.gsd/agent/ with newer templates via initResources().
- * Without eager caching, the in-memory extension code (which knows variable
- * set A) can read a newer template from disk (which expects variable set B),
- * causing a "template declares {{X}} but no value was provided" crash
- * mid-session — especially for late-loading templates like complete-milestone
- * that aren't read until the end of a long auto-mode run.
- */
-import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
-/**
- * Resolve the GSD extension directory.
- *
- * `import.meta.url` resolves to whichever copy of this module is executing.
- * On Windows (npm global install via MSYS2 / Git Bash) this can resolve to
- * the npm-global `AppData/Roaming/npm/…` path, which does NOT contain the
- * prompts/ and templates/ subtrees that initResources() copies to
- * `~/.gsd/agent/extensions/gsd/`. Detect the mismatch and fall back to
- * the user-local agent directory.
- */
-function resolveExtensionDir() {
-    const moduleDir = dirname(fileURLToPath(import.meta.url));
-    if (existsSync(join(moduleDir, "prompts")))
-        return moduleDir;
-    // Fallback: user-local agent directory
-    const gsdHome = process.env.LSD_HOME || join(homedir(), ".lsd");
-    const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
-    if (existsSync(join(agentGsdDir, "prompts")))
-        return agentGsdDir;
-    // Last resort: return the module dir (warmCache will silently handle the miss)
-    return moduleDir;
-}
-const __extensionDir = resolveExtensionDir();
-const promptsDir = join(__extensionDir, "prompts");
-const templatesDir = join(__extensionDir, "templates");
-// Cache all templates eagerly at module load — a running session uses the
-// template versions that were on disk at startup, immune to later overwrites.
-const templateCache = new Map();
-/**
- * Eagerly read all .md files from prompts/ and templates/ into cache.
- * Called once at module init so that every template is snapshot before
- * a concurrent initResources() can overwrite files on disk.
- */
-function warmCache() {
-    try {
-        for (const file of readdirSync(promptsDir)) {
-            if (!file.endsWith(".md"))
-                continue;
-            const name = file.slice(0, -3);
-            if (!templateCache.has(name)) {
-                templateCache.set(name, readFileSync(join(promptsDir, file), "utf-8"));
-            }
-        }
-    }
-    catch {
-        // prompts/ may not exist in test environments — lazy loading still works.
-        // Emit a diagnostic when running outside tests so wrong-path bugs are visible.
-        if (!process.env.VITEST && !process.env.NODE_TEST) {
-            process.stderr.write(`[gsd:prompt-loader] warmCache: prompts dir not found: ${promptsDir}\n`);
-        }
-    }
-    try {
-        for (const file of readdirSync(templatesDir)) {
-            if (!file.endsWith(".md"))
-                continue;
-            const cacheKey = `tpl:${file.slice(0, -3)}`;
-            if (!templateCache.has(cacheKey)) {
-                templateCache.set(cacheKey, readFileSync(join(templatesDir, file), "utf-8"));
-            }
-        }
-    }
-    catch {
-        // templates/ may not exist in test environments — lazy loading still works.
-        if (!process.env.VITEST && !process.env.NODE_TEST) {
-            process.stderr.write(`[gsd:prompt-loader] warmCache: templates dir not found: ${templatesDir}\n`);
-        }
-    }
-}
-// Snapshot all templates at module load time
-warmCache();
-/**
- * Load a prompt template and substitute variables.
- *
- * @param name - Template filename without .md extension (e.g. "execute-task")
- * @param vars - Key-value pairs to substitute for {{key}} placeholders
- */
-export function loadPrompt(name, vars = {}) {
-    let content = templateCache.get(name);
-    if (content === undefined) {
-        const path = join(promptsDir, `${name}.md`);
-        content = readFileSync(path, "utf-8");
-        templateCache.set(name, content);
-    }
-    const effectiveVars = {
-        skillActivation: "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.",
-        ...vars,
-    };
-    // Check BEFORE substitution: find all {{varName}} placeholders the template
-    // declares and verify every one has a value in vars. Checking after substitution
-    // would also flag {{...}} patterns injected by inlined content (e.g. template
-    // files embedded in {{inlinedContext}}), producing false positives.
-    const declared = content.match(/\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/g);
-    if (declared) {
-        const missing = [...new Set(declared)]
-            .map(m => m.slice(2, -2))
-            .filter(key => !(key in effectiveVars));
-        if (missing.length > 0) {
-            throw new GSDError(GSD_PARSE_ERROR, `loadPrompt("${name}"): template declares {{${missing.join("}}, {{")}}}} but no value was provided. ` +
-                `This usually means the extension code in memory is older than the template on disk. ` +
-                `Restart pi to reload the extension.`);
-        }
-    }
-    for (const [key, value] of Object.entries(effectiveVars)) {
-        // Use split/join instead of replaceAll to avoid JavaScript's special
-        // replacement patterns ($', $`, $&) being interpreted in the value.
-        // See: https://github.com/gsd-build/gsd-2/issues/2968
-        content = content.split(`{{${key}}}`).join(value);
-    }
-    return content.trim();
-}
-/**
- * Load a raw template file from the templates/ directory.
- * Cached with a `tpl:` prefix to avoid collisions with prompt cache keys.
- */
-export function loadTemplate(name) {
-    const cacheKey = `tpl:${name}`;
-    let content = templateCache.get(cacheKey);
-    if (content === undefined) {
-        const path = join(templatesDir, `${name}.md`);
-        content = readFileSync(path, "utf-8");
-        templateCache.set(cacheKey, content);
-    }
-    return content.trim();
-}
-/**
- * Load a template and wrap it with a labeled footer for inlining into prompts.
- * The template body is emitted first so that any YAML frontmatter (---) remains
- * at the first non-whitespace line of the template content.
- */
-export function inlineTemplate(name, label) {
-    const content = loadTemplate(name);
-    return `${content}\n\n### Output Template: ${label}\nSource: \`templates/${name}.md\``;
-}

package/dist/resources/extensions/gsd/prompt-ordering.js

@@ -1,170 +0,0 @@
-/**
- * Prompt Ordering Optimizer — reorders assembled prompt sections
- * to maximize cache prefix stability.
- *
- * Identifies sections by markdown heading patterns and rearranges
- * them so stable content appears first. Anthropic caches the last
- * user message by prefix match, so placing static/semi-static
- * content before dynamic content improves cache hit rates.
- */
-/**
- * Known heading to role mappings for GSD prompts.
- * Static: templates, executor constraints, system instructions
- * Semi-static: slice plan, decisions, requirements, prior summaries, overrides
- * Dynamic: task plan, resume state, carry-forward, verification
- */
-const HEADING_ROLES = {
-    // Static — never changes per task
-    "Output Template": "static",
-    "Executor Context Constraints": "static",
-    "Working Directory": "static",
-    "Backing Source Artifacts": "static",
-    // Semi-static — changes per slice but not per task
-    "Slice Plan Excerpt": "semi-static",
-    "Decisions": "semi-static",
-    "Requirements": "semi-static",
-    "Prior Task Summaries": "semi-static",
-    "Overrides": "semi-static",
-    "Project Knowledge": "semi-static",
-    "Dependency Summaries": "semi-static",
-    // Dynamic — changes per task
-    "Inlined Task Plan": "dynamic",
-    "Resume State": "dynamic",
-    "Carry-Forward Context": "dynamic",
-    "Verification": "dynamic",
-    "Verification Evidence": "dynamic",
-};
-/**
- * Extract the heading text from a line like "## Some Heading" or "## UNIT: Execute Task ...".
- * Returns the full text after "## " for role lookup.
- */
-function extractHeadingText(line) {
-    return line.replace(/^##\s+/, "").trim();
-}
-/**
- * Classify a heading by matching against known roles.
- * Uses substring matching so headings like "## UNIT: Execute Task T1.1" don't match
- * but "## Inlined Task Plan" does. Unknown headings default to "dynamic".
- */
-function classifyHeading(heading) {
-    for (const [key, role] of Object.entries(HEADING_ROLES)) {
-        if (heading === key || heading.startsWith(key)) {
-            return role;
-        }
-    }
-    return "dynamic";
-}
-/**
- * Split a prompt into sections at ## heading boundaries.
- * Sub-headings (### and deeper) stay with their parent ## section.
- * Returns a preamble (content before first ##) and an array of sections.
- */
-function splitSections(prompt) {
-    const lines = prompt.split("\n");
-    let preamble = "";
-    const sections = [];
-    let currentHeading = "";
-    let currentContent = [];
-    for (const line of lines) {
-        // Match ## headings but NOT ### or deeper
-        if (/^## (?!#)/.test(line)) {
-            // Flush previous section
-            if (currentHeading) {
-                sections.push({
-                    heading: currentHeading,
-                    content: currentContent.join("\n"),
-                    role: classifyHeading(currentHeading),
-                });
-            }
-            else if (currentContent.length > 0) {
-                preamble = currentContent.join("\n");
-            }
-            currentHeading = extractHeadingText(line);
-            currentContent = [line];
-        }
-        else {
-            currentContent.push(line);
-        }
-    }
-    // Flush last section
-    if (currentHeading) {
-        sections.push({
-            heading: currentHeading,
-            content: currentContent.join("\n"),
-            role: classifyHeading(currentHeading),
-        });
-    }
-    else if (currentContent.length > 0) {
-        preamble = currentContent.join("\n");
-    }
-    return { preamble, sections };
-}
-const ROLE_ORDER = {
-    "static": 0,
-    "semi-static": 1,
-    "dynamic": 2,
-};
-/**
- * Reorder a prompt's sections for cache efficiency.
- * Extracts sections by ## heading markers, classifies them,
- * and reorders: static -> semi-static -> dynamic.
- *
- * Content before the first ## heading is treated as a preamble
- * and always placed first (it's usually static instructions).
- *
- * @param prompt The assembled prompt string
- * @returns Reordered prompt string
- */
-export function reorderForCaching(prompt) {
-    const { preamble, sections } = splitSections(prompt);
-    // Nothing to reorder
-    if (sections.length <= 1) {
-        return prompt;
-    }
-    // Stable sort: sections with the same role keep their original relative order
-    const sorted = [...sections].sort((a, b) => {
-        return ROLE_ORDER[a.role] - ROLE_ORDER[b.role];
-    });
-    const parts = [];
-    if (preamble) {
-        parts.push(preamble);
-    }
-    for (const section of sorted) {
-        parts.push(section.content);
-    }
-    return parts.join("\n");
-}
-/**
- * Analyze a prompt's cache efficiency without reordering.
- * Returns stats about how much of the prompt is cacheable.
- */
-export function analyzeCacheEfficiency(prompt) {
-    const { preamble, sections } = splitSections(prompt);
-    let staticChars = preamble.length;
-    let semiStaticChars = 0;
-    let dynamicChars = 0;
-    for (const section of sections) {
-        switch (section.role) {
-            case "static":
-                staticChars += section.content.length;
-                break;
-            case "semi-static":
-                semiStaticChars += section.content.length;
-                break;
-            case "dynamic":
-                dynamicChars += section.content.length;
-                break;
-        }
-    }
-    const totalChars = staticChars + semiStaticChars + dynamicChars;
-    const cacheEfficiency = totalChars > 0
-        ? (staticChars + semiStaticChars) / totalChars
-        : 0;
-    return {
-        totalChars,
-        staticChars,
-        semiStaticChars,
-        dynamicChars,
-        cacheEfficiency,
-    };
-}

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -1,66 +0,0 @@
-You are executing GSD auto-mode.
-
-## UNIT: Complete Milestone {{milestoneId}} ("{{milestoneTitle}}")
-
-## Working Directory
-
-Your working directory is `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
-
-## Your Role in the Pipeline
-
-All slices are done. You are closing out the milestone — verifying that the assembled work actually delivers the promised outcome, writing the milestone summary, and updating project state. The milestone summary is the final record. After you finish, the system merges the worktree back to the integration branch. If there are queued milestones, the next one starts its own research → plan → execute cycle from a clean slate — the milestone summary is how it learns what was already built.
-
-All relevant context has been preloaded below — the roadmap, all slice summaries, requirements, decisions, and project context are inlined. Start working immediately without re-reading these files.
-
-{{inlinedContext}}
-
-Then:
-1. Use the **Milestone Summary** output template from the inlined context above
-2. {{skillActivation}}
-3. **Verify code changes exist.** Run `git diff --stat HEAD $(git merge-base HEAD main) -- ':!.gsd/'` (or the equivalent for the integration branch). If no non-`.gsd/` files appear in the diff, the milestone produced only planning artifacts and no actual code. Record this as a **verification failure**.
-4. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. Record any criterion that was NOT met as a **verification failure**.
-5. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly. Record any unmet items as a **verification failure**.
-6. If the roadmap includes a **Horizontal Checklist**, verify each item was addressed during the milestone. Note unchecked items in the milestone summary.
-7. Fill the **Decision Re-evaluation** table in the milestone summary. For each key decision from `.gsd/DECISIONS.md` made during this milestone, evaluate whether it is still valid given what was actually built. Flag decisions that should be revisited next milestone.
-8. Validate **requirement status transitions**. For each requirement that changed status during this milestone, confirm the transition is supported by evidence. Requirements can move between Active, Validated, Deferred, Blocked, or Out of Scope — but only with proof.
-
-### Verification Gate — STOP if verification failed
-
-**If ANY verification failure was recorded in steps 3, 4, or 5, you MUST follow the failure path below. Do NOT proceed to step 9.**
-
-**Failure path** (verification failed):
-- Do NOT call `gsd_complete_milestone` — the milestone must not be marked as complete.
-- Do NOT update `.gsd/PROJECT.md` to reflect completion.
-- Do NOT update `.gsd/REQUIREMENTS.md` to mark requirements as validated.
-- Write a clear summary of what failed and why to help the next attempt.
-- Say: "Milestone {{milestoneId}} verification FAILED — not complete." and stop.
-
-**Success path** (all verifications passed — continue with steps 9–13):
-
-9. **Persist completion through `gsd_complete_milestone`.** Call it with the parameters below. The tool updates the milestone status in the DB, renders `{{milestoneSummaryPath}}`, and validates all slices are complete before proceeding.
-
-   **Required parameters:**
-   - `milestoneId` (string) — Milestone ID (e.g. M001)
-   - `title` (string) — Milestone title
-   - `oneLiner` (string) — One-sentence summary of what the milestone achieved
-   - `narrative` (string) — Detailed narrative of what happened during the milestone
-   - `successCriteriaResults` (string) — Markdown detailing how each success criterion was met or not met
-   - `definitionOfDoneResults` (string) — Markdown detailing how each definition-of-done item was met
-   - `requirementOutcomes` (string) — Markdown detailing requirement status transitions with evidence
-   - `keyDecisions` (array of strings) — Key architectural/pattern decisions made during the milestone
-   - `keyFiles` (array of strings) — Key files created or modified during the milestone
-   - `lessonsLearned` (array of strings) — Lessons learned during the milestone
-   - `verificationPassed` (boolean) — Must be `true` — confirms that code change verification, success criteria, and definition of done checks all passed before completion
-
-   **Optional parameters:**
-   - `followUps` (string) — Follow-up items for future milestones
-   - `deviations` (string) — Deviations from the original plan
-10. For each requirement whose status changed in step 8, call `gsd_requirement_update` with the requirement ID and updated `status` and `validation` fields — the tool regenerates `.gsd/REQUIREMENTS.md` automatically.
-11. Update `.gsd/PROJECT.md`: use the `write` tool with `path: ".gsd/PROJECT.md"` and `content` containing the full updated document reflecting milestone completion and current project state. Do NOT use the `edit` tool for this — PROJECT.md is a full-document refresh.
-12. Review all slice summaries for cross-cutting lessons, patterns, or gotchas that emerged during this milestone. Append any non-obvious, reusable insights to `.gsd/KNOWLEDGE.md`.
-13. Do not commit manually — the system auto-commits your changes after this unit completes.
-- Say: "Milestone {{milestoneId}} complete."
-
-**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run.
-
-**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.

package/dist/resources/extensions/gsd/prompts/complete-slice.md

@@ -1,40 +0,0 @@
-You are executing GSD auto-mode.
-
-## UNIT: Complete Slice {{sliceId}} ("{{sliceTitle}}") — Milestone {{milestoneId}}
-
-## Working Directory
-
-Your working directory is `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
-
-## Your Role in the Pipeline
-
-Executor agents built each task and wrote task summaries. You are the closer — verify the assembled work actually delivers the slice goal, then compress everything into a slice summary. After you finish, a **reassess-roadmap agent** reads your slice summary to decide if the remaining roadmap still makes sense. The slice summary is also the primary record of what this slice achieved — future slice researchers and planners read it as a dependency summary when their work builds on yours.
-
-Write the summary for those downstream readers. What did this slice actually deliver? What patterns did it establish? What should the next slice know?
-
-All relevant context has been preloaded below — the slice plan, all task summaries, and the milestone roadmap are inlined. Start working immediately without re-reading these files.
-
-{{inlinedContext}}
-
-**Match effort to complexity.** A simple slice with 1-2 tasks needs a brief summary and lightweight verification. A complex slice with 5 tasks across multiple subsystems needs thorough verification and a detailed summary. Scale the work below accordingly.
-
-Then:
-1. Use the **Slice Summary** and **UAT** output templates from the inlined context above
-2. {{skillActivation}}
-3. Run all slice-level verification checks defined in the slice plan. All must pass before marking the slice done. If any fail, fix them first.
-4. If the slice plan includes observability/diagnostic surfaces, confirm they work. Skip this for simple slices that don't have observability sections.
-5. If the slice involved runtime behavior, fill the **Operational Readiness** section (Q8) in the slice summary: health signal, failure signal, recovery procedure, and monitoring gaps. Omit entirely for simple slices with no runtime concerns.
-6. If this slice produced evidence that a requirement changed status (Active → Validated, Active → Deferred, etc.), call `gsd_save_decision` with scope="requirement", decision="{requirement-id}", choice="{new-status}", rationale="{evidence}". Do NOT write `.gsd/REQUIREMENTS.md` directly — the engine renders it from the database.
-7. Write `{{sliceSummaryPath}}` (compress all task summaries).
-8. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
-9. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
-10. Review task summaries for patterns, gotchas, or non-obvious lessons learned. If any would save future agents from repeating investigation or hitting the same issues, append them to `.gsd/KNOWLEDGE.md`. Only add entries that are genuinely useful — don't pad with obvious observations.
-11. Call `gsd_complete_slice` with milestoneId, sliceId, the slice summary, and the UAT result. Do NOT manually mark the roadmap checkbox — the tool writes to the DB and renders the ROADMAP.md projection automatically.
-12. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
-13. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed: use the `write` tool with `path: ".gsd/PROJECT.md"` and `content` containing the full updated document reflecting current project state. Do NOT use the `edit` tool for this — PROJECT.md is a full-document refresh.
-
-**Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. You are running in auto-mode — there is no human available to answer questions. Make reasonable assumptions and document them in the slice summary. If a decision genuinely requires human input, note it in the summary and proceed with the best available option.
-
-**You MUST call `gsd_complete_slice` with the slice summary and UAT content before finishing. The tool persists to both DB and disk and renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}` automatically.**
-
-When done, say: "Slice {{sliceId}} complete."