@phren/cli 0.0.56 → 0.0.58

package/dist/shell/input.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Command palette and input handling for the phren interactive shell.
+ * Extracted from shell.ts to keep the orchestrator under 300 lines.
+ */
+import { ShellState } from "../data/access.js";
+import { type DoctorResultLike, type ShellDeps, type ShellView } from "./types.js";
+/** Interface for the shell methods that executePalette needs */
+interface PaletteHost {
+    phrenPath: string;
+    profile: string;
+    state: ShellState;
+    deps: ShellDeps;
+    showHelp: boolean;
+    healthCache: {
+        at: number;
+        result: DoctorResultLike;
+    } | undefined;
+    setMessage(msg: string): void;
+    setView(view: ShellState["view"]): void;
+    confirmThen(label: string, action: () => void): void;
+    snapshotForUndo(label: string, file: string): void;
+    ensureProjectSelected(): string | null;
+    invalidateSubsectionsCache(): void;
+    popUndo(): string;
+}
+/** Extended host interface for navigation and view-action methods */
+export interface NavigationHost extends PaletteHost {
+    currentCursor(): number;
+    setCursor(n: number): void;
+    moveCursor(delta: number): void;
+    getListItems(): {
+        id?: string;
+        name?: string;
+        text?: string;
+        line?: string;
+    }[];
+    startInput(ctx: string, initial: string): void;
+    inputMqId: string;
+    prevHealthView: ShellView | undefined;
+    filter: string | undefined;
+    setFilter(value: string): void;
+}
+export declare function executePalette(host: PaletteHost, input: string): Promise<void>;
+export declare function completeInput(line: string, phrenPath: string, profile: string, state: ShellState): string[];
+export declare function getListItems(phrenPath: string, profile: string, state: ShellState, healthLineCount: number): {
+    id?: string;
+    name?: string;
+    text?: string;
+    line?: string;
+}[];
+/**
+ * Handle p/b/l/m/s/k/h shortcut keys that switch the active view.
+ * Returns true if the key was handled.
+ */
+export declare function applyViewShortcut(host: NavigationHost, key: string): boolean;
+export declare function handleNavigateKey(host: NavigationHost, key: string): Promise<boolean>;
+export {};

package/dist/shell/palette.d.ts

@@ -0,0 +1,13 @@
+import type { TaskItem, QueueItem } from "../data/access.js";
+import { type PhrenResult } from "../shared.js";
+export declare function resultMsg(r: PhrenResult<unknown>): string;
+export declare function editDistance(a: string, b: string): number;
+export declare function tokenize(input: string): string[];
+export declare function tasksByFilter(items: TaskItem[], filter: string): TaskItem[];
+export declare function queueByFilter(items: QueueItem[], filter: string): QueueItem[];
+export declare function expandIds(input: string): string[];
+export declare function normalizeSection(sectionRaw: string): "Active" | "Queue" | "Done" | null;
+export declare function resolveEntryScript(): string;
+export declare function defaultRunHooks(phrenPath: string): Promise<string>;
+export declare function defaultRunUpdate(): Promise<string>;
+export declare function defaultRunRelink(phrenPath: string): Promise<string>;

package/dist/shell/render-api.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Read-only rendering API for the shell views, consumable by external packages
+ * (e.g. @phren/agent) via the "@phren/cli/shell/render-api" subpath export.
+ *
+ * Exposes renderMenuFrame (render a full shell view frame) and handleMenuKey
+ * (pure navigation logic) without pulling in mutation or MCP dependencies.
+ */
+import type { ShellState } from "./state-store.js";
+export type MenuView = ShellState["view"];
+export interface MenuState {
+    view: MenuView;
+    project?: string;
+    filter?: string;
+    cursor: number;
+    scroll: number;
+}
+export interface MenuRenderResult {
+    /** Full ANSI-rendered frame (multi-line string, no trailing newline) */
+    output: string;
+    /** Number of list items in the current view (for cursor clamping) */
+    listCount: number;
+}
+/** Render a full shell frame for the given state. Read-only, no mutations. */
+export declare function renderMenuFrame(phrenPath: string, profile: string, state: MenuState): Promise<MenuRenderResult>;
+/**
+ * Apply a key to the menu state. Returns a new state, or null to signal
+ * "exit menu mode" (Tab or Escape at top level).
+ */
+export declare function handleMenuKey(state: MenuState, keyName: string, listCount: number, phrenPath?: string, profile?: string): MenuState | null;

package/dist/shell/render-api.js

@@ -0,0 +1,101 @@
+import { listProjectCards } from "../data/access.js";
+import { renderShell } from "./view.js";
+import { getListItems } from "./input.js";
+// ── View cycling order (same as the shell tab bar) ──────────────────────────
+const VIEW_ORDER = [
+    "Projects", "Tasks", "Findings", "Review Queue", "Skills", "Hooks",
+];
+// ── Render ──────────────────────────────────────────────────────────────────
+/** Render a full shell frame for the given state. Read-only, no mutations. */
+export async function renderMenuFrame(phrenPath, profile, state) {
+    const shellState = {
+        version: 3,
+        view: state.view,
+        project: state.project,
+        filter: state.filter,
+    };
+    const ctx = {
+        phrenPath,
+        profile,
+        state: shellState,
+        currentCursor: () => state.cursor,
+        currentScroll: () => state.scroll,
+        setScroll: () => { },
+    };
+    const stubDoctor = async () => ({
+        ok: true,
+        checks: [],
+    });
+    const output = await renderShell(ctx, "navigate", // always navigate mode (no input mode in agent menu)
+    "", // no inputCtx
+    "", // no inputBuf
+    false, // no help
+    "Tab: Chat  ←→: Views  ↑↓: Navigate  Enter: Select  /: Filter  Esc: Back", stubDoctor, null, // subsectionsCache
+    () => { }, // setHealthLineCount
+    () => { });
+    const listCount = getListItems(phrenPath, profile, shellState, 0).length;
+    return { output, listCount };
+}
+// ── Navigation (pure function) ──────────────────────────────────────────────
+/**
+ * Apply a key to the menu state. Returns a new state, or null to signal
+ * "exit menu mode" (Tab or Escape at top level).
+ */
+export function handleMenuKey(state, keyName, listCount, phrenPath, profile) {
+    switch (keyName) {
+        // Exit menu
+        case "tab":
+        case "q":
+            return null;
+        // View cycling
+        case "left": {
+            const idx = VIEW_ORDER.indexOf(state.view);
+            const next = idx <= 0 ? VIEW_ORDER[VIEW_ORDER.length - 1] : VIEW_ORDER[idx - 1];
+            return { ...state, view: next, cursor: 0, scroll: 0, filter: undefined };
+        }
+        case "right": {
+            const idx = VIEW_ORDER.indexOf(state.view);
+            const next = idx >= VIEW_ORDER.length - 1 ? VIEW_ORDER[0] : VIEW_ORDER[idx + 1];
+            return { ...state, view: next, cursor: 0, scroll: 0, filter: undefined };
+        }
+        // Cursor movement
+        case "up":
+            return { ...state, cursor: Math.max(0, state.cursor - 1) };
+        case "down":
+            return { ...state, cursor: Math.min(Math.max(0, listCount - 1), state.cursor + 1) };
+        // Enter: drill into project (Projects view only)
+        case "return": {
+            if (state.view === "Projects" && phrenPath && profile) {
+                const cards = listProjectCards(phrenPath, profile);
+                const filtered = state.filter
+                    ? cards.filter((c) => `${c.name} ${c.summary} ${c.docs.join(" ")}`.toLowerCase().includes(state.filter.toLowerCase()))
+                    : cards;
+                const selected = filtered[state.cursor];
+                if (selected) {
+                    return { ...state, view: "Tasks", project: selected.name, cursor: 0, scroll: 0 };
+                }
+            }
+            // Escape from sub-view back to Projects
+            if (state.view !== "Projects" && state.project) {
+                return state; // no-op for non-projects views on enter
+            }
+            return state;
+        }
+        // Escape: clear filter, or go back to projects, or exit
+        case "escape": {
+            if (state.filter)
+                return { ...state, filter: undefined, cursor: 0, scroll: 0 };
+            if (state.view !== "Projects" && state.project) {
+                return { ...state, view: "Projects", project: undefined, cursor: 0, scroll: 0 };
+            }
+            return null; // exit menu
+        }
+        // Health shortcut
+        case "h":
+            if (state.view === "Health")
+                return { ...state, view: "Projects", cursor: 0, scroll: 0 };
+            return { ...state, view: "Health", cursor: 0, scroll: 0 };
+        default:
+            return state;
+    }
+}

package/dist/shell/render.d.ts

@@ -0,0 +1,50 @@
+export declare const RESET = "\u001B[0m";
+export declare const BOLD = "\u001B[1m";
+export declare const DIM = "\u001B[2m";
+export declare const GREEN = "\u001B[32m";
+export declare const YELLOW = "\u001B[33m";
+export declare const RED = "\u001B[31m";
+export declare const CYAN = "\u001B[36m";
+export declare const style: {
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    italic: (s: string) => string;
+    cyan: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    magenta: (s: string) => string;
+    blue: (s: string) => string;
+    white: (s: string) => string;
+    gray: (s: string) => string;
+    boldCyan: (s: string) => string;
+    boldGreen: (s: string) => string;
+    boldYellow: (s: string) => string;
+    boldRed: (s: string) => string;
+    boldMagenta: (s: string) => string;
+    boldBlue: (s: string) => string;
+    dimItalic: (s: string) => string;
+    invert: (s: string) => string;
+};
+export declare function badge(label: string, colorFn: (s: string) => string): string;
+export declare function separator(width?: number): string;
+export declare function stripAnsi(s: string): string;
+export declare function padToWidth(s: string, width: number): string;
+export declare function truncateLine(s: string, cols: number): string;
+export declare function renderWidth(columns?: number): number;
+interface WrapSegmentsOptions {
+    indent?: string;
+    maxLines?: number;
+    separator?: string;
+}
+export declare function wrapSegments(segments: string[], cols: number, opts?: WrapSegmentsOptions): string;
+export declare function gradient(text: string, colors?: string[]): string;
+export declare function lineViewport(allLines: string[], cursorFirstLine: number, cursorLastLine: number, height: number, prevStart: number): {
+    lines: string[];
+    scrollStart: number;
+};
+export declare function shellHelpText(): string;
+export declare function clearScreen(): void;
+export declare function clearToEnd(): void;
+export declare function shellStartupFrames(version: string): string[];
+export {};

package/dist/shell/shell.d.ts

@@ -0,0 +1,61 @@
+import { type ShellView, type ShellDeps, type DoctorResultLike } from "./types.js";
+export type { ShellView, ShellDeps } from "./types.js";
+export declare class PhrenShell {
+    readonly phrenPath: string;
+    readonly profile: string;
+    readonly deps: ShellDeps;
+    private state;
+    private message;
+    healthCache?: {
+        at: number;
+        result: DoctorResultLike;
+    };
+    prevHealthView: ShellView | undefined;
+    showHelp: boolean;
+    private pendingConfirm?;
+    private undoStack;
+    private navMode;
+    private inputBuf;
+    private inputCtx;
+    inputMqId: string;
+    private cursorMap;
+    private viewScrollMap;
+    private healthLineCount;
+    private _subsectionsCache;
+    get mode(): "navigate" | "input";
+    get inputBuffer(): string;
+    get filter(): string | undefined;
+    constructor(phrenPath: string, profile: string, deps?: ShellDeps);
+    close(): void;
+    setMessage(msg: string): void;
+    confirmThen(label: string, action: () => void): void;
+    setView(view: ShellView): void;
+    setFilter(value: string): void;
+    snapshotForUndo(label: string, file: string): void;
+    popUndo(): string;
+    ensureProjectSelected(): string | null;
+    invalidateSubsectionsCache(): void;
+    currentCursor(): number;
+    setCursor(n: number): void;
+    moveCursor(delta: number): void;
+    private currentScroll;
+    private setScroll;
+    getListItems(): {
+        id?: string;
+        name?: string;
+        text?: string;
+        line?: string;
+    }[];
+    startInput(ctx: string, initial: string): void;
+    private cancelInput;
+    private submitInput;
+    handleRawKey(key: string): Promise<boolean>;
+    private handleInputKey;
+    private doctorSnapshot;
+    render(): Promise<string>;
+    private asNavigationHost;
+    private runPalette;
+    handleInput(raw: string): Promise<boolean>;
+    completeInput(line: string): string[];
+}
+export { startShell } from "./entry.js";

package/dist/shell/state-store.d.ts

@@ -0,0 +1,14 @@
+import { type PhrenResult } from "../shared.js";
+export interface ShellState {
+    version: number;
+    view: "Projects" | "Tasks" | "Findings" | "Review Queue" | "Skills" | "Hooks" | "Machines/Profiles" | "Health";
+    project?: string;
+    filter?: string;
+    page?: number;
+    perPage?: number;
+    introMode?: "always" | "once-per-version" | "off";
+    introSeenVersion?: string;
+}
+export declare function loadShellState(phrenPath: string): ShellState;
+export declare function saveShellState(phrenPath: string, state: ShellState): void;
+export declare function resetShellState(phrenPath: string): PhrenResult<string>;

package/dist/shell/types.d.ts

@@ -0,0 +1,29 @@
+import type { ShellState } from "../data/access.js";
+import type { runDoctor } from "../link/link.js";
+export declare const SUB_VIEWS: readonly ["Tasks", "Findings", "Review Queue", "Skills", "Hooks"];
+export declare const TAB_ICONS: Record<string, string>;
+export interface UndoEntry {
+    label: string;
+    file: string;
+    content: string;
+}
+export declare const MAX_UNDO_STACK = 10;
+export type ShellView = ShellState["view"];
+export interface ShellDeps {
+    runDoctor: typeof runDoctor;
+    runRelink: (phrenPath: string) => Promise<string>;
+    runHooks: (phrenPath: string) => Promise<string>;
+    runUpdate: () => Promise<string>;
+}
+interface DoctorCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+export interface DoctorResultLike {
+    ok: boolean;
+    machine?: string;
+    profile?: string;
+    checks: DoctorCheck[];
+}
+export {};

package/dist/shell/view-list.d.ts

@@ -0,0 +1,5 @@
+export declare function formatSelectableLine(line: string, cols: number, selected: boolean): string;
+export declare function viewportWithStatus(allLines: string[], cursorFirstLine: number, cursorLastLine: number, usableHeight: number, previousScroll: number, currentIndex: number, totalItems: number): {
+    lines: string[];
+    scrollStart: number;
+};

package/dist/shell/view.d.ts

@@ -0,0 +1,34 @@
+/**
+ * View rendering functions for the phren interactive shell.
+ * Extracted from shell.ts to keep the orchestrator under 300 lines.
+ */
+import { ShellState } from "../data/access.js";
+import { type DoctorResultLike } from "./types.js";
+/** Shared rendering state passed from the orchestrator */
+export interface ViewContext {
+    phrenPath: string;
+    profile: string;
+    state: ShellState;
+    currentCursor: () => number;
+    currentScroll: () => number;
+    setScroll: (n: number) => void;
+}
+export interface SubsectionsCache {
+    project: string;
+    /** Keys are stable item IDs (bid hash when present, else "row:N") mapped to subsection name */
+    map: Map<string, string>;
+}
+export interface SkillEntry {
+    name: string;
+    path: string;
+    enabled: boolean;
+}
+export declare function getProjectSkills(phrenPath: string, project: string): SkillEntry[];
+export interface HookEntry {
+    event: string;
+    description: string;
+    enabled: boolean;
+}
+export declare function getHookEntries(phrenPath: string, project?: string | null): HookEntry[];
+export { writeInstallPreferences } from "../init/preferences.js";
+export declare function renderShell(ctx: ViewContext, navMode: "navigate" | "input", inputCtx: string, inputBuf: string, showHelp: boolean, message: string, doctorSnapshot: () => Promise<DoctorResultLike>, subsectionsCache: SubsectionsCache | null, setHealthLineCount: (n: number) => void, setSubsectionsCache: (c: SubsectionsCache | null) => void): Promise<string>;

package/dist/skill/files.d.ts

@@ -0,0 +1,5 @@
+import { type SkillManifest } from "./registry.js";
+export declare function syncScopeSkillsToDir(phrenPath: string, scope: string, destDir: string): SkillManifest;
+export declare function syncSkillLinksForScope(phrenPath: string, scope: string): SkillManifest | null;
+export declare function setSkillEnabledAndSync(phrenPath: string, scope: string, name: string, enabled: boolean): void;
+export declare function removeSkillPath(skillPath: string): string;

package/dist/skill/registry.d.ts

@@ -0,0 +1,55 @@
+export interface SkillEntry {
+    name: string;
+    source: string;
+    scopeType: "global" | "project";
+    sourceKind: "canonical";
+    format: "flat" | "folder";
+    path: string;
+    root: string;
+    description?: string;
+    enabled: boolean;
+    command: string;
+    aliases: string[];
+}
+interface ResolvedSkill extends Pick<SkillEntry, "path" | "format" | "root" | "name" | "source" | "enabled" | "description" | "command" | "aliases" | "scopeType" | "sourceKind"> {
+    visibleToAgents: boolean;
+    commandRegistered: boolean;
+    overrides: Array<{
+        source: string;
+        path: string;
+        sourceKind: "canonical";
+    }>;
+    mirrorTargets: string[];
+}
+interface SkillCommandRegistration {
+    command: string;
+    type: "skill";
+    skillId: string;
+    source: string;
+    path: string;
+    kind: "primary" | "alias";
+    registered: boolean;
+}
+interface SkillManifestProblem {
+    code: string;
+    message: string;
+    command?: string;
+    skillIds?: string[];
+}
+export interface SkillManifest {
+    scope: string;
+    project?: string;
+    generatedAt: string;
+    skills: ResolvedSkill[];
+    commands: SkillCommandRegistration[];
+    problems: SkillManifestProblem[];
+}
+export declare function getAllSkills(phrenPath: string, profile: string): SkillEntry[];
+export declare function buildSkillManifest(phrenPath: string, profile: string, scope: string, mirrorDir?: string): SkillManifest;
+export declare function getScopedSkills(phrenPath: string, profile: string, project?: string): ResolvedSkill[];
+export declare function findLocalSkill(phrenPath: string, scope: string, name: string): ResolvedSkill | null;
+export declare function findSkill(phrenPath: string, profile: string, project: string | undefined, name: string): ResolvedSkill | {
+    error: string;
+} | null;
+export declare function renderSkillInstructionsSection(manifest: SkillManifest): string;
+export {};

package/dist/skill/state.d.ts

@@ -0,0 +1,3 @@
+export type SkillScope = string;
+export declare function isSkillEnabled(phrenPath: string, scope: SkillScope, name: string): boolean;
+export declare function setSkillEnabled(phrenPath: string, scope: SkillScope, name: string, enabled: boolean): void;

package/dist/startup-embedding.d.ts

@@ -0,0 +1,15 @@
+import { type SqlJsDatabase } from "./shared/index.js";
+import type { EmbeddingCache } from "./shared/embedding-cache.js";
+export interface EmbeddingWarmupDeps {
+    checkOllamaAvailable(): Promise<boolean>;
+    embedText(text: string): Promise<number[] | null>;
+    getEmbeddingModel(): string;
+    getOllamaUrl(): string | null | undefined;
+    sleep(ms: number): Promise<void>;
+}
+export type EmbeddingCacheLike = Pick<EmbeddingCache, "load" | "get" | "set" | "flush">;
+export declare function startEmbeddingWarmup(db: SqlJsDatabase, cache: EmbeddingCacheLike, deps?: Partial<EmbeddingWarmupDeps>): {
+    loadPromise: Promise<void>;
+    backgroundPromise: Promise<number>;
+};
+export declare function backgroundEmbedMissingDocs(db: SqlJsDatabase, cache: EmbeddingCacheLike, deps?: Partial<EmbeddingWarmupDeps>): Promise<number>;

package/dist/status.d.ts

@@ -0,0 +1 @@
+export declare function runStatus(): Promise<void>;

package/dist/store-registry.d.ts

@@ -0,0 +1,60 @@
+export type StoreRole = "primary" | "team" | "readonly";
+export type StoreSyncMode = "managed-git" | "pull-only";
+export interface StoreEntry {
+    /** Immutable 8-char hex identifier. */
+    id: string;
+    /** Human-readable name (unique within registry). */
+    name: string;
+    /** Absolute path to the store root directory. */
+    path: string;
+    /** Store role — determines read/write/sync behavior. */
+    role: StoreRole;
+    /** Git remote URL (optional). */
+    remote?: string;
+    /** Sync mode for git operations. */
+    sync: StoreSyncMode;
+    /** Projects claimed by this store (for write routing in phase 2). */
+    projects?: string[];
+}
+export interface StoreRegistry {
+    version: 1;
+    stores: StoreEntry[];
+}
+/** Bootstrap metadata committed to a team store repo root. */
+export interface TeamBootstrap {
+    name: string;
+    description?: string;
+    default_role?: StoreRole;
+}
+export declare function storesFilePath(phrenPath: string): string;
+export declare function generateStoreId(): string;
+export declare function readStoreRegistry(phrenPath: string): StoreRegistry | null;
+export declare function writeStoreRegistry(phrenPath: string, registry: StoreRegistry): void;
+/**
+ * Resolve the full list of stores. This is the **key backward-compat function**:
+ * - If stores.yaml exists → parse and return entries
+ * - If stores.yaml is missing → return a single implicit primary entry for phrenPath
+ * - In both cases, append PHREN_FEDERATION_PATHS entries as readonly stores
+ */
+export declare function resolveAllStores(phrenPath: string): StoreEntry[];
+/** The primary store (role=primary). Falls back to implicit entry. */
+export declare function getPrimaryStore(phrenPath: string): StoreEntry;
+/** All stores that can be read (all roles). */
+export declare function getReadableStores(phrenPath: string): StoreEntry[];
+/** Non-primary stores (for federation search, multi-store sync). */
+export declare function getNonPrimaryStores(phrenPath: string): StoreEntry[];
+/** Find a store by name. */
+export declare function findStoreByName(phrenPath: string, name: string): StoreEntry | undefined;
+/** Get project directories for a store, filtered by the store's subscription list (if set). */
+export declare function getStoreProjectDirs(store: StoreEntry): string[];
+export declare function readTeamBootstrap(storePath: string): TeamBootstrap | null;
+/** Add a store entry to the registry. Creates stores.yaml if needed. Uses file locking. */
+export declare function addStoreToRegistry(phrenPath: string, entry: StoreEntry): void;
+/** Remove a store entry by name. Refuses to remove primary. Uses file locking. */
+export declare function removeStoreFromRegistry(phrenPath: string, name: string): StoreEntry;
+/** Update the projects[] claim list for a store. Uses file locking. */
+export declare function updateStoreProjects(phrenPath: string, storeName: string, projects: string[]): void;
+/** Add projects to a store's subscription list. Deduplicates. Uses file locking. */
+export declare function subscribeStoreProjects(phrenPath: string, storeName: string, projects: string[]): void;
+/** Remove projects from a store's subscription list. Uses file locking. */
+export declare function unsubscribeStoreProjects(phrenPath: string, storeName: string, projects: string[]): void;

package/dist/store-routing.d.ts

@@ -0,0 +1,37 @@
+import { type StoreEntry } from "./store-registry.js";
+export interface ResolvedProject {
+    store: StoreEntry;
+    projectName: string;
+    projectDir: string;
+}
+export interface ParsedProjectRef {
+    storeName?: string;
+    projectName: string;
+}
+/**
+ * Parse a project reference that may be store-qualified.
+ *
+ * "arc"          → { projectName: "arc" }
+ * "arc-team/arc" → { storeName: "arc-team", projectName: "arc" }
+ */
+export declare function parseStoreQualified(input: string): ParsedProjectRef;
+/**
+ * Resolve a project reference to a specific store + directory.
+ *
+ * Resolution rules:
+ * 1. If store-qualified ("store/project"), find that store and project within it
+ * 2. If bare ("project"), scan all readable stores for a matching project dir
+ * 3. Exactly one match → return it
+ * 4. Zero matches → throw NOT_FOUND
+ * 5. Multiple matches → throw VALIDATION_ERROR with disambiguation message
+ */
+export declare function resolveProject(phrenPath: string, input: string, profile?: string): ResolvedProject;
+/**
+ * List all projects across all readable stores.
+ * Returns entries with store context for display.
+ */
+export declare function listAllProjects(phrenPath: string, profile?: string): Array<{
+    store: StoreEntry;
+    projectName: string;
+    projectDir: string;
+}>;

package/dist/task/github.d.ts

@@ -0,0 +1,22 @@
+import { type PhrenResult } from "../shared.js";
+import type { TaskItem } from "../data/tasks.js";
+interface GithubIssueRef {
+    repo?: string;
+    issueNumber?: number;
+    url?: string;
+}
+export declare function parseGithubIssueUrl(url: string): GithubIssueRef | null;
+/** @internal Exported for tests. */
+export declare function extractGithubRepoFromText(content: string): string | undefined;
+export declare function resolveProjectGithubRepo(phrenPath: string, project: string): string | undefined;
+export declare function buildTaskIssueBody(project: string, item: TaskItem): string;
+export declare function createGithubIssueForTask(args: {
+    repo: string;
+    title: string;
+    body: string;
+}): PhrenResult<{
+    repo: string;
+    issueNumber?: number;
+    url: string;
+}>;
+export {};

package/dist/task/hygiene.d.ts

@@ -0,0 +1,13 @@
+interface TaskHygieneIssue {
+    id: string;
+    line: string;
+    reason: "anchors-missing" | "keywords-missing";
+    evidence: string[];
+}
+interface TaskHygieneResult {
+    ok: boolean;
+    detail: string;
+    issues: TaskHygieneIssue[];
+}
+export declare function inspectTaskHygiene(phrenPath: string, project: string, repoPath?: string | null): TaskHygieneResult;
+export {};

package/dist/task/lifecycle.d.ts

@@ -0,0 +1,26 @@
+import { type ProactivityLevel } from "../proactivity.js";
+export type TaskMode = "off" | "manual" | "suggest" | "auto";
+interface TaskPromptLifecycleResult {
+    mode: TaskMode;
+    noticeLines: string[];
+}
+export declare function handleTaskPromptLifecycle(args: {
+    phrenPath: string;
+    prompt: string;
+    project: string | null;
+    sessionId?: string;
+    intent: string;
+    taskLevel?: ProactivityLevel;
+}): TaskPromptLifecycleResult;
+export declare function finalizeTaskSession(args: {
+    phrenPath: string;
+    sessionId?: string;
+    status: "clean" | "saved-local" | "saved-pushed" | "no-upstream" | "error";
+    detail: string;
+}): void;
+/**
+ * Return the active TaskItem tracked for a session+project, if any.
+ * Used by mcp-finding.ts to link findings to active tasks.
+ */
+export declare function getActiveTaskForSession(phrenPath: string, sessionId: string, project: string): import("../data/tasks.js").TaskItem | null;
+export {};