@phren/cli 0.0.57 → 0.0.58

package/dist/init-modes.d.ts

@@ -0,0 +1,4 @@
+import type { McpMode } from "./init-walkthrough.js";
+export declare function parseMcpMode(raw?: string): McpMode | undefined;
+export declare function runMcpMode(modeArg?: string): Promise<void>;
+export declare function runHooksMode(modeArg?: string): Promise<void>;

package/dist/init-npm.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Version comparison utilities for phren init and update flows.
+ */
+/**
+ * Compare two semver strings. Returns true when `current` is strictly newer
+ * than `previous`. Pre-release versions (e.g. 1.2.3-rc.1) sort before the
+ * corresponding release (1.2.3). Among pre-release tags, comparison is
+ * lexicographic.
+ */
+export declare function isVersionNewer(current: string, previous?: string): boolean;

package/dist/init-project-local.d.ts

@@ -0,0 +1,2 @@
+import type { InitOptions } from "./init-types.js";
+export declare function runProjectLocalInit(opts?: InitOptions): Promise<void>;

package/dist/init-semantic.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Semantic search warm-up for init.
+ */
+export declare function warmSemanticSearch(phrenPath: string, profile?: string): Promise<string>;

package/dist/init-types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared types for init modules. Separated to avoid circular dependencies.
+ */
+import type { InstallMode } from "./shared.js";
+import type { ProjectOwnershipMode } from "./project-config.js";
+import type { ProactivityLevel } from "./proactivity.js";
+import type { McpMode, WorkflowRiskSection, StorageLocationChoice } from "./init-walkthrough.js";
+import type { InitProjectDomain, InferredInitScaffold } from "./init/setup.js";
+export type SkillsScope = "global" | "project";
+export interface InitOptions {
+    mode?: InstallMode;
+    machine?: string;
+    profile?: string;
+    mcp?: McpMode;
+    hooks?: McpMode;
+    projectOwnershipDefault?: ProjectOwnershipMode;
+    findingsProactivity?: ProactivityLevel;
+    taskProactivity?: ProactivityLevel;
+    lowConfidenceThreshold?: number;
+    riskySections?: WorkflowRiskSection[];
+    taskMode?: "off" | "manual" | "suggest" | "auto";
+    findingSensitivity?: "minimal" | "conservative" | "balanced" | "aggressive";
+    skillsScope?: SkillsScope;
+    applyStarterUpdate?: boolean;
+    dryRun?: boolean;
+    yes?: boolean;
+    template?: "python-project" | "monorepo" | "library" | "frontend" | string;
+    /** Set by walkthrough to pass project name to init logic */
+    _walkthroughProject?: string;
+    /** Set by walkthrough for personalized GitHub next-steps output */
+    _walkthroughGithub?: {
+        username?: string;
+        repo: string;
+    };
+    /** Set by walkthrough to seed project docs/topics by domain */
+    _walkthroughDomain?: InitProjectDomain;
+    /** Set by walkthrough to seed adaptive project scaffold from current repo content */
+    _walkthroughInferredScaffold?: InferredInitScaffold;
+    /** Set by walkthrough when user enables auto-capture; triggers writing ~/.phren/.env */
+    _walkthroughAutoCapture?: boolean;
+    /** Set by walkthrough when user opts into local semantic search */
+    _walkthroughSemanticSearch?: boolean;
+    /** Set by walkthrough when user enables LLM semantic dedup */
+    _walkthroughSemanticDedup?: boolean;
+    /** Set by walkthrough when user enables LLM conflict detection */
+    _walkthroughSemanticConflict?: boolean;
+    /** Set by walkthrough when user provides a git clone URL for existing phren */
+    _walkthroughCloneUrl?: string;
+    /** Set by walkthrough when the user wants the current repo enrolled immediately */
+    _walkthroughBootstrapCurrentProject?: boolean;
+    /** Set by walkthrough for the ownership mode selected for the current repo */
+    _walkthroughBootstrapOwnership?: ProjectOwnershipMode;
+    /** Set by walkthrough to select where phren data is stored */
+    _walkthroughStorageChoice?: StorageLocationChoice;
+    /** Set by walkthrough to pass resolved storage path to init logic */
+    _walkthroughStoragePath?: string;
+    /** Set by walkthrough when project-local storage is chosen */
+    _walkthroughStorageRepoRoot?: string;
+}

package/dist/init-uninstall.d.ts

@@ -0,0 +1,3 @@
+export declare function runUninstall(opts?: {
+    yes?: boolean;
+}): Promise<void>;

package/dist/init-update.d.ts

@@ -0,0 +1,10 @@
+import type { InitOptions, SkillsScope } from "./init-types.js";
+export declare function runExistingInstallUpdate(phrenPath: string, opts: InitOptions, params: {
+    mcpEnabled: boolean;
+    hooksEnabled: boolean;
+    skillsScope: SkillsScope;
+    ownershipDefault: string;
+    syncIntent: "sync" | "local";
+    shouldBootstrapCurrentProject: boolean;
+    bootstrapOwnership: string;
+}): Promise<void>;

package/dist/init-walkthrough.d.ts

@@ -0,0 +1,55 @@
+import { type InitProjectDomain, type InferredInitScaffold } from "./init/setup.js";
+import { type ProjectOwnershipMode } from "./project-config.js";
+import { type ProactivityLevel } from "./proactivity.js";
+export type WorkflowRiskSection = "Review" | "Stale" | "Conflicts";
+export type StorageLocationChoice = "global" | "project" | "custom";
+export type McpMode = "on" | "off";
+export type WalkthroughChoice<T extends string> = {
+    value: T;
+    name: string;
+    description?: string;
+};
+export type WalkthroughPromptUi = {
+    input(message: string, initialValue?: string): Promise<string>;
+    confirm(message: string, defaultValue?: boolean): Promise<boolean>;
+    select<T extends string>(message: string, choices: WalkthroughChoice<T>[], defaultValue?: T): Promise<T>;
+};
+export type WalkthroughStyle = {
+    header: (text: string) => string;
+    success: (text: string) => string;
+    warning: (text: string) => string;
+};
+export declare function withFallbackColors(style?: {
+    header?: (text: string) => string;
+    success?: (text: string) => string;
+    warning?: (text: string) => string;
+}): WalkthroughStyle;
+export declare function createWalkthroughStyle(): Promise<WalkthroughStyle>;
+export declare function createWalkthroughPrompts(): Promise<WalkthroughPromptUi>;
+export declare function runWalkthrough(phrenPath: string): Promise<{
+    storageChoice: StorageLocationChoice;
+    storagePath: string;
+    storageRepoRoot?: string;
+    machine: string;
+    profile: string;
+    mcp: McpMode;
+    hooks: McpMode;
+    projectOwnershipDefault: ProjectOwnershipMode;
+    findingsProactivity: ProactivityLevel;
+    taskProactivity: ProactivityLevel;
+    lowConfidenceThreshold: number;
+    riskySections: WorkflowRiskSection[];
+    taskMode: "off" | "manual" | "suggest" | "auto";
+    bootstrapCurrentProject: boolean;
+    bootstrapOwnership?: ProjectOwnershipMode;
+    ollamaEnabled: boolean;
+    autoCaptureEnabled: boolean;
+    semanticDedupEnabled: boolean;
+    semanticConflictEnabled: boolean;
+    findingSensitivity: "minimal" | "conservative" | "balanced" | "aggressive";
+    githubUsername?: string;
+    githubRepo?: string;
+    cloneUrl?: string;
+    domain: InitProjectDomain;
+    inferredScaffold?: InferredInitScaffold;
+}>;

package/dist/link/checksums.d.ts

@@ -0,0 +1,8 @@
+export declare function updateFileChecksums(phrenPath: string, profileName?: string): {
+    updated: number;
+    files: string[];
+};
+export declare function verifyFileChecksums(phrenPath: string): Array<{
+    file: string;
+    status: "ok" | "mismatch" | "missing";
+}>;

package/dist/link/context.d.ts

@@ -0,0 +1,7 @@
+export declare function claudeProjectKey(): string;
+export declare function writeContextDefault(machine: string, profile: string, mcpStatus: string, projects: string[], phrenPath: string): void;
+export declare function writeContextDebugging(machine: string, profile: string, mcpStatus: string, projects: string[], phrenPath: string): void;
+export declare function writeContextPlanning(machine: string, profile: string, mcpStatus: string, projects: string[], phrenPath: string): void;
+export declare function writeContextClean(machine: string, profile: string, mcpStatus: string, projects: string[]): void;
+export declare function readBackNativeMemory(phrenPath: string, projects: string[]): void;
+export declare function rebuildMemory(phrenPath: string, projects: string[]): void;

package/dist/link/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorResult } from "./link.js";
+export declare function runDoctor(phrenPath: string, fix?: boolean, checkData?: boolean): Promise<DoctorResult>;

package/dist/link/link.d.ts

@@ -0,0 +1,29 @@
+import { type McpMode } from "../init/init.js";
+export { runDoctor } from "./doctor.js";
+export { updateFileChecksums, verifyFileChecksums } from "./checksums.js";
+export { findProjectDir } from "../project-locator.js";
+export { parseSkillFrontmatter, validateSkillFrontmatter, validateSkillsDir, readSkillManifestHooks, } from "./skills.js";
+export type { ManifestHooks, SkillFrontmatter, } from "./skills.js";
+interface LinkOptions {
+    machine?: string;
+    profile?: string;
+    register?: boolean;
+    task?: "debugging" | "planning" | "clean";
+    allTools?: boolean;
+    mcp?: McpMode;
+}
+export interface DoctorResult {
+    ok: boolean;
+    machine?: string;
+    profile?: string;
+    checks: Array<{
+        name: string;
+        ok: boolean;
+        detail: string;
+    }>;
+}
+export { getMachineName } from "../machine-identity.js";
+export declare function lookupProfile(phrenPath: string, machine: string): string;
+export declare function findProfileFile(phrenPath: string, profileName: string): string | null;
+export declare function getProfileProjects(profileFile: string): string[];
+export declare function runLink(phrenPath: string, opts?: LinkOptions): Promise<void>;

package/dist/link/skills.d.ts

@@ -0,0 +1,47 @@
+export interface ManifestHooks {
+    SessionStart?: string;
+    UserPromptSubmit?: string;
+    Stop?: string;
+}
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    version?: string;
+    license?: string;
+    dependencies?: string[];
+    hooks?: Record<string, unknown>;
+    command?: string;
+    aliases?: string[];
+}
+export interface SkillValidationResult {
+    valid: boolean;
+    errors: string[];
+    frontmatter?: SkillFrontmatter;
+}
+export declare function parseSkillFrontmatter(rawContent: string): {
+    frontmatter: Record<string, unknown> | null;
+    body: string;
+};
+export declare function validateSkillFrontmatter(content: string, filePath?: string): SkillValidationResult;
+export declare function validateSkillsDir(skillsDir: string): SkillValidationResult[];
+export declare function readSkillManifestHooks(phrenPath: string): ManifestHooks | null;
+export interface SkillCollision {
+    skillName: string;
+    destPath: string;
+    message: string;
+}
+/**
+ * Returns true if `destPath` is a symlink whose resolved target lives under
+ * `managedRoot`.  Used to decide whether phren owns a symlink.
+ */
+export declare function isManagedSymlink(destPath: string, managedRoot: string): boolean;
+/**
+ * Scan destDir for files that phren would want to link (based on srcDir) but
+ * can't because a user-owned file already occupies the destination slot.
+ */
+export declare function detectSkillCollisions(srcDir: string, destDir: string, managedRoot: string): SkillCollision[];
+export declare function linkSkillsDir(srcDir: string, destDir: string, managedRoot: string, symlinkFile: (src: string, dest: string, managedRoot: string) => boolean, opts?: {
+    phrenPath?: string;
+    scope?: string;
+}): SkillCollision[];
+export declare function writeSkillMd(phrenPath: string): void;

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function log(level: LogLevel, tool: string, message: string, extra?: object): void;
+export declare const logger: {
+    debug: (tool: string, message: string, extra?: object) => void;
+    info: (tool: string, message: string, extra?: object) => void;
+    warn: (tool: string, message: string, extra?: object) => void;
+    error: (tool: string, message: string, extra?: object) => void;
+};
+export {};

package/dist/machine-identity.d.ts

@@ -0,0 +1,4 @@
+export declare function machineFilePath(): string;
+export declare function defaultMachineName(): string;
+export declare function getMachineName(): string;
+export declare function persistMachineName(machine: string): void;

package/dist/package-metadata.d.ts

@@ -0,0 +1,4 @@
+export declare const ROOT: string;
+export declare const PACKAGE_NAME: string;
+export declare const VERSION: string;
+export declare const PACKAGE_SPEC: string;

package/dist/phren-art.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Phren character ASCII/Unicode art for CLI presence.
+ *
+ * Based on the pixel art: purple 8-bit brain with diamond eyes,
+ * smile, little legs, and cyan sparkle.
+ */
+/**
+ * Phren truecolor art (24px wide, generated from phren-transparent.png).
+ * Uses half-block ▀ with RGB foreground+background for pixel-faithful rendering.
+ * Requires truecolor terminal (most modern terminals support it).
+ */
+export declare const PHREN_ART: string[];
+export declare const PHREN_ART_RIGHT: string[];
+export interface PhrenAnimator {
+    getFrame(): string[];
+    start(): void;
+    stop(): void;
+}
+export declare function createPhrenAnimator(options?: {
+    facing?: "left" | "right";
+    size?: number;
+}): PhrenAnimator;
+/**
+ * Return the phren art as a single string, optionally indented.
+ */
+export declare function renderPhrenArt(indent?: string): string;

package/dist/phren-core.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Minimal cross-domain starter set for fragment/conflict detection.
+ *
+ * Kept intentionally small: only terms that are genuinely universal across
+ * disciplines (languages, infra primitives, version control). Framework-specific
+ * tools (React, Django, Unity, JUCE, Ansible, ...) are learned dynamically from
+ * each project's FINDINGS.md via extractDynamicEntities().
+ */
+export declare const UNIVERSAL_TECH_TERMS_RE: RegExp;
+/**
+ * Additional fragment patterns beyond CamelCase and acronyms.
+ * Each pattern has a named group so callers can identify the fragment type.
+ */
+export declare const EXTRA_ENTITY_PATTERNS: Array<{
+    re: RegExp;
+    label: string;
+}>;
+/** Union of all directory names reserved by phren infrastructure — not valid project names. */
+export declare const RESERVED_PROJECT_DIR_NAMES: Set<string>;
+export declare const EXEC_TIMEOUT_MS = 30000;
+export declare const EXEC_TIMEOUT_QUICK_MS = 10000;
+export declare const PhrenError: {
+    readonly PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND";
+    readonly INVALID_PROJECT_NAME: "INVALID_PROJECT_NAME";
+    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly MALFORMED_JSON: "MALFORMED_JSON";
+    readonly MALFORMED_YAML: "MALFORMED_YAML";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly AMBIGUOUS_MATCH: "AMBIGUOUS_MATCH";
+    readonly LOCK_TIMEOUT: "LOCK_TIMEOUT";
+    readonly EMPTY_INPUT: "EMPTY_INPUT";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly INDEX_ERROR: "INDEX_ERROR";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+};
+export type PhrenErrorCode = typeof PhrenError[keyof typeof PhrenError];
+export type PhrenResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    code?: PhrenErrorCode;
+};
+export declare function phrenOk<T>(data: T): PhrenResult<T>;
+export declare function phrenErr<T>(error: string, code?: PhrenErrorCode): PhrenResult<T>;
+export declare function forwardErr<T>(result: PhrenResult<unknown>): PhrenResult<T>;
+export declare function parsePhrenErrorCode(msg: string): PhrenErrorCode | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Shallow-merge data onto defaults so missing keys get filled in. */
+export declare function withDefaults<T extends object>(data: Partial<T>, defaults: T): T;
+/** All valid finding type tags — used for writes, search filters, and hook extraction */
+export declare const FINDING_TYPES: readonly ["decision", "pitfall", "pattern", "tradeoff", "architecture", "bug"];
+export type FindingType = (typeof FINDING_TYPES)[number];
+/** Searchable finding tags (same set as FINDING_TYPES) */
+export declare const FINDING_TAGS: readonly ["decision", "pitfall", "pattern", "tradeoff", "architecture", "bug"];
+export type FindingTag = FindingType;
+/** Canonical set of known observation tags — derived from FINDING_TYPES */
+export declare const KNOWN_OBSERVATION_TAGS: Set<string>;
+/** Document types in the FTS index */
+export declare const DOC_TYPES: readonly ["claude", "findings", "reference", "skills", "summary", "task", "changelog", "canonical", "review-queue", "skill", "other"];
+export type DocType = (typeof DOC_TYPES)[number];
+export declare function capCache<K, V>(cache: Map<K, V>): void;

package/dist/phren-dotenv.d.ts

@@ -0,0 +1,2 @@
+export declare function bootstrapPhrenDotEnv(phrenPath?: string): string | null;
+export declare function resetPhrenDotEnvBootstrapForTests(): void;

package/dist/phren-paths.d.ts

@@ -0,0 +1,60 @@
+export type InstallMode = "shared" | "project-local";
+export type SyncMode = "managed-git" | "workspace-git";
+export interface PhrenRootManifest {
+    version: 1;
+    installMode: InstallMode;
+    syncMode: SyncMode;
+    workspaceRoot?: string;
+    primaryProject?: string;
+}
+export interface InstallContext extends PhrenRootManifest {
+    phrenPath: string;
+}
+export declare const ROOT_MANIFEST_FILENAME = "phren.root.yaml";
+export declare function homeDir(): string;
+export declare function homePath(...parts: string[]): string;
+export declare function expandHomePath(input: string): string;
+export declare function defaultPhrenPath(): string;
+export declare function rootManifestPath(phrenPath: string): string;
+export declare function atomicWriteText(filePath: string, content: string): void;
+export declare function readRootManifest(phrenPath: string): PhrenRootManifest | null;
+export declare function writeRootManifest(phrenPath: string, manifest: PhrenRootManifest): void;
+export declare function resolveInstallContext(phrenPath: string): InstallContext;
+export declare function findNearestPhrenPath(startDir?: string): string | null;
+export declare function findPhrenPath(): string | null;
+export declare function ensurePhrenPath(): string;
+export declare function findPhrenPathWithArg(arg?: string): string;
+export declare function isProjectLocalMode(phrenPath: string): boolean;
+export declare function runtimeDir(phrenPath: string): string;
+/** Unlink a file, ignoring ENOENT. Rethrows any other error. */
+export declare function tryUnlink(filePath: string): void;
+export declare function sessionsDir(phrenPath: string): string;
+export declare function runtimeFile(phrenPath: string, name: string): string;
+export declare function installPreferencesFile(phrenPath: string): string;
+export declare function runtimeHealthFile(phrenPath: string): string;
+export declare function shellStateFile(phrenPath: string): string;
+export declare function sessionMetricsFile(phrenPath: string): string;
+export declare function memoryScoresFile(phrenPath: string): string;
+export declare function memoryUsageLogFile(phrenPath: string): string;
+export declare function sessionMarker(phrenPath: string, name: string): string;
+export declare function debugLog(msg: string): void;
+/** Always-on structured error log (no PHREN_DEBUG gate). */
+export declare function errorLog(tool: string, msg: string): void;
+export declare function appendIndexEvent(phrenPath: string, event: Record<string, unknown>): void;
+/** Resolve the canonical findings file for a project directory. */
+export declare function resolveFindingsPath(projectDir: string): string | undefined;
+export declare function normalizeProjectNameForCreate(name: string): string;
+export declare function findProjectNameCaseInsensitive(phrenPath: string, name: string): string | null;
+export declare function findArchivedProjectNameCaseInsensitive(phrenPath: string, name: string): string | null;
+export declare function getProjectDirs(phrenPath: string, profile?: string): string[];
+export declare function collectNativeMemoryFiles(): Array<{
+    project: string;
+    file: string;
+    fullPath: string;
+}>;
+export declare function computePhrenLiveStateToken(phrenPath: string): string;
+export declare function getPhrenPath(): string;
+export declare function qualityMarkers(phrenPathLocal: string): {
+    done: string;
+    lock: string;
+};

package/dist/proactivity.d.ts

@@ -0,0 +1,13 @@
+export declare const PROACTIVITY_LEVELS: readonly ["high", "medium", "low"];
+export type ProactivityLevel = typeof PROACTIVITY_LEVELS[number];
+export declare function getProactivityLevel(explicitPhrenPath?: string): ProactivityLevel;
+export declare function getProactivityLevelForFindings(explicitPhrenPath?: string): ProactivityLevel;
+export declare function getProactivityLevelForTask(explicitPhrenPath?: string): ProactivityLevel;
+export declare function hasExplicitFindingSignal(...texts: Array<string | undefined | null>): boolean;
+export declare function hasExplicitTaskSignal(...texts: Array<string | undefined | null>): boolean;
+export declare function shouldAutoCaptureFindingsForLevel(level: ProactivityLevel, ...texts: Array<string | undefined | null>): boolean;
+export declare function shouldAutoCaptureTaskForLevel(level: ProactivityLevel, ...texts: Array<string | undefined | null>): boolean;
+export declare function hasExecutionIntent(...texts: Array<string | undefined | null>): boolean;
+export declare function hasDiscoveryIntent(...texts: Array<string | undefined | null>): boolean;
+export declare function hasSuppressTaskIntent(...texts: Array<string | undefined | null>): boolean;
+export declare function hasCodeChangeContext(...texts: Array<string | undefined | null>): boolean;

package/dist/profile-store.d.ts

@@ -0,0 +1,34 @@
+import { type PhrenResult } from "./shared.js";
+import type { RetentionPolicyPatch } from "./governance/policy.js";
+export interface ProfilePolicyDefaults {
+    findingSensitivity?: "minimal" | "conservative" | "balanced" | "aggressive";
+    proactivity?: "high" | "medium" | "low";
+    proactivityFindings?: "high" | "medium" | "low";
+    proactivityTask?: "high" | "medium" | "low";
+    taskMode?: "off" | "manual" | "suggest" | "auto";
+    retentionPolicy?: RetentionPolicyPatch;
+    workflowPolicy?: {
+        lowConfidenceThreshold?: number;
+        riskySections?: Array<"Review" | "Stale" | "Conflicts">;
+    };
+}
+export interface ProfileInfo {
+    name: string;
+    file: string;
+    projects: string[];
+    defaults?: ProfilePolicyDefaults;
+}
+export interface ProjectCard {
+    name: string;
+    summary: string;
+    docs: string[];
+}
+export declare function resolveActiveProfile(phrenPath: string, requestedProfile?: string): PhrenResult<string | undefined>;
+export declare function getDefaultMachineAlias(): string;
+export declare function listMachines(phrenPath: string): PhrenResult<Record<string, string>>;
+export declare function setMachineProfile(phrenPath: string, machine: string, profile: string): PhrenResult<string>;
+export declare function getActiveProfileDefaults(phrenPath: string, profile?: string): ProfilePolicyDefaults | undefined;
+export declare function listProfiles(phrenPath: string): PhrenResult<ProfileInfo[]>;
+export declare function addProjectToProfile(phrenPath: string, profile: string, project: string): PhrenResult<string>;
+export declare function removeProjectFromProfile(phrenPath: string, profile: string, project: string): PhrenResult<string>;
+export declare function listProjectCards(phrenPath: string, profile?: string): ProjectCard[];

package/dist/project-config.d.ts

@@ -0,0 +1,60 @@
+import type { RetentionPolicyPatch } from "./governance/policy.js";
+export declare const PROJECT_OWNERSHIP_MODES: readonly ["phren-managed", "detached", "repo-managed"];
+export type ProjectOwnershipMode = typeof PROJECT_OWNERSHIP_MODES[number];
+export interface ProjectMcpServerEntry {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface ProjectConfigOverrides {
+    findingSensitivity?: "minimal" | "conservative" | "balanced" | "aggressive";
+    proactivity?: "high" | "medium" | "low";
+    proactivityFindings?: "high" | "medium" | "low";
+    proactivityTask?: "high" | "medium" | "low";
+    taskMode?: "off" | "manual" | "suggest" | "auto";
+    retentionPolicy?: RetentionPolicyPatch;
+    workflowPolicy?: {
+        lowConfidenceThreshold?: number;
+        riskySections?: Array<"Review" | "Stale" | "Conflicts">;
+    };
+}
+export interface ProjectAccessControl {
+    admins?: string[];
+    contributors?: string[];
+    readers?: string[];
+}
+export interface ProjectConfig {
+    ownership?: ProjectOwnershipMode;
+    sourcePath?: string;
+    skills?: boolean;
+    hooks?: {
+        enabled?: boolean;
+        UserPromptSubmit?: boolean;
+        Stop?: boolean;
+        SessionStart?: boolean;
+        PostToolUse?: boolean;
+    };
+    mcpServers?: Record<string, ProjectMcpServerEntry>;
+    config?: ProjectConfigOverrides;
+    access?: ProjectAccessControl;
+}
+export declare const PROJECT_HOOK_EVENTS: readonly ["UserPromptSubmit", "Stop", "SessionStart", "PostToolUse"];
+export type ProjectHookEvent = typeof PROJECT_HOOK_EVENTS[number];
+type ProjectHookConfig = NonNullable<ProjectConfig["hooks"]>;
+export declare function parseProjectOwnershipMode(raw: string | undefined | null): ProjectOwnershipMode | undefined;
+export declare function projectConfigPath(phrenPath: string, project: string): string;
+export declare function clearProjectConfigCache(): void;
+export declare function readProjectConfig(phrenPath: string, project: string): ProjectConfig;
+export declare function writeProjectConfig(phrenPath: string, project: string, patch: Partial<ProjectConfig>): ProjectConfig;
+export declare function updateProjectConfigOverrides(phrenPath: string, project: string, updater: (current: ProjectConfigOverrides) => ProjectConfigOverrides): ProjectConfig;
+export declare function getProjectSourcePath(phrenPath: string, project: string, config?: ProjectConfig): string | undefined;
+export declare function getProjectOwnershipDefault(phrenPath: string): ProjectOwnershipMode;
+export declare function getProjectOwnershipMode(phrenPath: string, project: string, config?: ProjectConfig): ProjectOwnershipMode;
+export declare function isProjectHookEnabled(phrenPath: string, project: string | null | undefined, event: ProjectHookEvent, config?: ProjectConfig): boolean;
+/**
+ * Remove a per-project hook override, restoring inheritance from global config.
+ * Pass event to clear a specific event override; omit to clear the whole hooks block.
+ */
+export declare function clearProjectHookOverride(phrenPath: string, project: string, event?: string): ProjectConfig;
+export declare function writeProjectHookConfig(phrenPath: string, project: string, patch: Partial<ProjectHookConfig>): ProjectConfig;
+export {};

package/dist/project-locator.d.ts

@@ -0,0 +1 @@
+export declare function findProjectDir(name: string): string | null;