freeharness 0.4.1 → 0.4.3

package/dist/adapters/memory/worker-control.d.ts

@@ -0,0 +1,9 @@
+import fs from "node:fs";
+export interface StopResult {
+    /** True when no worker answers and no live pid file remains. */
+    stopped: boolean;
+    wasRunning: boolean;
+    reason?: string;
+}
+/** True when `pidFile` exists and names a live process, or cannot be read as a pid record. */
+export declare function pidFileLive(pidFile: string, f?: typeof fs): boolean;

package/dist/adapters/memory/worker-control.js

@@ -0,0 +1,30 @@
+// The worker's pid-file check and the stop outcome shared by the doctor's stop and restart paths.
+import fs from "node:fs";
+function readJsonText(raw) {
+    try {
+        return JSON.parse(raw) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** True when `pidFile` exists and names a live process, or cannot be read as a pid record. */
+export function pidFileLive(pidFile, f = fs) {
+    let raw;
+    try {
+        raw = f.readFileSync(pidFile, "utf8");
+    }
+    catch {
+        return false;
+    }
+    const pid = Number(readJsonText(raw).pid);
+    if (!Number.isInteger(pid) || pid <= 0)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}

package/dist/adapters/sync/diff.js

@@ -87,7 +87,10 @@ function manifest(target, repo, fork) {
                 label: "plugin/.mcp.json", vendored: path.join(v, "plugin/.mcp.json"), upstream: path.join(fork, "plugin/.mcp.json"), contract: true,
                 divergent: "rewritten to spawn ${CLAUDE_PLUGIN_ROOT}/scripts/mcp-server.cjs directly (memory-slim)",
             },
-            { label: "mem-search/SKILL.md", vendored: path.join(v, "plugin/skills/mem-search/SKILL.md"), upstream: path.join(fork, "plugin/skills/mem-search/SKILL.md"), contract: true },
+            {
+                label: "mem-search/SKILL.md", vendored: path.join(v, "plugin/skills/mem-search/SKILL.md"), upstream: path.join(fork, "plugin/skills/mem-search/SKILL.md"), contract: true,
+                divergent: "rewritten to name only the tools the slim MCP server registers (radar-w43-fixes)",
+            },
         ];
     }
     throw new Error(`Unknown sync target: ${target}. Valid: sdd, memory.`);

package/dist/cli/cleanup-prompt.d.ts

@@ -0,0 +1,35 @@
+import type { PromptPort } from "@freeharness/core";
+import { type CleanupItem, type CleanupPlan, type CleanupResult } from "./cleanup.js";
+import { type HardPlan, type HardResult } from "./hard-cleanup.js";
+export interface CleanupAnswers {
+    main: boolean;
+    backups: boolean;
+    hard: boolean;
+}
+export interface CleanupDecision {
+    abort?: string;
+    remove: (item: CleanupItem) => boolean;
+    moveHard: boolean;
+}
+/**
+ * Maps the answers to pass-2 actions; the hard answer counts only with --hard.
+ * @param offersMoves The cleanup plan holds an archive item, so the abort line names moves too.
+ */
+export declare function cleanupDecision(answers: CleanupAnswers, withHard: boolean, offersMoves?: boolean): CleanupDecision;
+/** The third cleanup confirmation, for the hard items. */
+export declare function hardPrompt(count: number, archiveRoot: string): string;
+export interface CleanupPass2 {
+    plan: CleanupPlan;
+    hard?: HardPlan;
+    /** `--yes`: every prompt is answered yes and none is shown. */
+    yes: boolean;
+    prompt: Pick<PromptPort, "confirm">;
+    log: (line: string) => void;
+}
+/** `archived` is absent when the hard plan was not confirmed. */
+export interface CleanupPass2Result {
+    done: CleanupResult;
+    archived?: HardResult;
+}
+/** Asks the three confirmations, then applies what was confirmed; undefined when all were no. */
+export declare function runCleanupPass2(input: CleanupPass2): Promise<CleanupPass2Result | undefined>;

package/dist/cli/cleanup-prompt.js

@@ -0,0 +1,68 @@
+import { applyCleanup } from "./cleanup.js";
+import { applyHard, printable } from "./hard-cleanup.js";
+/**
+ * Maps the answers to pass-2 actions; the hard answer counts only with --hard.
+ * @param offersMoves The cleanup plan holds an archive item, so the abort line names moves too.
+ */
+export function cleanupDecision(answers, withHard, offersMoves = false) {
+    const moveHard = withHard && answers.hard;
+    const nothing = !answers.main && !answers.backups && !moveHard;
+    let abort;
+    if (nothing)
+        abort = withHard || offersMoves ? "Aborted; nothing was removed or moved." : "Aborted; nothing was removed.";
+    return { abort, remove: (i) => (i.group === "backups" ? answers.backups : answers.main), moveHard };
+}
+/** The first cleanup confirmation; a zero remove or archive count is left out. */
+function mainPrompt(removeCount, archiveCount) {
+    if (archiveCount === 0)
+        return `\nRemove the ${removeCount} item(s) above (backups excluded)?`;
+    if (removeCount === 0)
+        return `\nArchive the ${archiveCount} item(s) above (backups excluded)?`;
+    return `\nRemove ${removeCount} and archive ${archiveCount} item(s) above (backups excluded)?`;
+}
+/** The third cleanup confirmation, for the hard items. */
+export function hardPrompt(count, archiveRoot) {
+    return `Move the ${count} item(s) to ${printable(archiveRoot)}?`;
+}
+/** Asks the three confirmations, then applies what was confirmed; undefined when all were no. */
+export async function runCleanupPass2(input) {
+    const { plan, hard, yes, prompt, log } = input;
+    const removable = plan.items.filter((i) => !i.refused);
+    const main = removable.filter((i) => i.group !== "backups");
+    const backups = removable.filter((i) => i.group === "backups");
+    const movable = hard?.items.filter((i) => !i.refused) ?? [];
+    const archive = main.filter((i) => i.archiveDest !== undefined).length;
+    let confirmMain = yes;
+    let confirmBackups = yes;
+    let confirmHard = yes;
+    if (!yes) {
+        if (main.length > 0)
+            confirmMain = await prompt.confirm(mainPrompt(main.length - archive, archive));
+        if (backups.length > 0) {
+            const total = backups.reduce((n, b) => n + (b.bytes ?? 0), 0);
+            confirmBackups = await prompt.confirm(`Also delete the ${backups.length} memory backup dir(s) (${total >= 1048576 ? `${(total / 1048576).toFixed(1)} MB` : `${total} B`})? They cannot be recovered.`);
+        }
+        if (hard && movable.length > 0)
+            confirmHard = await prompt.confirm(hardPrompt(movable.length, hard.archiveRoot));
+    }
+    const decision = cleanupDecision({ main: confirmMain, backups: confirmBackups, hard: confirmHard }, hard !== undefined, archive > 0);
+    if (decision.abort) {
+        log(decision.abort);
+        return undefined;
+    }
+    const done = applyCleanup(plan, decision.remove);
+    for (const r of done.removed)
+        log(`  removed: ${printable(r)}`);
+    for (const m of done.moved)
+        log(`  moved:   ${printable(m)}`);
+    for (const k of done.skipped)
+        log(`  kept:    ${printable(k)}`);
+    for (const w of done.warnings)
+        log(`  WARN     ${printable(w)}`);
+    const archived = hard && decision.moveHard ? applyHard(hard) : undefined;
+    for (const m of archived?.moved ?? [])
+        log(`  moved:   ${printable(m)}`);
+    for (const w of archived?.warnings ?? [])
+        log(`  WARN     ${printable(w)}`);
+    return { done, archived };
+}

package/dist/cli/cleanup.d.ts

@@ -1,6 +1,5 @@
 import type { Scope } from "@freeharness/core";
 import { UPSTREAM_PLUGIN_NAME } from "../adapters/memory/vendored.js";
-import { type InstallManifest } from "../infra/manifest.js";
 import { type MemoryDiagnosis } from "../adapters/memory/doctor.js";
 /** The vendored `openspec` bin replaces it. */
 export declare const LEGACY_OPENSPEC_PACKAGE = "@fission-ai/openspec";
@@ -8,25 +7,11 @@ export declare const LEGACY_OPENSPEC_PACKAGE = "@fission-ai/openspec";
 export declare const CLI_PACKAGE = "freeharness";
 /** Backups confirm separately. */
 export type CleanupGroup = "memory" | "backups" | "legacy" | "duplicates" | "npm" | "retired";
-/** Retired by a rename or a fold, bare names under `~/.claude`. */
-export declare const RETIRED: {
-    readonly skills: readonly ["local-code-intel"];
-    readonly agents: readonly ["mle-reviewer", "mle-evaluator"];
-};
-/** One retired name found on disk, with its manifest-recorded flag. */
-export interface RetiredFinding {
-    kind: "skill" | "agent";
-    name: string;
-    /** Skill dir or agent file. */
-    path: string;
-    /** Manifest lists `path` (agent) or a file under it (skill dir). */
-    recorded: boolean;
-}
-/** Whose entries a `hooks` item prunes. */
-export type HookOwner = "freeharness" | typeof UPSTREAM_PLUGIN_NAME;
+/** Whose entries a `hooks` item prunes; `retired` is only the entries running a retired hook script. */
+export type HookOwner = "freeharness" | typeof UPSTREAM_PLUGIN_NAME | "retired";
 /** One leftover the cleanup knows how to remove. */
 export interface CleanupItem {
-    kind: "dir" | "file" | "hooks" | "npm-global" | "settings-key";
+    kind: "dir" | "file" | "hooks" | "npm-global" | "json-key";
     /** Filesystem path, or the package name for `npm-global`. */
     target: string;
     reason: string;
@@ -39,8 +24,14 @@ export interface CleanupItem {
     hookOwner?: HookOwner;
     /** `npm-global` items: try `npm unlink -g` first, then `npm uninstall -g`. */
     unlink?: boolean;
-    /** `settings-key` items: the `enabledPlugins` key removed from `target`. */
-    settingsKey?: string;
+    /** `json-key` items: the key removed from the JSON object in `target`, outermost first. */
+    keyPath?: string[];
+    /** Plugin-cache and IDE-rule items: the archive path the item moves to instead of being removed; `json-key` items: where the pre-edit copy goes. */
+    archiveDest?: string;
+    /** Marks an IDE rule file, whose archive check differs from a plugin-cache item's. */
+    ideRule?: boolean;
+    /** Upstream launcher items, each kind with its own pass-2 check. */
+    launcher?: "mcp" | "marketplace";
 }
 /** What a cleanup pass would (or did) do. */
 export interface CleanupPlan {
@@ -48,10 +39,14 @@ export interface CleanupPlan {
     items: CleanupItem[];
     /** Informational lines: seen, but out of the fixed list. */
     notes: string[];
+    /** User scope: the dated archive every `archiveDest` lies in. */
+    archiveRoot?: string;
 }
 /** Outcome of `applyCleanup`. */
 export interface CleanupResult {
     removed: string[];
+    /** One `source -> destination` line per plugin-cache item moved into the archive. */
+    moved: string[];
     /** Refused, or not confirmed. */
     skipped: string[];
     /** Non-fatal failures (an npm uninstall that exited non-zero). */
@@ -63,6 +58,8 @@ export interface CleanupDeps {
     memory?: MemoryDiagnosis;
     /** Names the agents/skills a project may duplicate. */
     canonicalDir?: string;
+    /** The run's dated archive, shared with the hard plan (default: today's under the home dir). */
+    archiveRoot?: string;
 }
 /** Sums the size (bytes) of every file under a directory. */
 export declare function dirBytes(dir: string): number;
@@ -72,12 +69,13 @@ export declare function humanBytes(n: number): string;
 export declare function globalNpmPackages(): Record<string, string> | null;
 /** The `<npm prefix -g>/bin/freeharness` shadowing ours on PATH (an old `npm link -g`); undefined when absent, identical to ours, or npm is unavailable. */
 export declare function globalNpmFreeharnessBin(): string | undefined;
-/** Claude-mem data backups written by `freeharness memory backup` (`<dataDir>-backup-<stamp>`), oldest first. */
-export declare function memoryBackupDirs(): string[];
+/**
+ * Memory data backups written by `freeharness memory backup` (`<dataDir>-backup-<stamp>`), sorted.
+ * Backups of the default directory count even while a redirected directory is in use.
+ */
+export declare function memoryBackupDirs(env?: Record<string, string | undefined>, home?: string): string[];
 /** Drops install-manifest entries whose file no longer exists (else every removal is "drift"); 0 without a manifest. */
 export declare function pruneManifest(scope: Scope, projectRoot: string): number;
-/** Retired skill/agent names still present under a `.claude` dir: `update`'s additive merge never deletes them; an absent path is skipped. */
-export declare function retiredFindings(claudeDir: string, manifest: InstallManifest | undefined): RetiredFinding[];
 /** Builds the cleanup plan for a scope without touching anything; `items` is empty when there is nothing to do. */
 export declare function planCleanup(scope: Scope, projectRoot: string, deps?: CleanupDeps): Promise<CleanupPlan>;
 /** Removes the confirmed items of a plan (`confirmed` defaults to all); refused items are always skipped. */