@lmzhen/dsh-evolution-commands 0.21.0 → 0.23.0

package/lib/types/doctor.d.ts

@@ -1,4 +1,5 @@
 import { type PlatformServiceProbe, type ScopedProbeReport } from '@lmzhen/dsh-evolution-core';
+import type { MountedProfile } from './profiles.ts';
 /** P2-20 (audit): the TS-side copy of the install-target tails. The script
  * side (install-layered.mjs, verify-profile-bundles.mjs) imports the list
  * from packages/scripts/lib-family-packages.mjs; guard-scripts.spec.ts pins
@@ -79,6 +80,11 @@ export interface DoctorReport {
      * counterpart (inferred from the install form, P0-1) and may disagree on a
      * multi-profile machine; the render marks the aggregation explicitly. */
     bundles: string[];
+    /** G3 (0.22): profile directories under this home that are NOT the profile this process runs in.
+     * On a one-home-two-planes machine (or after a home clone) they are leftovers from the other
+     * plane: the write-path exclusion ignores them, while {@link bundles} still counts them — this
+     * list is what makes that difference visible instead of mysterious. */
+    foreignProfiles: string[];
     conflicts: string[];
     envIssues: string[];
     /** S0.2 (v37 P0-1): memory files carrying the platform's `{{` prompt-variable
@@ -153,6 +159,7 @@ export declare function diagnose(ctx: {
     get(name: string): unknown;
 }, options?: {
     home?: string;
+    mounted?: MountedProfile;
 }): Promise<DoctorReport>;
 export declare function renderDoctorText(report: DoctorReport): string;
 //# sourceMappingURL=doctor.d.ts.map

package/lib/types/index.d.ts

@@ -12,6 +12,8 @@ declare module '@deepseek-ai/dsh-llm' {
         } & ContextFormed;
     }
 }
+import { atomicWriteFiles } from '@lmzhen/dsh-evolution-core';
+export { atomicWriteFiles };
 export declare const name = "evolution-commands";
 export interface Config {
     /** Skill-tree root for maintain/restructure; empty uses the default tree.
@@ -71,46 +73,4 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     threatExemptLabels: z<string[], string[], "defined">;
 }>>, "plain">;
 export declare function apply(ctx: Context, rawConfig?: Config): void;
-/** F-211: the fs surface atomicWriteFiles uses — injectable so the commit-phase
- * rename-failure path is deterministically testable. Defaults to node:fs.
- * `mtime` (optional) probes a path's last-write time so the failed-commit
- * recovery message can name the generation it restored from. */
-interface FsOps {
-    writeFileSync(path: string, data: string | Uint8Array): void;
-    existsSync(path: string): boolean;
-    copyFileSync(from: string, to: string): void;
-    renameSync(from: string, to: string): void;
-    rmSync(path: string, options?: {
-        force?: boolean;
-        recursive?: boolean;
-    }): void;
-    mtime?(path: string): number | null;
-}
-/**
- * S6.3 (E-40): atomically replace a set of files within one directory.
- * Each file is staged to a sibling `<name>.tmp`, then renamed into place
- * (atomic on the same filesystem); a pre-existing file keeps a single
- * `<name>.bak`. A failure at ANY staging step removes the staged temps and
- * leaves the previous files untouched — a half-written target is impossible
- * up to the staging and backup phases.
- *
- * F-211: the rename COMMIT phase does not carry the same guarantee. When a
- * filesystem refuses to overwrite the destination, the code removes it and
- * retries the rename; if the retry ALSO fails the destination is gone. The
- * single `.bak` created above still holds the previous content, so the target
- * is restored from it (best-effort) before the original rename error is
- * rethrown, so a failed commit never leaves the file missing.
- *
- * V4-17: the `.bak` is refreshed to the committed content after every
- * successful commit, so a later failed commit always recovers to the most
- * recent good generation (a once-at-first-install `.bak` could otherwise
- * restore content several installs old). The recovery error names the `.bak`
- * source (and mtime when available) so the caller knows the generation it
- * restored from.
- */
-export declare function atomicWriteFiles(targetDir: string, writes: Array<{
-    name: string;
-    content: string | Uint8Array;
-}>, fs?: FsOps, logger?: (message: string) => void): void;
-export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/types/parse.d.ts

@@ -0,0 +1,65 @@
+/**
+ * F-4/G7.4 (C7): the ONE parser for the /evolution command surface.
+ *
+ * The surface used to answer each subcommand with its own regex (`^params(?: --group ([a-z-]+))?(?: --json)?$`
+ * and nine siblings), so `params --json --group review` and `params --group=review` were refused as
+ * "not a subcommand", while a sibling regex accepted `=` — and a mistyped group name degraded into the
+ * generic error instead of the one that lists the known groups.
+ *
+ * This parser is order- and `=`-tolerant, matches the subcommand name case-insensitively, keeps a flag
+ * VALUE's case intact (the domain layer is the one that validates it), and answers a SYNTAX failure when a
+ * declared value flag is left without its value (F-3: `policy set a.b --expect 3` must not read
+ * `--expect 3` as the value).
+ *
+ * @module @lmzhen/dsh-evolution-commands/parse
+ */
+/** The flags whose declared form takes a value (`--group <name>`, `--expect <revision>`, …). */
+/**
+ * Exported so the command-table gate can tie it to the table's usage lines (P2: two declarations of
+ * "which flags take a value" would otherwise be free to drift apart).
+ */
+export declare const VALUE_FLAGS: readonly string[];
+/** One parsed command line. */
+export interface ParsedCommand {
+    /** The subcommand name, lower-cased (the table stores it lower-case too). */
+    readonly name: string;
+    /** Declared flags: a value when the flag takes one, `true` when it is bare. */
+    readonly flags: ReadonlyMap<string, string | true>;
+    /** Everything that was neither the name nor a flag, in order. */
+    readonly positionals: readonly string[];
+}
+/** A SYNTAX failure — the caller answers it as a usage error, never as a domain error. */
+export interface ParseFailure {
+    /** Which syntax rule was broken. */
+    readonly kind: 'unknown-subcommand' | 'unknown-flag' | 'missing-value';
+    /** The subcommand name the caller saw (empty when the line was empty). */
+    readonly name: string;
+    /** The flag involved, for the two flag failures. */
+    readonly flag?: string;
+}
+/**
+ * Narrow a parse result: true when it is the syntax failure rather than a command.
+ * @param result - what {@link parseSubcommand} answered.
+ * @returns whether the line was refused.
+ */
+export declare function isParseFailure(result: ParsedCommand | ParseFailure): result is ParseFailure;
+/**
+ * Read one SUB-FORM line: `maintain status`, `maintain report`, … — the shape the regexes used to own.
+ *
+ * A sub-form matches only when: the line parses, the name matches, the first positional is the sub-form,
+ * and every flag the line carries is DECLARED by the table (an undeclared flag keeps the old
+ * "unknown arguments" answer instead of silently becoming a bare flag).
+ * @param input - the text after `/evolution`.
+ * @param name - the subcommand name the table declares (e.g. `maintain`).
+ * @param sub - the sub-form word (e.g. `status`).
+ * @param declaredFlags - the flags the table declares for `name` (`flagsOf(name)`).
+ * @returns the parsed command, or null when this line is not that sub-form.
+ */
+export declare function subcommandOf(input: string, name: string, sub: string, declaredFlags: readonly string[]): ParsedCommand | null;
+/**
+ * Parse one command line into its name, flags and positionals.
+ * @param input - the text after `/evolution`.
+ * @returns the parsed command, or the syntax failure that refused it.
+ */
+export declare function parseSubcommand(input: string): ParsedCommand | ParseFailure;
+//# sourceMappingURL=parse.d.ts.map

package/lib/types/profiles.d.ts

@@ -0,0 +1,74 @@
+/** The patch file name inside a profile directory (the platform's own spelling). */
+export declare const PROFILE_PATCH_FILENAME = "cordis.patch.yml";
+/** One profile directory under a home. */
+export interface HomeProfile {
+    /** The profile's directory name (what `--profile` spells). */
+    readonly profile: string;
+    /** Its absolute (or home-relative-joined) directory. */
+    readonly dir: string;
+}
+/** The outcome of reading `<home>/profiles`: the entries, or why they could not be read. */
+export type ProfilesScan = {
+    readonly kind: 'scanned';
+    readonly profiles: readonly HomeProfile[];
+} | {
+    readonly kind: 'unreadable';
+    readonly error: unknown;
+};
+/** The ONLY directory read of `<home>/profiles` in the family.
+ * `profiles/node_modules` is a platform-created directory that never carries a manifest (S2.1), dot-entries
+ * are not profiles, and a directory without `package.json` is not one either.
+ * @param home - the resolved DSH home.
+ * @returns the scanned entries, or the enumeration error (never a silent empty list).
+ */
+export declare function scanProfiles(home: string): ProfilesScan;
+/** Every profile directory under one home, by name — the DIAGNOSTIC question (doctor's cross-profile
+ * summary). An unreadable home answers the empty list here because doctor reports the failure on its
+ * own DEGRADED row; a write path must ask {@link installExclusionTarget} instead.
+ * @param home - the resolved DSH home.
+ * @returns one entry per profile directory carrying a manifest.
+ */
+export declare function homeProfiles(home: string): readonly HomeProfile[];
+/** The bundle names one profile's manifest declares.
+ * @param profileDir - the profile directory.
+ * @param onError - called with the read/parse failure; a torn manifest is NOT "no bundles".
+ * @returns the declared bundle names (empty when the manifest is absent).
+ */
+export declare function profileBundles(profileDir: string, onError?: (error: unknown) => void): string[];
+/** One optional file's text, or `''` when it is absent or unreadable.
+ * @param path - the file to read.
+ * @returns the text.
+ */
+export declare function readTextOrEmpty(path: string): string;
+/** The profile's own patch text, or `''` when it has none.
+ * @param profileDir - the profile directory.
+ * @returns the patch text.
+ */
+export declare function profilePatchText(profileDir: string): string;
+/** The profile this PROCESS is mounted in, as the write-path exclusion must see it. */
+export interface MountedProfile {
+    /** The mounted profile's name. */
+    readonly profile: string;
+    /** Its directory. */
+    readonly dir: string;
+    /** The bundles this plane actually STARTED (the platform's `startedBundles`). */
+    readonly bundles: readonly string[];
+}
+/** Where the preset-install exclusion must look: THIS plane only, or an explicit refusal.
+ *
+ * The write path does NOT scan the home: the mounted profile is the whole question (its started
+ * bundles plus the ones its own manifest declares — either can double-mount), and a question that
+ * cannot be answered still REFUSES. That is what makes a leftover profile from the other plane
+ * harmless here: it is not this plane's profile, so it is never consulted.
+ * @param mounted - the mounted profile, or undefined outside a profile (a bare library mount).
+ * @returns the profile to judge with its bundle rows, or the reason a refusal is mandatory.
+ */
+export declare function installExclusionTarget(mounted: MountedProfile | undefined): {
+    readonly kind: 'mounted';
+    readonly profile: HomeProfile;
+    readonly bundles: readonly string[];
+} | {
+    readonly kind: 'undecidable';
+    readonly reason: string;
+};
+//# sourceMappingURL=profiles.d.ts.map

package/lib/types/registry.d.ts

@@ -12,9 +12,17 @@
 export interface CommandEntry {
     /** The subcommand as typed after `/evolution`. Variants use `|` (curator run|pause). */
     usage: string;
+    /** C7: true when the subcommand only READS (no skill/param write). Stored: not derivable. */
+    readonly: boolean;
     /** One-line purpose rendered in the help output. */
     summary: string;
 }
+/** The flags the TABLE declares for one subcommand (name → `--flag`), DERIVED from its usage. */
+export declare function flagsOf(name: string): string[];
+/** C7 shape, DERIVED: the subcommand name is the first token of `usage` (variants use `|`). */
+export declare function entryName(entry: CommandEntry): string;
+/** C7 shape, DERIVED: the flags a `usage` declares, in the form `--flag` (value flags keep their name). */
+export declare function entryFlags(entry: CommandEntry): string[];
 export declare const COMMAND_ENTRIES: CommandEntry[];
 /** The input-declaration hint (single line, ` | `-separated). */
 export declare function renderHint(): string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-commands",
   "description": "Human commands for the evolution family (/evolution pending|curator|maintain|doctor) (community build)",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,17 +27,18 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.4",
-    "@lmzhen/dsh-evolution-approval": "^0.21.0",
-    "@lmzhen/dsh-evolution-core": "^0.21.0",
-    "@lmzhen/dsh-evolution-maintenance": "^0.21.0"
+    "@lmzhen/dsh-evolution-approval": "^0.23.0",
+    "@lmzhen/dsh-evolution-core": "^0.23.0",
+    "@lmzhen/dsh-evolution-maintenance": "^0.23.0"
   },
   "optionalDependencies": {
-    "@lmzhen/dsh-evolution-agent-preset": "^0.21.0"
+    "@lmzhen/dsh-evolution-agent-preset": "^0.23.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-commands": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.2.0-rc.1"
+    "@deepseek-ai/dsh-llm": "^0.2.0-rc.1",
+    "@lmzhen/dsh-evolution-io": "^0.23.0"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-commands": "^0.2.0-rc.1"