thevoidforge 21.0.5 → 21.0.6

package/dist/wizard/api/blueprint.d.ts

@@ -32,14 +32,3 @@ export declare function executeBlueprintMerge(projectRoot: string, directivesPat
     merged: boolean;
     reason: string;
 }>;
-/**
- * Handle blueprint API requests. Mount at /api/blueprint/*
- *
- * GET  /api/blueprint/detect?dir=<path>  — Check if PRD exists
- * GET  /api/blueprint/validate?dir=<path> — Full validation
- * POST /api/blueprint/merge — Execute CLAUDE.md merge
- */
-export declare function handleBlueprintRequest(method: string, path: string, body: unknown): Promise<{
-    status: number;
-    body: unknown;
-} | null>;

package/dist/wizard/api/blueprint.js

@@ -109,38 +109,15 @@ export async function executeBlueprintMerge(projectRoot, directivesPath) {
  * GET  /api/blueprint/validate?dir=<path> — Full validation
  * POST /api/blueprint/merge — Execute CLAUDE.md merge
  */
-export async function handleBlueprintRequest(method, path, body) {
-    if (method === 'GET' && path === '/api/blueprint/detect') {
-        // Quick check: does docs/PRD.md exist in the current project?
-        const projectRoot = process.cwd();
-        const prdPath = join(projectRoot, 'docs/PRD.md');
-        const exists = existsSync(prdPath);
-        if (exists) {
-            const content = await readFile(prdPath, 'utf-8');
-            const { frontmatter } = parseFrontmatter(content);
-            return {
-                status: 200,
-                body: {
-                    detected: true,
-                    name: frontmatter.name ?? 'Unnamed',
-                    description: frontmatter.type ?? 'Unknown type',
-                },
-            };
-        }
-        return { status: 200, body: { detected: false } };
-    }
-    if (method === 'GET' && path === '/api/blueprint/validate') {
-        const projectRoot = process.cwd();
-        const result = await validateBlueprint(projectRoot);
-        return { status: 200, body: result };
-    }
-    if (method === 'POST' && path === '/api/blueprint/merge') {
-        const projectRoot = process.cwd();
-        const params = body;
-        const result = await executeBlueprintMerge(projectRoot, params?.directivesPath ?? null);
-        return { status: 200, body: result };
-    }
-    return null; // Not a blueprint route
+// Resolve project root from request query param, falling back to marker discovery.
+// The wizard is standalone (v21.0) — CWD is NOT a project directory.
+import { findProjectRoot } from '../lib/marker.js';
+function resolveProjectRoot(req) {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    const dirParam = url.searchParams.get('dir');
+    if (dirParam && dirParam !== 'undefined')
+        return dirParam;
+    return findProjectRoot() ?? process.cwd();
 }
 // ── JSON Response Helper ────────────────────────────
 function sendJson(res, status, data) {
@@ -149,9 +126,7 @@ function sendJson(res, status, data) {
 }
 // ── Route Registration ──────────────────────────────
 addRoute('GET', '/api/blueprint/detect', async (req, res) => {
-    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
-    const dirParam = url.searchParams.get('dir');
-    const projectRoot = dirParam && dirParam !== 'undefined' ? dirParam : process.cwd();
+    const projectRoot = resolveProjectRoot(req);
     const prdPath = join(projectRoot, 'docs/PRD.md');
     if (existsSync(prdPath)) {
         const content = await readFile(prdPath, 'utf-8');
@@ -166,8 +141,8 @@ addRoute('GET', '/api/blueprint/detect', async (req, res) => {
         sendJson(res, 200, { detected: false });
     }
 });
-addRoute('GET', '/api/blueprint/validate', async (_req, res) => {
-    const projectRoot = process.cwd();
+addRoute('GET', '/api/blueprint/validate', async (req, res) => {
+    const projectRoot = resolveProjectRoot(req);
     const result = await validateBlueprint(projectRoot);
     sendJson(res, 200, result);
 });
@@ -180,7 +155,7 @@ addRoute('POST', '/api/blueprint/merge', async (req, res) => {
         params = JSON.parse(body);
     }
     catch { /* empty body is fine — directivesPath defaults to null */ }
-    const projectRoot = process.cwd();
+    const projectRoot = resolveProjectRoot(req);
     const result = await executeBlueprintMerge(projectRoot, params.directivesPath ?? null);
     sendJson(res, 200, result);
 });

package/dist/wizard/api/project.js

@@ -41,8 +41,9 @@ addRoute('POST', '/api/project/validate', async (req, res) => {
             // Directory doesn't exist — that's fine
         }
     }
+    const homeDir = process.env['HOME'] ?? process.env['USERPROFILE'] ?? '/tmp';
     const suggestedDir = body.name
-        ? resolve(process.cwd(), '..', sanitizeDirName(body.name))
+        ? resolve(homeDir, 'Projects', sanitizeDirName(body.name))
         : undefined;
     sendJson(res, 200, { valid: errors.length === 0, errors, suggestedDir });
 });

package/dist/wizard/lib/autonomy-controller.d.ts

@@ -33,7 +33,7 @@ interface AutonomyState {
         endHour: number;
     }>;
 }
-declare const AUTONOMY_STATE_PATH: string;
+declare function getAutonomyStatePath(): string;
 declare const DEFAULT_STATE: AutonomyState;
 export declare function loadAutonomyState(): Promise<AutonomyState>;
 export declare function saveAutonomyState(state: AutonomyState): Promise<void>;
@@ -73,4 +73,4 @@ interface SoftLimits {
 }
 declare const DEFAULT_SOFT_LIMITS: SoftLimits;
 export type { AutonomyState, CircuitBreakerResult, SoftLimits };
-export { DEFAULT_STATE, DEFAULT_SOFT_LIMITS, AUTONOMY_STATE_PATH };
+export { DEFAULT_STATE, DEFAULT_SOFT_LIMITS, getAutonomyStatePath };

package/dist/wizard/lib/autonomy-controller.js

@@ -9,8 +9,9 @@
 import { existsSync } from 'node:fs';
 import { readFile, open, rename, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { DEEP_CURRENT_DIR } from './deep-current.js';
-const AUTONOMY_STATE_PATH = join(DEEP_CURRENT_DIR, 'autonomy-state.json');
+import { deepCurrentDir } from './deep-current.js';
+import { findProjectRoot } from './marker.js';
+function getAutonomyStatePath() { return join(deepCurrentDir(findProjectRoot() ?? process.cwd()), 'autonomy-state.json'); }
 const DEFAULT_STATE = {
     tier: 1,
     active: false,
@@ -29,10 +30,10 @@ const DEFAULT_STATE = {
 };
 // ── State Persistence ─────────────────────────────────
 export async function loadAutonomyState() {
-    if (!existsSync(AUTONOMY_STATE_PATH))
+    if (!existsSync(getAutonomyStatePath()))
         return { ...DEFAULT_STATE };
     try {
-        const content = await readFile(AUTONOMY_STATE_PATH, 'utf-8');
+        const content = await readFile(getAutonomyStatePath(), 'utf-8');
         return JSON.parse(content);
     }
     catch {
@@ -48,9 +49,9 @@ function serialized(fn) {
 }
 export function saveAutonomyState(state) {
     return serialized(async () => {
-        await mkdir(DEEP_CURRENT_DIR, { recursive: true });
+        await mkdir(deepCurrentDir(findProjectRoot() ?? process.cwd()), { recursive: true });
         // IG-R4 LOKI-001: Atomic write — temp+fsync+rename prevents kill switch reset on crash
-        const tmpPath = AUTONOMY_STATE_PATH + '.tmp';
+        const tmpPath = getAutonomyStatePath() + '.tmp';
         const fh = await open(tmpPath, 'w', 0o600);
         try {
             await fh.writeFile(JSON.stringify(state, null, 2));
@@ -59,7 +60,7 @@ export function saveAutonomyState(state) {
         finally {
             await fh.close();
         }
-        await rename(tmpPath, AUTONOMY_STATE_PATH);
+        await rename(tmpPath, getAutonomyStatePath());
     });
 }
 /**
@@ -180,4 +181,4 @@ const DEFAULT_SOFT_LIMITS = {
     lessonDecayHalfLifeDays: 90,
     minRoasBeforeFreeze: 1.0,
 };
-export { DEFAULT_STATE, DEFAULT_SOFT_LIMITS, AUTONOMY_STATE_PATH };
+export { DEFAULT_STATE, DEFAULT_SOFT_LIMITS, getAutonomyStatePath };

package/dist/wizard/lib/campaign-proposer.js

@@ -9,7 +9,8 @@
 import { mkdir, writeFile as writeFileAsync } from 'node:fs/promises';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { PROPOSALS_DIR } from './deep-current.js';
+import { proposalsDir } from './deep-current.js';
+import { findProjectRoot } from './marker.js';
 import { findWeakestDimension } from './gap-analysis.js';
 // ── Proposal Templates Per Dimension ──────────────────
 function proposeForFeatureCompleteness(model) {
@@ -144,11 +145,11 @@ export function generateProposal(model) {
  * Save a proposal to disk as markdown.
  */
 export async function saveProposal(proposal) {
-    await mkdir(PROPOSALS_DIR, { recursive: true });
+    await mkdir(proposalsDir(findProjectRoot() ?? process.cwd()), { recursive: true });
     const date = new Date().toISOString().split('T')[0];
     const slug = proposal.name.toLowerCase().replace(/\s+/g, '-');
     const filename = `${date}-${slug}.md`;
-    const filepath = join(PROPOSALS_DIR, filename);
+    const filepath = join(proposalsDir(findProjectRoot() ?? process.cwd()), filename);
     const content = `# Campaign Proposal — ${proposal.name}
 ## Generated by: The Deep Current (Tuvok)
 ## Date: ${proposal.generatedAt}

package/dist/wizard/lib/correlation-engine.js

@@ -9,11 +9,12 @@
  */
 import { appendFile, readFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { CORRELATIONS_PATH, PREDICTIONS_PATH, DEEP_CURRENT_DIR } from './deep-current.js';
+import { correlationsPath, predictionsPath, deepCurrentDir } from './deep-current.js';
+import { findProjectRoot } from './marker.js';
 // ── Event Logging ─────────────────────────────────────
 async function appendEvent(entry) {
-    await mkdir(DEEP_CURRENT_DIR, { recursive: true });
-    await appendFile(CORRELATIONS_PATH, JSON.stringify(entry) + '\n', 'utf-8');
+    await mkdir(deepCurrentDir(findProjectRoot() ?? process.cwd()), { recursive: true });
+    await appendFile(correlationsPath(findProjectRoot() ?? process.cwd()), JSON.stringify(entry) + '\n', 'utf-8');
 }
 export async function logCampaignComplete(name, missions, dimension) {
     await appendEvent({
@@ -40,9 +41,9 @@ export async function logMetric(metric, value, source) {
  * Uses before/after comparison with configurable lag windows.
  */
 export async function detectCorrelations(lagDays = 7) {
-    if (!existsSync(CORRELATIONS_PATH))
+    if (!existsSync(correlationsPath(findProjectRoot() ?? process.cwd())))
         return [];
-    const content = await readFile(CORRELATIONS_PATH, 'utf-8');
+    const content = await readFile(correlationsPath(findProjectRoot() ?? process.cwd()), 'utf-8');
     const lines = content.trim().split('\n').filter(Boolean);
     const events = lines.map(l => { try {
         return JSON.parse(l);
@@ -97,20 +98,20 @@ export async function detectCorrelations(lagDays = 7) {
     return correlations;
 }
 export async function recordPrediction(proposal) {
-    await mkdir(DEEP_CURRENT_DIR, { recursive: true });
+    await mkdir(deepCurrentDir(findProjectRoot() ?? process.cwd()), { recursive: true });
     const record = {
         proposalId: proposal.id,
         proposalName: proposal.name,
         predictedImpact: proposal.expectedImpact,
         recordedAt: new Date().toISOString(),
     };
-    await appendFile(PREDICTIONS_PATH, JSON.stringify(record) + '\n', 'utf-8');
+    await appendFile(predictionsPath(findProjectRoot() ?? process.cwd()), JSON.stringify(record) + '\n', 'utf-8');
 }
 export async function evaluatePrediction(proposalId, actualImpact, accuracy) {
     // Read existing predictions, find the matching one, update it
-    if (!existsSync(PREDICTIONS_PATH))
+    if (!existsSync(predictionsPath(findProjectRoot() ?? process.cwd())))
         return;
-    const content = await readFile(PREDICTIONS_PATH, 'utf-8');
+    const content = await readFile(predictionsPath(findProjectRoot() ?? process.cwd()), 'utf-8');
     const lines = content.trim().split('\n').filter(Boolean);
     const updated = lines.map(line => {
         try {
@@ -127,15 +128,15 @@ export async function evaluatePrediction(proposalId, actualImpact, accuracy) {
         }
     });
     const { writeFile: wf } = await import('node:fs/promises');
-    await wf(PREDICTIONS_PATH, updated.join('\n') + '\n');
+    await wf(predictionsPath(findProjectRoot() ?? process.cwd()), updated.join('\n') + '\n');
 }
 /**
  * Calculate average prediction accuracy across all evaluated predictions.
  */
 export async function getAveragePredictionAccuracy() {
-    if (!existsSync(PREDICTIONS_PATH))
+    if (!existsSync(predictionsPath(findProjectRoot() ?? process.cwd())))
         return 0;
-    const content = await readFile(PREDICTIONS_PATH, 'utf-8');
+    const content = await readFile(predictionsPath(findProjectRoot() ?? process.cwd()), 'utf-8');
     const records = content.trim().split('\n').filter(Boolean)
         .map(l => { try {
         return JSON.parse(l);

package/dist/wizard/lib/deep-current.d.ts

@@ -8,11 +8,11 @@
  * PRD Reference: ROADMAP v12.0, docs/methods/DEEP_CURRENT.md
  */
 import type { SiteScanResult } from './site-scanner.js';
-declare const DEEP_CURRENT_DIR: string;
-declare const SITUATION_PATH: string;
-declare const PROPOSALS_DIR: string;
-declare const PREDICTIONS_PATH: string;
-declare const CORRELATIONS_PATH: string;
+declare function deepCurrentDir(projectDir: string): string;
+declare function situationPath(projectDir: string): string;
+declare function proposalsDir(projectDir: string): string;
+declare function predictionsPath(projectDir: string): string;
+declare function correlationsPath(projectDir: string): string;
 type ProjectState = 'GREENFIELD' | 'IDEA_PRD' | 'PARTIAL' | 'DEPLOYED' | 'OPERATING';
 interface ProjectClassification {
     state: ProjectState;
@@ -59,8 +59,8 @@ interface SituationModel {
     autonomyTier: 1 | 2 | 3;
     lastSiteScan?: SiteScanResult;
 }
-export declare function loadSituation(): Promise<SituationModel | null>;
-export declare function saveSituation(model: SituationModel): Promise<void>;
+export declare function loadSituation(projectDir: string): Promise<SituationModel | null>;
+export declare function saveSituation(projectDir: string, model: SituationModel): Promise<void>;
 export declare function sense(model: SituationModel): Promise<SituationModel>;
 interface IntakeResult {
     classification: ProjectClassification;
@@ -72,6 +72,6 @@ interface IntakeResult {
  * Cold start intake: classify the project, scan if deployed, create situation model.
  * Returns the initial situation and a recommended first action.
  */
-export declare function intake(projectName: string): Promise<IntakeResult>;
+export declare function intake(projectName: string, projectDir?: string): Promise<IntakeResult>;
 export type { ProjectState, ProjectClassification, SituationModel, DimensionScore, CampaignRecord, IntakeResult };
-export { DEEP_CURRENT_DIR, SITUATION_PATH, PROPOSALS_DIR, PREDICTIONS_PATH, CORRELATIONS_PATH };
+export { deepCurrentDir, situationPath, proposalsDir, predictionsPath, correlationsPath };

package/dist/wizard/lib/deep-current.js

@@ -12,11 +12,23 @@ import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { scanSite, scoreScan } from './site-scanner.js';
-const DEEP_CURRENT_DIR = join(process.cwd(), 'logs', 'deep-current');
-const SITUATION_PATH = join(DEEP_CURRENT_DIR, 'situation.json');
-const PROPOSALS_DIR = join(DEEP_CURRENT_DIR, 'proposals');
-const PREDICTIONS_PATH = join(DEEP_CURRENT_DIR, 'predictions.jsonl');
-const CORRELATIONS_PATH = join(DEEP_CURRENT_DIR, 'correlations.jsonl');
+// Lazy path resolution — project dir is passed by callers, not assumed from CWD.
+// The wizard is standalone (v21.0) — CWD is NOT a project directory.
+function deepCurrentDir(projectDir) {
+    return join(projectDir, 'logs', 'deep-current');
+}
+function situationPath(projectDir) {
+    return join(deepCurrentDir(projectDir), 'situation.json');
+}
+function proposalsDir(projectDir) {
+    return join(deepCurrentDir(projectDir), 'proposals');
+}
+function predictionsPath(projectDir) {
+    return join(deepCurrentDir(projectDir), 'predictions.jsonl');
+}
+function correlationsPath(projectDir) {
+    return join(deepCurrentDir(projectDir), 'correlations.jsonl');
+}
 /**
  * Classify the current project's state by checking for key files and config.
  */
@@ -84,20 +96,21 @@ function createEmptyModel(projectName, state) {
     };
 }
 // ── Persistence ───────────────────────────────────────
-export async function loadSituation() {
-    if (!existsSync(SITUATION_PATH))
+export async function loadSituation(projectDir) {
+    const path = situationPath(projectDir);
+    if (!existsSync(path))
         return null;
     try {
-        const content = await readFile(SITUATION_PATH, 'utf-8');
+        const content = await readFile(path, 'utf-8');
         return JSON.parse(content);
     }
     catch {
         return null;
     }
 }
-export async function saveSituation(model) {
-    await mkdir(DEEP_CURRENT_DIR, { recursive: true });
-    await writeFileAsync(SITUATION_PATH, JSON.stringify(model, null, 2));
+export async function saveSituation(projectDir, model) {
+    await mkdir(deepCurrentDir(projectDir), { recursive: true });
+    await writeFileAsync(situationPath(projectDir), JSON.stringify(model, null, 2));
 }
 // ── SENSE Step — Update situation model from scans ────
 export async function sense(model) {
@@ -167,7 +180,7 @@ function buildGrowthGaps(scan) {
  * Cold start intake: classify the project, scan if deployed, create situation model.
  * Returns the initial situation and a recommended first action.
  */
-export async function intake(projectName) {
+export async function intake(projectName, projectDir = process.cwd()) {
     const classification = await classifyProject();
     const model = createEmptyModel(projectName, classification.state);
     let siteScan;
@@ -209,7 +222,7 @@ export async function intake(projectName) {
             break;
     }
     // Save the model
-    await saveSituation(model);
+    await saveSituation(projectDir, model);
     return { classification, situation: model, siteScan, recommendedFirstAction };
 }
 function findLowestDimension(model) {
@@ -231,4 +244,4 @@ function findLowestDimension(model) {
     };
     return `${labels[lowest]} (${lowestScore}/100)`;
 }
-export { DEEP_CURRENT_DIR, SITUATION_PATH, PROPOSALS_DIR, PREDICTIONS_PATH, CORRELATIONS_PATH };
+export { deepCurrentDir, situationPath, proposalsDir, predictionsPath, correlationsPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thevoidforge",
-  "version": "21.0.5",
+  "version": "21.0.6",
   "description": "From nothing, everything. A methodology framework for building with Claude Code.",
   "type": "module",
   "engines": {