@planu/cli 4.13.0 → 5.0.0

package/dist/engine/filesystem-watcher/index.d.ts

@@ -4,13 +4,13 @@ import type { FsHookConfig, FsHooksConfig, FsHookTriggerEvent, FsHookResult } fr
  */
 export declare function getDefaultHooksConfig(): FsHooksConfig;
 /**
- * Loads the hooks configuration from `.planu/hooks.json` in the given project path.
+ * Loads the hooks configuration from `planu/hooks.json` in the given project path.
  * Returns the default config if the file does not exist.
  */
 export declare function loadHooksConfig(projectPath: string): Promise<FsHooksConfig>;
 /**
- * Saves the hooks configuration to `.planu/hooks.json` in the given project path.
- * Creates the `.planu` directory if it does not exist.
+ * Saves the hooks configuration to `planu/hooks.json` in the given project path.
+ * Creates the `planu` directory if it does not exist.
  */
 export declare function saveHooksConfig(projectPath: string, config: FsHooksConfig): Promise<void>;
 /**

package/dist/engine/filesystem-watcher/index.js

@@ -2,7 +2,7 @@
 // engine/filesystem-watcher/index.ts — SPEC-329: Filesystem watcher engine
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-const HOOKS_FILE = '.planu/hooks.json';
+const HOOKS_FILE = 'planu/hooks.json';
 /**
  * Returns the default hooks configuration (disabled with no hooks).
  */
@@ -10,7 +10,7 @@ export function getDefaultHooksConfig() {
     return { enabled: false, hooks: [] };
 }
 /**
- * Loads the hooks configuration from `.planu/hooks.json` in the given project path.
+ * Loads the hooks configuration from `planu/hooks.json` in the given project path.
  * Returns the default config if the file does not exist.
  */
 export async function loadHooksConfig(projectPath) {
@@ -24,11 +24,11 @@ export async function loadHooksConfig(projectPath) {
     }
 }
 /**
- * Saves the hooks configuration to `.planu/hooks.json` in the given project path.
- * Creates the `.planu` directory if it does not exist.
+ * Saves the hooks configuration to `planu/hooks.json` in the given project path.
+ * Creates the `planu` directory if it does not exist.
  */
 export async function saveHooksConfig(projectPath, config) {
-    const dir = join(projectPath, '.planu');
+    const dir = join(projectPath, 'planu');
     await mkdir(dir, { recursive: true });
     const filePath = join(projectPath, HOOKS_FILE);
     await writeFile(filePath, JSON.stringify(config, null, 2), 'utf-8');

package/dist/engine/framework-detector.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from './technology-registry.js';
 // Planu — Framework, ORM, and database detection
 import { join } from 'node:path';
 import { fileExists, hasAnyFile, collectDependencies, readJsonFile } from './detection-utils.js';
@@ -79,12 +78,12 @@ export async function detectDatabase(projectPath, signatures) {
 }
 const KNOWN_ENGINES = new Set([
     'postgresql',
-    'supabase',
+    technologyValue('technology-supabase-4d7594'),
     'mysql',
     'sqlite',
     'mongodb',
     'firebase',
-    'redis',
+    technologyValue('technology-redis-34fb46'),
     'memcached',
     'valkey',
     'elasticsearch',
@@ -129,24 +128,24 @@ function isKnownEngine(engine) {
 export async function detectOrm(projectPath) {
     const deps = await collectDependencies(projectPath);
     const ormMap = {
-        prisma: ['@prisma/client', 'prisma'],
+        prisma: ['@prisma/client', technologyValue('technology-prisma-99497c')],
         drizzle: ['drizzle-orm'],
-        typeorm: ['typeorm'],
-        sequelize: ['sequelize'],
-        mongoose: ['mongoose'],
+        typeorm: [technologyValue('technology-typeorm-527d4d')],
+        sequelize: [technologyValue('technology-sequelize-d18291')],
+        mongoose: [technologyValue('technology-mongoose-4e1812')],
         mikro: ['@mikro-orm/core'],
         objection: ['objection'],
         knex: ['knex'],
-        sqlalchemy: ['sqlalchemy'],
-        'django-orm': ['django'],
+        sqlalchemy: [technologyValue('technology-sqlalchemy-37f268')],
+        'django-orm': [technologyValue('technology-django-7d8a08')],
         tortoise: ['tortoise-orm'],
         peewee: ['peewee'],
         gorm: ['gorm.io/gorm'],
         ent: ['entgo.io/ent'],
-        diesel: ['diesel'],
+        diesel: [technologyValue('technology-diesel-f83cff')],
         'sea-orm': ['sea-orm'],
         ecto: ['ecto'],
-        'active-record': ['activerecord'],
+        'active-record': [technologyValue('technology-activerecord-97a448')],
         eloquent: ['illuminate/database'],
     };
     for (const [orm, packages] of Object.entries(ormMap)) {
@@ -158,11 +157,11 @@ export async function detectOrm(projectPath) {
     }
     // Check for Prisma schema file
     if (await hasAnyFile(projectPath, ['prisma/schema.prisma'])) {
-        return 'prisma';
+        return technologyValue('technology-prisma-99497c');
     }
     // Check for Drizzle config
     if (await hasAnyFile(projectPath, ['drizzle.config.ts', 'drizzle.config.js'])) {
-        return 'drizzle';
+        return technologyValue('technology-drizzle-424f22');
     }
     return null;
 }
@@ -218,7 +217,7 @@ export async function detectTestCommand(projectPath, packageManager) {
     }
     if ((await fileExists(projectPath, 'pytest.ini')) ||
         (await fileExists(projectPath, 'pyproject.toml'))) {
-        return 'pytest';
+        return technologyValue('technology-pytest-2b0121');
     }
     return null;
 }

package/dist/engine/git/planu-autocommit.js

@@ -1,19 +1,20 @@
 // engine/git/planu-autocommit.ts — Idempotent git commit helper for staged planu/ docs
-import { execFile as execFileCb } from 'node:child_process';
-import { promisify } from 'node:util';
 import { access } from 'node:fs/promises';
 import { join } from 'node:path';
-const execFile = promisify(execFileCb);
+import { runAbortableProcess } from '../abortable-process-runner.js';
 export function isPlanuAutocommitEnabled() {
     return process.env.PLANU_ENABLE_AUTOCOMMIT === 'true';
 }
-/** Run git with execFile (no shell injection risk). */
+/** Run git through the request-aware process-group supervisor. */
 async function runGit(cwd, args) {
-    const result = await execFile('git', args, {
+    const result = await runAbortableProcess('git', args, {
         cwd,
-        maxBuffer: 1024 * 1024,
-        timeout: 15_000,
+        maxBufferBytes: 1024 * 1024,
+        timeoutMs: 15_000,
     });
+    if (result.status !== 0 || result.error) {
+        throw result.error ?? new Error(result.stderr || `git exited with ${String(result.status)}`);
+    }
     return { stdout: result.stdout, stderr: result.stderr };
 }
 /** Build commit message based on reason and optional specId. */

package/dist/engine/git/repository-probe.d.ts

@@ -0,0 +1,3 @@
+/** O(1) probe that supports both normal repositories and worktree `.git` files. */
+export declare function hasGitMetadata(projectPath: string): Promise<boolean>;
+//# sourceMappingURL=repository-probe.d.ts.map

package/dist/engine/git/repository-probe.js

@@ -0,0 +1,13 @@
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/** O(1) probe that supports both normal repositories and worktree `.git` files. */
+export async function hasGitMetadata(projectPath) {
+    try {
+        const metadata = await stat(join(projectPath, '.git'));
+        return metadata.isDirectory() || metadata.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=repository-probe.js.map

package/dist/engine/global-rules-manager.js

@@ -1,12 +1,12 @@
 // engine/global-rules-manager.ts — Global Steering Rules manager (SPEC-351)
 import { readFile, writeFile, readdir, unlink, mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
+import { resolveStorageLayout } from '../storage/storage-layout.js';
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
 export function globalRulesDir() {
-    return join(homedir(), '.planu', 'global-rules');
+    return join(resolveStorageLayout().config, 'global-rules');
 }
 function ruleFile(slug) {
     return join(globalRulesDir(), `${slug}.md`);

package/dist/engine/handoff-artifacts/io.js

@@ -50,9 +50,8 @@ function eventTypeForKind(kind) {
 export async function appendArtifact(input) {
     const { projectId, specId, kind, payload } = input;
     const lockKey = `${projectId}:${specId}:${kind}`;
-    // We use projectId as the 'projectPath' for the lock — the lock dir is relative
-    // to cwd, so we use a combined specId that encodes the artifact key
-    const lockHandle = await acquireLock('.', lockKey, { reason: `handoff.${kind}` });
+    const lockResourceId = `__handoff-${createHash('sha256').update(lockKey).digest('hex')}`;
+    const lockHandle = await acquireLock(projectId, lockResourceId, { reason: `handoff.${kind}` });
     if (lockHandle === null) {
         throw new Error(`[handoff-artifacts] Could not acquire lock for ${lockKey}`);
     }

package/dist/engine/handoff-artifacts/schemas/red-tests-handoff.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../../technology-registry.js';
 // engine/handoff-artifacts/schemas/red-tests-handoff.ts — SPEC-750
 // Zod schema for the red-tests handoff artifact produced by TestArchitect.
 import { z } from 'zod';
@@ -6,7 +7,13 @@ export const RedTestsHandoffSchema = z.object({
     version: z.literal(1),
     specId: z.string().min(1),
     testFiles: z.array(z.string()).min(1),
-    testFramework: z.enum(['vitest', 'jest', 'playwright', 'pytest', 'rspec']),
+    testFramework: z.enum([
+        technologyValue('technology-vitest-a9127f'),
+        technologyValue('technology-jest-35e99f'),
+        technologyValue('technology-playwright-7827e8'),
+        technologyValue('technology-pytest-2b0121'),
+        'rspec',
+    ]),
     expectedFailures: z.array(z.string()).min(1),
     authoredBy: z.string().min(1),
     authoredAt: z.string().min(1),

package/dist/engine/handoff-artifacts/schemas.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { ArtifactKind } from '../../types/handoff-artifacts.js';
+import type { ArtifactKind, ReconciliationReceiptV1 } from '../../types/handoff-artifacts.js';
 import type { ValidationOk, ValidationErr } from './validation-result.js';
 export declare const SchemaVersion: z.ZodString;
 export declare const IntakeV1Schema: z.ZodObject<{
@@ -61,6 +61,8 @@ export declare const ImplementationReportV1Schema: z.ZodObject<{
     testsRun: z.ZodNumber;
     testsPassed: z.ZodNumber;
     completedAt: z.ZodISODateTime;
+    receiptId: z.ZodOptional<z.ZodString>;
+    receiptKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const ValidationReportV1Schema: z.ZodObject<{
     schema_version: z.ZodString;
@@ -155,6 +157,7 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
     score: z.ZodOptional<z.ZodNumber>;
     completedAt: z.ZodISODateTime;
 }, z.core.$strip>;
+export declare const ReconciliationReceiptV1Schema: z.ZodType<ReconciliationReceiptV1>;
 export declare const ARTIFACT_SCHEMAS: {
     readonly intake: z.ZodObject<{
         schema_version: z.ZodString;
@@ -215,6 +218,8 @@ export declare const ARTIFACT_SCHEMAS: {
         testsRun: z.ZodNumber;
         testsPassed: z.ZodNumber;
         completedAt: z.ZodISODateTime;
+        receiptId: z.ZodOptional<z.ZodString>;
+        receiptKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly 'validation-report': z.ZodObject<{
         schema_version: z.ZodString;

package/dist/engine/handoff-artifacts/schemas.js

@@ -47,6 +47,11 @@ export const ImplementationReportV1Schema = z.object({
     testsRun: z.number().int().min(0),
     testsPassed: z.number().int().min(0),
     completedAt: z.iso.datetime(),
+    receiptId: z
+        .string()
+        .regex(/^sha256:[a-f0-9]{64}$/u)
+        .optional(),
+    receiptKey: z.string().min(1).optional(),
 });
 export const ValidationReportV1Schema = z.object({
     schema_version: SchemaVersion,
@@ -116,6 +121,39 @@ export const ValidationReportV1Schema = z.object({
     score: z.number().optional(),
     completedAt: z.iso.datetime(),
 });
+export const ReconciliationReceiptV1Schema = z.object({
+    schema_version: z.literal('1.0.0'),
+    projectId: z.string().min(1),
+    specId: z.string().min(1),
+    requestId: z
+        .string()
+        .regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u),
+    sourceImplementingTransitionId: z.string().min(1),
+    sourceUpdatedAt: z.iso.datetime(),
+    bindingDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    reasonDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    implementationReviewDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    supersededArtifacts: z.array(z.object({
+        artifactId: z.string().min(1),
+        sha256: z
+            .string()
+            .regex(/^sha256:[a-f0-9]{64}$/u)
+            .optional(),
+    })),
+    state: z.enum(['prepared', 'committed', 'aborted']),
+    stateHistory: z.array(z.object({
+        state: z.enum(['prepared', 'committed', 'aborted']),
+        at: z.iso.datetime(),
+        reason: z.string().optional(),
+    })),
+    preparedAt: z.iso.datetime(),
+    committedAt: z.iso.datetime().optional(),
+    abortedAt: z.iso.datetime().optional(),
+    committedTransitionId: z.string().min(1).optional(),
+    transitionId: z.string().min(1).optional(),
+    phase: z.enum(['prepared', 'status-committed', 'spec-synced', 'audit-appended']).optional(),
+    auditPending: z.boolean().optional(),
+});
 // ---------------------------------------------------------------------------
 // Schema registry
 // ---------------------------------------------------------------------------

package/dist/engine/handoff-packager.d.ts

@@ -1,3 +1,22 @@
 import type { Spec, ProjectKnowledge, HandoffPackage } from '../types/index.js';
+/** Normalize one repository-relative ownership path without retaining unsafe input in diagnostics. */
+export declare function normalizeOwnedPath(value: string): {
+    status: 'valid';
+    path: string;
+} | {
+    status: 'none';
+} | {
+    status: 'invalid';
+    code: 'INVALID_FILE_OWNERSHIP_EMPTY' | 'INVALID_FILE_OWNERSHIP_FENCED' | 'INVALID_FILE_OWNERSHIP_NUL' | 'INVALID_FILE_OWNERSHIP_ABSOLUTE' | 'INVALID_FILE_OWNERSHIP_HOME_RELATIVE' | 'INVALID_FILE_OWNERSHIP_UNC' | 'INVALID_FILE_OWNERSHIP_DRIVE_ABSOLUTE' | 'INVALID_FILE_OWNERSHIP_URI' | 'INVALID_FILE_OWNERSHIP_TRAVERSAL' | 'INVALID_FILE_OWNERSHIP_MARKDOWN' | 'INVALID_FILE_OWNERSHIP_DESCRIPTION';
+};
+/** Normalize a raw traceability changed-file value without interpreting Markdown or prose. */
+export declare function normalizeChangedFilePath(value: string): ReturnType<typeof normalizeOwnedPath>;
+export declare function extractCanonicalFileOwnership(content: string): {
+    present: boolean;
+    toModify: string[];
+    toCreate: string[];
+    toTest: string[];
+    blockers: string[];
+};
 export declare function packageHandoff(spec: Spec, knowledge: ProjectKnowledge): Promise<HandoffPackage>;
 //# sourceMappingURL=handoff-packager.d.ts.map