@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/state-6HV3D3O4.js

@@ -0,0 +1,717 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  EXIT_OK,
+  EXIT_USAGE
+} from "./chunk-Y7B67G22.js";
+import {
+  terminalDisplayText
+} from "./chunk-EEDZOGV4.js";
+import {
+  cliProjectRoot
+} from "./chunk-H6B6AROX.js";
+import {
+  hashedSlugForCwd,
+  isEntityId,
+  slugForCwd
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/integrations/state/report.ts
+import { constants } from "node:fs";
+import { lstat, open, opendir, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve, sep } from "node:path";
+var MAX_METADATA_BYTES = 4 * 1024 * 1024;
+var MAX_REPORTED_ISSUES = 100;
+var MAX_ENTRIES = 1e5;
+var AUTHORED_TOP_LEVEL = /* @__PURE__ */ new Set(["agents", "commands", "plugins", "skills", "MEMORY.md"]);
+var CONFIG_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "config.yaml",
+  "credentials.json",
+  "identity.json",
+  "preferences.json",
+  "plugin-settings",
+  "trust.json"
+]);
+var RUNTIME_TOP_LEVEL = /* @__PURE__ */ new Set(["attachments", "cli", "cli.json", "projects", "index.sqlite"]);
+var LEGACY_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "state",
+  "sessions",
+  "titles.json",
+  "desktop-sessions.json",
+  "delegation-history",
+  "checkpoints",
+  "tenants",
+  "goals",
+  "feedback",
+  "learning",
+  "residents",
+  "worktrees",
+  "memory"
+]);
+var CONTROL_TOP_LEVEL = /* @__PURE__ */ new Set([".migration"]);
+var PRIVATE_BOUNDARIES = ["attachments", "plugin-settings", "projects"];
+var EntryChangedError = class extends Error {
+  static {
+    __name(this, "EntryChangedError");
+  }
+};
+async function inspectNamzuState(options = {}) {
+  const cwd = await canonicalBase(options.cwd ?? process.cwd());
+  const home = await canonicalBase(options.home ?? homedir());
+  const projectRoot = join(cwd, ".namzu");
+  const environment = options.env ?? (options.home !== void 0 ? {} : process.env);
+  const configuredHome = environment.NAMZU_HOME;
+  const userRoot = await canonicalBase(
+    configuredHome === void 0 || configuredHome.length === 0 ? join(home, ".namzu") : configuredHome
+  );
+  const overlap = projectRoot === userRoot;
+  const specs = overlap ? [{ path: projectRoot, roles: ["project", "user"] }] : [
+    { path: projectRoot, roles: ["project"] },
+    { path: userRoot, roles: ["user"] }
+  ];
+  const roots = [];
+  const collections = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const collection = await collectRoot(
+      spec.path,
+      Math.max(1, Math.floor(options.entryLimit ?? MAX_ENTRIES))
+    );
+    collections.set(spec.path, collection);
+    roots.push(
+      await projectRootReport(collection, spec.roles, {
+        platform: options.platform ?? process.platform,
+        uid: options.uid ?? process.getuid?.()
+      })
+    );
+  }
+  const physicalTotals = roots.reduce(
+    (acc, root) => ({
+      roots: acc.roots + (root.exists ? 1 : 0),
+      files: acc.files + root.files,
+      logicalBytes: acc.logicalBytes + root.logicalBytes
+    }),
+    { roots: 0, files: 0, logicalBytes: 0 }
+  );
+  const projectConfigPath = join(cwd, "namzu.config.json");
+  const projectConfig = await inspectOneRegularFile(projectConfigPath);
+  const userCollection = collections.get(userRoot);
+  const projectBinding = await inspectProjectBinding(userCollection, cwd);
+  return {
+    version: 2,
+    readOnly: true,
+    snapshot: {
+      consistency: "best-effort-unlocked",
+      detail: "No writer lease is acquired. Metadata files are re-statted when inspected, but concurrent writers can change other counts after they are observed."
+    },
+    complete: roots.every((root) => root.complete) && projectBinding.status !== "unknown" && (projectConfig.status === "present" || projectConfig.status === "absent"),
+    scopeRoots: { project: projectRoot, user: userRoot, overlap },
+    physicalTotals,
+    roots,
+    projectConfig: {
+      path: projectConfigPath,
+      status: projectConfig.status,
+      logicalBytes: projectConfig.logicalBytes
+    },
+    projectBinding
+  };
+}
+__name(inspectNamzuState, "inspectNamzuState");
+async function canonicalBase(path) {
+  const absolute = resolve(path);
+  try {
+    return await realpath(absolute);
+  } catch {
+    return absolute;
+  }
+}
+__name(canonicalBase, "canonicalBase");
+async function inspectOneRegularFile(path) {
+  try {
+    const stat = await lstat(path);
+    return stat.isFile() ? { status: "present", logicalBytes: stat.size } : { status: "unsupported", logicalBytes: 0 };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "absent", logicalBytes: 0 };
+    }
+    return { status: "unreadable", logicalBytes: 0 };
+  }
+}
+__name(inspectOneRegularFile, "inspectOneRegularFile");
+async function collectRoot(root, entryLimit) {
+  const sink = { issues: [], omitted: 0 };
+  let rootStat;
+  try {
+    rootStat = await lstat(root);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { root, exists: false, entries: [], issues: [], omittedIssues: 0 };
+    }
+    addIssue(sink, root, error);
+    return { root, exists: true, entries: [], issues: sink.issues, omittedIssues: sink.omitted };
+  }
+  if (rootStat.isSymbolicLink()) {
+    pushIssue(sink, {
+      code: "symlink_not_followed",
+      path: ".",
+      detail: "The state root is a symbolic link and was not followed."
+    });
+    return {
+      root,
+      exists: true,
+      entries: [],
+      rootEntry: rootEntry(root, rootStat),
+      issues: sink.issues,
+      omittedIssues: sink.omitted
+    };
+  }
+  if (!rootStat.isDirectory()) {
+    pushIssue(sink, {
+      code: "unsupported_entry",
+      path: ".",
+      detail: "The state root exists but is not a directory."
+    });
+    return {
+      root,
+      exists: true,
+      entries: [],
+      rootEntry: rootEntry(root, rootStat),
+      issues: sink.issues,
+      omittedIssues: sink.omitted
+    };
+  }
+  const entries = [];
+  await walk(root, "", entries, sink, entryLimit);
+  return {
+    root,
+    exists: true,
+    entries,
+    rootEntry: rootEntry(root, rootStat),
+    issues: sink.issues,
+    omittedIssues: sink.omitted
+  };
+}
+__name(collectRoot, "collectRoot");
+function entryKind(stat) {
+  return stat.isDirectory() ? "directory" : stat.isFile() ? "file" : stat.isSymbolicLink() ? "symlink" : "other";
+}
+__name(entryKind, "entryKind");
+function rootEntry(root, stat) {
+  return {
+    absolute: root,
+    relative: ".",
+    kind: entryKind(stat),
+    size: stat.isFile() ? stat.size : 0,
+    device: stat.dev,
+    inode: stat.ino,
+    modifiedAt: stat.mtimeMs,
+    mode: stat.mode,
+    ...typeof stat.uid === "number" ? { uid: stat.uid } : {}
+  };
+}
+__name(rootEntry, "rootEntry");
+async function walk(root, relativeDir, entries, sink, entryLimit) {
+  const absoluteDir = relativeDir === "" ? root : join(root, relativeDir);
+  const childDirectories = [];
+  try {
+    const directory = await opendir(absoluteDir);
+    for await (const child of directory) {
+      const relativePath = relativeDir === "" ? child.name : join(relativeDir, child.name);
+      if (entries.length >= entryLimit) {
+        pushIssue(sink, {
+          code: "inspection_skipped",
+          path: normalizeRelative(relativePath),
+          detail: `Filesystem inventory reached its ${entryLimit}-entry memory bound; remaining entries were not counted.`
+        });
+        return false;
+      }
+      const absolute = join(root, relativePath);
+      let stat;
+      try {
+        stat = await lstat(absolute);
+      } catch (error) {
+        addIssue(sink, relativePath, error);
+        continue;
+      }
+      const entry = {
+        absolute,
+        relative: normalizeRelative(relativePath),
+        kind: entryKind(stat),
+        size: stat.isFile() ? stat.size : 0,
+        device: stat.dev,
+        inode: stat.ino,
+        modifiedAt: stat.mtimeMs,
+        mode: stat.mode,
+        ...typeof stat.uid === "number" ? { uid: stat.uid } : {}
+      };
+      entries.push(entry);
+      if (entry.kind === "directory") {
+        childDirectories.push(relativePath);
+      } else if (entry.kind === "symlink") {
+        pushIssue(sink, {
+          code: "symlink_not_followed",
+          path: entry.relative,
+          detail: "Symbolic link was counted as an entry but its target was not read."
+        });
+      } else if (entry.kind === "other") {
+        pushIssue(sink, {
+          code: "unsupported_entry",
+          path: entry.relative,
+          detail: "Entry is not a regular file, directory, or symbolic link."
+        });
+      }
+    }
+  } catch (error) {
+    addIssue(sink, relativeDir || ".", error);
+    return true;
+  }
+  for (const childDirectory of childDirectories) {
+    if (!await walk(root, childDirectory, entries, sink, entryLimit)) return false;
+  }
+  return true;
+}
+__name(walk, "walk");
+function normalizeRelative(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+__name(normalizeRelative, "normalizeRelative");
+function addIssue(sink, path, error) {
+  const code = error.code;
+  pushIssue(sink, {
+    code: code === "EACCES" || code === "EPERM" ? "permission_denied" : "unreadable",
+    path: normalizeRelative(path),
+    detail: error instanceof Error ? error.message : String(error)
+  });
+}
+__name(addIssue, "addIssue");
+function pushIssue(sink, issue) {
+  if (sink.issues.length < MAX_REPORTED_ISSUES) sink.issues.push(issue);
+  else sink.omitted += 1;
+}
+__name(pushIssue, "pushIssue");
+async function projectRootReport(collection, roles, privacyContext) {
+  const categories = {
+    authored: emptyMeasure(),
+    configuration: emptyMeasure(),
+    runtime: emptyMeasure(),
+    legacy: emptyMeasure(),
+    control: emptyMeasure(),
+    transient: emptyMeasure(),
+    unknown: emptyMeasure()
+  };
+  let files = 0;
+  let logicalBytes = 0;
+  let directories = 0;
+  for (const entry of collection.entries) {
+    if (entry.kind === "directory") directories += 1;
+    if (entry.kind !== "file") continue;
+    files += 1;
+    logicalBytes += entry.size;
+    const category = categoryOf(entry.relative);
+    categories[category].files += 1;
+    categories[category].logicalBytes += entry.size;
+  }
+  const analysisSink = {
+    issues: [...collection.issues],
+    omitted: collection.omittedIssues
+  };
+  const inventory = inventoryOf(collection);
+  const legacy = legacyOf(collection);
+  const privacy = privacyOf(collection, privacyContext, analysisSink);
+  return {
+    path: collection.root,
+    roles,
+    exists: collection.exists,
+    complete: analysisSink.issues.length === 0 && analysisSink.omitted === 0,
+    files,
+    directories,
+    logicalBytes,
+    categories,
+    inventory,
+    legacy,
+    privacy,
+    issues: analysisSink.issues,
+    omittedIssues: analysisSink.omitted
+  };
+}
+__name(projectRootReport, "projectRootReport");
+function emptyMeasure() {
+  return { files: 0, logicalBytes: 0 };
+}
+__name(emptyMeasure, "emptyMeasure");
+function legacyKey(path) {
+  const [top, second] = path.split("/");
+  if (top === void 0) return void 0;
+  if (LEGACY_TOP_LEVEL.has(top)) return { key: top, kind: "top-level" };
+  if (top === "projects" && second !== void 0 && isEntityId(second, "project")) {
+    return { key: `projects/${second}`, kind: "uuid-project" };
+  }
+  return void 0;
+}
+__name(legacyKey, "legacyKey");
+function categoryOf(path) {
+  const top = path.split("/")[0] ?? path;
+  const name = basename(path);
+  if (legacyKey(path)) return "legacy";
+  if (name.endsWith(".lock") || name.includes(".tmp.") || name.includes(".tmp-") || name.endsWith(".candidate")) {
+    return "transient";
+  }
+  if (AUTHORED_TOP_LEVEL.has(top)) return "authored";
+  if (CONFIG_TOP_LEVEL.has(top)) return "configuration";
+  if (RUNTIME_TOP_LEVEL.has(top) || /^index\.sqlite(-wal|-shm|-journal)?$/.test(top))
+    return "runtime";
+  if (CONTROL_TOP_LEVEL.has(top)) return "control";
+  return "unknown";
+}
+__name(categoryOf, "categoryOf");
+function legacyOf(collection) {
+  const found = /* @__PURE__ */ new Map();
+  for (const entry of collection.entries) {
+    const legacy = legacyKey(entry.relative);
+    if (!legacy) continue;
+    const current = found.get(legacy.key) ?? { kind: legacy.kind, files: 0, bytes: 0 };
+    if (entry.kind === "file") {
+      current.files += 1;
+      current.bytes += entry.size;
+    }
+    found.set(legacy.key, current);
+  }
+  return [...found.entries()].map(([path, value]) => ({
+    path,
+    kind: value.kind,
+    files: value.files,
+    logicalBytes: value.bytes
+  })).sort((a, b) => a.path.localeCompare(b.path));
+}
+__name(legacyOf, "legacyOf");
+function inSlugProject(path) {
+  const parts = path.split("/");
+  if (parts[0] !== "projects" || parts.length < 3) return void 0;
+  const slug = parts[1];
+  if (isEntityId(slug, "project") || !/^[A-Za-z0-9-]+$/.test(slug)) return void 0;
+  return { slug, rest: parts.slice(2) };
+}
+__name(inSlugProject, "inSlugProject");
+function inventoryOf(collection) {
+  const files = collection.entries.filter(
+    (entry) => entry.kind === "file"
+  );
+  const projects = /* @__PURE__ */ new Set();
+  const sessionLogs = [];
+  const subagentLogs = [];
+  const checkpointFiles = [];
+  const toolResultFiles = [];
+  for (const entry of files) {
+    const located = inSlugProject(entry.relative);
+    if (!located) continue;
+    const { slug, rest } = located;
+    const file = rest.at(-1) ?? "";
+    if (rest.length === 1 && file === "project.json") projects.add(slug);
+    else if (rest.length === 1 && file.endsWith(".jsonl") && isEntityId(file.slice(0, -6), "session"))
+      sessionLogs.push(entry);
+    else if (rest.at(-2) === "subagents" && file.endsWith(".jsonl") && isEntityId(file.slice(0, -6), "session"))
+      subagentLogs.push(entry);
+    else if (rest.at(-2) === "checkpoints" && file.endsWith(".json") && isEntityId(file.slice(0, -5), "checkpoint"))
+      checkpointFiles.push(entry);
+    else if (rest.at(-2) === "tool-results") toolResultFiles.push(entry);
+  }
+  const attachmentFiles = files.filter((entry) => entry.relative.startsWith("attachments/"));
+  const attachmentKeys = /* @__PURE__ */ new Map();
+  for (const entry of attachmentFiles) {
+    const suffix = entry.relative.endsWith(".bin") ? ".bin" : entry.relative.endsWith(".type") ? ".type" : void 0;
+    if (!suffix) continue;
+    const key = entry.relative.slice("attachments/".length, -suffix.length);
+    const pair = attachmentKeys.get(key) ?? {};
+    if (suffix === ".bin") pair.data = entry;
+    else pair.type = entry;
+    attachmentKeys.set(key, pair);
+  }
+  return {
+    projects: projects.size,
+    sessionLogs: measureFiles(sessionLogs),
+    subagentLogs: measureFiles(subagentLogs),
+    checkpointFiles: measureFiles(checkpointFiles),
+    toolResultFiles: measureFiles(toolResultFiles),
+    attachments: {
+      ...measureFiles(attachmentFiles),
+      pairs: [...attachmentKeys.values()].filter((pair) => pair.data && pair.type).length,
+      orphanedDataFiles: [...attachmentKeys.values()].filter((pair) => pair.data && !pair.type).length,
+      orphanedTypeFiles: [...attachmentKeys.values()].filter((pair) => pair.type && !pair.data).length
+    }
+  };
+}
+__name(inventoryOf, "inventoryOf");
+function measureFiles(entries) {
+  return {
+    files: entries.length,
+    logicalBytes: entries.reduce((sum, entry) => sum + entry.size, 0)
+  };
+}
+__name(measureFiles, "measureFiles");
+function privacyOf(collection, context, sink) {
+  const byRelative = new Map(collection.entries.map((entry) => [entry.relative, entry]));
+  const out = [];
+  for (const segment of PRIVATE_BOUNDARIES) {
+    const entry = byRelative.get(segment);
+    if (!entry) continue;
+    if (entry.kind !== "directory") {
+      out.push({ path: segment, status: "insecure", detail: "Boundary is not a directory." });
+      continue;
+    }
+    if (context.platform === "win32" || context.uid === void 0) {
+      out.push({
+        path: segment,
+        status: "unknown",
+        detail: "POSIX mode bits cannot establish the effective owner-only ACL on this platform."
+      });
+      continue;
+    }
+    const root = collection.rootEntry;
+    const rootOwnerMatches = root?.uid === void 0 || context.uid === void 0 || root.uid === context.uid;
+    const rootIsPrivate = root?.kind === "directory" && rootOwnerMatches && (root.mode & 63) === 0;
+    if (entry.uid !== void 0 && entry.uid !== context.uid) {
+      pushIssue(sink, {
+        code: "owner_mismatch",
+        path: segment,
+        detail: `Boundary is owned by uid ${entry.uid}, current uid is ${context.uid}.`
+      });
+      out.push({ path: segment, status: "insecure", detail: "Boundary owner does not match." });
+      continue;
+    }
+    const exposed = entry.mode & 63;
+    out.push(
+      exposed === 0 || rootIsPrivate ? {
+        path: segment,
+        status: "secure",
+        detail: exposed === 0 ? "Owner-only directory boundary." : "Shared child mode is contained by the owner-only state root."
+      } : {
+        path: segment,
+        status: "insecure",
+        detail: `Directory mode ${modeText(entry.mode)} grants group or other access.`
+      }
+    );
+  }
+  return out;
+}
+__name(privacyOf, "privacyOf");
+function modeText(mode) {
+  return (mode & 511).toString(8).padStart(3, "0");
+}
+__name(modeText, "modeText");
+async function inspectProjectBinding(collection, canonicalCwd) {
+  if (!collection.exists) {
+    return { status: "uninitialized", detail: "No application home exists yet." };
+  }
+  let projectRoot;
+  try {
+    projectRoot = await canonicalBase(cliProjectRoot(canonicalCwd));
+  } catch (error) {
+    return {
+      status: "unknown",
+      detail: `The checkout root could not be resolved: ${errorMessage(error)}`
+    };
+  }
+  const files = new Map(
+    collection.entries.filter((entry) => entry.kind === "file").map((entry) => [entry.relative, entry])
+  );
+  for (const slug of [slugForCwd(projectRoot), hashedSlugForCwd(projectRoot)]) {
+    const entry = files.get(`projects/${slug}/project.json`);
+    if (!entry) continue;
+    let record;
+    try {
+      const value = JSON.parse(await readBoundedRegularFile(entry, MAX_METADATA_BYTES));
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return { status: "corrupt-project", slug, detail: "project.json is not an object." };
+      }
+      record = value;
+    } catch (error) {
+      return {
+        status: "corrupt-project",
+        slug,
+        detail: `project.json could not be read as bounded JSON: ${errorMessage(error)}`
+      };
+    }
+    if (record.v !== 1 || record.kind !== "project" || !isEntityId(record.projectId, "project") || typeof record.cwd !== "string") {
+      return { status: "corrupt-project", slug, detail: "project.json is not a project document." };
+    }
+    if (record.cwd !== projectRoot) continue;
+    return {
+      status: "bound",
+      slug,
+      projectId: record.projectId,
+      detail: `Project ${record.projectId} at projects/${slug} stands for ${projectRoot}.`
+    };
+  }
+  return {
+    status: "uninitialized",
+    detail: "No project in this application home stands for this working directory yet."
+  };
+}
+__name(inspectProjectBinding, "inspectProjectBinding");
+async function readBoundedRegularFile(entry, maxBytes) {
+  if (entry.kind !== "file") throw new Error("entry is not a regular file");
+  if (entry.size > maxBytes) throw new Error(`metadata exceeds ${maxBytes} bytes`);
+  const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW ?? 0;
+  const handle = await open(entry.absolute, constants.O_RDONLY | noFollow);
+  try {
+    const before = await handle.stat();
+    assertSameEntry(entry, before);
+    if (before.size > maxBytes) throw new Error(`metadata exceeds ${maxBytes} bytes`);
+    const contents = await handle.readFile({ encoding: "utf8" });
+    const after = await handle.stat();
+    if (after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
+      throw new EntryChangedError("entry changed while its contents were being read");
+    }
+    return contents;
+  } finally {
+    await handle.close();
+  }
+}
+__name(readBoundedRegularFile, "readBoundedRegularFile");
+function assertSameEntry(entry, stat) {
+  if (!stat.isFile()) throw new EntryChangedError("entry is no longer a regular file");
+  if (stat.dev !== entry.device || stat.ino !== entry.inode || stat.size !== entry.size || stat.mtimeMs !== entry.modifiedAt) {
+    throw new EntryChangedError("entry changed after filesystem enumeration");
+  }
+}
+__name(assertSameEntry, "assertSameEntry");
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(errorMessage, "errorMessage");
+
+// src/commands/state.ts
+var HELP = `namzu state \u2014 inspect local Namzu state without changing it
+
+Usage:
+  namzu state
+  namzu state report
+
+Output:
+  Use the global --format json or --format yaml flag for structured output.
+
+This command does not load project configuration, create a Session, repair,
+move, chmod, or delete state. Future mutating operations live under explicit
+state subcommands; unknown subcommands are refused.
+
+Options:
+  -h, --help  Show this help`;
+function createStateCommand(deps) {
+  return {
+    name: "state",
+    description: "Inspect local Namzu state without changing it",
+    passThrough: true,
+    help: HELP,
+    handler: /* @__PURE__ */ __name(async ({ ctx, rawArgs }) => {
+      if (!(rawArgs.length === 0 || rawArgs.length === 1 && rawArgs[0] === "report")) {
+        ctx.formatter.error({ message: "Usage: namzu state [report]" });
+        return EXIT_USAGE;
+      }
+      const report = await deps.inspect();
+      ctx.formatter.print({ ...report, text: renderStateReport(report) });
+      return EXIT_OK;
+    }, "handler")
+  };
+}
+__name(createStateCommand, "createStateCommand");
+var stateCommand = createStateCommand({
+  inspect: inspectNamzuState
+});
+function renderStateReport(report) {
+  const lines = [
+    "Namzu state \u2014 read-only inventory",
+    `Scan complete: ${report.complete ? "yes" : "no"}`,
+    `Snapshot: ${report.snapshot.consistency} \u2014 ${report.snapshot.detail}`,
+    `Physical total: ${formatBytes(report.physicalTotals.logicalBytes)} \xB7 ${report.physicalTotals.files} files \xB7 ${report.physicalTotals.roots} roots`
+  ];
+  if (report.scopeRoots.overlap) {
+    lines.push(
+      "Project and user scopes resolve to the same physical .namzu directory; bytes are counted once."
+    );
+  }
+  for (const root of report.roots) {
+    lines.push("");
+    lines.push(`${root.roles.join(" + ")}: ${safePath(root.path)}`);
+    if (!root.exists) {
+      lines.push("  not initialized");
+      continue;
+    }
+    lines.push(
+      `  ${formatBytes(root.logicalBytes)} \xB7 ${root.files} files \xB7 ${root.directories} directories`
+    );
+    for (const [category, measure] of Object.entries(root.categories)) {
+      if (measure.files === 0) continue;
+      lines.push(`  ${category}: ${formatBytes(measure.logicalBytes)} \xB7 ${measure.files} files`);
+    }
+    const inventory = root.inventory;
+    if (inventory.projects > 0 || inventory.sessionLogs.files > 0) {
+      lines.push(
+        `  projects ${inventory.projects} \xB7 session logs ${inventory.sessionLogs.files} (${formatBytes(inventory.sessionLogs.logicalBytes)}) \xB7 subagent logs ${inventory.subagentLogs.files} \xB7 checkpoints ${inventory.checkpointFiles.files} (${formatBytes(inventory.checkpointFiles.logicalBytes)})`
+      );
+    }
+    if (inventory.attachments.files > 0) {
+      lines.push(
+        `  attachment files ${inventory.attachments.files} (${formatBytes(inventory.attachments.logicalBytes)}) \xB7 ${inventory.attachments.pairs} complete pairs \xB7 ${inventory.attachments.orphanedDataFiles + inventory.attachments.orphanedTypeFiles} orphan halves`
+      );
+    }
+    if (root.legacy.length > 0) {
+      lines.push(
+        "  legacy (the layout before session logs; not read by this version, never changed here):"
+      );
+      for (const entry of root.legacy) {
+        lines.push(
+          `    ${safePath(entry.path)} \u2014 ${formatBytes(entry.logicalBytes)} \xB7 ${entry.files} files`
+        );
+      }
+    }
+    for (const boundary of root.privacy) {
+      if (boundary.status === "secure") continue;
+      lines.push(
+        `  privacy ${boundary.status}: ${safePath(boundary.path)} \u2014 ${safeLine(boundary.detail)}`
+      );
+    }
+    for (const issue of root.issues) {
+      lines.push(`  issue ${issue.code}: ${safePath(issue.path)} \u2014 ${safeLine(issue.detail)}`);
+    }
+    if (root.omittedIssues > 0) lines.push(`  ${root.omittedIssues} additional issues omitted`);
+  }
+  lines.push("");
+  lines.push(
+    `Project binding: ${report.projectBinding.status} \u2014 ${safeLine(report.projectBinding.detail)}`
+  );
+  lines.push(
+    `Project config: ${report.projectConfig.status}${report.projectConfig.status === "present" ? ` \xB7 ${formatBytes(report.projectConfig.logicalBytes)}` : ""} at ${safePath(report.projectConfig.path)}`
+  );
+  lines.push("No files were changed. Legacy state is reported, not declared safe to delete.");
+  return lines.join("\n");
+}
+__name(renderStateReport, "renderStateReport");
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KiB", "MiB", "GiB", "TiB"];
+  let value = bytes / 1024;
+  let unit = units[0];
+  for (let index = 1; index < units.length && value >= 1024; index += 1) {
+    value /= 1024;
+    unit = units[index];
+  }
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${unit}`;
+}
+__name(formatBytes, "formatBytes");
+function safePath(path) {
+  return safeLine(path);
+}
+__name(safePath, "safePath");
+function safeLine(text) {
+  return terminalDisplayText(text).replaceAll("\n", "\\n").replaceAll("	", "\\t");
+}
+__name(safeLine, "safeLine");
+export {
+  createStateCommand,
+  renderStateReport,
+  stateCommand
+};
+//# sourceMappingURL=state-6HV3D3O4.js.map