lsd-pi 1.0.0 → 1.1.0

package/dist/resources/extensions/gsd/dev-execution-policy.js

@@ -1,24 +0,0 @@
-/**
- * dev-execution-policy.ts — DevExecutionPolicy implementation.
- *
- * Stub policy for the dev engine. All methods return safe defaults.
- * Real verification/closeout continues running through phases.ts via LoopDeps.
- * Wiring this policy into the loop is S04's responsibility.
- */
-export class DevExecutionPolicy {
-    async prepareWorkspace(_basePath, _milestoneId) {
-        // no-op — workspace preparation handled by existing GSD logic
-    }
-    async selectModel(_unitType, _unitId, _context) {
-        return null; // use default model selection
-    }
-    async verify(_unitType, _unitId, _context) {
-        return "continue";
-    }
-    async recover(_unitType, _unitId, _context) {
-        return { outcome: "retry" };
-    }
-    async closeout(_unitType, _unitId, _context) {
-        return { committed: false, artifacts: [] };
-    }
-}

package/dist/resources/extensions/gsd/dev-workflow-engine.js

@@ -1,82 +0,0 @@
-/**
- * dev-workflow-engine.ts — DevWorkflowEngine implementation.
- *
- * Implements WorkflowEngine by delegating to existing GSD state derivation
- * and dispatch logic. This is the "dev" engine — it wraps the current GSD
- * auto-mode behavior behind the engine-polymorphic interface.
- */
-import { deriveState } from "./state.js";
-import { resolveDispatch } from "./auto-dispatch.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-// ─── Bridge: DispatchAction → EngineDispatchAction ────────────────────────
-/**
- * Map a GSD-specific DispatchAction (which carries `matchedRule`, `unitType`,
- * etc.) to the engine-generic EngineDispatchAction discriminated union.
- *
- * Exported for unit testing.
- */
-export function bridgeDispatchAction(da) {
-    switch (da.action) {
-        case "dispatch":
-            return {
-                action: "dispatch",
-                step: {
-                    unitType: da.unitType,
-                    unitId: da.unitId,
-                    prompt: da.prompt,
-                },
-            };
-        case "stop":
-            return {
-                action: "stop",
-                reason: da.reason,
-                level: da.level,
-            };
-        case "skip":
-            return { action: "skip" };
-    }
-}
-// ─── DevWorkflowEngine ───────────────────────────────────────────────────
-export class DevWorkflowEngine {
-    engineId = "dev";
-    async deriveState(basePath) {
-        const gsd = await deriveState(basePath);
-        return {
-            phase: gsd.phase,
-            currentMilestoneId: gsd.activeMilestone?.id ?? null,
-            activeSliceId: gsd.activeSlice?.id ?? null,
-            activeTaskId: gsd.activeTask?.id ?? null,
-            isComplete: gsd.phase === "complete",
-            raw: gsd,
-        };
-    }
-    async resolveDispatch(state, context) {
-        const gsd = state.raw;
-        const mid = gsd.activeMilestone?.id ?? "";
-        const midTitle = gsd.activeMilestone?.title ?? "";
-        const loaded = loadEffectiveGSDPreferences();
-        const prefs = loaded?.preferences ?? undefined;
-        const dispatchCtx = {
-            basePath: context.basePath,
-            mid,
-            midTitle,
-            state: gsd,
-            prefs,
-        };
-        const result = await resolveDispatch(dispatchCtx);
-        return bridgeDispatchAction(result);
-    }
-    async reconcile(state, _completedStep) {
-        return {
-            outcome: state.isComplete ? "milestone-complete" : "continue",
-        };
-    }
-    getDisplayMetadata(state) {
-        return {
-            engineLabel: "GSD Dev",
-            currentPhase: state.phase,
-            progressSummary: `${state.currentMilestoneId ?? "no milestone"} / ${state.activeSliceId ?? "—"} / ${state.activeTaskId ?? "—"}`,
-            stepCount: null,
-        };
-    }
-}

package/dist/resources/extensions/gsd/diff-context.js

@@ -1,168 +0,0 @@
-/**
- * Diff-aware context module — prioritizes recently-changed files when building
- * context for the AI agent. Uses git diff/status to discover changes, then
- * provides ranking utilities for context-window budget allocation.
- *
- * Standalone module: only imports node:child_process and node:path.
- */
-import { execFileSync, execFile } from "node:child_process";
-import { resolve } from "node:path";
-import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
-// ─── Helpers ────────────────────────────────────────────────────────────────
-const EXEC_OPTS = {
-    encoding: "utf-8",
-    timeout: 5000,
-    stdio: ["pipe", "pipe", "pipe"],
-};
-/** Synchronous git — used where sequential control flow is required (fallback paths). */
-function gitSync(args, cwd) {
-    return execFileSync("git", args, { ...EXEC_OPTS, cwd }).trim();
-}
-/** Async git — returns stdout on success, empty string on any error. */
-function gitAsync(args, cwd) {
-    return new Promise((resolve) => {
-        execFile("git", args, { encoding: "utf-8", timeout: 5000, cwd }, (err, stdout) => resolve(err ? "" : stdout.trim()));
-    });
-}
-function splitLines(output) {
-    return output
-        .split("\n")
-        .map((l) => l.trim())
-        .filter(Boolean);
-}
-// ─── Public API ─────────────────────────────────────────────────────────────
-/**
- * Returns recently-changed file paths, deduplicated and sorted by recency
- * (most recent first). Combines committed diffs, staged changes, and
- * unstaged/untracked files from `git status`.
- *
- * The three git queries (log, diff --cached, status) run concurrently.
- */
-export async function getRecentlyChangedFiles(cwd, options) {
-    const maxFiles = options?.maxFiles ?? 20;
-    const sinceDays = options?.sinceDays ?? 7;
-    const dir = resolve(cwd);
-    try {
-        const days = Math.max(1, Math.floor(Number(sinceDays)));
-        if (!Number.isFinite(days))
-            throw new GSDError(GSD_PARSE_ERROR, "invalid sinceDays");
-        // Run all three queries concurrently — they read independent git state
-        const [logRaw, stagedRaw, statusRaw] = await Promise.all([
-            // 1. Committed changes since N days ago (fallback to HEAD~10 on error)
-            gitAsync(["log", "--diff-filter=ACMR", "--name-only", "--pretty=format:", `--since=${days} days ago`], dir)
-                .then((out) => out || gitAsync(["diff", "--name-only", "HEAD~10"], dir)),
-            // 2. Staged changes
-            gitAsync(["diff", "--cached", "--name-only"], dir),
-            // 3. Unstaged / untracked
-            gitAsync(["status", "--porcelain"], dir),
-        ]);
-        const committedFiles = splitLines(logRaw);
-        const stagedFiles = splitLines(stagedRaw);
-        const statusFiles = splitLines(statusRaw).map((line) => line.slice(3)); // strip XY + space
-        // Deduplicate, preserving insertion order (most-recent-first: status → staged → committed)
-        const seen = new Set();
-        const result = [];
-        for (const file of [...statusFiles, ...stagedFiles, ...committedFiles]) {
-            if (!seen.has(file)) {
-                seen.add(file);
-                result.push(file);
-            }
-        }
-        return result.slice(0, maxFiles);
-    }
-    catch {
-        // Non-git directory or git unavailable — graceful fallback
-        return [];
-    }
-}
-/**
- * Returns richer change metadata: change type and approximate line counts.
- *
- * The three git queries (diff --cached --numstat, diff --numstat, status --porcelain)
- * run concurrently — they read independent git state.
- */
-export async function getChangedFilesWithContext(cwd) {
-    const dir = resolve(cwd);
-    try {
-        // Run all three queries concurrently
-        const [cachedNumstat, unstagedNumstat, statusRaw] = await Promise.all([
-            gitAsync(["diff", "--cached", "--numstat"], dir),
-            gitAsync(["diff", "--numstat"], dir),
-            gitAsync(["status", "--porcelain"], dir),
-        ]);
-        const result = [];
-        const seen = new Set();
-        const add = (info) => {
-            if (!seen.has(info.path)) {
-                seen.add(info.path);
-                result.push(info);
-            }
-        };
-        // 1. Staged files with numstat
-        for (const line of splitLines(cachedNumstat)) {
-            const [added, deleted, filePath] = line.split("\t");
-            if (!filePath)
-                continue;
-            const lines = added === "-" || deleted === "-"
-                ? undefined
-                : Number(added) + Number(deleted);
-            add({ path: filePath, changeType: "staged", linesChanged: lines });
-        }
-        // 2. Unstaged modifications with numstat
-        for (const line of splitLines(unstagedNumstat)) {
-            const [added, deleted, filePath] = line.split("\t");
-            if (!filePath)
-                continue;
-            const lines = added === "-" || deleted === "-"
-                ? undefined
-                : Number(added) + Number(deleted);
-            add({ path: filePath, changeType: "modified", linesChanged: lines });
-        }
-        // 3. Untracked / deleted from porcelain status
-        for (const line of splitLines(statusRaw)) {
-            const code = line.slice(0, 2);
-            const filePath = line.slice(3);
-            if (seen.has(filePath))
-                continue;
-            if (code.includes("?")) {
-                add({ path: filePath, changeType: "added" });
-            }
-            else if (code.includes("D")) {
-                add({ path: filePath, changeType: "deleted" });
-            }
-            else if (code.includes("A")) {
-                add({ path: filePath, changeType: "added" });
-            }
-            else {
-                add({ path: filePath, changeType: "modified" });
-            }
-        }
-        return result;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Ranks a file list so that recently-changed files appear first.
- * Files present in `changedFiles` are placed at the front (in their
- * original changedFiles order), followed by unchanged files in their
- * original order.
- */
-export function rankFilesByRelevance(files, changedFiles) {
-    const changedSet = new Set(changedFiles);
-    const changed = [];
-    const rest = [];
-    for (const f of files) {
-        if (changedSet.has(f)) {
-            changed.push(f);
-        }
-        else {
-            rest.push(f);
-        }
-    }
-    // Maintain changedFiles priority order within the changed group
-    const changedOrder = new Map(changedFiles.map((f, i) => [f, i]));
-    changed.sort((a, b) => (changedOrder.get(a) ?? 0) - (changedOrder.get(b) ?? 0));
-    return [...changed, ...rest];
-}

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -1,114 +0,0 @@
-// GSD Dispatch Guard — prevents out-of-order slice dispatch
-import { resolveMilestoneFile } from "./paths.js";
-import { findMilestoneIds } from "./guided-flow.js";
-import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
-import { parseRoadmap } from "./parsers-legacy.js";
-import { readFileSync } from "node:fs";
-const SLICE_DISPATCH_TYPES = new Set([
-    "research-slice",
-    "plan-slice",
-    "replan-slice",
-    "execute-task",
-    "complete-slice",
-]);
-export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unitId) {
-    if (!SLICE_DISPATCH_TYPES.has(unitType))
-        return null;
-    const { milestone: targetMid, slice: targetSid } = parseUnitId(unitId);
-    if (!targetMid || !targetSid)
-        return null;
-    // Parallel worker isolation: when GSD_MILESTONE_LOCK is set, this worker
-    // is scoped to a single milestone. Skip the cross-milestone dependency
-    // check — other milestones are being handled by their own workers.
-    // Without this, the dispatch guard sees incomplete slices in M010/M011
-    // (cloned into the worktree DB) and blocks M012 from ever starting. #2797
-    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
-    // Use findMilestoneIds to respect custom queue order.
-    // Only check milestones that come BEFORE the target in queue order.
-    // When locked to a specific milestone, only check that milestone's
-    // intra-slice dependencies — skip all cross-milestone checks.
-    const allIds = milestoneLock && targetMid === milestoneLock
-        ? [targetMid]
-        : findMilestoneIds(base);
-    const targetIdx = allIds.indexOf(targetMid);
-    if (targetIdx < 0)
-        return null;
-    const milestoneIds = allIds.slice(0, targetIdx + 1);
-    for (const mid of milestoneIds) {
-        if (resolveMilestoneFile(base, mid, "PARKED"))
-            continue;
-        if (resolveMilestoneFile(base, mid, "SUMMARY"))
-            continue;
-        let slices = null;
-        if (isDbAvailable()) {
-            const rows = getMilestoneSlices(mid);
-            if (rows.length > 0) {
-                slices = rows.map((r) => ({
-                    id: r.id,
-                    done: r.status === "complete",
-                    depends: r.depends ?? [],
-                }));
-            }
-        }
-        if (!slices) {
-            // File-based fallback: parse roadmap checkboxes
-            const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-            if (!roadmapPath)
-                continue;
-            let roadmapContent;
-            try {
-                roadmapContent = readFileSync(roadmapPath, "utf-8");
-            }
-            catch {
-                continue;
-            }
-            const parsed = parseRoadmap(roadmapContent);
-            if (parsed.slices.length === 0)
-                continue;
-            slices = parsed.slices.map((s) => ({
-                id: s.id,
-                done: s.done,
-                depends: s.depends ?? [],
-            }));
-        }
-        if (mid !== targetMid) {
-            const incomplete = slices.find((slice) => !slice.done);
-            if (incomplete) {
-                return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${mid}/${incomplete.id} is not complete.`;
-            }
-            continue;
-        }
-        const targetSlice = slices.find((slice) => slice.id === targetSid);
-        if (!targetSlice)
-            return null;
-        // Dependency-aware ordering: if the target slice declares dependencies,
-        // only require those specific slices to be complete — not all positionally
-        // earlier slices.  This prevents deadlocks when a positionally-earlier
-        // slice depends on a positionally-later one (e.g. S05 depends_on S06).
-        //
-        // When the target has NO declared dependencies, fall back to the original
-        // positional ordering for backward compatibility.
-        if (targetSlice.depends.length > 0) {
-            const sliceMap = new Map(slices.map((s) => [s.id, s]));
-            for (const depId of targetSlice.depends) {
-                const dep = sliceMap.get(depId);
-                if (dep && !dep.done) {
-                    return `Cannot dispatch ${unitType} ${unitId}: dependency slice ${targetMid}/${depId} is not complete.`;
-                }
-                // If dep is not found in this milestone's slices, ignore it —
-                // it may be a cross-milestone reference handled elsewhere.
-            }
-        }
-        else {
-            const targetIndex = slices.findIndex((slice) => slice.id === targetSid);
-            const incomplete = slices
-                .slice(0, targetIndex)
-                .find((slice) => !slice.done);
-            if (incomplete) {
-                return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${targetMid}/${incomplete.id} is not complete.`;
-            }
-        }
-    }
-    return null;
-}

package/dist/resources/extensions/gsd/docs/claude-marketplace-import.md

@@ -1,214 +0,0 @@
-# Claude Marketplace Import
-
-This document describes the Claude marketplace import feature in GSD: what it reads, what it imports, what it persists, and what it does not translate into active GSD/Pi runtime behavior.
-
----
-
-## What this feature does
-
-GSD can read Claude Code marketplace catalogs, inspect the plugins they reference, and import selected Claude skills into GSD/Pi while preserving Claude-style namespace identity.
-
-The interactive entry point is:
-
-```text
-/gsd prefs import-claude
-```
-
-You can also choose scope explicitly:
-
-```text
-/gsd prefs import-claude global
-/gsd prefs import-claude project
-```
-
----
-
-## Claude Code model this feature follows
-
-Anthropic documents Claude marketplaces as sources users add with:
-
-```text
-/plugin marketplace add <github repo or local path>
-```
-
-A marketplace contains a catalog at:
-
-```text
-.claude-plugin/marketplace.json
-```
-
-Anthropic distinguishes between:
-
-- **Marketplace source** — where Claude fetches `marketplace.json`
-- **Plugin source** — where Claude fetches each plugin listed in that marketplace
-- **Installed plugin cache** — Claude copies installed plugin payloads into:
-
-```text
-~/.claude/plugins/cache
-```
-
-Anthropic also documents user-added marketplace sources under:
-
-```text
-~/.claude/plugins/marketplaces
-```
-
-GSD aligns its Claude import flow to that model.
-
----
-
-## Where GSD looks
-
-For Claude plugin and marketplace material, GSD prefers Claude-managed locations first:
-
-1. `~/.claude/plugins/marketplaces`
-2. `~/.claude/plugins/cache`
-3. `~/.claude/plugins`
-
-After that, GSD still allows local clone-style convenience paths such as sibling repos or `~/repos/...` paths. Those fallbacks remain supported for developer workflows, but they are not the primary Claude storage model.
-
----
-
-## What GSD imports
-
-### Imported into GSD/Pi settings
-
-- Claude skills discovered directly from configured skill roots
-- Marketplace-derived skills
-
-Imported marketplace skills preserve canonical namespace identity, for example:
-
-```text
-python3-development:stinkysnake
-scientific-method:experiment-protocol
-```
-
-### Discovered, modeled, and validated
-
-- Marketplace-derived agents
-
-### Discovered but not translated into active Pi-native runtime behavior
-
-- hooks
-- MCP server definitions
-- LSP server definitions
-- other plugin metadata that does not currently map directly into active GSD/Pi runtime surfaces
-
----
-
-## Import flow
-
-The import flow does the following:
-
-1. discover Claude skills and marketplace/plugin roots
-2. identify marketplace roots by checking for `.claude-plugin/marketplace.json`
-3. inspect discovered plugins and inventory their components
-4. let you select components to import
-5. validate the selection for canonical conflicts and ambiguity
-6. persist imported resources into GSD/Pi settings
-
----
-
-## Namespace behavior
-
-GSD preserves Claude plugin namespace semantics rather than flattening plugin components into anonymous global names.
-
-### Canonical references
-
-Canonical references remain available for imported components:
-
-- skills: `plugin-name:skill-name`
-- agents: `plugin-name:agent-name`
-
-### Shorthand
-
-GSD supports shorthand lookup when it is unambiguous.
-
-### Local-first resolution
-
-When a namespaced component refers to another component by bare name, GSD tries the same plugin namespace first before broader lookup.
-
----
-
-## Important safeguard: marketplace agent directories are not stored as package sources
-
-Claude plugin agent directories are markdown agent-definition directories, for example:
-
-```text
-.../plugins/python3-development/agents
-```
-
-GSD does **not** persist imported marketplace agent directories into:
-
-```json
-settings.packages
-```
-
-This is intentional.
-
-### Why
-
-Persisting an `.../agents` directory into `settings.packages` can cause Pi startup to treat that directory as an extension/package root. In real host validation, that produced extension loader failures such as:
-
-```text
-Cannot find module '.../agents'
-```
-
-GSD now avoids writing those entries.
-
----
-
-## Settings effects
-
-### Skills
-
-Imported skills are persisted into Pi skill settings. Depending on the selection path, they may also be added to GSD preferences.
-
-### Marketplace agents
-
-Marketplace agents remain part of the import model and validation surface, but their `agents/` directories are not persisted as package roots.
-
----
-
-## Diagnostics
-
-GSD distinguishes between:
-
-- **canonical conflicts** — hard errors
-- **shorthand overlaps** — warnings when canonical names remain distinct
-- **alias conflicts** — diagnostics for alias collisions or shadowing
-
-This allows imported marketplace content to be validated without reporting valid overlap as fatal breakage.
-
----
-
-## Verification status of this feature
-
-This feature has been verified in three ways:
-
-1. **Contract/unit tests** for parsing, namespacing, resolution, diagnostics, and import behavior
-2. **Portable integration-style tests** using local or cloned marketplace fixtures
-3. **Real host validation** against the installed `gsd` binary and actual Claude-managed directories on the host machine
-
-Real host validation included:
-
-- clean startup of the installed `gsd` binary after fixing stale bad settings
-- successful invocation of an imported skill (`/stinkysnake`)
-- successful execution of `/gsd prefs import-claude global`
-- verification that imported marketplace agent directories were **not** reintroduced into `settings.packages`
-
----
-
-## Current limitations
-
-- GSD does not yet translate every Claude plugin component type into active Pi-native runtime behavior
-- marketplace-derived agents are not persisted as package roots, by design
-- clone-style local fallbacks still exist for developer convenience, even though Claude-managed marketplace/plugin locations are preferred first
-
----
-
-## References
-
-- Anthropic: Claude Code settings
-- Anthropic: Create and distribute a plugin marketplace
-- Anthropic: Plugins and plugin reference